yoga 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e30bbc7d17d9d4847b096576cc5efb39c71eec4e
-  data.tar.gz: 5813baee5ef2e6704fa2db41a3f77316e478ec3f
+  metadata.gz: 03845e88ffb4574489a6881d994554233bffe779
+  data.tar.gz: 1217f182ff6402b7df6f5997f7f24dca773e39d2
 SHA512:
-  metadata.gz: 0d6a878a6eaaf68427d1c4b873c465d82d82a61bef900f5f53cd173dc2e12b83e17e0bca277511edf3bfde66b009755a2272e75a9c6f6232a45cad8e253d0458
-  data.tar.gz: 642ddf68de1ce8acd8d69d198eaa4f7af87abd45c1deaba76e230b738f3abcb8aedad2dfec061bb4f01b1816f4d5527be5c8b9f59e0f755b057b50491ec2d277
+  metadata.gz: 14e9209587fc857be6637316ae9e3cdfe08022b61d5326987b2d7f7a3e2ba18b2c20e2bc8277097f7f35dfa38742813378b2acb02114c7afb9780afdea4e3343
+  data.tar.gz: 84892e0eca95a1d0b56f64ccab0bb1b6c532f3775185e31b89b54f21386c0803873e872361abf66d6d425c8383d6423eacfa4790618b4e576e71859c2c1f5643

data/lib/yoga/parser.rb

@@ -13,6 +13,7 @@ module Yoga
     # @param tokens [::Enumerable<Yoga::Token>]
     def initialize(tokens)
       @tokens = tokens
+      @buffer = []
     end
 
     # Performs the parsing.

data/lib/yoga/parser/helpers.rb

@@ -112,25 +112,39 @@ module Yoga
       #
       # @return [Yoga::Token]
       def peek
-        if next?
-          @_last = @tokens.peek
-        else
-          @_last
-        end
+        @_last = (@buffer.any? ? @buffer.first : @tokens.peek)
+      rescue ::StopIteration
+        @_last
       end
 
-      # Checks if the next token exists.  It does this by checking for a
-      # `StopIteration` error.  This is actually really slow, but there's
-      # not much else I can do.
+      # Peeks out to a given token.  If peeking would cause a `StopIteration`
+      # error, it instead returns the last value that was peeked.  This is
+      # an expensive operation, and should be used sparingly.  All other
+      # methods work as normal, even after this.
       #
-      # @return [::Boolean]
-      def next?
-        @tokens.peek
-        true
-      rescue StopIteration
-        false
+      # @param to [::Numeric] The distance to peek to.
+      # @return [Yoga::Token]
+      def peek_out(to)
+        return @buffer[to] if to <= @buffer.size
+        (to - @buffer.size + 1).times { @buffer << @tokens.next }
+        @buffer.last
+      rescue ::StopIteration
+        @buffer.last
+      end
+
+      # Pushes back tokens onto the buffer.  These, in reverse order, are
+      # the tokens that are pulled out by `peek/1`, `peek_to/1`, `expect/1`,
+      # and `shift/1`.
+      #
+      # @param tokens [<Yoga::Token>]
+      # @return [self]
+      def push(*tokens)
+        tokens.each { |t| @buffer.push(t) }
+        self
       end
 
+      alias_method :<<, :push
+
       # Switches the function executed based on the given nodes.  If the
       # peeked node matches one of the mappings, it calls the resulting
       # block or method.
@@ -140,10 +154,10 @@ module Yoga
       # @see ClassMethods#switch
       # @param name [::Symbol] The name of the switch to use.
       # @return [::Object] The result of calling the block.
-      def switch(name, *param)
+      def switch(name, *param, token: peek)
         switch = self.class.switch(name)
         block = switch
-                .fetch(peek.kind) { switch.fetch(:$else) { error(switch.keys) } }
+                .fetch(token.kind) { switch.fetch(:$else) { error(switch.keys) } }
         instance_exec(*param, &block)
       end
 
@@ -165,10 +179,13 @@ module Yoga
         return [] if (ending && peek?(ending)) || (!ending && !join)
 
         children << yield
-        while (join && expect(join)) && !(ending && peek?(ending))
-          children << yield
+
+        cond = proc do
+          (join ? peek?(join) && expect(join) : true) &&
+            !(ending && peek?(ending))
         end
 
+        (children << yield) while cond.call
         children
       end
 
@@ -184,11 +201,24 @@ module Yoga
         tokens.include?(peek.kind)
       end
 
+      # Peeks out to a specific point in the future to match.  This is an
+      # expensive operation.
+      #
+      # @see #peek?
+      # @see peek_out
+      # @param to [::Numeric] The distance to peek to.
+      # @param tokens [<::Symbol>] The kinds of tokens to check for.
+      # @return [::Boolean]
+      def peek_out?(to, tokens)
+        tokens = Utils.flatten_into_set([tokens])
+        tokens.include?(peek_out(to).kind)
+      end
+
       # Shifts to the next token, and returns the old token.
       #
       # @return [Yoga::Token]
       def shift
-        @tokens.next
+        @buffer.any? ? @buffer.shift : @tokens.next
       rescue ::StopIteration
         fail InvalidShiftError, location: peek.location
       end

data/lib/yoga/version.rb

@@ -5,5 +5,5 @@ module Yoga
   # The version of the module.
   #
   # @return [::String]
-  VERSION = "0.3.2"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yoga
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.1
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixture