I’d been putting this off for couple of reasons really:

1. I’d got to grips with the likes of Cairngorm/PureMVC by reading Chris Giametta’s APress Pro Flex on Spring book. But it didn’t quite give me a good enough understanding how some of the XML configuration would work for a basic Java project using BlazeDS – which I finally mastered this past week or so after reading Filippo di Pisa’s APress Beginning Java and Flex book. I figured it would be prudent to have a good understanding of the basics before moving on to Spicefactory’s wares.
   See my Amazon reviews here: 
   • Pro Flex on Spring
   • Beginning Java and Flex
2. The fact you can’t print the documentation off, and you have to sift through a tons of it whilst glued to the web browser which took me the best part of a couple of days solid reading.
   I much prefer to print stuff off and pencil notes against a hard copy…

In summary Spicefactory has four projects:

Spicelib

This is a foundational project for Parsley that provides:

• enhanced Flex reflection capabilities
• a bi-directional XML to AS3 object class mapper.(I wasn’t sure if there was a pluggable implementation here and how scalable it was. I.e. a event driven streaming affair a la SAX or a load the whole thing into memory).
  It didn’t grab me as having the same elegance you find with Groovy XML builders. (XMLParser/XMLSlurper). (Scott Davis’s Groovy Recipes book rocks on this subject).
• An expressions parser a la JSP EL/Velocity/Freemarker/Groovy GStrings etc. (which seemed to have a missing swc in download)
• Logging capabilities (a la Commons logging for AS3)
• A task framework. I really though this was a great idea, enabling you to abstract away fine grained events into a a higher level unit of work.

Parsley

A Flex DI framework. It sounds similar to RobotLegs, but my take it’s a bit more extensible and consequently a bit more of a learning curve. (Think Spring/Google Guice for the Flex world). The framework makes extensive use of metatags that works in either a Flash or Flex world. (Things like [Inject]) – similar to annotations in the Java world.
There’s a few strokes of genius in that the project, although I was a bit surprised none of the examples made use of the newer Vector class and still used Arrays:

• It uses a DSL builder, somewhat reminiscent of jQuery, so that configuration/wiring of components can be done with XML, AS3 or MXML that builds upon the DSL under the covers.
• The messaging infrastructure does away with the nasty constants and lots if type casting you see in the likes of Cairngorm and instead uses metatags for the publication/subscription process for events which is very clean. You can also scope the level at which you listen for events which is useful when dealing with nested visual components (Think filtered bubbling).

If you want to see a sample project, Christophe Coenraet has a handy blog post here.
Unfortunately, he didn’t go the extra mile and demonstrate integration with Pimento too.
Watch this space. I’m going to have a crack at modifying the project to do just that.

Cinammon Remoting

Jens Halm points out that the regular RemoteObject MXML tag is not type safe and you normally have to write a business delegate wrapper. Consequently in essence, this is the nut this project cracks.

Pimento

There’s some definite pluses to this project, but it has some peculiarities to it as well.
In essence it provides JPA/Hibernate/Flex/Spring integration and solves a lot of the complex issues with like lazy loading. It does this by embellishing the Java domain classes with annotations and effectively provides client-side caching. You can tweak the properties that get sent across the wire via AMF too, by doing things like making things read-only on the AS3 side, or using a @Hidden annotation.
It did seem awkward however to use interceptors to provide constrain functionality (See section 2.6 of documentation). I’d much prefer to have seen something along the lines of utilising annotations (as you see in the JSR303 Bean Validation framework/Hibernate Validator) (see Willie Wheeler’s blog post for an example). Or even better from my perspective integration with GORM.
It would be good if the project could create the appropriate MXML components for things like emails, dates etc too from annotations/data types/constraints etc.
If I can get my head around elegantly creating an example that uses Pimento and Parsley, I’ll have a crack at creating some Grails plug-ins.

Integration testing makes use of DBUnit server-side and Fluint client-side (which facilitates asynchronous operations).
I think there are some better options that have surfaced server-side than DBUnit, that I’ve seen in the Grails community. (but I’m wracking my memory to remember them as I write this… Will post back later).

The project bears a slight bit resemblance to Struts 2 in a couple of ways, in that it uses interceptors and Freemarker templates to convert Java domain classes into ActionScript. These get invoked by running Ant tasks. Felippo’s book also mentioned you can achieve similar results via UML tooling too with the likes of Visual Paradigm. (UML to Java and ActionScript 3).

You can also do things like have a named query in your Hibernate class and call into it from the Actionscript side. (Although I’m not sure if this is a potential security hole. Can you obfuscate your SWCs to avoid this?)

def t = '134 445 887 6667 456-987 fdcf'
def p1 = /(?!^)\d{3}\b/            // No good selects 667
def p2 = /(?!^)\b\d{3}\b/          // Great
def p3 = /((\s)(\d{3})(?=\D))/     // No good omits 987 also 3 groups..
def p4 = /((\s|\-)(\d{3})(?=\D))/  //Good again, but 3 groups, result third (post 4 first is full)
def p5 = /((?!^)(?<!\-)(?=\b)(\d{3})(?!\-)(?=\b))/  // Great if you want to omit ###-### permutation
def m1 = (t =~ p1)
def m2 = (t =~ p2)
def m3 = (t =~ p3)
def m4 = (t =~ p4)
def m5 = (t =~ p5)
assert m1.size() == 5
m1.each{assert it in ['445','887','667','456','987']}
assert m2.size() == 4
m2.each{assert it in ['445','887','456','987']}
assert m3.size() == 3
m3.each{assert it[3] in ['445','887','456']}
assert m4.size() == 4
m4.each{assert it[3] in ['445','887','456','987']}
assert m5.size() == 2
m5.each{assert it[0] in ['445','887']}

