astrolabe 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c17d30b9bee8cee926de9b4b2527950eb5c50763
-  data.tar.gz: 218e6135e0a8019b136651f4b92c0ca8648326a2
+  metadata.gz: 1306bd1680b44a33bad44374f71f0254be88dd30
+  data.tar.gz: f49d728a8cde1724e8c312475bcd8dad607c4eb6
 SHA512:
-  metadata.gz: 0e705c920bc838e45e1e0abc555e21582647c37f857e43ad36bea9057db9e9e50431c0e6eb6a9a57a7f271d8f0ec66bf45735907e1a03c159ec7016ddaf9d72b
-  data.tar.gz: 255f1615ab127be042ead82d9c363c06667c1e50caf9983920330313e2c9ac95fdcf09ff3b255449469a8b557e616fce7de0f02a6858b31463110ac7f4a0ceda
+  metadata.gz: 47f5e3637d1d87069147a9d1f574ae36d853ce942fa1f3a44330430184519639490aa28c0e6c5c81e8a126ec3dbef1152eb754209c1bc2bbf35c0a2cff69f234
+  data.tar.gz: 10468278e65896eb7d8a641fbe57789823a7a11bb91e89b8b34f976037b0ae3f7e6c9066e1bf583223123c23430f9143c6eb874ba95e01621b1f5e8ab4bc9d18

data/lib/astrolabe/node.rb

@@ -82,7 +82,7 @@ module Astrolabe
     # @return [self] if a block is given
     # @return [Enumerator] if no block is given
     def each_ancestor(*types)
-      return to_enum(__method__) unless block_given?
+      return to_enum(__method__, *types) unless block_given?
 
       types.flatten!
       last_node = self
@@ -117,7 +117,7 @@ module Astrolabe
     # @return [self] if a block is given
     # @return [Enumerator] if no block is given
     def each_child_node(*types)
-      return to_enum(__method__) unless block_given?
+      return to_enum(__method__, *types) unless block_given?
 
       types.flatten!
 
@@ -148,7 +148,7 @@ module Astrolabe
     # @return [self] if a block is given
     # @return [Enumerator] if no block is given
     def each_descendant(*types, &block)
-      return to_enum(__method__) unless block_given?
+      return to_enum(__method__, *types) unless block_given?
       types.flatten!
       visit_descendants(types, &block)
       self
@@ -176,7 +176,7 @@ module Astrolabe
     # @return [self] if a block is given
     # @return [Enumerator] if no block is given
     def each_node(*types, &block)
-      return to_enum(__method__) unless block_given?
+      return to_enum(__method__, *types) unless block_given?
       types.flatten!
       yield self if types.empty? || types.include?(type)
       visit_descendants(types, &block)

data/lib/astrolabe/version.rb

@@ -6,7 +6,7 @@ module Astrolabe
   module Version
     MAJOR = 0
     MINOR = 5
-    PATCH = 0
+    PATCH = 1
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/spec/astrolabe/node_spec.rb

@@ -68,6 +68,23 @@ module Astrolabe
 
             expect { enumerator.next }.to raise_error(StopIteration)
           end
+
+          context 'when a node type symbol is passed' do
+            subject(:enumerator) { target_node.send(method_name, :send) }
+
+            it 'enumerates only nodes matching the type' do
+              count = 0
+
+              begin
+                loop do
+                  expect(enumerator.next.type).to eq(:send)
+                  count += 1
+                end
+              rescue StopIteration
+                expect(count).to be > 0
+              end
+            end
+          end
         end
       end
     end
@@ -112,45 +129,45 @@ module Astrolabe
           returned_value = target_node.each_ancestor {}
           expect(returned_value).to equal(target_node)
         end
-      end
 
-      include_examples 'node enumerator', :each_ancestor
+        context 'and a node type symbol is passed' do
+          it 'scans all the ancestor nodes but yields only nodes matching the type' do
+            yielded_types = []
 
-      context 'when a node type symbol is passed' do
-        it 'scans all the ancestor nodes but yields only nodes matching the type' do
-          yielded_types = []
+            target_node.each_ancestor(:begin) do |node|
+              yielded_types << node.type
+            end
 
-          target_node.each_ancestor(:begin) do |node|
-            yielded_types << node.type
+            expect(yielded_types).to eq([:begin])
           end
-
-          expect(yielded_types).to eq([:begin])
         end
-      end
 
-      context 'when multiple node type symbols are passed' do
-        it 'scans all the ancestor nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and multiple node type symbols are passed' do
+          it 'scans all the ancestor nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_ancestor(:begin, :def) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_ancestor(:begin, :def) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:def, :begin])
+            expect(yielded_types).to eq([:def, :begin])
+          end
         end
-      end
 
-      context 'when an array including type symbols are passed' do
-        it 'scans all the ancestor nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and an array including type symbols are passed' do
+          it 'scans all the ancestor nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_ancestor([:begin, :def]) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_ancestor([:begin, :def]) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:def, :begin])
+            expect(yielded_types).to eq([:def, :begin])
+          end
         end
       end
+
+      include_examples 'node enumerator', :each_ancestor
     end
 
     describe '#each_child_node' do
@@ -184,45 +201,45 @@ module Astrolabe
           returned_value = target_node.each_child_node {}
           expect(returned_value).to equal(target_node)
         end
-      end
 
-      include_examples 'node enumerator', :each_child_node
+        context 'and a node type symbol is passed' do
+          it 'scans all the child nodes but yields only nodes matching the type' do
+            yielded_types = []
 
-      context 'when a node type symbol is passed' do
-        it 'scans all the child nodes but yields only nodes matching the type' do
-          yielded_types = []
+            target_node.each_child_node(:send) do |node|
+              yielded_types << node.type
+            end
 
-          target_node.each_child_node(:send) do |node|
-            yielded_types << node.type
+            expect(yielded_types).to eq([:send])
           end
-
-          expect(yielded_types).to eq([:send])
         end
-      end
 
-      context 'when multiple node type symbols are passed' do
-        it 'scans all the child nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and multiple node type symbols are passed' do
+          it 'scans all the child nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_child_node(:send, :args) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_child_node(:send, :args) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:args, :send])
+            expect(yielded_types).to eq([:args, :send])
+          end
         end
-      end
 
-      context 'when an array including type symbols are passed' do
-        it 'scans all the child nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and an array including type symbols are passed' do
+          it 'scans all the child nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_child_node([:send, :args]) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_child_node([:send, :args]) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:args, :send])
+            expect(yielded_types).to eq([:args, :send])
+          end
         end
       end
+
+      include_examples 'node enumerator', :each_child_node
     end
 
     describe '#each_descendant' do
@@ -265,45 +282,45 @@ module Astrolabe
           returned_value = target_node.each_descendant {}
           expect(returned_value).to equal(target_node)
         end
-      end
 
-      include_examples 'node enumerator', :each_descendant
+        context 'and a node type symbol is passed' do
+          it 'scans all the descendant nodes but yields only nodes matching the type' do
+            yielded_types = []
 
-      context 'when a node type symbol is passed' do
-        it 'scans all the descendant nodes but yields only nodes matching the type' do
-          yielded_types = []
+            target_node.each_descendant(:send) do |node|
+              yielded_types << node.type
+            end
 
-          target_node.each_descendant(:send) do |node|
-            yielded_types << node.type
+            expect(yielded_types).to eq([:send, :send])
           end
-
-          expect(yielded_types).to eq([:send, :send])
         end
-      end
 
-      context 'when multiple node type symbols are passed' do
-        it 'scans all the descendant nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and multiple node type symbols are passed' do
+          it 'scans all the descendant nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_descendant(:send, :def) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_descendant(:send, :def) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:send, :def, :send])
+            expect(yielded_types).to eq([:send, :def, :send])
+          end
         end
-      end
 
-      context 'when an array including type symbols are passed' do
-        it 'scans all the descendant nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and an array including type symbols are passed' do
+          it 'scans all the descendant nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_descendant([:send, :def]) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_descendant([:send, :def]) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:send, :def, :send])
+            expect(yielded_types).to eq([:send, :def, :send])
+          end
         end
       end
+
+      include_examples 'node enumerator', :each_descendant
     end
 
     describe '#each_node' do
@@ -346,45 +363,45 @@ module Astrolabe
           returned_value = target_node.each_node {}
           expect(returned_value).to equal(target_node)
         end
-      end
 
-      include_examples 'node enumerator', :each_node
+        context 'and a node type symbol is passed' do
+          it 'scans all the nodes but yields only nodes matching the type' do
+            yielded_types = []
 
-      context 'when a node type symbol is passed' do
-        it 'scans all the nodes but yields only nodes matching the type' do
-          yielded_types = []
+            target_node.each_node(:send) do |node|
+              yielded_types << node.type
+            end
 
-          target_node.each_node(:send) do |node|
-            yielded_types << node.type
+            expect(yielded_types).to eq([:send, :send])
           end
-
-          expect(yielded_types).to eq([:send, :send])
         end
-      end
 
-      context 'when multiple node type symbols are passed' do
-        it 'scans all the nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and multiple node type symbols are passed' do
+          it 'scans all the nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_node(:send, :def) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_node(:send, :def) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:send, :def, :send])
+            expect(yielded_types).to eq([:send, :def, :send])
+          end
         end
-      end
 
-      context 'when an array including type symbols are passed' do
-        it 'scans all the nodes but yields only nodes matching any of the types' do
-          yielded_types = []
+        context 'and an array including type symbols are passed' do
+          it 'scans all the nodes but yields only nodes matching any of the types' do
+            yielded_types = []
 
-          target_node.each_node([:send, :def]) do |node|
-            yielded_types << node.type
-          end
+            target_node.each_node([:send, :def]) do |node|
+              yielded_types << node.type
+            end
 
-          expect(yielded_types).to eq([:send, :def, :send])
+            expect(yielded_types).to eq([:send, :def, :send])
+          end
         end
       end
+
+      include_examples 'node enumerator', :each_node
     end
 
     describe '#send_type?' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: astrolabe
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Yuji Nakayama