regparsec 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg/*

data/README.rdoc

@@ -0,0 +1,28 @@
+= RegParsec
+
+This be development version yet.
+
+== Installation
+
+  $ git clone git@github.com:pasberth/RegParsec.git
+  $ cd RegParsec
+  $ gem build regparsec.gemspec
+  $ gem install regparsec-0.1.0.gem
+  
+== Try RegParsec
+
+  $ irb
+
+  require 'regparsec'
+  # => true 
+  StringParser = RegParsec::Regparsers.between('"', '"', /(?:(?:\\\")|[^"])*/)
+  StringParser.parse('"this is a string"')
+  # => #<MatchData "this is a string"> 
+  StringParser.parse('"can escape the \" !"')
+  # => #<MatchData "can escape the \\\" !"> 
+
+== Result hook
+
+  StringParser = RegParsec::Regparsers.between('"', '"', /(?:(?:\\\")|[^"])*/) { |match_data| "Result: " + match_data[0] }
+  StringParser.parse('"Success!"')
+  # => "Result: Success!" 

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/string_parser.rb

@@ -0,0 +1,24 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'regparsec'
+
+StringParser = RegParsec::Regparsers.between('"', '"', /(?:(?:\\\")|[^"])*/)
+p StringParser.parse('"this is a string"')
+# => #<MatchData "this is a string"> 
+p StringParser.parse('"can escape the \" !"')
+# => #<MatchData "can escape the \\\" !"> 
+
+QuoteParser = RegParsec::Regparsers.instance_eval do
+  between(
+    apply('q', update_state(:quotation_mark, apply(/./) { |q| q[0].to_s })),
+    ->(state) { apply( state.quotation_mark ) },
+    ->(state) {
+      q = Regexp.quote( state.quotation_mark )  # "\"" => "\\\""
+      apply( /(?:(?:\\#{ q })|[^#{ q }])*/ )    # /(?:(?:\\\")|[^"])*/
+    }
+  ) { |body| body[0].to_s }
+end
+
+p QuoteParser.parse('q"the double quotation!"')
+# => "the double quotation!"
+p QuoteParser.parse('q# the quotation by number marks! #')
+# => " the quotation by number marks! "

data/lib/regparsec.rb

@@ -0,0 +1,13 @@
+require 'give4each'
+
+module RegParsec
+  
+  require 'regparsec/state_attributes'
+  require 'regparsec/result'
+  require 'regparsec/regparser_helpers'
+  require 'regparsec/regparseable'
+  require 'regparsec/regparsers'
+  require 'regparsec/regular_object'
+  require 'regparsec/regparser_delegator'
+  require 'regparsec/regparser'
+end

data/lib/regparsec/parser/base.rb

@@ -0,0 +1,9 @@
+require 'regparsec'
+require 'regparsec/regparsers'
+
+class RegParsec::Regparsers::Base
+  
+  include RegParsec
+  include RegParsec::RegparserHelpers
+  include RegParsec::Regparseable
+end

data/lib/regparsec/parser/combinators.rb

@@ -0,0 +1,139 @@
+module RegParsec::Regparsers
+
+  [ [:try, :TryParser],
+    [:apply, :ApplyParser],
+    [:many, :ManyParser],
+    [:many1, :Many1Parser],
+    [:between, :BetweenParser],
+    [:one_of, :OneOfParser]
+  ].each do |method, klass|
+    module_eval(<<-DEF)
+      def #{method}(*args, &result_hook)
+        regparser = ::RegParsec::Regparsers::#{klass}.new.curry!(*args)
+        regparser.result_hook!(&result_hook) if result_hook
+        regparser
+      end
+    DEF
+  end
+end
+
+module RegParsec::Regparsers
+
+class TryParser < Base
+  
+  def __regparse__ state, doing
+    commit = state.commit!
+    case result = doing.regparse(state)
+    when Result::Success, Result::Valid
+      state.commit!
+      result
+    else
+      state.commit! commit
+      result
+    end
+  end
+end
+
+class ApplyParser < Base
+
+  def __regparse__ state, *regparsers
+    consumed = ''
+    list = []
+    valid = false
+    regparsers.each do |regp|
+      result = regp.regparse(state)
+      case result
+      when Result::Success, Result::Valid
+        consumed << result.matching_string
+        list << result.return_value
+        valid = result.is_a? Result::Valid
+      when Result::Accepted
+        consumed << result.matching_string
+        list << result.return_value
+        return Result::Accepted.new( :return_value => list, :matching_string => consumed )
+      when Result::Invalid
+        return Result::Invalid.new
+      end
+    end
+    
+    valid ?
+      Result::Valid.new( :return_value => list , :matching_string => consumed ) :
+      Result::Success.new( :return_value => list , :matching_string => consumed )
+  end
+end
+
+class ManyParser < Base
+  
+  def __regparse__ state, doing
+    consumed = ''
+    valid = false
+    list = [].tap do |list|
+      while result = try(doing).regparse(state)
+        case result
+        when Result::Success, Result::Valid then 
+          consumed << result.matching_string
+          list << result.return_value
+          valid = result.is_a? Result::Valid
+        when Result::Accepted then
+          return Result::Valid.new( :return_value => list, :matching_string => consumed )
+        when Result::Invalid then
+          break
+        end
+      end
+    end
+
+    valid ?
+      Result::Valid.new( :return_value => list , :matching_string => consumed ) :
+      Result::Success.new( :return_value => list , :matching_string => consumed )
+  end
+end
+
+class Many1Parser < Base
+  
+  def __regparse__ state, doing
+    case head = try(doing).regparse(state)
+    when Result::Invalid then head
+    when Result::Accepted then head
+    when Result::Success, Result::Valid
+      result = many(doing).regparse(state)
+      if result.return_value.empty? and head.is_a? Result::Valid or result.is_a? Result::Valid then
+        Result::Valid.new( :return_value => [head.return_value, *result.return_value], :matching_string => head.matching_string + result.matching_string )
+      elsif result.is_a? Result::Success then
+        Result::Success.new( :return_value => [head.return_value, *result.return_value], :matching_string => head.matching_string + result.matching_string )
+    # when Result::Accepted
+    # when Result::Invalid
+      end
+    end
+  end
+end
+
+class BetweenParser < Base
+  
+  def __regparse__ state, open, close, body
+    case result = apply(open, body, close).regparse(state)
+    when Result::Success
+      Result::Success.new( :return_value => result.return_value[1], :matching_string => result.matching_string )
+    when Result::Valid
+      Result::Valid.new( :return_value => result.return_value[1], :matching_string => result.matching_string )
+    when Result::Accepted
+      Result::Accepted.new( :return_value => result.return_value[1], :matching_string => result.matching_string )
+    else
+      result
+    end
+  end
+end
+
+class OneOfParser < Base
+  
+  def __regparse__ state, *choices
+    accepted = nil
+    choices.any? do |a|
+      case result = try(a).regparse(state)
+      when Result::Success, Result::Valid then return result
+      when Result::Accepted then accepted ||= result; false
+      else false
+      end
+    end or accepted or Result::Invalid.new
+  end
+end
+end

data/lib/regparsec/parser/primary_parsers.rb

@@ -0,0 +1,90 @@
+require 'regparsec/regparsers'
+
+class String
+  
+  def to_regparser
+    ::RegParsec::Regparsers::StringParser.well_defined_parser_get(self)
+  end
+end
+
+class Regexp
+  
+  def to_regparser
+    ::RegParsec::Regparsers::RegexpParser.well_defined_parser_get(self)
+  end
+end
+
+class Proc
+  
+  def to_regparser
+    ::RegParsec::Regparsers::ProcParser.new.curry!(self)
+  end
+end
+
+class RegParsec::Regparsers::StringParser < RegParsec::Regparsers::Base
+  
+  def self.well_defined_parser_get str
+    (@_well_defined_parsers ||= {})[str] ||= new.curry!(str)
+  end
+  
+  def format_args expecting, *args
+    [expecting, *args]
+  end
+
+  def __regparse__ state, expecting
+    if state.input[0, expecting.length] == expecting
+      state.input.sub!(expecting, '')
+      Result::Success.new( :return_value => expecting, :matching_string => expecting )
+    elsif expecting[0, state.input.length] == state.input
+      Result::Accepted.new( :return_value => state.input, :matching_string => state.input )
+    else
+      Result::Invalid.new( :return_value => nil )
+    end
+  end
+end
+
+class RegParsec::Regparsers::RegexpParser < RegParsec::Regparsers::Base
+  
+  def self.well_defined_parser_get regexp
+    (@_well_defined_parsers ||= {})[regexp] ||= new.curry!(regexp)
+  end
+  
+  def format_args expecting, *args
+    [expecting, *args]
+  end
+
+  def __regparse__ state, regexp
+    case state.input                                       # case "abc;def;"
+    when /\A#{regexp}\z/                                   # when /\A(.*?);\z/
+      md = $~; md[0] =~ /\A#{regexp}/                      #   "abc;def;" =~ /\A(.*?);/
+      if $~[0] != md[0]                                    #   if "abc;" != "abc;def;"
+        md = $~
+        state.input.sub!(md[0], '')
+        Result::Success.new( :return_value => md,
+                             :matching_string => md[0] )
+      else
+        state.input.sub!(md[0], '')
+        Result::Valid.new( :return_value => md,
+                              :matching_string => md[0] )
+      end
+    when /\A#{regexp}/
+      md = $~
+      state.input.sub!(md[0], '')
+      Result::Success.new( :return_value => md,
+                           :matching_string => md[0] )
+    else
+      Result::Invalid.new( :return_value => nil )
+    end
+  end
+end
+
+class RegParsec::Regparsers::ProcParser < RegParsec::Regparsers::Base
+  
+  def format_args proc, *args
+    [proc, *args]
+  end
+
+  def __regparse__ state, proc
+    try_convert_into_regparser!( proc.call(state) ).regparse( state )
+  end
+end

data/lib/regparsec/parser/state.rb

@@ -0,0 +1,51 @@
+require 'regparsec/regparsers'
+
+module RegParsec::Regparsers
+
+
+  [ [:update_state, :UpdateStateParser],
+    [:give_state, :GiveStateParser]
+  ].each do |method, klass|
+    module_eval(<<-DEF)
+      def #{method}(*args, &result_hook)
+        regparser = ::RegParsec::Regparsers::#{klass}.new.curry!(*args)
+        regparser.result_hook!(&result_hook) if result_hook
+        regparser
+      end
+    DEF
+  end
+end
+
+class RegParsec::Regparsers::UpdateStateParser < RegParsec::Regparsers::Base
+  
+  def format_args *args
+    [ args[0].to_sym,
+      try_convert_into_regparser!(args[1]),
+      *args[2..-1]
+    ]
+  end
+
+  def __regparse__ state, binding_variable, regparser
+    case result = regparser.regparse( state )
+    when Result::Success
+      state.merge!(binding_variable => result.return_value)
+      result
+    else
+      result
+    end
+  end
+end
+
+class RegParsec::Regparsers::GiveStateParser < RegParsec::Regparsers::Base
+  
+  def format_args *args
+    [ args[0].to_sym,
+      try_convert_into_regparser!(args[1]),
+      *args[2..-1]
+    ]
+  end
+
+  def __regparse__ state, binding_variable, regparser
+    regparser.curry( state[binding_variable] ).regparse( state )
+  end
+end

data/lib/regparsec/regparseable.rb

@@ -0,0 +1,86 @@
+require 'regparsec'
+
+module RegParsec::Regparseable
+  
+  [ :regparse, :parse ].each do |method|
+    class_eval(<<-DEFINE)
+      def __#{method}__(*args, &block)
+        raise NotImplementedError, "need to define `#{method}'"
+      end
+    DEFINE
+  end
+
+  def regparse state
+    result = __regparse__ ::RegParsec::RegparserHelpers.build_state_attributes(state), *format_args(*curried_args)
+    case result
+    when ::RegParsec::Result::Success, ::RegParsec::Result::Valid
+      result.return_value = result_hooks.inject(result.return_value) { |r, hook| hook.call(r) }
+    end
+    result
+  end
+  
+  def parse state
+    __parse__ ::RegParsec::RegparserHelpers.build_state_attributes(state), *format_args(*curried_args)
+  end
+
+  def __parse__ state, *args
+    case result = regparse(state)
+    when ::RegParsec::Result::Success, ::RegParsec::Result::Valid
+      result.return_value
+    else
+      nil
+    end
+  end
+
+  def format_args *args
+    args.map &:try_convert_into_regparser!.in(::RegParsec::RegparserHelpers)
+  end
+  
+  def result_hook &block
+    clone.result_hook! &block
+  end
+
+  def result_hook! &hook
+    result_hooks << hook || raise(ArgumentError, "tried to put a result hook without a block.")
+  end
+  
+  def curry! *args, &block
+    args.each &:push.to(curried_args)
+    # TODO: How will using to the block
+    # result_procs << result_proc if result_procs.empty? and result_proc
+    self
+  end
+  
+  def curry *args, &block
+    clone.curry! *args, &block
+  end
+  
+  def clone
+    cln = super
+    cln.curried_args = curried_args.clone
+    cln.result_hooks = result_hooks.clone
+    cln
+  end
+  
+  def to_regparser
+    self
+  end
+
+  protected
+
+    def curried_args= a
+      @_curried_args = a
+    end
+
+    def curried_args
+      @_curried_args ||= []
+    end
+  
+    def result_hooks= a
+      @_result_hooks = a
+    end
+
+    def result_hooks
+      @_result_hooks ||= []
+    end
+end

data/lib/regparsec/regparser.rb

@@ -0,0 +1,49 @@
+require 'regparsec'
+require 'stringio'
+
+class RegParsec::Regparser
+  include RegParsec
+  include RegParsec::Regparseable
+  
+  def initialize regparser
+    @regparser = ::RegParsec::RegparserHelpers.try_convert_into_regparser!(regparser)
+  end
+
+  def __regparse__ state
+    consumed = ''
+    case state.input
+    when String
+      input = StringIO.new(state.input)
+    else
+      input = state.input
+    end
+    
+    return_value = [].tap do |list|
+      state.input = ""
+      state.commit!
+      while line = input.gets or !state.input.empty?
+        state.input << line if line
+        commit = state.commit!
+        case result = @regparser.regparse(state)
+        when Result::Success then
+          state.commit!
+          consumed << result.matching_string
+          list << result.return_value
+        when Result::Valid
+          (state.commit!(commit); next) if line
+          state.commit!
+          consumed << result.matching_string
+          list << result.return_value
+        when Result::Accepted then line ? (state.commit!(commit); next) : break
+        when Result::Invalid then state.commit!(commit); break
+        end
+      end
+    end
+    
+    if return_value.empty?
+      Result::Invalid.new
+    else
+      Result::Success.new :return_value => return_value, :matching_string => consumed
+    end
+  end
+end

data/lib/regparsec/regparser_delegator.rb

@@ -0,0 +1,39 @@
+require 'regparsec'
+
+module RegParsec::RegparserDelegatable
+  
+  include ::RegParsec::Regparseable
+
+  def regular_object
+    @_regparser_regobj ||= ::RegParsec::RegparserHelpers.try_convert_into_regparser!(__build_regparser__)
+  end
+  
+  def __build_regparser__
+    raise NotImplementedError, "need to define `__build_regparser__'"
+  end
+  
+  def format_args *args
+    args
+  end
+  
+  def __regparse__ *args, &block
+    regular_object.regparse *args, &block
+  end
+  
+  def __parse__ *args, &block
+    regular_object.parse *args, &block
+  end
+end
+
+class RegParsec::RegparserDelegator
+
+  include ::RegParsec::RegparserDelegatable
+  
+  def initialize regparser
+    @_regparser_regobj = ::RegParsec::RegparserHelpers.try_convert_into_regparser!(regparser)
+  end
+  
+  def __build_regparser__
+    @_regparser_regobj
+  end
+end

data/lib/regparsec/regparser_helpers.rb

@@ -0,0 +1,22 @@
+require 'regparsec'
+
+module RegParsec::RegparserHelpers
+
+  extend self
+
+  def try_convert_into_regparser! regobj
+    if regobj.respond_to? :to_regparser
+      regobj.to_regparser
+    else
+      raise TypeError, "Can't convert #{regobj.class} into Regparser"
+    end
+  end
+  
+  def build_state_attributes state
+    case state
+    when ::RegParsec::StateAttributes then state
+    when String then ::RegParsec::StateAttributes.new :input => state
+    when Hash then ::RegParsec::StateAttributes.new state
+    end
+  end
+end

data/lib/regparsec/regparsers.rb

@@ -0,0 +1,18 @@
+require 'regparsec'
+require 'regparsec/regparseable'
+
+module RegParsec
+
+  module Regparsers
+    extend self
+  end
+  
+  module Regparseable
+    include Regparsers
+  end
+end
+
+require 'regparsec/parser/base'
+require 'regparsec/parser/state'
+require 'regparsec/parser/primary_parsers'
+require 'regparsec/parser/combinators'

data/lib/regparsec/regular_object.rb

@@ -0,0 +1,16 @@
+require 'regparsec'
+
+class RegParsec::RegularObject < RegParsec::Regparsers::Base
+
+  def initialize
+    @regparsers = []
+  end
+  
+  def concat regparser
+    @regparsers << try_convert_into_regparser!(regparser)
+  end
+
+  def __regparse__ state
+    return apply( *@regparsers ).regparse state
+  end
+end

data/lib/regparsec/result.rb

@@ -0,0 +1,40 @@
+require 'regparsec'
+
+class RegParsec::Result
+  
+  include RegParsec
+  attr_accessor :return_value
+
+  def initialize informations={}
+    informations.each { |key, val| send(:"#{key}=", val) }
+    @information_keys = informations.each_key.to_a
+  end
+  
+  def == other
+    self.class == other.class and @information_keys.all? do |key|
+      send(key) == other.send(key)
+    end
+  rescue NoMethodError
+    false
+  end
+
+  # apply("string").regparse("string") # => Success
+  class Success < Result
+    attr_accessor :matching_string
+  end
+  
+  # apply(/\d+/).regparse("123") # => Valid
+  # apply(/\d+/).regparse("123 ") # => Success
+  class Valid < Result
+    attr_accessor :matching_string
+  end
+
+  # apply("string").regparse("str") # => Accepted
+  class Accepted < Result
+    attr_accessor :matching_string
+  end
+
+  # apply("string").regparse("invalid") # => Invalid
+  class Invalid < Result
+  end
+end

data/lib/regparsec/state_attributes.rb

@@ -0,0 +1,78 @@
+module RegParsec::StateAttributesHelpers
+  
+  def try_convert_into_state_attributes! attributes
+    case attributes
+    when ::RegParsec::StateAttributes then attributes
+    when ::Hash then ::RegParsec::StateAttributes.new(attributes)
+    else raise TypeError, "Can't convert #{attributes.class} into RegParsec::StateAttributes"
+    end
+  end
+end
+
+class RegParsec::StateAttributes
+  
+  def initialize attributes={}
+    commit! attributes
+  end
+  
+  def [] *args, &block
+    @head.send :[], *args, &block
+  end
+  
+  def []= *args, &block
+    @head.send :[]=, *args, &block
+  end
+  
+  def method_missing f, *args, &block
+    if f.to_s =~ /^(.*?)(\=)?$/ and @head.keys.map(&:to_sym).include? $1.to_sym or $2
+      send :"[]#{$2}", $1.to_sym, *args, &block
+    else
+      super
+    end
+  end
+  
+  def checkout! commit
+    @head = Hash[*commit.map { |key, val| [key, (val.clone rescue val)] }.flatten(1)]
+  end
+
+  def backdate!
+    checkout! commits.pop
+  end
+  
+  def refresh!
+    checkout! commits.last
+  end
+
+  def commit! commit = @head
+    commits << commit
+    refresh!
+  end
+  
+  def merge! commit
+    checkout! merge commit
+  end
+
+  protected
+  
+    def head
+      @head
+    end
+    
+    def updated_commit
+      commits.last
+    end
+
+  private
+
+    def commits
+      @commits ||= []
+    end
+
+    def merge commit
+      commit = case commit
+               when ::RegParsec::StateAttributes then commit.updated_commit
+               when Hash then commit
+               end
+      @head.merge(commit)
+    end
+end

data/regparsec.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "regparsec"
+  s.version = File.read("VERSION")
+  s.authors = ["pasberth"]
+  s.description = %{A parsing library}
+  s.summary = %q{}
+  s.email = "pasberth@gmail.com"
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.homepage = "http://github.com/pasberth/RegParsec"
+  s.require_paths = ["lib"]
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- spec/*`.split("\n")
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+end

data/spec/delegation_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class ExampleDelegation
+    
+  include ::RegParsec::RegparserDelegatable
+
+  def __build_regparser__
+    apply("abc", "def")
+  end
+end
+  
+describe ExampleDelegation do
+  
+  example { subject.parse("abc").should == nil }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", ""], :matching_string => "abc" ) }
+  example { subject.parse("a").should == nil }
+  example { subject.regparse("a").should == ::RegParsec::Result::Accepted.new( :return_value => ["a"], :matching_string => "a" ) }
+  example { subject.parse("abcd").should == nil }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", "d"], :matching_string => "abcd" ) }
+  example { subject.regparse("abcdef").should == ::RegParsec::Result::Success.new( :return_value => ["abc", "def"], :matching_string => "abcdef" ) }
+  example { subject.parse("abcdef").should == ["abc", "def"] }
+  example { subject.regparse("def").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("def").should == nil }
+end

data/spec/regparser_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ::RegParsec::Regparser do
+  subject { described_class.new("abc") }
+
+  example { subject.parse("abc").should == ["abc"] }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Success.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("abcabc").should == ["abc", "abc"] }
+  example { subject.regparse("abcabc").should == ::RegParsec::Result::Success.new( :return_value => ["abc", "abc"], :matching_string => "abcabc" ) }
+  example { subject.parse("def").should be_nil }
+  example { subject.regparse("def").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("abcdef").should == ["abc"] }
+  example { subject.regparse("abcdef").should == ::RegParsec::Result::Success.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("abcab").should == ["abc"] }
+  example { subject.regparse("abcab").should == ::RegParsec::Result::Success.new( :return_value => ["abc"], :matching_string => "abc" ) }
+end

data/spec/regparsers/apply_parser_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::ApplyParser do
+  
+  subject { described_class.new.curry!("abc", "def") }
+
+  example { subject.parse("abc").should be_nil }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", ""], :matching_string => "abc" ) }
+  example { subject.parse("a").should be_nil }
+  example { subject.regparse("a").should == ::RegParsec::Result::Accepted.new( :return_value => ["a"], :matching_string => "a" ) }
+  example { subject.parse("abcd").should be_nil }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", "d"], :matching_string => "abcd" ) }
+  example { subject.regparse("abcdef").should == ::RegParsec::Result::Success.new( :return_value => ["abc", "def"], :matching_string => "abcdef" ) }
+  example { subject.parse("abcdef").should == ["abc", "def"] }
+  example { subject.regparse("def").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("def").should be_nil }
+
+  context "valid input" do
+    subject { described_class.new.curry!(/.*/) }
+    example { subject.parse("abc").should_not be_nil }
+    example { subject.regparse("abc").should be_is_a ::RegParsec::Result::Valid }
+    example { subject.parse("abc\n").should_not be_nil }
+    example { subject.regparse("abc\n").should be_is_a ::RegParsec::Result::Success }
+  end
+end

data/spec/regparsers/between_parser_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::BetweenParser do
+  
+  subject { described_class.new.curry!('"', '"', "abc") }
+
+  example { subject.parse(%q_"abc"_).should == "abc" }
+  example { subject.regparse(%q_"abc"_).should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => %q_"abc"_ ) }
+  example { subject.parse(%q_"abc" "abc"_).should == "abc" }
+  example { subject.regparse(%q_"abc" "abc"_).should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => %q_"abc"_ ) }
+  example { subject.parse(%q_"a"_).should == nil }
+  example { subject.regparse(%q_"a"_).should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse(%q_"abcd"_).should == nil }
+  example { subject.regparse(%q_"abcd"_).should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("abc").should == nil }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse(%q_abc"_).should == nil }
+  example { subject.regparse(%q_abc"_).should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse(%q_"abc_).should == nil }
+  example { subject.regparse(%q_"abc_).should == ::RegParsec::Result::Accepted.new( :return_value => "abc", :matching_string => %q_"abc_) }
+end

data/spec/regparsers/give_state_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe ::RegParsec::Regparsers::GiveStateParser do
+  subject { described_class.new.curry(:x, ::RegParsec::Regparsers.apply) }
+
+  example { subject.parse( :input => 'abc', :x => 'abc' ).should == ["abc"] }
+  example { subject.regparse( :input => 'abc', :x => 'abc' ).should == ::RegParsec::Result::Success.new( :return_value => ['abc'], :matching_string => 'abc' ) }
+  example { subject.parse( :input => 'def', :x => 'abc' ).should be_nil }
+  example { subject.regparse( :input => 'def', :x => 'abc' ).should == ::RegParsec::Result::Invalid.new }
+end

data/spec/regparsers/many1_parser_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::Many1Parser do
+  subject { described_class.new.curry!("abc") }
+
+  example { subject.parse("abc").should == ["abc"] }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Valid.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("a").should be_nil }
+  example { subject.regparse("a").should == ::RegParsec::Result::Accepted.new( :return_value => "a", :matching_string => "a" ) }
+  example { subject.parse("abca").should == ["abc"] }
+  example { subject.regparse("abca").should == ::RegParsec::Result::Valid.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("d").should be_nil }
+  example { subject.regparse("d").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("abcd").should == ["abc"] }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Success.new( :return_value => ["abc"], :matching_string => "abc" ) }
+end

