parslet 1.7.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 546221c33c4829eb1bede8a241b40418197462de
-  data.tar.gz: d440cbbac367cf7909bdeeb764b431bc3a32bdf7
+  metadata.gz: 930ed2d329af700f3465739d6db3e2897ef64fbc
+  data.tar.gz: ea14cb80ebd03f9b6b9e55aa461021ffaa79a622
 SHA512:
-  metadata.gz: adae2aa91f57458cf679d60c3aefd5545a02f99895745cfc61e05290e86cae69adc1b38c121756e96beb4c6ffb4bce375af04e39050ecfe59154ecd3e187a76a
-  data.tar.gz: f8eeac537a6b4dcc958efeb1355d4ad6040e88e91efa2e0397706803ba58c42f69b970720b62cae7f29ff550f50e652c984853af41cab31da7a6ebb4cccbc4ae
+  metadata.gz: 0872f8510339d1dfd97c4060ac4298115f2270765b192804e7722e27f93c90df38b915af6cc867792ecfca3137fd8291b4d7ac854b20849884dd9214185d837f
+  data.tar.gz: 76bb599af2b8df83c53dccbc4bd49652b1a49c3046c9e5bd6f37dd8e30dfe66db07142eb66032886cf0dd78b55bb3763840962d6c41b956e8394e3ca2bd7fcf4

data/HISTORY.txt

@@ -1,7 +1,21 @@
+
 = 2.0 / ?? (future release changes, like a reminder to self)
   
   - prsnt? and absnt? are now finally banned into oblivion. Wasting vocals for
     the win. 
+    
+= 1.8 / 3Apr2017
+
+  + The `ignored` atom that allows to ignore a part of the matched text. 
+    `str('foo').ignore` will match 'foo', but not yield any parse output. 
+    Thanks to chrismwendt (Chris Wendt).
+  + Infix expression parser (arithmetics, anyone?) now supports custom reducers
+    in block form. Thanks to chrismwendt (Chris Wendt).
+  ! Small patches to memory footprint (Christophe Bliard).
+  - blankslate dependency removed. You should be good - but if things break, 
+    please let us know (Nikita Shilnikov).
+  ! Parslet now has `parse_failure_cause`, replaces the earlier `cause`.
+  ! Fixes all these interpreter warnings on modern rubies. 
 
 = 1.7 / 12Mar2015
 

data/lib/parslet.rb

@@ -55,13 +55,13 @@ module Parslet
   
   # Raised when the parse failed to match. It contains the message that should
   # be presented to the user. More details can be extracted from the
-  # exceptions #cause member: It contains an instance of {Parslet::Cause} that
+  # exceptions #parse_failure_cause member: It contains an instance of {Parslet::Cause} that
   # stores all the details of your failed parse in a tree structure. 
   #
   #   begin
   #     parslet.parse(str)
   #   rescue Parslet::ParseFailed => failure
-  #     puts failure.cause.ascii_tree
+  #     puts failure.parse_failure_cause.ascii_tree
   #   end
   #
   # Alternatively, you can just require 'parslet/convenience' and call the
@@ -72,15 +72,15 @@ module Parslet
   #   parslet.parse_with_debug(str)
   #
   class ParseFailed < StandardError
-    def initialize(message, cause=nil)
+    def initialize(message, parse_failure_cause=nil)
       super(message)
-      @cause = cause
+      @parse_failure_cause = parse_failure_cause
     end
     
     # Why the parse failed. 
     #
     # @return [Parslet::Cause]
-    attr_reader :cause 
+    attr_reader :parse_failure_cause
   end
   
   module ClassMethods
@@ -100,6 +100,7 @@ module Parslet
     #   end
     #
     def rule(name, opts={}, &definition)
+      undef_method name if method_defined? name
       define_method(name) do
         @rules ||= {}     # <name, rule> memoization
         return @rules[name] if @rules.has_key?(name)
