cannonbol 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a648c8cfd875765efac54d699ee04acbbcd7f422
-  data.tar.gz: 47910f41c8d1cfb8953247fa8b788a09ce7d20fd
+  metadata.gz: a8b090116c27ac8cf008c2a0b54b5aa2eb259bf4
+  data.tar.gz: 6899f4b674be76248a133b664870632eae5d48bd
 SHA512:
-  metadata.gz: 7dea1273241b4517b6542de8f557f2401fcd6880330d5662edc533428e3878fc15680bfb8a5ae0537c21cfa2a7a62a85dc12e080a74922e8fdbd5a053492d66d
-  data.tar.gz: 14bd53603b2c261ea45cc25f9593fc38c7437aa040eef859651e0b428e40525761b5842237996818f27fecf2d6e45db599fc1dfd5711daa2e216cc0704a57540
+  metadata.gz: 9e820fa3e6b2758aa2e5fd67d7b9d24c6482bc96ad33b4b2763b071f3d73d5b8944fe5da77e56bdfd1fb03df303f4a13c024d3cb0884745fac100ddc4429baec
+  data.tar.gz: 201b97e9cdf60edbf9b3c5b84d9801b7883f06371f2a23c234616c4e0662ccc7d8eb716d9e52fb01cdf422ce458377881fc71fe550e8e33cff5dfca7d3d5f06a

data/README.md

@@ -9,6 +9,7 @@ CannonBol is a ruby DSL for patten matching based on SNOBOL4 and SPITBOL.
 * Complete SNOBOL4 + SPITBOL extensions!
 * Based on the well documented, proven SNOBOL4 language!
 * Simple syntax looks great within your ruby code!
+* Tested with ruby 1.9.3, 2.1.1 and [Opal](www.opalrb.org)
 
 ## Installation
 