data/spec/regparsers/many_parser_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::ManyParser do
+  subject { described_class.new.curry!("abc") }
+
+  example { subject.parse("abc").should == ["abc"] }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Valid.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("a").should == [] }
+  example { subject.regparse("a").should == ::RegParsec::Result::Valid.new( :return_value => [], :matching_string => "" ) }
+  example { subject.parse("abca").should == ["abc"] }
+  example { subject.regparse("abca").should == ::RegParsec::Result::Valid.new( :return_value => ["abc"], :matching_string => "abc" ) }
+  example { subject.parse("d").should == [] }
+  example { subject.regparse("d").should == ::RegParsec::Result::Success.new( :return_value => [], :matching_string => "" ) }
+  example { subject.parse("abcd").should == ["abc"] }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Success.new( :return_value => ["abc"], :matching_string => "abc" ) }
+end

data/spec/regparsers/one_of_parser_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::OneOfParser do
+  subject { described_class.new.curry!("abc", "def") }
+
+  example { subject.parse("abc").should == "abc" }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => "abc" ) }
+  example { subject.parse("a").should == nil }
+  example { subject.regparse("a").should == ::RegParsec::Result::Accepted.new( :return_value => "a", :matching_string => "a" ) }
+  example { subject.parse("def").should == "def" }
+  example { subject.regparse("def").should == ::RegParsec::Result::Success.new( :return_value => "def", :matching_string => "def" ) }
+  example { subject.parse("d").should == nil }
+  example { subject.regparse("d").should == ::RegParsec::Result::Accepted.new( :return_value => "d", :matching_string => "d" ) }
+  example { subject.regparse("abcdef").should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => "abc" ) }
+  example { subject.parse("abcdef").should == "abc" }
+  example { subject.regparse("defabc").should == ::RegParsec::Result::Success.new( :return_value => "def", :matching_string => "def" ) }
+  example { subject.parse("defabc").should == "def" }
+end