@@ -217,18 +218,26 @@ module Parslet
   # associativity is chosen, it would be interpreted as '1 + (2 + 3)'. Note 
   # that the hash trees output reflect that choice as well. 
   #
-  # Example:
+  # An optional block can be provided in order to manipulate the generated tree.
+  # The block will be called on each operator and passed 3 arguments: the left
+  # operand, the operator, and the right operand.
+  #
+  # Examples:
   #   infix_expression(integer, [add_op, 1, :left])
   #   # would parse things like '1 + 2'
   #
+  #   infix_expression(integer, [add_op, 1, :left]) { |l,o,r| { :plus => [l, r] } }
+  #   # would parse '1 + 2 + 3' as:
+  #   # { :plus => [1, { :plus => [2, 3] }] }
+  #
   # @param element [Parslet::Atoms::Base] elements that take the NUMBER position
   #    in the expression
   # @param operations [Array<(Parslet::Atoms::Base, Integer, {:left, :right})>]
   #  
   # @see Parslet::Atoms::Infix
   #
-  def infix_expression(element, *operations)
-    Parslet::Atoms::Infix.new(element, operations)
+  def infix_expression(element, *operations, &reducer)
+    Parslet::Atoms::Infix.new(element, operations, &reducer)
   end
   module_function :infix_expression
   
@@ -299,4 +308,4 @@ require 'parslet/pattern/binding'
 require 'parslet/transform'
 require 'parslet/parser'
 require 'parslet/error_reporter'
-require 'parslet/scope'
+require 'parslet/scope'

data/lib/parslet/accelerator.rb

@@ -77,6 +77,7 @@ module Parslet::Accelerator
     def join_or_new tag, other_expr
       if type == tag
         @args << other_expr
+        self
       else
         Expression.new(tag, self, other_expr)
       end

data/lib/parslet/atoms.rb

@@ -19,6 +19,7 @@ module Parslet::Atoms
   require 'parslet/atoms/context'
   require 'parslet/atoms/dsl'
   require 'parslet/atoms/base'
+  require 'parslet/atoms/ignored'
   require 'parslet/atoms/named'
   require 'parslet/atoms/lookahead'
   require 'parslet/atoms/alternative'

data/lib/parslet/atoms/base.rb

@@ -83,7 +83,7 @@ class Parslet::Atoms::Base
   def apply(source, context, consume_all=false)
     old_pos = source.bytepos
     
-    success, value = result = context.try_with_cache(self, source, consume_all)
+    success, _ = result = context.try_with_cache(self, source, consume_all)
 
     if success
       # Notify context
@@ -137,7 +137,7 @@ class Parslet::Atoms::Base
   end
   precedence BASE
   def to_s(outer_prec=OUTER)
-    str = @label || to_s_inner(precedence)
+    str = label || to_s_inner(precedence)
     if outer_prec < precedence
       "(#{str})"
     else

data/lib/parslet/atoms/can_flatten.rb

@@ -120,7 +120,7 @@ module Parslet::Atoms
       return [] if named && list.empty?
 
       # If there are only strings, concatenate them and return that. 
-      foldl(list) { |s,e| s+e }
+      foldl(list.compact) { |s,e| s+e }
     end
 
     # That annoying warning 'Duplicate subtrees while merging result' comes 

data/lib/parslet/atoms/dsl.rb

@@ -35,6 +35,17 @@ module Parslet::Atoms::DSL
     Parslet::Atoms::Repetition.new(self, 0, 1, :maybe)
   end
 
+  # Returns a new parslet atom that will not show up in the output. This
+  # is synonymous to calling #repeat(0,1). Generated tree value will always be 
+  # nil.
+  #
+  # Example: 
+  #   str('foo').ignore
+  #
+  def ignore
+    Parslet::Atoms::Ignored.new(self)
+  end
+
   # Chains two parslet atoms together as a sequence. 
   #
   # Example: 

data/lib/parslet/atoms/entity.rb

@@ -16,6 +16,7 @@ class Parslet::Atoms::Entity < Parslet::Atoms::Base
     @name = name
     @label = label
     @block = block
+    @parslet = nil
   end
 
   def try(source, context, consume_all)

data/lib/parslet/atoms/ignored.rb

@@ -0,0 +1,26 @@
+# Ignores the result of a match.
+#
+# Example:
+#
+#   str('foo')            # will return 'foo',
+#   str('foo').ignore     # will return nil
+#
+class Parslet::Atoms::Ignored < Parslet::Atoms::Base
+  attr_reader :parslet
+  def initialize(parslet)
+    super()
+
+    @parslet = parslet
+  end
+
+  def apply(source, context, consume_all)
+    success, _ = result = parslet.apply(source, context, consume_all)
+
+    return result unless success
+    succ(nil)
+  end
+  
+  def to_s_inner(prec)
+    "ignored(#{parslet.to_s(prec)})"
+  end
+end

data/lib/parslet/atoms/infix.rb

@@ -1,11 +1,12 @@
 class Parslet::Atoms::Infix < Parslet::Atoms::Base
-  attr_reader :element, :operations
+  attr_reader :element, :operations, :reducer
 
-  def initialize(element, operations)
+  def initialize(element, operations, &reducer)
     super()
 
     @element = element
     @operations = operations
+    @reducer = reducer || lambda { |left, op, right| {l: left, o: op, r: right} }
   end
   
   def try(source, context, consume_all)
@@ -31,9 +32,9 @@ class Parslet::Atoms::Infix < Parslet::Atoms::Base
 
       if right.kind_of? Array
         # Subexpression -> Subhash
-        left = {l: left, o: op, r: produce_tree(right)}
+        left = reducer.call(left, op, produce_tree(right))
       else
-        left = {l: left, o: op, r: right}
+        left = reducer.call(left, op, right)
       end
     end
 

data/lib/parslet/atoms/lookahead.rb

@@ -25,7 +25,7 @@ class Parslet::Atoms::Lookahead < Parslet::Atoms::Base
     rewind_pos  = source.bytepos
     error_pos   = source.pos
 
-    success, value = bound_parslet.apply(source, context, consume_all)
+    success, _ = bound_parslet.apply(source, context, consume_all)
     
     if positive
       return succ(nil) if success

data/lib/parslet/cause.rb

@@ -5,8 +5,8 @@ module Parslet
   #
   class Cause
     def initialize(message, source, pos, children)
-      @message, @source, @pos, @children = 
-        message, source, pos, children
+      @message, @source, @pos, @children, @context =
+        message, source, pos, children, nil
     end
     
     # @return [String, Array] A string or an array of message pieces that 

data/lib/parslet/context.rb

@@ -1,5 +1,3 @@
-require 'blankslate'
-
 # Provides a context for tree transformations to run in. The context allows
 # accessing each of the bindings in the bindings hash as local method.
 #
@@ -11,24 +9,12 @@ require 'blankslate'
 #   end
 #
 # @api private
-class Parslet::Context < BlankSlate
-  reveal :methods
-  reveal :respond_to?
-  reveal :inspect
-  reveal :to_s
-  reveal :instance_variable_set
-
+class Parslet::Context
   include Parslet
-  
-  def meta_def(name, &body)
-    metaclass = class << self; self; end
 
-    metaclass.send(:define_method, name, &body)
-  end
-  
   def initialize(bindings)
     bindings.each do |key, value|
-      meta_def(key.to_sym) { value }
+      singleton_class.send(:define_method, key) { value }
       instance_variable_set("@#{key}", value)
     end
   end

data/lib/parslet/convenience.rb

@@ -5,7 +5,7 @@ class Parslet::Atoms::Base
   #    begin
   #      tree = parser.parse('something')
   #    rescue Parslet::ParseFailed => error