This is very similar to my earlier post
Groovy Regular Expressions to abbreviate compass directions with look ahead and look behind.
If I break apart pattern 5 by groups, we have:

• (?!^) : Lookahead negative start (ie Not at start)
• (?<!\-)   Lookbehind negative for ‘-’ i.e. exclude -###
• (?=\b) Lookahead positive for word boundary
• (\d{3}) 3 digits ###
• (?!\-) Lookahead negative for ‘-’ i.e. exclude ###-
• (?=\b) Lookahead positive for word boundary

I was basically looking for a way to replace area codes in a string with placeholders.
I adapted this example from Jeffrey Friedel’s Mastering Regular Expressions book (P383).

def t = new StringBuilder('742 : Reserved as a future area code in the 289/905 region (to be overlain by 365 in 2013). [7]')
def p = /\b\d{3}\b/
def m = java.util.regex.Pattern.compile(p).matcher(t)
//def m = (t =~p)
m.each{println it}
def mp = 0
def i  = 0
while(m.find(mp)) {
 def iSt = i.toString()
 def ms = m.start()
 def me = m.end()
 mp = me
 t.replace(ms, me, iSt)
 def ml = me - ms
 mp = mp - ml + iSt.size()
 i+= 1
}
println t

742
289
905
365
0 : Reserved as a future area code in the 1/2 region (to be overlain by 3 in 2013). [7]

I couldn’t get the commented out Groovier declaration of m to work correctly, so I resorted to the more Java centric approach in order to get this working.

I’m guessing Groovy doesn’t re-establish the pattern for updated StringBuilder.
This is the result if I flip the commenting of m around (lines 3 & 4)!

0 : Reserved as a future area code in the 28105 2ion (to be overlain by 365 in313). [7]

I’m wondering is this a Groovy bug? Or is there another way of doing the compile in a Groovier way. Comments welcome,

This also works:

def t = '123 xxx 444 fgg 654'
def p = ~/\b\d{3}\b/
def m = (t =~ p)
def ms, me, ml, p1, p2, r, d, s, f
d = 0
m.eachWithIndex{it, i ->
  ms = m.start()
  me = m.end()
  ml = me - ms // Match length
  s = ms + d  // Adjusted Start
  f = me + d  // Adjusted End (Finish)
  p1 = (s) ? t[0..s-1] : '' // Part 1
  p2 = (f == t.size()) ? '' : t[f..-1] // Part 2
  r = '\$' + (i+1)  // Placeholder Replacement
  d = d - ml + r.size() // Update cummulative adjustment with diff in length
  t = p1 + r + p2 // recombine t with placeholder
}
println t

$1 xxx $2 fgg $3

Here are some associated useful links:

• StringBuilder
• Javadoc for java.util.regex package

I’d rather have a sharper scalpel and a better trained surgeon than a duller blade.

But I still think it’s still a useful exercise create your own getters/setters under such conditions.

Anyway, back to the task at hand…

Ever get confused as to how to name getters and setters for properties?
If property is all lowercase you just convert first letter to uppercase and that’s easy enough.
If it’s all uppercase, no problem too. Just leave it as is.
Java & Groovy convention dictates properties shouldn’t begin with upper case and then revert to lower, so you can’t define getters and setters for such a property (Tx below). This is normally reserved for class names, so a getter/setter never gets called when you don’t manually call the property via the get/set method names and resort to property syntax alone (ie field name).
If they are camelCase like qText or rText, things get a bit more tricky to remember.
I made each accessor/mutator (getter/setter) write some output when invoked to test this out.
As you can see, uppercasing qText to QText property isn’t correct. It fires a blank. So you leave the property in it’s camel case state.
You can see this is right by examining the output of LHS (setter) or RHS (getter) property access when you access the property with field style syntax.

package jgf
class J {
 def ptext
 def qText
 def rText
 def ST
 def Tx
 void setPtext(s) {
   println 'setter ptext'
   this.ptext = s
 }
 def getPtext() {
   println 'getter ptext'
   return ptext
 }
 void setQtext(s) {
   println 'setter qText'
   this.ptext = s
 }
 def getQtext() {
   println 'getter qText'
   return ptext
 }
  void setrText(s) {
   println 'setter rText'
   this.rText = s
 }
 def getrText() {
   println 'getter rText'
   return rText
 }
  void setST(s) {
   println 'setter ST'
   this.ST = s
 }
 def getST() {
   println 'getter ST'
   return ST
 }
  void setTx(s) {
   println 'setter Tx'
   this.Tx = s
 }
 def getTx() {
   println 'getter Tx'
   return Tx
 }

}
def x = new J()
println '-'*5 + ' p: ' + '-'*5
x.ptext = 'a'
println x.ptext
println '-'*5 + ' q: ' + '-'*5
x.qText = 'b'
println x.qText
println '-'*5 + ' r: ' + '-'*5
x.rText = 'c'
println x.rText
println '-'*5 + ' s: ' + '-'*5
x.ST = 'd'
println x.ST
println '-'*5 + ' t: ' + '-'*5
x.Tx = 'e'
println x.Tx

----- p: -----
setter ptext
getter ptext
a
----- q: -----
b
----- r: -----
setter rText
getter rText
c
----- s: -----
setter ST
getter ST
d
----- t: -----
e

def points = [[k: ~/(N|n)ortheast(ern)?/                                                                        , v:'NE'],
              [k: ~/(?>(N|n)orth(W|w)est(ern|:)?)(?! Terrotories)/                                              , v:'NW'],
              [k: ~/(S|s)outheast(ern)?/                                                                        , v:'SE'],
              [k: ~/(?>(S|s)outh(\s)?west(ern)?)(?! Hill| Bend)/                                                , v:'SW'],
              [k: ~/(?>(N|n)orth(ern)?|Upstate)(?! Carolina| Dakota| Platte| Neck| Mariana Islands| Bay|ridge)/ , v:'N' ],
              [k: ~/(E|e)ast(ern)?/                                                                             , v:'E' ],
              [k: ~/(?>(S|s)outh(ern|side)?)(?! Carolina| Dakota)/                                              , v:'S' ],
              [k: ~/(?!(?<=George ))(?>(W|w)est(ern| of the)?)(?! Virginia| Palm Beach)/                        , v:'W' ],
              [k: ~/(?>(C|c)entral|Center|Middle|the middle section of the)(?!town| Peninsula| Tennessee|ia)/   , v:'C' ]
             ]
def text =  'West Virginia'
points.each {p ->
  def matcher = (text =~ p.k)
  text = matcher.replaceAll(p.v)
  println "p.v: ${p.v} text: $text"
}
return null

If I break apart  line 8, which is the most sophisticated of the lines in the example, it’s saying:

1. Don’t match ‘West’ (or a variation) if it’s prefixed by ‘George ‘.
2. It’s using a ‘look behind’ ie. ?<= for ‘George ‘.  So effectively after It’s matched ‘West’, it would discount ‘George West’.
3. The exclamation mark is the ‘not’ symbol.
4. Then we have the variations: ‘West’, ‘Western’, or ‘West of the’ (upper/lower case permutations).
5. The question mark represents an ‘optional (zero or one occurrence)’, and the vertical bar an ‘or’ condition.
6. The parentheses breaks the regex into ‘groups’ to which you can then apply qualifiers or cardinality rules.
7. The ?> symbol this time is doing the a ‘look ahead’ to match anything matched from the West grouping variations but excluding ‘!’ a suffix of ‘ Virginia’ or ‘|’ ‘ Palm Beach’.
8. So, finally ‘West Virginia’ or ‘West Palm Beach’ will not be matched, but ‘West Los Angeles’ would match.

Try setting text to ‘Northridge’, ‘George West’, ‘Middletown’, ‘South Bend’ etc and you’ll see it doesn’t abbreviate the text. But something like ‘East Los Angeles’, would become ‘E Los Angeles’.

Footnote:

After reading Mastering Regular Expressions, I found you can also set the regular expression to ‘ignore case’ mode with (?i) So the (N|n) can be simplified, by prefixing the RegEx pattern like so.
Obviously the RegEx would now match ‘NORTHERNEASTERN’, whereas it didn’t before, so it’s a broader matcher.

def points = [[k: ~/(?i:)northeast(ern)?/                                                                        , v:'NE'],
//... rest of code as before
                    ]

Here are some associated useful links:

• Regex on Snipplr
• DZone Refcard on Groovy (has Regex symbols & examples)
• Javadoc for java.util.regex package
• The Java Tutorials: Regular Expressions
• Daniel S. Meyer’s Positive examples of positive and negative lookahead example
• Groovy Regex text manipulation example
• Groovy script demonstrating Regular Expressions to manipulate Dates
• Ascertaining how subtract works with Strings in Groovy

One of the things I’ve been working on at the moment is extracting content from the Wiki page for NANP telephones.

I had a hell of a time tweaking and debugging a recursive routine to construct the paragraph text. The final result was quite elegant but the path to the solution wasn’t obvious and quite arduous to get right.
So, I thought I’d share the final result with a little debugging routine I built into the recursive process to evaluate the path the code follows.

I basically extract the P and UL nodes associated to each area code and dump the nodes out into a separate AreaCode class.

The getText() method of AreaCode has an overloaded signature. You call it in it’s simple form with a single parameter from the client code and it calls into the helper routine. The depth parameter isn’t strictly necessary, but acts as a debugging aid in following the path through the code.

By analysing the debugging dump, I was surprised to find that you can call each on a String and it will return a character at a time and consequently refactored the code to make the program behave more intelligently, so that when a text node is encountered the whole node is added rather than character by character to the resulting StringBuffer!

The AreaCode class has a debug flag, set to false on creation. When it’s set to true, the code will dump out a debugging/trace output.
I’ve highlighted the code you can tweak to enable debugging:

1. If you look at the toString() method, you can uncomment lines 115/125 & change the debug flag to true on line 116.
2. Uncomment the ‘if statement’ on line 66 to only debug certain area codes.

I ended up setting the debug flag in the toString() method, because the getText() method indirectly gets called in the code() method via pText() and I didn’t want to create debugging output inadvertently.

The append text method, that intelligently adds a space at the appropriate time as the text gets built was at the heart of gettting the desired result.

Here’s the code for crawlWikiNANPDialingCodes7.groovy:

Hope you enjoy.

package jgf
import groovy.grape.Grape
import com.thoughtworks.selenium.*

@Grapes([
    @Grab(group='net.sourceforge.nekohtml', module='nekohtml', version='1.9.14'),
    @Grab(group='xerces', module='xercesImpl', version='2.9.1'),
    @Grab(group='org.seleniumhq.selenium.client-drivers', module='selenium-java-client-driver', version='1.0.1') ])

class CrawlWikiNANPDialingCodes extends GroovySeleneseTestCase {

  @Override
  void setUp() throws Exception {
    super.setUp('http://en.wikipedia.org', '*chrome')
    setDefaultTimeout(50000)
    setCaptureScreenshotOnFailure(false)
    return null
  }

  void testCrawlWikiUKDialingCallingCodes() throws Exception {
    def crawl = init()
    extract200to900(crawl)

    return null
  }

  def init() {
    selenium.open("http://en.wikipedia.org/wiki/List_of_NANP_area_codes")
    def crawl = [:]
    crawl.with {
      page                            = getNekoHtml()
      areaCodes                       = []
    }
    println ''
    return crawl
  }

  def getNekoHtml() {
    def parser = new org.cyberneko.html.parsers.SAXParser()
    parser.setFeature('http://xml.org/sax/features/namespaces', false)
    def nekoHtml = new XmlParser(parser).parseText(selenium.getHtmlSource())
    return nekoHtml
  }

  def extract200to900(crawl) {
    crawl.with {
      def bc     = page.depthFirst().DIV.find{it.'@id' == 'bodyContent'}
      def ignore = true
      def ac
      bc.each{node ->
        if (node.name() == 'H2' && ignore && node.SPAN[1].'@id' == '200')
          ignore = false
        if (node.name() == 'H2' && !ignore && node.SPAN[1].'@id'.startsWith('By_state'))
           ignore = true
        if (!ignore) {
          switch (node.name()) {
             case 'P'  : ac        = new AreaCode()
                         areaCodes << ac
                         ac.pNode  = node
                         break
             case 'UL' : ac.ulNode = node
                         break
          }
        } // don't ignore
      } // bc.each (body content)
      areaCodes.each{ //if ((it.code() in ['928','971','975', '989']))
         println it
      }
    } // crawl.with
  }

}

class AreaCode {
   def pNode
   def ulNode
   def debug

   AreaCode() {
     debug = false
   }

   def pText() {
     return getText(pNode)
   }

   static nl() {
     return System.getProperty("line.separator")
   }

   def liNodes() {
     return (ulNode) ? ulNode.LI : null
   }

   def code() {
     return pText()[0..2]
   }

   def uText() {
     def res
     if (ulNode) {
       def sb = new StringBuilder()
       liNodes().each{node ->
         def liText = getText(node)
         sb.append("$liText${nl()}")
       }
       res = sb.toString()[0..-2]
     } else {
       res = ''
     }
     return res
   }

   String toString() {
     //println "-- Beg ${code()} ---"
     debug = false // Change to true to debug recursion
     def res
     def p = pText()
     if (ulNode) {
       res    = "$p${nl()}${uText()}"
     } else {
       res = p
     }
     debug = false
     //println "--- End ${code()} ---"
     return res
   }

   def getText(node) {
     def res = new StringBuilder()
     getText(node, 1, res)
     return res
   }

   def getText(node, depth, res) {
    if (debug) println "0B: $depth res: |$res|"
    if (node.class.simpleName =='String') {
      if (debug) println "1B: $depth res: |$res| node: $node"
      appendText(res, node)
      if (debug) println "1A: $depth res: |$res| node: $node"
    } else {
      node.each{child ->
        if (child.class.simpleName == 'String') {
          if (debug) println "2B: $depth res: |$res| child: |$child|"
         appendText(res, child)
          if (debug) println "2A: $depth res: |$res| child: |$child|"
        } else  {
          if (debug) println "3B: $depth res: |$res| child: |${child.name()}|"
          getText(child, depth +1, res)
          if (debug) println "3A: $depth res: |$res| child: |${child.name()}|"
        }
      }
    }
    if (debug) println "0A: $depth res: |$res|"
    return res.toString()
  }

  def appendText(res, newText) {
    if ( // if text being added doesn't start with . , ) or ]
         // and result has data
         // and result doesn't end with space ( or [
         // then append a space to result
         // Note: charAt returns type Char, so you need to cast to String for in to work..
        (!
          ( newText[0] in ['.', ')', ',', ']'] )
        ) &&
        ( res &&
          (!
            (
              (res.charAt(res.size() -1) as String)
               in [' ','(','[']
            )
          )
        )
       ) {
           res.append(' ')
         }
    res.append(newText)
  }
}

Here’s a sample of the tail end of the output in normal mode:

954 : Florida (all of Broward County : Fort Lauderdale, Hollywood, Coral Springs)
Created in 1995 by split from 305.
Overlain by 754 in 2002.
955 : not used
956 : Texas (Laredo, Brownsville, McAllen, Harlingen and South Texas)
Created in 1997 by split from 210.
957–958 : not used
959 : Connecticut
Overlain on 860 in 2001.
960–969 : not used (96x block reserved in case consecutive numbers are ever needed)
970 : Colorado (Aspen, Durango, Grand Junction, Fort Collins and northern and western Colorado)
Created in 1995 by split from 303.
971 : Oregon (Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)
Partially overlain on 503 in 2000. Clatsop and Tillamook Counties, originally excluded from the overlay, were added in 2008.
972 : Texas
Created in 1996 by split from 214. In 1999 the split was reversed to become an overlay, and a second overlay of 469 was added.
973 : New Jersey (Newark, Paterson and northwestern New Jersey)
Created in 1997 by split from 201.
Overlain by 862.
974 : not used
975 is assigned for numbering relief to 816 (Missouri) but no date has been scheduled for this to go into effect.
976–977 : not used
978 : Massachusetts (Fitchburg, Peabody and northeastern Massachusetts)
Created in 1997 by split from 508.
Overlain by 351 in 2001.
979 : Texas (Wharton, Bryan, Bay City, College Station, Lake Jackson, La Grange and Southeast Texas)
Created in 2000 by split from 409.
980 : North Carolina
Overlain on 704 in 2001.
981–983 : not used
984 is assigned for overlay relief to 919 (North Carolina) but no date has been scheduled for this to go into effect.
985 : Louisiana (Houma, Slidell and southeastern Louisiana excluding New Orleans)
Created in 2001 by split from 504.
986–988 : not used
989 : Michigan (Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)
Created in 2000 by split from 517.

Here’s a sample of the output in debug mode:

The quirky B/A in first column means before/after and correlates to the specific println statements, the depth of recursion comes next, then res (the string that gets appended to), then, either the HTML node type or text node value.

-- Beg 928 ---
0B: 1 res: ||
3B: 1 res: || child: |B|
0B: 2 res: ||
3B: 2 res: || child: |A|
0B: 3 res: ||
2B: 3 res: || child: |928|
2A: 3 res: |928| child: |928|
0A: 3 res: |928|
3A: 2 res: |928| child: |A|
0A: 2 res: |928|
3A: 1 res: |928| child: |B|
2B: 1 res: |928| child: |:|
2A: 1 res: |928 :| child: |:|
3B: 1 res: |928 :| child: |A|
0B: 2 res: |928 :|
2B: 2 res: |928 :| child: |Arizona|
2A: 2 res: |928 : Arizona| child: |Arizona|
0A: 2 res: |928 : Arizona|
3A: 1 res: |928 : Arizona| child: |A|
2B: 1 res: |928 : Arizona| child: |(|
2A: 1 res: |928 : Arizona (| child: |(|
3B: 1 res: |928 : Arizona (| child: |A|
0B: 2 res: |928 : Arizona (|
2B: 2 res: |928 : Arizona (| child: |Flagstaff|
2A: 2 res: |928 : Arizona (Flagstaff| child: |Flagstaff|
0A: 2 res: |928 : Arizona (Flagstaff|
3A: 1 res: |928 : Arizona (Flagstaff| child: |A|
2B: 1 res: |928 : Arizona (Flagstaff| child: |,|
2A: 1 res: |928 : Arizona (Flagstaff,| child: |,|
3B: 1 res: |928 : Arizona (Flagstaff,| child: |A|
0B: 2 res: |928 : Arizona (Flagstaff,|
2B: 2 res: |928 : Arizona (Flagstaff,| child: |Kingman|
2A: 2 res: |928 : Arizona (Flagstaff, Kingman| child: |Kingman|
0A: 2 res: |928 : Arizona (Flagstaff, Kingman|
3A: 1 res: |928 : Arizona (Flagstaff, Kingman| child: |A|
2B: 1 res: |928 : Arizona (Flagstaff, Kingman| child: |,|
2A: 1 res: |928 : Arizona (Flagstaff, Kingman,| child: |,|
3B: 1 res: |928 : Arizona (Flagstaff, Kingman,| child: |A|
0B: 2 res: |928 : Arizona (Flagstaff, Kingman,|
2B: 2 res: |928 : Arizona (Flagstaff, Kingman,| child: |Prescott|
2A: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott| child: |Prescott|
0A: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott|
3A: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott| child: |A|
2B: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott| child: |,|
2A: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott,| child: |,|
3B: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott,| child: |A|
0B: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott,|
2B: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott,| child: |Yuma|
2A: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma| child: |Yuma|
0A: 2 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma|
3A: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma| child: |A|
2B: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma| child: |and northern and western Arizona)|
2A: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma and northern and western Arizona)| child: |and northern and western Arizona)|
0A: 1 res: |928 : Arizona (Flagstaff, Kingman, Prescott, Yuma and northern and western Arizona)|
0B: 1 res: ||
2B: 1 res: || child: |Created in 2001 by split from|
2A: 1 res: |Created in 2001 by split from| child: |Created in 2001 by split from|
3B: 1 res: |Created in 2001 by split from| child: |B|
0B: 2 res: |Created in 2001 by split from|
3B: 2 res: |Created in 2001 by split from| child: |A|
0B: 3 res: |Created in 2001 by split from|
2B: 3 res: |Created in 2001 by split from| child: |520|
2A: 3 res: |Created in 2001 by split from 520| child: |520|
0A: 3 res: |Created in 2001 by split from 520|
3A: 2 res: |Created in 2001 by split from 520| child: |A|
0A: 2 res: |Created in 2001 by split from 520|
3A: 1 res: |Created in 2001 by split from 520| child: |B|
2B: 1 res: |Created in 2001 by split from 520| child: |.|
2A: 1 res: |Created in 2001 by split from 520.| child: |.|
0A: 1 res: |Created in 2001 by split from 520.|
--- End 928 ---
928 : Arizona (Flagstaff, Kingman, Prescott, Yuma and northern and western Arizona)
Created in 2001 by split from 520.
-- Beg 971 ---
0B: 1 res: ||
3B: 1 res: || child: |B|
0B: 2 res: ||
3B: 2 res: || child: |A|
0B: 3 res: ||
2B: 3 res: || child: |971|
2A: 3 res: |971| child: |971|
0A: 3 res: |971|
3A: 2 res: |971| child: |A|
0A: 2 res: |971|
3A: 1 res: |971| child: |B|
2B: 1 res: |971| child: |:|
2A: 1 res: |971 :| child: |:|
3B: 1 res: |971 :| child: |A|
0B: 2 res: |971 :|
2B: 2 res: |971 :| child: |Oregon|
2A: 2 res: |971 : Oregon| child: |Oregon|
0A: 2 res: |971 : Oregon|
3A: 1 res: |971 : Oregon| child: |A|
2B: 1 res: |971 : Oregon| child: |(Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)|
2A: 1 res: |971 : Oregon (Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)| child: |(Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)|
0A: 1 res: |971 : Oregon (Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)|
0B: 1 res: ||
2B: 1 res: || child: |Partially overlain on|
2A: 1 res: |Partially overlain on| child: |Partially overlain on|
3B: 1 res: |Partially overlain on| child: |B|
0B: 2 res: |Partially overlain on|
2B: 2 res: |Partially overlain on| child: |503|
2A: 2 res: |Partially overlain on 503| child: |503|
0A: 2 res: |Partially overlain on 503|
3A: 1 res: |Partially overlain on 503| child: |B|
2B: 1 res: |Partially overlain on 503| child: |in 2000.|
2A: 1 res: |Partially overlain on 503 in 2000.| child: |in 2000.|
3B: 1 res: |Partially overlain on 503 in 2000.| child: |A|
0B: 2 res: |Partially overlain on 503 in 2000.|
2B: 2 res: |Partially overlain on 503 in 2000.| child: |Clatsop|
2A: 2 res: |Partially overlain on 503 in 2000. Clatsop| child: |Clatsop|
0A: 2 res: |Partially overlain on 503 in 2000. Clatsop|
3A: 1 res: |Partially overlain on 503 in 2000. Clatsop| child: |A|
2B: 1 res: |Partially overlain on 503 in 2000. Clatsop| child: |and|
2A: 1 res: |Partially overlain on 503 in 2000. Clatsop and| child: |and|
3B: 1 res: |Partially overlain on 503 in 2000. Clatsop and| child: |A|
0B: 2 res: |Partially overlain on 503 in 2000. Clatsop and|
2B: 2 res: |Partially overlain on 503 in 2000. Clatsop and| child: |Tillamook|
2A: 2 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook| child: |Tillamook|
0A: 2 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook|
3A: 1 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook| child: |A|
2B: 1 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook| child: |Counties, originally excluded from the overlay, were added in 2008.|
2A: 1 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook Counties, originally excluded from the overlay, were added in 2008.| child: |Counties, originally excluded from the overlay, were added in 2008.|
0A: 1 res: |Partially overlain on 503 in 2000. Clatsop and Tillamook Counties, originally excluded from the overlay, were added in 2008.|
--- End 971 ---
971 : Oregon (Portland, Salem, Hillsboro, Beaverton and northwestern Oregon)
Partially overlain on 503 in 2000. Clatsop and Tillamook Counties, originally excluded from the overlay, were added in 2008.
-- Beg 975 ---
0B: 1 res: ||
3B: 1 res: || child: |B|
0B: 2 res: ||
3B: 2 res: || child: |A|
0B: 3 res: ||
2B: 3 res: || child: |975|
2A: 3 res: |975| child: |975|
0A: 3 res: |975|
3A: 2 res: |975| child: |A|
0A: 2 res: |975|
3A: 1 res: |975| child: |B|
2B: 1 res: |975| child: |is assigned for numbering relief to|
2A: 1 res: |975 is assigned for numbering relief to| child: |is assigned for numbering relief to|
3B: 1 res: |975 is assigned for numbering relief to| child: |B|
0B: 2 res: |975 is assigned for numbering relief to|
3B: 2 res: |975 is assigned for numbering relief to| child: |A|
0B: 3 res: |975 is assigned for numbering relief to|
2B: 3 res: |975 is assigned for numbering relief to| child: |816|
2A: 3 res: |975 is assigned for numbering relief to 816| child: |816|
0A: 3 res: |975 is assigned for numbering relief to 816|
3A: 2 res: |975 is assigned for numbering relief to 816| child: |A|
0A: 2 res: |975 is assigned for numbering relief to 816|
3A: 1 res: |975 is assigned for numbering relief to 816| child: |B|
2B: 1 res: |975 is assigned for numbering relief to 816| child: |(Missouri) but no date has been scheduled for this to go into effect.|
2A: 1 res: |975 is assigned for numbering relief to 816 (Missouri) but no date has been scheduled for this to go into effect.| child: |(Missouri) but no date has been scheduled for this to go into effect.|
0A: 1 res: |975 is assigned for numbering relief to 816 (Missouri) but no date has been scheduled for this to go into effect.|
--- End 975 ---
975 is assigned for numbering relief to 816 (Missouri) but no date has been scheduled for this to go into effect.
-- Beg 989 ---
0B: 1 res: ||
3B: 1 res: || child: |B|
0B: 2 res: ||
3B: 2 res: || child: |A|
0B: 3 res: ||
2B: 3 res: || child: |989|
2A: 3 res: |989| child: |989|
0A: 3 res: |989|
3A: 2 res: |989| child: |A|
0A: 2 res: |989|
3A: 1 res: |989| child: |B|
2B: 1 res: |989| child: |:|
2A: 1 res: |989 :| child: |:|
3B: 1 res: |989 :| child: |A|
0B: 2 res: |989 :|
2B: 2 res: |989 :| child: |Michigan|
2A: 2 res: |989 : Michigan| child: |Michigan|
0A: 2 res: |989 : Michigan|
3A: 1 res: |989 : Michigan| child: |A|
2B: 1 res: |989 : Michigan| child: |(Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)|
2A: 1 res: |989 : Michigan (Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)| child: |(Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)|
0A: 1 res: |989 : Michigan (Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)|
0B: 1 res: ||
2B: 1 res: || child: |Created in 2000 by split from|
2A: 1 res: |Created in 2000 by split from| child: |Created in 2000 by split from|
3B: 1 res: |Created in 2000 by split from| child: |B|
0B: 2 res: |Created in 2000 by split from|
3B: 2 res: |Created in 2000 by split from| child: |A|
0B: 3 res: |Created in 2000 by split from|
2B: 3 res: |Created in 2000 by split from| child: |517|
2A: 3 res: |Created in 2000 by split from 517| child: |517|
0A: 3 res: |Created in 2000 by split from 517|
3A: 2 res: |Created in 2000 by split from 517| child: |A|
0A: 2 res: |Created in 2000 by split from 517|
3A: 1 res: |Created in 2000 by split from 517| child: |B|
2B: 1 res: |Created in 2000 by split from 517| child: |.|
2A: 1 res: |Created in 2000 by split from 517.| child: |.|
0A: 1 res: |Created in 2000 by split from 517.|
--- End 989 ---
989 : Michigan (Alpena, Mt. Pleasant, Bay City, Saginaw, Midland, Owosso and central Michigan)
Created in 2000 by split from 517.

def text = '201 : New Jersey ( Hackensack , Jersey City , Hoboken , Bayonne , Ridgewood , Union City , Teaneck , New Milford , and northeast New Jersey)'
def textPattern = /(.*)(\()(.*)(\))/         /* Break text into constituent parts.
                                                You have to escape brackets and colons as they make up Regex expressions.
                                                Thank heavens for Groovy / to quote regular expressions otherwise massive escape sequences would apply
                                                1) before '('
                                                2) '('
                                                3) between '(' & ')'
                                                4) ')'
                                              */
def p1Pattern = /(\d{3})(\s\:\s)([\w|\s]+)/  /* Break part 1 from above into
                                                1) Digits
                                                2) ' : '
                                                3) (Word or space) one or more times
                                              */
def p3Pattern = /([\w|\s]+)/                 /* The single Word or space once or more works here, Text from 3) of textPattern will split on commas (or any non word/space character)
                                              * A word character: [a-zA-Z_0-9] See: http://java.sun.com/docs/books/tutorial/essential/regex/pre_char_classes.html
                                              */
(text =~ textPattern).each{fullText, p1, openbracket, p3, closebracket ->
  println fullText
  println "p1: $p1"
  (p1 =~ p1Pattern).each{fullP1, code, p2, state  ->
    println "code: $code"
    println "state: $state|"
  }
  println "p3: $p3"
  def matchP3 = (p3 =~ p3Pattern)
  println matchP3.groupCount()                  /* You can call a group count on Regex. Useful for checking no of params to left of rocket symbol. Remember first always full match
                                                 * So if you leave default it property you will get a list with one group, entry 0 = full match. Entry 1 = first group.
                                                 * Since there's only one group entry 0 and 1 will always be equal (it[0] = it[1])
                                                 */
  matchP3.each{
    println "${it[1]}"
  }
}

Output from running program:

201 : New Jersey ( Hackensack , Jersey City , Hoboken , Bayonne , Ridgewood , Union City , Teaneck , New Milford , and northeast New Jersey)
p1: 201 : New Jersey
code: 201
state: New Jersey |
p3:  Hackensack , Jersey City , Hoboken , Bayonne , Ridgewood , Union City , Teaneck , New Milford , and northeast New Jersey
1
 Hackensack
 Jersey City
 Hoboken
 Bayonne
 Ridgewood
 Union City
 Teaneck
 New Milford
 and northeast New Jersey

Also note the difference:

def x = ~/(\w+)/
def y = /(\w+)/
println "x: ${x.class}"
println "y: ${y.class}"

x: class java.util.regex.Pattern
y: class java.lang.String

So strictly speaking it’s going to be better to precompile patterns with the ~/ / style syntax.

Also note the Groovy ‘find’ operator =~ is a Matcher object, whereas the ‘match’ operator ==~ is a Boolean and is more restrictive.

The pattern for ‘match’ has to be a full match on text search string to return a result of true. See here.

You can also get caught by the loose terminology Java applies to the pre-defined character class of ‘.’ denoted as ‘any character’ here. :-( Grrr!

def t            = '257–259 : not used'
def patCodeRange = ~/\d{3}\.\d{3}/
def r = (t =~ patCodeRange)
if (r) println "found"
r.each{println it}
return null

This doesn’t yield a match!

Whereas this does:

def t            = '257–259 : not used'
def patCodeRange = ~/\d{3}\W\d{3}/
def r = (t =~ patCodeRange)
if (r) println "found"
r.each{println it}
return null

Footnote:

Since purchasing Jeffrey Friedl’s Mastering Regular Expressions book, I’ve found out that you can also use \p{Pd} to represents hyphens and dashes of all sorts (P123, Table 3.9).

This also gets a mention here by way of the the Javadoc for Pattern.

found
257–259

Here are some associated useful links:

• Regex on Snipplr
• DZone Refcard on Groovy (has Regex symbols & examples)
• Javadoc for java.util.regex package
• The Java Tutorials: Regular Expressions
• Daniel S. Meyer’s Positive examples of positive and negative lookahead example
• Groovy script demonstrating Regular Expressions to manipulate Dates

def a = 'abc xyz abc'
def b = a - 'abc'
println b

Does b result in?:
a) ‘abc xyz ‘ (subtracting right to left)
b) ‘ xyz abc’ (subtracting left to right)
c) ‘ xyz ‘ (a greedy subtract subtracting all instances)

The answer is b!

If you could somehow syntactically specify the three variants in the subtract or specify a starting position to search from in the syntax I’d be a happier camper.
Depending on your needs you’re back to using Regular Expressions, String Replace or some sort of manual splicing of strings with the indexOf variants.

If you want the result specified by c), for example you can do this (courtesy of Venkat’s Programming Groovy P113) The replaceAll is an empty string, two back to back single quotes:

def c = (a =~ /abc/).replaceAll('')

Here’s a few other variants:

def a = 'abc xyz abc'
def b = /abc/
def c = (a =~ b)
def d = c.replaceFirst('')
def e = a.replaceFirst(b, '')
println "d: $d"
println "e: $e"
def st,fin
def cm1 = (c.size() -1)
c.eachWithIndex{m, i ->
  if (i == cm1)  {
    st = c.start()
    fin = c.end()
  }
}
def p1 = (st == 0) ? '' : a[0..st-1]
def p2 = (fin == a.size()) ? '' : a[fin..-1]
a = p1+p2
println "a: |$a|"
return null

d:  xyz abc
e:  xyz abc
a: |abc xyz |

Here are some associated useful links:

• Groovy String API
• Java String API
• StringBuilder
• StringBuffer
• Regex on Snipplr
• DZone Refcard on Groovy (has Regex symbols & examples)
• Javadoc for java.util.regex package
• The Java Tutorials: Regular Expressions
• Daniel S. Meyer’s Positive examples of positive and negative lookahead example
• Groovy script demonstrating Regular Expressions to manipulate Dates

enum NANPCodeGroup {
  USA(3), Canada(4), Carribean(5), USPacific(6)
  NANPCodeGroup(int value) {this.value = value}
  private final int value
  public int value() {return value}
}
NANPCodeGroup.each{println "1: $it"}
NANPCodeGroup.each{println "2: ${it.value()}"}
println "3: ${NANPCodeGroup.values()}"
NANPCodeGroup.values().each{println "4: $it"}
println "5: ${NANPCodeGroup.USA.value()}"
println "6: ${NANPCodeGroup.USA}"
x = NANPCodeGroup.grep{it.value() == 3}[0]?:''
println "7: $x , ${x.class}"

1: USA
1: Canada
1: Carribean
1: USPacific
2: 3
2: 4
2: 5
2: 6
3: [USA, Canada, Carribean, USPacific]
4: USA
4: Canada
4: Carribean
4: USPacific
5: 3
6: USA
7: USA , class NANPCodeGroup