@@ -34,28 +35,31 @@ Strings, Regexes and primitives are combined using & (concatenation) and | (alte
 
 Here is a simple pattern that matches a simple noun clause:
 
-    ("a" | "the") & /\s+/ & ("boy" | "girl")
+    > ("a" | "the") & /\s+/ & ("boy" | "girl")
     
-So we will match either "a" or "the" followed white space and then by "boy or "girl".  Okay!  Lets use it!
+This will match either "a" or "the" followed white space and then by "boy or "girl".  Okay!  Lets use it!
 
-    ("a" | "the") & /\s+/ & ("boy" | "girl").match?("he saw a boy going home")
+    > ("a" | "the") & /\s+/ & ("boy" | "girl").match?("he saw a boy going home")
     => "a boy"
-    ("a" | "the") & /\s+/ & ("boy" | "girl").match?("he saw a big boy going home")
+    > ("a" | "the") & /\s+/ & ("boy" | "girl").match?("he saw a big boy going home")
     => nil
 
-Now let's save the pieces of the match using the capture? (pronounced _capture IF_) method:
+Now let's save the pieces of the match using the `capture?` (pronounced _capture IF_) method:
 
-    article, noun = nil, nil
-    pattern = ("a" | "the").capture? { |m| article = m } & /\s+/ & ("boy" | "girl").capture? { |m| noun = m }
-    pattern.match?("he saw the girl going home")
-    noun
+    > article, noun = nil, nil;
+    * pattern = ("a" | "the").capture? { |m| article = m } & /\s+/ & ("boy" | "girl").capture? { |m| noun = m };
+    * pattern.match?("he saw the girl going home")
+    => the girl
+    > noun
     => girl
-    article
+    > article
     => the
 
-The capture? method and its friend capture! (pronounced _capture NOW_) have many powerful features. As shown above it can take a block which is passed the matching substring, _IF the match succeeds_.  The other features of the capture method will be detailed [below.](Advanced capture techniques)
+The `capture?` method and its friend `capture!` (pronounced _capture NOW_) have many powerful features. 
+As shown above it can take a block which is passed the matching substring, _IF the match succeeds_.  
+The other features of the capture method will be detailed [below.](Advanced capture techniques)
 
-Arrays can be turned into patterns using the match_any and match_all methods:
+Arrays can be turned into patterns using the `match_any` and `match_all` methods:
 
     ARTICLES = ["a", "the"]
     NOUNS = ["boy", "girl", "dog", "cat"]
@@ -64,7 +68,7 @@ Arrays can be turned into patterns using the match_any and match_all methods:
     [ARTICLES.match_any, [WS, [WS, ADJECTIVES.match_any, WS].match_all].match_any, NOUNS.match_any].match_all
     
 This is equivilent to 
-   
+
     ("a" | "the") & (WS | (WS & ("big" | "small" | "fierce" | "friendly") & WS)) & ("boy" | "girl" | "dog" | "cat")
     
 ### match? options
@@ -80,20 +84,30 @@ replace_with | nil | When a non-falsy value is supplied, the value will replace
 
 Example of replace with:
 
-    "hello".match?("She said hello!")
+    > "hello".match?("She said hello!")
     => hello
-    "hello".match?("She said hello!", replace_with => "goodby")
+    > "hello".match?("She said hello!", replace_with => "goodby")
     => She said goodby!
+    
+#### Ignore case on a subpattern
+
+Sometimes its useful to run the matcher in the default case sensitive mode, and only turn off matching for one part of the pattern.  To do this
+prefix a subpattern with a "-".  For example
 
+    > (-"GIRL" | "boy").match?("A big girl!")
+    => girl
+    > (-"GIRL" | "boy").match?("A big BOY!")
+    => nil
+   
 ### Patterns, Subjects, Cursors, Alternatives, and Backtracking 
 
 A pattern is an object that responds to the match? method.  Cannonbol adds the match? method to Ruby strings, and regexes, and provides a number of _primitive_ patterns.  A pattern can be combined with another pattern using the &, and | operators.  There are also several primitive patterns that take a pattern and create a new pattern.  Here are some example patterns:
 
-    "hello" # matches any string containing hello
-    /\s+/   # matches one or more white space characters
+    "hello"  # matches any string containing hello
+    /\s+/    # matches one or more white space characters
     "hello" & /\s+/ & "there"  # matches "hello" and "there" seperated by white space
-    "hello" | "goodby"  # matches EITHER "hello" or "there"
-    ARB # a primitive pattern that matches anything (similar to /.*/)
+    "hello" | "goodby"         # matches EITHER "hello" or "there"
+    ARB      # a primitive pattern that matches anything (similar to /.*/)
     ("hello" | "goodby") & ARB & "Fred"  # matches "hello" or "goodby" followed by any characters and finally "Fred"
 
 Patterns are just objects, so they can be assigned to variables:
@@ -270,18 +284,19 @@ We can use this to clean up the palindrome pattern a little bit:
 
 Another way to get the capture variables is to interogate the value returned by match?.  The value returned by match? is a subclass of string, that has some extra methods.  One of these is the captured method which gives a hash of all the captured variables.  For example:
 
-    ("dog" | "cat").capture?(:pet).match?("He had a dog named Spot.").captured[:pet]
+    > ("dog" | "cat").capture?(:pet).match?("He had a dog named Spot.").captured[:pet]
     => dog
 
 You can also give a block to the match? method which will be called whether the block passes or not.  For example:
 
-    ("dog" | "cat").capture?(:pet).match?("He had a dog named Spot."){ |match| match.captured[:pet] if match}
+    > ("dog" | "cat").capture?(:pet).match?("He had a dog named Spot."){ |match| match.captured[:pet] if match}
     => dog
    
 The match? block can also explicitly name any capture variables you need to get the values of.  So for example:
 
-    pet_data = (POS(0) & ARBNO(("big" | "small").capture?(:size) | ("dog" | "cat").capture?(:pet) | LEN(1)) & RPOS(0))
-    pet_data.match?("He has a big dog!") { |m, pet, size| "type of pet: #{pet.upcase}, size: #{size.upcase}"}
+    > pet_data = (POS(0) & ARBNO(("big" | "small").capture?(:size) | ("dog" | "cat").capture?(:pet) | LEN(1)) & RPOS(0))
+    => #<Cannonbol::Concat .... etc
+    > pet_data.match?("He has a big dog!") { |m, pet, size| "type of pet: #{pet.upcase}, size: #{size.upcase}"}
     => type of pet: DOG, size: BIG
 
 If the match? block mentions capture variables that were not assigned in the match they get nil.
@@ -289,14 +304,14 @@ If the match? block mentions capture variables that were not assigned in the mat
 #### Initializing capture variables
 
 When used as a parameter to a primitve the capture variable may be given an initial value.   For example:
-    
+
     LEN(baz: 12)
 
-would match LEN(12) if :baz had not yet been set.
+would match `LEN(12)` if :baz had not yet been set.
 
 A second way to initialize (or update capture variables) is to combine capture variables with a capture block like this:
 
-    some_pattern.capture!(:baz) { |match, position, baz| baz || position * 2 } initializes :baz to position * 2
+    some_pattern.capture!(:baz) { |match, position, baz| baz || position * 2 } # initializes :baz to position * 2
     
 If a symbol is specified in a capture!, and there is a block, then the symbol will be set to the value returned by the block.
 
@@ -349,15 +364,13 @@ The difference is that FENCE will fail the whole match, but FENCE(pattern) will
 
 These can be used together to do some interesting things.  For example
 
-    pattern = POS(0) & SUCCEED & (FENCE(TAB(n: 1).capture!(:n) { |m, p, n|  puts m; p+1 } | ABORT)) & FAIL
-    pattern.match?("abcd")
-    
-prints
-
+    > pattern = POS(0) & SUCCEED & (FENCE(TAB(n: 1).capture!(:n) { |m, p, n|  puts m; p+1 } | ABORT)) & FAIL;
+    * pattern.match?("abcd")
     a
     ab
     abc
     abcd
+    => nil
     
 The SUCCEED and FAIL primitives keep forcing the matcher to retry.  Eventually the TAB will fail causing the ABORT alternative to execute the matcher.
 
@@ -397,19 +410,24 @@ Cannonbol can be used to easily translate the email BNF spec into an email addre
 
 So for example we can even parse an obscure email with groups and routes
 
-    email = 'here is my "big fat \\\n groupen" : someone@catprint.com, Fred Nurph<@sub1.sub2@sub3.sub4:fred.nurph@catprint.com>;'
-    match = address.match?(email)
-    match.captured[:group_mailboxes].first.captured[:mailbox]
+    > email = 'here is my "big fat \\\n groupen" : someone@catprint.com, Fred Nurph<@sub1.sub2@sub3.sub4:fred.nurph@catprint.com>;'
+    => here is my "big fat \\\n groupen" : someone@catprint.com, Fred Nurph<@sub1.sub2@sub3.sub4:fred.nurph@catprint.com>;
+    > match = address.match?(email)
+    => here is my "big fat \\\n groupen" : someone@catprint.com, Fred Nurph<@sub1.sub2@sub3.sub4:fred.nurph@catprint.com>;
+    > match.captured[:group_mailboxes].first.captured[:mailbox]
     => someone@catprint.com
-    match.captured[:group_name]
+    > match.captured[:group_name]
     => here is my "big fat \\\n groupen
 
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bundle install` to install dependencies. 
+
+### Specs
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Run `bundle exec rspec` to run the tests on your server environment
+Run `bundle exec rake rackup` and then point your browser to your machine to run the tests in the opal 
 
 ## Contributing
 

data/Rakefile

@@ -1,3 +1,3 @@
-require "bundler/gem_tasks"
-
-Dir.glob('tasks/**/*.rake').each(&method(:import))
+require 'bundler'
+Bundler.require
+Bundler::GemHelper.install_tasks

data/cannonbol.gemspec

@@ -33,4 +33,6 @@ Simple syntax looks great alongside ruby!
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "opal-rspec"
+  spec.add_development_dependency "opal"
 end

data/config.ru

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler.require
+
+require 'opal-rspec'
+Opal.append_path File.expand_path('../spec', __FILE__)
+
+run Opal::Server.new { |s|
+  s.main = 'opal/rspec/sprockets_runner'
+  s.append_path 'spec'
+  s.debug = false
+  s.index_path = 'spec/index.html.erb'
+}
+

data/lib/cannonbol.rb

@@ -1,678 +1,9 @@
-module Cannonbol
-  
-  class MatchFailed < Exception; end
-    
-  class MatchString < String
-    
-    attr_reader :captured
-    attr_reader :match_start
-    attr_reader :match_end
-    
-    def initialize(string, match_start, match_end, captured)
-      @cannonbol_string = string
-      @match_start = match_start
-      @match_end = match_end
-      @captured = captured.dup
-      super(@match_end < 0 ? "" : string[@match_start..@match_end])
-    end 
-    
-    def replace_match_with(s)
-      before_match = ""
-      before_match = @cannonbol_string[0..@match_start-1] if @match_start > 0
-      after_match = @cannonbol_string[@match_end+1..-1] || ""
-      before_match + s + after_match
-    end
-    
+require_relative 'cannonbol/cannonbol'
+require_relative 'cannonbol/version'
+unless RUBY_ENGINE == 'opal'
+  begin 
+    require 'opal'
+    Opal.append_path File.expand_path('..', __FILE__).untaint
+  rescue LoadError
   end
-  
-  class Needle
-    
-    attr_reader :cursor
-    attr_reader :string
-    attr_accessor :captures
-    attr_accessor :match_failed
-    attr_accessor :ignore_case
-    
-    def initialize(string)
-      @string = string
-    end
-    
-    def thread(pattern, opts = {}, &match_block)
-      @captures = {}
-      anchor = opts[:anchor]
-      raise_error = opts[:raise_error]
-      replace_with = opts[:replace_match_with]
-      ignore_case = opts[:ignore_case]
-      @cursor = -1
-      match = nil
-      begin
-        while !match and !match_failed and @cursor < @string.length-1
-          @cursor += 1
-          @starting_character = nil
-          @success_blocks = []
-          @ignore_case = ignore_case
-          match = pattern._match?(self)
-          break if !match and anchor  
-        end
-      rescue MatchFailed
-      end
-      if match
-        @success_blocks.each(&:call)
-        match = MatchString.new(@string, @starting_character || @cursor, @cursor-1, @captures)
-      else
-        raise MatchFailed if raise_error
-      end
-      if match_block
-        match = match_block.call(*([match] + (match_block.parameters[1..-1] || []).collect { |param| @captures[param[1].to_sym] }))
-      elsif replace_with
-        match = match.replace_match_with(replace_with)
-      end
-      match
-    end
-    
-    def capture(name, value)
-      @captures[name.to_sym] = value if name
-      value
-    end
-      
-       
-    def remaining_string
-      @string[@cursor..-1]
-    end
-     
-    def push(length, &success_block)
-      thread_state = [@starting_character, @cursor, @success_blocks.dup, @ignore_case]
-      @starting_character ||= @cursor
-      @cursor += length
-      @success_blocks << success_block if success_block
-      thread_state
-    end
-      
-    def pull(thread_state)
-      @starting_character, @cursor, @success_blocks, @ignore_case = thread_state if thread_state
-      nil
-    end
-      
-  end
-  
-  module Operators
-        
-    def _match?(needle, *args, &block)
-      return if needle.match_failed
-      __match?(needle, *args, &block)
-    end
-    
-    def match?(s, opts = {}, &match_block)
-      Needle.new(s).thread(self, opts, &match_block)
-    end
-    
-    def |(pattern)
-      Choose.new(self, pattern)
-    end
-  
-    def &(pattern)
-      Concat.new(self, pattern)
-    end
-    
-    def -@
-      CaseSensitiveOff.new(self)
-    end 
-
-    def capture?(opts = {}, &block)
-      OnSuccess.new(self, opts, &block)
-    end
-    
-    def capture!(opts = {},  &block)
-      OnMatch.new(self, opts, &block)
-    end
-    
-  end
-   
-  class Pattern 
-    
-    include Operators
-    
-    def __match?(needle)
-      []
-    end
-      
-  end
-  
-  class Choose < Pattern
-    
-    def __match?(needle, i = 0, s = [])
-      while i < @params.length
-        s = @params[i]._match?(needle, *s)
-        return [i, s] if s
-        s = []
-        i += 1
-      end
-      nil
-    end
-    
-    def initialize(p1, p2)
-      @params = [p1, p2]
-    end
-    
-  end
-  
-  class Concat < Pattern
-    
-    def __match?(needle, i = 0, s = [])
-      while i < @params.length and i >= 0
-        s[i] = @params[i]._match?(needle, *(s[i] || []))
-        i = s[i] ? i+1 : i-1
-      end
-      [i-1, s] if i == @params.length
-    end
-    
-    def initialize(p1, p2)
-      @params = [p1, p2]
-    end
-    
-  end
-  
-  class CaseSensitiveOff < Pattern
-    
-    def initialize(pattern)
-      @pattern = pattern
-    end 
-    
-    def __match?(needle, thread=nil, s=[])
-      needle.pull(thread)
-      thread = needle.push(0)
-      needle.ignore_case = true
-      s = @pattern._match?(needle, *s)
-      return [thread, s] if s
-    end
-    
-  end
-  
-  class OnSuccess < Pattern
-    
-    def initialize(pattern, opts, &block)
-      if opts.class == Hash
-        if opts.first
-          @capture_name = opts.first.first
-          @initial_capture_value = opts.first.last
-        end 
-      else
-        @capture_name = opts
-      end
-      @pattern = pattern
-      @block = block
-    end
-    
-    def __match?(needle, thread_state = nil, starting_cursor = nil, s=[])
-      needle.pull(thread_state)
-      starting_cursor ||= needle.cursor
-      if s = @pattern._match?(needle, *s)
-        ending_cursor = needle.cursor-1
-        push = needle.push(0) do
-          match_string = MatchString.new(needle.string, starting_cursor, ending_cursor, needle.captures)
-          capture_value = @capture_name && (needle.captures.has_key?(@capture_name) ? needle.captures[@capture_name] : @initial_capture_value) 
-          if @block
-            match_string = @block.call(match_string, ending_cursor+1, capture_value) 
-          elsif capture_value.class == Array
-            match_string = capture_value + [match_string]
-          end
-          needle.capture(@capture_name, match_string)
-        end
-        [ push, starting_cursor, s ]
-      end
-    end
-    
-  end
-  
-  class OnMatch < OnSuccess
-    
-    def __match?(needle, starting_cursor = nil, s=[])
-      starting_cursor ||= needle.cursor
-      if s = @pattern._match?(needle, *s)
-        match_string = MatchString.new(needle.string, starting_cursor, needle.cursor-1, needle.captures)
-        capture_value = @capture_name && (needle.captures.has_key?(@capture_name) ? needle.captures[@capture_name] : @initial_capture_value) 
-        match_string = @block.call(match_string, needle.cursor, capture_value) if @block
-        needle.capture(@capture_name, match_string)
-        [starting_cursor, s]
-      end
-    end
-    
-  end
-  
-  class Match < Pattern
-    
-    def initialize(sub_pattern_or_name = nil, &block)
-      if block
-        @block = block
-      elsif sub_pattern_or_name and sub_pattern_or_name.class == Symbol
-        @name = sub_pattern_or_name
-      elsif sub_pattern_or_name and sub_pattern_or_name.respond_to? "_match?"
-        @pattern = sub_pattern_or_name 
-      elsif sub_pattern_or_name and sub_pattern_or_name.respond_to? "to_s"
-        @pattern = sub_pattern_or_name.to_s
-      end
-    end 
-    
-    def __match?(needle, pattern = nil, s = [])
-      pattern ||= if @block
-        @block.call
-      elsif @name
-        needle.captures[@name] || ""
-      else
-        @pattern
-      end
-      existing_captures = needle.captures.dup
-      s = pattern._match?(needle, *s)
-      needle.captures = needle.captures.merge(existing_captures)
-      [pattern, s] if s
-    end 
-    
-  end
-  
-  class Rem < Pattern
-    
-    def __match?(needle, thread_state = nil)
-      if thread_state
-        needle_pull(thread_state)
-      else
-        [needle.push(needle.string.length-needle.cursor)]
-      end 
-    end
-    
-  end
-  
-  class Arb < Pattern
-    
-    def __match?(needle, match_length = 0, thread_state = nil)
-      needle.pull(thread_state)
-      if needle.remaining_string.length >= match_length 
-        thread_state = needle.push(match_length)
-        match_length += 1
-        [match_length, thread_state]
-      end
-    end
-    
-  end
-  
-  class ParameterizedPattern < Pattern
-    
-    def initialize(opts = nil, &block)
-      if opts.class == Hash
-        if opts.first
-          @param_name = opts.first.first
-          @initial_param_value = opts.first.last
-        end 
-      else
-        @initial_param_value = opts
-      end
-      @block = block
-    end
-    
-    def self.parameter(name, &post_processor)
-      @post_processor = post_processor
-      define_method(name) do |needle|
-        value = (@param_name && needle.captures.has_key?(@param_name)) ? needle.captures[@param_name] : @initial_param_value
-        value = @block.call(value) if @block
-        needle.capture(@param_name, value)        
-        value = post_processor.call(value) if @post_processor
-        value
-      end
-    end
-    
-  end
-  
-  class Len < ParameterizedPattern
-    
-    parameter :len
-    
-    def __match?(needle, thread_state = nil)
-
-      if thread_state
-        needle.pull(thread_state)
-      else
-        len_temp = len(needle)
-        [needle.push(len_temp)] if needle.remaining_string.length >= len_temp
-      end
-      
-    end
-    
-  end
-  
-  class Pos < ParameterizedPattern
-    
-    parameter :pos
-    
-    def __match?(needle, matched = nil)
-      return [true] if needle.cursor == pos(needle) and !matched
-    end 
-    
-  end 
-  
-  class RPos < ParameterizedPattern
-    
-    parameter :pos
-    
-    def __match?(needle, matched = nil)
-      return [true] if needle.string.length-needle.cursor == pos(needle) and !matched
-    end 
-    
-  end
-  
-  class Tab < ParameterizedPattern
-    
-    parameter :pos
-    
-    def __match?(needle, thread_state = nil)
-      
-      if thread_state
-        needle.pull(thread_state)
-      else
-        len = pos(needle) - needle.cursor
-        [needle.push(len)] if len >= 0 and needle.remaining_string.length >= len 
-      end
-    end
-    
-  end
-  
-  class RTab < ParameterizedPattern
-    
-    parameter :pos
-    
-    def __match?(needle, thread_state = nil)
-      if thread_state
-        needle.pull(thread_state)
-      else
-        len = (needle.remaining_string.length - pos(needle)) 
-        [needle.push(len)] if len >= 0 and needle.remaining_string.length >= len
-      end
-    end
-    
-  end
-  
-  class Any < ParameterizedPattern
-    
-    parameter :chars, &:split
-    
-    def __match?(needle, thread_state = nil)
-      if thread_state
-        needle.pull(thread_state)
-      elsif chars(needle).include? needle.remaining_string[0..0]
-        [needle.push(1)]
-      end
-    end
-    
-  end
-  
-  class NotAny < ParameterizedPattern
-    
-    parameter :chars, &:split
-    
-    def __match?(needle, thread_state = nil)
-      if thread_state
-        needle.pull(thread_state)
-      elsif !(chars(needle).include? needle.remaining_string[0..0])
-        [needle.push(1)]
-      end
-    end
-    
-  end  
-  
-  class Span < ParameterizedPattern
-    
-    parameter :chars, &:split
-    
-    def __match?(needle, match_length = nil, thread_state = nil)
-      unless match_length
-        the_chars, match_length = chars(needle), 0
-        while needle.remaining_string.length > match_length and the_chars.include? needle.remaining_string[match_length..match_length]
-          match_length += 1
-        end 
-      end
-      needle.pull(thread_state)
-      if match_length > 0 
-        thread_state = needle.push(match_length)
-        match_length -= 1
-        [match_length, thread_state]
-      end
-    end
-    
-  end
-  
-  class Break < ParameterizedPattern
-    
-    parameter :chars, &:split
-    
-    def __match?(needle, thread_state = nil)
-      if thread_state
-        needle.pull(thread_state)
-      else
-        the_chars, len = chars(needle), 0
-        while needle.remaining_string.length > len and !(the_chars.include? needle.remaining_string[len..len])
-          len += 1
-        end 
-        [needle.push(len)]
-      end 
-    end 
-    
-  end 
-
-  
-  class BreakX < ParameterizedPattern
-    
-    parameter :chars, &:split
-    
-    def __match?(needle, len = 0, thread_state = nil)
-      needle.pull(thread_state)
-      the_chars = chars(needle)
-      while needle.remaining_string.length > len and !(the_chars.include? needle.remaining_string[len..len])
-        len += 1
-      end 
-      [len+1, needle.push(len)] if needle.remaining_string.length >= len
-    end 
-    
-  end   
-  
-  class Arbno < Match
-    
-    def __match?(needle, pattern = nil, s = [[]])
-      return if s.length == 0
-      if pattern
-        existing_captures = needle.captures.dup
-        s[-1] = pattern._match?(needle, *(s.last))
-        s = s[-1] ? s + [[]] : s[0..-2]
-        needle.captures = needle.captures.merge(existing_captures)
-      else
-        if @block
-          pattern = @block.call
-        elsif @name
-          pattern = needle.captures[@name] || ""
-        else
-          pattern = @pattern
-        end
-      end
-      [pattern, s]
-    end 
-    
-  end
-  
-  class FailPat < Pattern
-    
-    def __match?(needle)
-    end 
-    
-  end
-  
-  class Abort < Pattern
-    
-    def __match?(needle)
-      raise MatchFailed
-    end 
-    
-  end
-  
-  class Fence < Match
-    
-    def __match?(needle, on_backtrack = nil)
-      if on_backtrack == :fail_match
-        needle.match_failed = true
-        return nil
-      elsif on_backtrack == :return_nil
-        return nil
-      elsif @block
-        pattern = @block.call
-      elsif @name
-        pattern = needle.captures[@name] || ""
-      elsif @pattern
-        pattern = @pattern
-      else
-        return [:fail_match]
-      end
-      return [:return_nil] if pattern._match?(needle)
-    end 
-    
-  end 
-  
-  class Succeed < Pattern
-    def _match?(needle, thread_state = nil)
-      needle.pull(thread_state)
-      [needle.push(0)]
-    end
-  end
-  
-end
-
-class String
-  
-  include Cannonbol::Operators
-  
-  def __match?(needle, thread_state = nil)
-    if thread_state
-      needle.pull(thread_state)
-    elsif self.length == 0 or 
-          (!needle.ignore_case and needle.remaining_string[0..self.length-1] == self) or 
-          (needle.ignore_case and needle.remaining_string[0..self.length-1].upcase == self.upcase)
-      [needle.push(self.length)]
-    end
-  end
-  
-end
-
-class Regexp
-  
-  include Cannonbol::Operators
-  
-  def __match?(needle, thread_state = nil)
-    if defined? Opal
-      options = ""
-      options += "m" if `#{self}.multiline`
-      options += "g" if `#{self}.global`
-      options += "i" if needle.ignore_case or `#{self}.ignoreCase`
-    else
-      options = self.options | (needle.ignore_case ? Regexp::IGNORECASE : 0)
-    end
-    @cannonbol_regex ||= Regexp.new("^#{self.source}", options )
-    if thread_state
-      needle.pull(thread_state)
-    elsif m = @cannonbol_regex.match(needle.remaining_string)
-      [needle.push(m[0].length)]
-    end
-  end
-  
-end
-
-if defined? Opal
-  
-  class Proc
-    
-    def parameters
-      /.*function[^(]*\(([^)]*)\)/.match(`#{self}.toString()`)[1].split(",").collect { |param| [:req, param.strip.to_sym]}
-    end
-    
-  end 
-  
-end
-
-module Enumerable
-  
-  def match_any
-    if self.first 
-      self[1..-1].inject(self.first) { |memo, item| memo | item }
-    else
-      FAIL
-    end
-  end 
-  
-  def match_all
-    self.inject("") { |memo, item| memo & item }
-  end 
-  
-end
-  
-
-class Object
-    
-  REM = Cannonbol::Rem.new
-  
-  ARB = Cannonbol::Arb.new
-  
-  FAIL = Cannonbol::FailPat.new
-  
-  ABORT = Cannonbol::Abort.new
-  
-  FENCE = Cannonbol::Fence.new
-  
-  SUCCEED = Cannonbol::Succeed.new
-  
-  def LEN(p={}, &block)
-    Cannonbol::Len.new(p, &block)
-  end
-  
-  def POS(p=nil, &block)
-    Cannonbol::Pos.new(p, &block)
-  end  
-  
-  def RPOS(p=nil, &block)
-    Cannonbol::RPos.new(p, &block)
-  end  
-  
-  def TAB(p=nil, &block)
-    Cannonbol::Tab.new(p, &block)
-  end
-  
-  def RTAB(p=nil, &block)
-    Cannonbol::RTab.new(p, &block)
-  end
-  
-  def ANY(p=nil, &block)
-    Cannonbol::Any.new(p, &block)
-  end 
-  
-  def NOTANY(p=nil, &block)
-    Cannonbol::NotAny.new(p, &block)
-  end
-    
-  def SPAN(p=nil, &block)
-    Cannonbol::Span.new(p, &block)
-  end
-     
-  def BREAK(p=nil, &block)
-    Cannonbol::Break.new(p, &block)
-  end 
-  
-  def BREAKX(p=nil, &block)
-    Cannonbol::BreakX.new(p, &block)
-  end 
-   
-  def MATCH(p=nil, &block)
-    Cannonbol::Match.new(p, &block)
-  end 
-   
-  def ARBNO(p=nil, &block)
-    Cannonbol::Arbno.new(p, &block)
-  end  
-  
-  def FENCE(p=nil, &block)
-    Cannonbol::Fence.new(p, &block)
-  end
-  
 end