-  #      puts parser.cause.ascii_tree
+  #      puts parser.parse_failure_cause.ascii_tree
   #    end
   #
   # into a convenient method.
@@ -27,7 +27,7 @@ class Parslet::Atoms::Base
   def parse_with_debug str, opts={}
     parse str, opts
   rescue Parslet::ParseFailed => error
-    puts error.cause.ascii_tree
+    puts error.parse_failure_cause.ascii_tree
   end
 
 end

data/lib/parslet/error_reporter/deepest.rb

@@ -64,7 +64,7 @@ module Parslet
       # current deepest error that was saved as a reference.
       #
       def deepest(cause)
-        rank, leaf = deepest_child(cause)
+        _, leaf = deepest_child(cause)
         
         if !deepest_cause || leaf.pos >= deepest_cause.pos
           # This error reaches deeper into the input, save it as reference.

data/lib/parslet/parser.rb

@@ -51,6 +51,7 @@ class Parslet::Parser < Parslet::Atoms::Base
     #   end
     #
     def root(name)
+      undef_method :root if method_defined? :root
       define_method(:root) do
         self.send(name)
       end
@@ -64,4 +65,4 @@ class Parslet::Parser < Parslet::Atoms::Base
   def to_s_inner(prec)
     root.to_s(prec)
   end
-end
+end

data/lib/parslet/pattern.rb

@@ -48,11 +48,10 @@ class Parslet::Pattern
   #
   def element_match(tree, exp, bindings) 
     # p [:elm, tree, exp]
-    case [tree, exp].map { |e| e.class }
-      when [Hash,Hash]
-        return element_match_hash(tree, exp, bindings)
-      when [Array,Array]
-        return element_match_ary_single(tree, exp, bindings)
+    if tree.is_a?(Hash) && exp.is_a?(Hash)
+      return element_match_hash(tree, exp, bindings)
+    elsif tree.is_a?(Array) && exp.is_a?(Array)
+      return element_match_ary_single(tree, exp, bindings)
     else
       # If elements match exactly, then that is good enough in all cases
       return true if exp === tree

data/lib/parslet/rig/rspec.rb

@@ -2,13 +2,6 @@ RSpec::Matchers.define(:parse) do |input, opts|
   as = block = nil
   result = trace = nil
 
-  unless self.respond_to? :failure_message # if RSpec 2.x
-    class << self
-      alias_method :failure_message, :failure_message_for_should
-      alias_method :failure_message_when_negated, :failure_message_for_should_not
-    end
-  end
-
   match do |parser|
     begin
       result = parser.parse(input)
@@ -16,12 +9,12 @@ RSpec::Matchers.define(:parse) do |input, opts|
         block.call(result) : 
         (as == result || as.nil?)
     rescue Parslet::ParseFailed => ex
-      trace = ex.cause.ascii_tree if opts && opts[:trace]
+      trace = ex.parse_failure_cause.ascii_tree if opts && opts[:trace]
       false
     end
   end
 
-  failure_message do |is|
+  public_send(respond_to?(:failure_message) ? :failure_message : :failure_message_for_should) do |is|
     if block
       "expected output of parsing #{input.inspect}" <<
       " with #{is.inspect} to meet block conditions, but it didn't"
@@ -37,7 +30,7 @@ RSpec::Matchers.define(:parse) do |input, opts|
     end
   end
 
-  failure_message_when_negated do |is|
+  public_send(respond_to?(:failure_message_when_negated) ? :failure_message_when_negated : :failure_message_for_should_not) do |is|
     if block
       "expected output of parsing #{input.inspect} with #{is.inspect} not to meet block conditions, but it did"
     else
@@ -52,8 +45,8 @@ RSpec::Matchers.define(:parse) do |input, opts|
 
   # NOTE: This has a nodoc tag since the rdoc parser puts this into 
   # Object, a thing I would never allow. 
-  chain :as do |expected_output=nil, &block|
+  chain :as do |expected_output=nil, &my_block|
     as = expected_output
-    block = block
+    block = my_block
   end
 end

data/lib/parslet/slice.rb

@@ -105,6 +105,6 @@ class Parslet::Slice
   # Prints the slice as <code>"string"@offset</code>.
   def inspect
 
-    str.inspect << "@#{offset}"
+    str.inspect + "@#{offset}"
   end
 end

data/lib/parslet/source/line_cache.rb

@@ -10,6 +10,7 @@ class Parslet::Source
       # but probably make a scan to that position neccessary.
       @line_ends = []
       @line_ends.extend RangeSearch
+      @last_line_end = nil
     end
 
     # Returns a <line, column> tuple for the given input position. Input

data/lib/parslet/transform.rb

@@ -131,7 +131,7 @@ class Parslet::Transform
     # Allows accessing the class' rules
     #
     def rules 
-      @__transform_rules || []
+      @__transform_rules ||= []
     end
 
     def inherited(subclass)
@@ -140,7 +140,8 @@ class Parslet::Transform
     end
   end
   
-  def initialize(&block) 
+  def initialize(raise_on_unmatch: false, &block) 
+    @raise_on_unmatch = raise_on_unmatch
     @rules = []
     
     if block
@@ -236,7 +237,14 @@ class Parslet::Transform
     end
     
     # No rule matched - element is not transformed
-    return elt
+    if @raise_on_unmatch && elt.is_a?(Hash)
+      elt_types = elt.map do |key, value|
+        [ key, value.class ]
+      end.to_h
+      raise NotImplementedError, "Failed to match `#{elt_types.inspect}`"
+    else
+      return elt
+    end
   end
 
   # @api private 

data/parslet.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'parslet'
-  s.version = '1.7.1'
+  s.version = '1.8.0'
 
   s.authors = ['Kaspar Schiess']
   s.email = 'kaspar.schiess@absurd.li'
@@ -12,7 +12,5 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
   s.rdoc_options = ['--main', 'README']
   s.require_paths = ['lib']
-  s.summary = 'Parser construction library with great error reporting in Ruby.'  
-  
-  s.add_dependency 'blankslate', '>= 2.0', '<= 4.0'
+  s.summary = 'Parser construction library with great error reporting in Ruby.'
 end

data/spec/acceptance/examples_spec.rb

@@ -12,7 +12,7 @@ describe "Regression on" do
       end
       
       it "runs successfully" do
-        stdin, stdout, stderr = Open3.popen3("ruby #{example}")
+        _, stdout, stderr = Open3.popen3("ruby #{example}")
         
         handle_map = {
           stdout => :out, 
@@ -21,7 +21,7 @@ describe "Regression on" do
         expectation_found = handle_map.any? do |io, ext|
           name = product_path(example, ext)
           
-          if File.exists?(name)
+          if File.exist?(name)
             io.read.strip.should == File.read(name).strip
             true
           end

data/spec/acceptance/infix_parser_spec.rb

@@ -109,4 +109,13 @@ Don't know what to do with "%" at line 1 char 2.
       end
     end
   end
+  describe "providing a reducer block" do
+    class InfixExpressionReducerParser < Parslet::Parser
+      rule(:top) { infix_expression(str('a'), [str('-'), 1, :right]) { |l,o,r| {:and=>[l,r]} } }
+    end
+    
+    it "applies the reducer" do
+      InfixExpressionReducerParser.new.top.parse("a-a-a").should == {:and=>["a", {:and=>["a", "a"]}]}
+    end
+  end
 end

data/spec/parslet/atoms/ignored_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Parslet::Atoms::Ignored do
+  include Parslet
+
+  describe "ignore" do
+    it "ignores parts of the input" do
+      str('a').ignore.parse('a').should == nil
+      (str('a') >> str('b').ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').as(:name).ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').maybe.ignore >> str('c')).parse('abc').should == 'ac'
+      (str('a') >> str('b').maybe.ignore >> str('c')).parse('ac').should == 'ac'
+    end
+  end
+end

data/spec/parslet/atoms_spec.rb

@@ -225,7 +225,7 @@ describe Parslet do
     
     it "should not loop infinitely" do
       lambda {
-        timeout(1) { parslet.parse('bar') }
+        Timeout.timeout(1) { parslet.parse('bar') }
       }.should raise_error(Parslet::ParseFailed)
     end 
   end
@@ -398,7 +398,7 @@ describe Parslet do
   end
 
   describe "combinations thereof (regression)" do
-    success=[
+    [
       [(str('a').repeat >> str('b').repeat), 'aaabbb'] 
     ].each do |(parslet, input)|
       describe "#{parslet.inspect} applied to #{input.inspect}" do
@@ -408,7 +408,7 @@ describe Parslet do
       end 
     end
 
-    inspection=[
+    [
       [str('a'),                              "'a'"                 ], 
       [(str('a') | str('b')).maybe,           "('a' / 'b')?"        ], 
       [(str('a') >> str('b')).maybe,          "('a' 'b')?"          ], 

data/spec/parslet/transform/context_spec.rb

@@ -9,22 +9,6 @@ describe Parslet::Context do
     context(:a => 'value').instance_eval { a }.
       should == 'value'
   end
-  describe 'when a method in BlankSlate is inherited from the environment somehow' do
-    before(:each) { BlankSlate.send(:define_method, :a) { 'c' } }
-    after(:each) { BlankSlate.send(:undef_method, :a) }
-    
-    it "masks what is already on blank slate" do
-      context(:a => 'b').instance_eval { a }.
-        should == 'b'
-    end  
-  end
-  it "should not reveal define_singleton_method for all users of blankslate, just for us" do
-    expect {
-      BlankSlate.new.instance_eval {
-        define_singleton_method(:foo) { 'foo' }
-      }
-    }.to raise_error(NoMethodError)
-  end 
   it "one contexts variables aren't the next ones" do
     ca = context(:a => 'b')
     cb = context(:b => 'c')
@@ -32,4 +16,41 @@ describe Parslet::Context do
     ca.methods.should_not include(:b)
     cb.methods.should_not include(:a)
   end
+
+  describe 'works as a Ruby object should' do
+    let(:obj) { context(a: 1) }
+
+    it 'responds_to? :a' do
+      assert obj.respond_to?(:a)
+    end
+    it 'includes :a in #methods' do
+      obj.methods.assert.include?(:a)
+    end
+    it 'allows inspection' do
+      obj.inspect.assert.match(/@a=1/)
+    end
+    it 'allows conversion to string' do
+      obj.to_s.assert.match(/Parslet::Context:0x/)
+    end
+
+    context 'when the context is enhanced' do
+      before(:each) do
+        class << obj
+          def foo
+            'foo'
+          end
+        end
+      end
+
+      it 'responds_to correctly' do
+        assert obj.respond_to?(:foo)
+      end
+      it 'includes :foo also in methods' do
+        obj.methods.assert.include?(:foo)
+      end
+      it 'allows calling #foo' do
+        obj.foo.assert == 'foo'
+      end
+    end
+  end
 end

data/spec/parslet/transform_spec.rb

@@ -6,10 +6,6 @@ describe Parslet::Transform do
   include Parslet
   
   let(:transform) { Parslet::Transform.new }
-  attr_reader :transform
-  before(:each) do
-    @transform = Parslet::Transform.new
-  end
   
   class A < Struct.new(:elt); end
   class B < Struct.new(:elt); end
@@ -77,6 +73,26 @@ describe Parslet::Transform do
       transform.apply(:a => 'a').should == A.new('a')
     end
 
+    context "optionally raise when no match found" do
+      class BumbleBee < Parslet::Transform
+        def initialize(&block)
+          super(raise_on_unmatch: true, &block)
+        end
+        rule(:a => simple(:x)) { A.new(x) }
+      end
+      let(:transform) { BumbleBee.new }
+
+      it "should evaluate rules" do
+        transform.apply(:a => 'a').should == A.new('a')
+      end
+
+      it "should raise when no rules are matched" do
+        lambda {
+          transform.apply(:z => 'z')
+        }.should raise_error(NotImplementedError, /Failed to match/)
+      end
+    end
+
     context "with inheritance" do
       class OptimusPrimeJunior < OptimusPrime
         rule(:b => simple(:x)) { B.new(x.upcase) }
@@ -137,7 +153,9 @@ describe Parslet::Transform do
       it "should execute in its own context" do
         @bar = 'test'
         transform.call_on_match(bindings, proc do
-          @bar.should_not == 'test'
+          if instance_variable_defined?("@bar")
+            instance_variable_get("@bar").should_not == 'test'
+          end
         end)
       end
     end

data/spec/spec_helper.rb

@@ -5,6 +5,8 @@ require 'parslet/rig/rspec'
 require 'parslet/atoms/visitor'
 require 'parslet/export'
 
+require 'ae'
+
 RSpec.configure do |config|
   config.mock_with :flexmock
 
@@ -29,7 +31,7 @@ def catch_failed_parse
     yield
   rescue Parslet::ParseFailed => exception
   end
-  exception.cause
+  exception.parse_failure_cause
 end
 
 def slet name, &block

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: parslet
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.8.0
 platform: ruby
 authors:
 - Kaspar Schiess
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-27 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: blankslate
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: '4.0'
+date: 2017-04-03 00:00:00.000000000 Z
+dependencies: []
 description: 
 email: kaspar.schiess@absurd.li
 executables: []
@@ -51,7 +31,6 @@ files:
 - example/email_parser.rb
 - example/empty.rb
 - example/erb.rb
-- example/ignore.rb
 - example/ip_address.rb
 - example/json.rb
 - example/local.rb
@@ -111,6 +90,7 @@ files:
 - lib/parslet/atoms/dsl.rb
 - lib/parslet/atoms/dynamic.rb
 - lib/parslet/atoms/entity.rb
+- lib/parslet/atoms/ignored.rb
 - lib/parslet/atoms/infix.rb
 - lib/parslet/atoms/lookahead.rb
 - lib/parslet/atoms/named.rb
@@ -154,6 +134,7 @@ files:
 - spec/parslet/atoms/combinations_spec.rb
 - spec/parslet/atoms/dsl_spec.rb
 - spec/parslet/atoms/entity_spec.rb
+- spec/parslet/atoms/ignored_spec.rb
 - spec/parslet/atoms/infix_spec.rb
 - spec/parslet/atoms/lookahead_spec.rb
 - spec/parslet/atoms/named_spec.rb
@@ -206,8 +187,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Parser construction library with great error reporting in Ruby.
 test_files: []
+has_rdoc: 

data/example/ignore.rb

@@ -1,33 +0,0 @@
-# A small example on how to make parslet ignore parts of the parse tree. 
-
-$:.unshift File.dirname(__FILE__) + "/../lib"
-require 'parslet'
-
-class IgnoreParslet < Parslet::Atoms::Base
-  def initialize(parslet)
-    @parslet = parslet
-  end
-  def to_s_inner(prec)
-    @parslet.to_s(prec)
-  end
-  def try(source, context, consume_all)
-    success, value = result = @parslet.try(source, context, consume_all)
-    
-    return succ(nil) if success
-    return result
-  end
-  
-end
-module IgnoreDSL
-  def ignore
-    IgnoreParslet.new(self)
-  end
-end
-
-class Parslet::Atoms::Base
-  include IgnoreDSL
-end
-
-include Parslet
-p (str('a') >> str('b').ignore >> str('c')).
-  parse('abc')