data/spec/regparsers/regexp_parser_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::RegexpParser do
+  
+  context ' /(.*?);/ case ' do
+    subject { described_class.new.curry!(/(.*?);/) }
+
+    example { subject.parse("abc").should be_nil }
+    example { subject.regparse("abc").should be_is_a ::RegParsec::Result::Invalid }
+    example { subject.parse("abc;")[0].should == "abc;" }
+    example { subject.parse("abc;")[1].should == "abc" }
+    example { subject.regparse("abc;").should be_is_a ::RegParsec::Result::Valid }
+    example { subject.parse("abc;def;")[0].should == "abc;" }
+    example { subject.parse("abc;def;")[1].should == "abc" }
+    example { subject.regparse("abc;def;").should be_is_a ::RegParsec::Result::Success }
+  end
+  
+  context ' /./ case ' do
+    subject { described_class.new.curry!(/./) }
+
+    example { subject.parse("a")[0].should == "a" }
+    example { subject.regparse("a").should be_is_a ::RegParsec::Result::Valid }
+    example { subject.parse("ab")[0].should == "a" }
+    example { subject.regparse("ab").should be_is_a ::RegParsec::Result::Success }
+    example { subject.parse("").should be_nil }
+    example { subject.regparse("").should be_is_a ::RegParsec::Result::Invalid }
+  end
+  
+  context ' /.*/ case ' do
+    subject { described_class.new.curry!(/.*/) }
+
+    example { subject.parse("abc")[0].should == "abc" }
+    example { subject.regparse("abc").should be_is_a ::RegParsec::Result::Valid }
+    example { subject.parse("abc\n")[0].should == "abc" }
+    example { subject.regparse("abc\n").should be_is_a ::RegParsec::Result::Success }
+    example { subject.parse("abc\ndef")[0].should == "abc" }
+    example { subject.regparse("abc\ndef").should be_is_a ::RegParsec::Result::Success }
+    example { subject.parse("abc\ndef\n")[0].should == "abc" }
+    example { subject.regparse("abc\ndef\n").should be_is_a ::RegParsec::Result::Success }
+  end
+  
+  context ' /#(.*)\n/ case ' do
+    subject { described_class.new.curry!(/\#(.*?)\n/) }
+
+    example { subject.parse("abc").should be_nil }
+    example { subject.regparse("abc").should be_is_a ::RegParsec::Result::Invalid }
+
+    example { subject.parse("# abc\n")[0].should == "# abc\n" }
+    example { subject.parse("# abc\n")[1].should == " abc" }
+    example { subject.regparse("# abc\n").should be_is_a ::RegParsec::Result::Valid }
+
+    example { subject.parse("# abc\n def")[0].should == "# abc\n" }
+    example { subject.parse("# abc\n def")[1].should == " abc" }
+    example { subject.regparse("# abc\n def").should be_is_a ::RegParsec::Result::Success }
+  end
+  
+  context ' /#(.*)\n+/ case ' do
+    subject { described_class.new.curry!(/\#(.*?)\n+/) }
+
+    example { subject.parse("abc").should be_nil }
+    example { subject.regparse("abc").should be_is_a ::RegParsec::Result::Invalid }
+
+    example { subject.parse("# abc\n")[0].should == "# abc\n" }
+    example { subject.parse("# abc\n")[1].should == " abc" }
+    example { subject.regparse("# abc\n").should be_is_a ::RegParsec::Result::Valid }
+
+    example { subject.parse("# abc\n def")[0].should == "# abc\n" }
+    example { subject.parse("# abc\n def")[1].should == " abc" }
+    example { subject.regparse("# abc\n def").should be_is_a ::RegParsec::Result::Success }
+
+    example { subject.parse("# abc\n\n\n")[0].should == "# abc\n\n\n" }
+    example { subject.parse("# abc\n\n\n")[1].should == " abc" }
+    example { subject.regparse("# abc\n\n\n").should be_is_a ::RegParsec::Result::Valid }
+
+    example { subject.parse("# abc\n\n\n def")[0].should == "# abc\n\n\n" }
+    example { subject.parse("# abc\n\n\n def")[1].should == " abc" }
+    example { subject.regparse("# abc\n\n\n def").should be_is_a ::RegParsec::Result::Success }
+  end
+end

data/spec/regparsers/string_parser_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe RegParsec::Regparsers::StringParser do
+  
+  subject { described_class.new.curry!("abc") }
+
+  example { subject.parse("abc").should == "abc" }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => "abc" ) }
+  example { subject.parse("ab").should be_nil }
+  example { subject.regparse("ab").should == ::RegParsec::Result::Accepted.new( :return_value => "ab", :matching_string => "ab" ) }
+  example { subject.parse("abcd").should == "abc" }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Success.new( :return_value => "abc", :matching_string => "abc" ) }
+  example { subject.parse("d").should be_nil }
+  example { subject.regparse("d").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("abd").should be_nil }
+  example { subject.regparse("abd").should == ::RegParsec::Result::Invalid.new }
+end

data/spec/regparsers/update_state_parser_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ::RegParsec::Regparsers::UpdateStateParser do
+  subject { described_class.new.curry(:x, "abc") }
+  let(:state) { ::RegParsec::StateAttributes.new( :x => '' ) }
+
+  example do
+    state.input = "abc"
+    subject.parse( state )
+    state.x.should == "abc"
+  end
+
+  example do
+    state.input = "def"
+    subject.parse( state )
+    state.x.should == ''
+  end
+end

data/spec/regparsers_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/result_hook_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "result hook" do
+  subject { ::RegParsec::Regparsers.apply("abc", "def") { |list| list.join ', ' } }
+
+  example { subject.parse("abc").should == nil }
+  example { subject.regparse("abc").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", ""], :matching_string => "abc" ) }
+  example { subject.parse("a").should == nil }
+  example { subject.regparse("a").should == ::RegParsec::Result::Accepted.new( :return_value => ["a"], :matching_string => "a" ) }
+  example { subject.parse("abcd").should == nil }
+  example { subject.regparse("abcd").should == ::RegParsec::Result::Accepted.new( :return_value => ["abc", "d"], :matching_string => "abcd" ) }
+  example { subject.regparse("abcdef").should == ::RegParsec::Result::Success.new( :return_value => "abc, def", :matching_string => "abcdef" ) }
+  example { subject.parse("abcdef").should == "abc, def" }
+  example { subject.regparse("def").should == ::RegParsec::Result::Invalid.new }
+  example { subject.parse("def").should == nil }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'regparsec'

data/spec/state_attributes_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ::RegParsec::StateAttributes do
+  
+  context "Getting and Setting to the :x" do
+
+    subject { described_class.new(:x => 0) }
+
+    example { subject[:x].should == 0 }
+    example { subject[:x] = 1; subject[:x].should == 1 }
+    example { subject[:y].should be_nil }
+    example { subject[:y] = 1; subject[:y].should == 1 }
+
+    example { expect { subject.x }.should_not raise_error NoMethodError }
+    example { expect { subject.x = 0 }.should_not raise_error NoMethodError }
+    example { expect { subject.y }.should raise_error NoMethodError }
+    example { expect { subject.y = 0 }.should_not raise_error NoMethodError }
+    example { subject.y = 1; expect { subject.y }.should_not raise_error NoMethodError }
+
+    example { subject.x.should == 0 }
+    example { subject.x = 1; subject.x.should == 1 }
+    example { subject.y = 1; subject.y.should == 1 }
+  end
+
+  context "Substitute and Refresh" do
+
+    subject { described_class.new(:x => 0) }
+
+    example { subject.x == 0 } 
+    example { subject.x = 1; subject.x == 1 }
+
+    example { subject.x = 1; subject.refresh!; subject.x == 0 } 
+    example { subject.x = 1; subject.refresh!; subject.commit!; subject.x == 0 } 
+
+    example { subject.x = 1; subject.commit!; subject.x == 1 } 
+    example { subject.x = 1; subject.commit!; subject.refresh!; subject.x == 1 } 
+
+    example { subject.x = 1; subject.commit!; subject.backdate!; subject.x == 1 }
+    example { subject.x = 1; subject.commit!; subject.backdate!; subject.refresh!; subject.x == 0  }
+    
+    example { subject.merge!(:x => 1); subject.x == 1 }
+    example { subject.merge!(:x => 1); subject.refresh!; subject.x == 0 }
+  end
+
+  context "Destructive change and Refresh" do
+    
+    subject { described_class.new(:x => 'a') }
+
+    example { subject.x == 'a' } 
+    example { subject.x << 'b'; subject.x == 'ab' }
+
+    example { subject.x << 'b'; subject.refresh!; subject.x == 'a' } 
+    example { subject.x << 'b'; subject.refresh!; subject.commit!; subject.x == 'a' } 
+
+    example { subject.x << 'b'; subject.commit!; subject.x == 'ab' } 
+    example { subject.x << 'b'; subject.commit!; subject.refresh!; subject.x == 'ab' } 
+
+    example { subject.x << 'b'; subject.commit!; subject.backdate!; subject.x == 'ab' }
+    example { subject.x << 'b'; subject.commit!; subject.backdate!; subject.refresh!; subject.x == 'a'  }
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: regparsec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- pasberth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-24 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70325019159360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325019159360
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70325019158340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325019158340
+description: A parsing library
+email: pasberth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- .gitignore
+- README.rdoc
+- VERSION
+- examples/string_parser.rb
+- lib/regparsec.rb
+- lib/regparsec/parser/base.rb
+- lib/regparsec/parser/combinators.rb
+- lib/regparsec/parser/primary_parsers.rb
+- lib/regparsec/parser/state.rb
+- lib/regparsec/regparseable.rb
+- lib/regparsec/regparser.rb
+- lib/regparsec/regparser_delegator.rb
+- lib/regparsec/regparser_helpers.rb
+- lib/regparsec/regparsers.rb
+- lib/regparsec/regular_object.rb
+- lib/regparsec/result.rb
+- lib/regparsec/result/accepted.rb
+- lib/regparsec/result/invalid.rb
+- lib/regparsec/result/success.rb
+- lib/regparsec/state_attributes.rb
+- regparsec.gemspec
+- spec/delegation_spec.rb
+- spec/regparser_spec.rb
+- spec/regparsers/apply_parser_spec.rb
+- spec/regparsers/between_parser_spec.rb
+- spec/regparsers/give_state_spec.rb
+- spec/regparsers/many1_parser_spec.rb
+- spec/regparsers/many_parser_spec.rb
+- spec/regparsers/one_of_parser_spec.rb
+- spec/regparsers/regexp_parser_spec.rb
+- spec/regparsers/string_parser_spec.rb
+- spec/regparsers/try_parser_spec.rb
+- spec/regparsers/update_state_parser_spec.rb
+- spec/regparsers_spec.rb
+- spec/result_hook_spec.rb
+- spec/spec_helper.rb
+- spec/state_attributes_spec.rb
+homepage: http://github.com/pasberth/RegParsec
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/delegation_spec.rb
+- spec/regparser_spec.rb
+- spec/regparsers/apply_parser_spec.rb
+- spec/regparsers/between_parser_spec.rb
+- spec/regparsers/give_state_spec.rb
+- spec/regparsers/many1_parser_spec.rb
+- spec/regparsers/many_parser_spec.rb
+- spec/regparsers/one_of_parser_spec.rb
+- spec/regparsers/regexp_parser_spec.rb
+- spec/regparsers/string_parser_spec.rb
+- spec/regparsers/try_parser_spec.rb
+- spec/regparsers/update_state_parser_spec.rb
+- spec/regparsers_spec.rb
+- spec/result_hook_spec.rb
+- spec/spec_helper.rb
+- spec/state_attributes_spec.rb
+has_rdoc: