astrolabe 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46c2d6149556152034a1102c6a17a722068b7d05
+  data.tar.gz: 89ff885e03757862cd9d5345bfae9127cd5665c0
+SHA512:
+  metadata.gz: b76199cb0b7abcab33a57187876733b87eac1e88f0c1db2f96954b99c13b2f707481bfdb71778eac70c02e180bc65a35508b11dceadc46c9bc41aa3be28a7839
+  data.tar.gz: 3cee02d4725f5ed4a98a3b7ba49818855480a2cdcbd241855dabeb37dea5fe6aaa697544ff8da485f91e5acd9433d24d41a57f435ef9ad9db73b32740a1bdbe0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,29 @@
+
+LineLength:
+  Max: 100
+
+AlignHash:
+  # Alignment of entries using hash rocket as separator. Valid values are:
+  #
+  # key - left alignment of keys
+  #   'a' => 2
+  #   'bb' => 3
+  # separator - alignment of hash rockets, keys are right aligned
+  #    'a' => 2
+  #   'bb' => 3
+  # table - left alignment of keys, hash rockets, and values
+  #   'a'  => 2
+  #   'bb' => 3
+  EnforcedHashRocketStyle: table
+  # Alignment of entries using colon as separator. Valid values are:
+  #
+  # key - left alignment of keys
+  #   a: 0
+  #   bb: 1
+  # separator - alignment of colons, keys are right aligned
+  #    a: 0
+  #   bb: 1
+  # table - left alignment of keys and values
+  #   a:  0
+  #   bb: 1
+  EnforcedColonStyle: separator

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - ruby-head
+  - jruby
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+before_install: gem update --remote bundler
+script: bundle exec rake ci

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--hide-api private
+-
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls', '~> 0.7'
+end

data/Guardfile

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+# This group allows Guard to skip running RuboCop if RSpec failed.
+group :red_green_refactor, halt_on_fail: true do
+  guard :rspec, all_on_start: true, cmd: 'bundle exec rspec --format Fuubar' do
+    watch(%r{^spec/.+_spec\.rb$})
+    watch(%r{^lib/(.+)\.rb$})        { |m| "spec/#{m[1]}_spec.rb" }
+    watch('spec/spec_helper.rb')     { 'spec' }
+    watch(%r{^spec/support/.+\.rb$}) { 'spec' }
+  end
+
+  guard :rubocop, cli: '--format fuubar' do
+    watch(%r{.+\.rb$})
+    watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yuji Nakayama
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+[![Gem Version](http://img.shields.io/gem/v/astrolabe.svg)](http://badge.fury.io/rb/astrolabe)
+[![Dependency Status](http://img.shields.io/gemnasium/yujinakayama/astrolabe.svg)](https://gemnasium.com/yujinakayama/astrolabe)
+[![Build Status](https://travis-ci.org/yujinakayama/astrolabe.svg?branch=master)](https://travis-ci.org/yujinakayama/astrolabe)
+[![Coverage Status](http://img.shields.io/coveralls/yujinakayama/astrolabe/master.svg)](https://coveralls.io/r/yujinakayama/astrolabe)
+[![Code Climate](http://img.shields.io/codeclimate/github/yujinakayama/astrolabe.svg)](https://codeclimate.com/github/yujinakayama/astrolabe)
+
+# Astrolabe
+
+**Astrolabe** is an AST node library that provides an object-oriented way to handle AST by extending [Parser](https://github.com/whitequark/parser)'s node class.
+
+## Installation
+
+Add this line to your `Gemfile`:
+
+```ruby
+gem 'astrolabe'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage
+
+You can generate an AST that consists of `Astrolabe::Node` by using `Astrolabe::Builder` along with `Parser`:
+
+```ruby
+require 'astrolabe/builder'
+require 'parser/current'
+
+buffer = Parser::Source::Buffer.new('(string)')
+buffer.source = 'puts :foo'
+
+builder = Astrolabe::Builder.new
+parser = Parser::CurrentRuby.new(builder)
+
+root_node = parser.parse(buffer)
+root_node.class # => Astrolabe::Node
+```
+
+`Astrolabe::Node` is a subclass of [`Parser::AST::Node`](http://rubydoc.info/gems/parser/Parser/AST/Node).
+
+## APIs
+
+See these references for all the public APIs:
+
+* [`Astrolabe::Node`](http://rubydoc.info/gems/astrolabe/Astrolabe/Node)
+* [`Astrolabe::Builder`](http://rubydoc.info/gems/astrolabe/Astrolabe/Builder)
+
+### Node Type Predicate Methods
+
+These would be useful especially when combined with `Enumerable` methods (described below).
+
+```ruby
+node.send_type?    # Equivalent to: `node.type == :send`
+node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`
+
+# Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
+node.defined_type? # Equivalent to: `node.type == :defined?`
+```
+
+### Access to Parent Node
+
+```ruby
+def method_taking_block?(node)
+  return unless node.parent.block_type?
+  node.parent.children.first.equal?(node)
+end
+
+block_node = parser.parse(buffer)
+# (block
+#   (send
+#     (int 3) :times)
+#   (args
+#     (arg :i))
+#   (send nil :do_something))
+
+send_node, args_node, body_node = *block_node
+method_taking_block?(send_node) # => true
+```
+
+### AST Traversal
+
+These methods bring the power of `Enumerable` to AST.
+
+Note that you may want to use [`Parser::AST::Processor`](http://rubydoc.info/gems/parser/Parser/AST/Processor)
+if you don't need to track context of AST.
+
+```ruby
+# Iterate ancestor nodes in the order from parent to root.
+node.each_ancestor do |ancestor_node|
+  p ancestor_node
+end
+
+# This is different from `node.children.each { |child| ... }`
+# which yields all children including non-node element.
+node.each_child_node do |child_node|
+  p child_node
+end
+
+# Collect all lvar nodes under the receiver node.
+lvar_nodes = node.each_descendant.select(&:lvar_type?)
+```
+
+## Compatibility
+
+Tested on MRI 1.9, 2.0, 2.1, JRuby in 1.9 mode and Rubinius 2.0+.
+
+## License
+
+Copyright (c) 2014 Yuji Nakayama
+
+See the [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:style)
+
+task default: %w(spec style)
+task ci: %w(spec style)

data/astrolabe.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'astrolabe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'astrolabe'
+  spec.version       = Astrolabe::Version.to_s
+  spec.authors       = ['Yuji Nakayama']
+  spec.email         = ['nkymyj@gmail.com']
+  spec.summary       = 'Object-oriented AST library for Parser'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/yujinakayama/astrolabe'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^spec\//)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'parser', '~> 2.1'
+
+  spec.add_development_dependency 'bundler',       '~> 1.6'
+  spec.add_development_dependency 'rake',          '~> 10.3'
+  spec.add_development_dependency 'yard',          '~> 0.8'
+  spec.add_development_dependency 'rspec',         '~> 3.0'
+  spec.add_development_dependency 'fuubar',        '~> 2.0.0.rc1'
+  spec.add_development_dependency 'simplecov',     '~> 0.7'
+  spec.add_development_dependency 'rubocop',       '~> 0.24'
+  spec.add_development_dependency 'guard-rspec',   '>= 4.2.3', '< 5.0'
+  spec.add_development_dependency 'guard-rubocop', '~> 1.0'
+  spec.add_development_dependency 'ruby_gntp',     '~> 0.3'
+end

data/lib/astrolabe/builder.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require 'astrolabe/node'
+require 'parser'
+
+module Astrolabe
+  # `Astrolabe::Builder` is an AST builder that is utilized to let `Parser` generate AST with
+  # {Astrolabe::Node}.
+  #
+  # @example
+  #   require 'astrolabe/builder'
+  #   require 'parser/current'
+  #
+  #   buffer = Parser::Source::Buffer.new('(string)')
+  #   buffer.source = 'puts :foo'
+  #
+  #   builder = Astrolabe::Builder.new
+  #   parser = Parser::CurrentRuby.new(builder)
+  #   root_node = parser.parse(buffer)
+  class Builder < Parser::Builders::Default
+    # Generates {Node} from the given information.
+    #
+    # @return [Node] the generated node
+    def n(type, children, source_map)
+      Node.new(type, children, location: source_map)
+    end
+  end
+end

data/lib/astrolabe/node.rb

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+require 'parser'
+
+module Astrolabe
+  # `Astrolabe::Node` is a subclass of `Parser::AST::Node`. It provides an access to parent node and
+  # an object-oriented way to handle AST with the power of `Enumerable`.
+  #
+  # Though not described in the auto-generated API documentation, it has predicate methods for every
+  # node type. These methods would be useful especially when combined with `Enumerable` methods.
+  #
+  # @example
+  #   node.send_type?    # Equivalent to: `node.type == :send`
+  #   node.op_asgn_type? # Equivalent to: `node.type == :op_asgn`
+  #
+  #   # Non-word characters (other than a-zA-Z0-9_) in type names are omitted.
+  #   node.defined_type? # Equivalent to: `node.type == :defined?`
+  #
+  #   # Collect all lvar nodes under the receiver node.
+  #   lvar_nodes = node.each_descendant.select(&:lvar_type?)
+  class Node < Parser::AST::Node
+    # @see http://rubydoc.info/gems/ast/AST/Node:initialize
+    def initialize(type, children = [], properties = {})
+      @mutable_attributes = {}
+
+      # ::AST::Node#initialize freezes itself.
+      super
+
+      # #parent= would be invoked multiple times for a node because there are pending nodes while
+      # constructing AST and they are replaced later.
+      # For example, `lvar` and `send` type nodes are initially created as an `ident` type node and
+      # fixed to each type later.
+      # So, the #parent attribute needs to be mutable.
+      each_child_node do |child_node|
+        child_node.parent = self
+      end
+    end
+
+    Parser::Meta::NODE_TYPES.each do |node_type|
+      method_name = "#{node_type.to_s.gsub(/\W/, '')}_type?"
+      define_method(method_name) do
+        type == node_type
+      end
+    end
+
+    # Returns the parent node, or `nil` if the receiver is a root node.
+    #
+    # @return [Node, nil] the parent node or `nil`
+    def parent
+      @mutable_attributes[:parent]
+    end
+
+    def parent=(node)
+      @mutable_attributes[:parent] = node
+    end
+
+    protected :parent=
+
+    # Returns whether the receiver is a root node or not.
+    #
+    # @return [Boolean] whether the receiver is a root node or not
+    def root?
+      parent.nil?
+    end
+
+    # Calls the given block for each ancestor node in the order from parent to root.
+    # If no block is given, an `Enumerator` is returned.
+    #
+    # @yieldparam [Node] node each ancestor node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_ancestor(&block)
+      return to_enum(__method__) unless block_given?
+
+      if parent
+        yield parent
+        parent.each_ancestor(&block)
+      end
+
+      self
+    end
+
+    # Calls the given block for each child node.
+    # If no block is given, an `Enumerator` is returned.
+    #
+    # Note that this is different from `node.children.each { |child| ... }` which yields all
+    # children including non-node element.
+    #
+    # @yieldparam [Node] node each child node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_child_node
+      return to_enum(__method__) unless block_given?
+
+      children.each do |child|
+        next unless child.is_a?(Node)
+        yield child
+      end
+
+      self
+    end
+
+    # Calls the given block for each descendant node with depth first order.
+    # If no block is given, an `Enumerator` is returned.
+    #
+    # @yieldparam [Node] node each descendant node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_descendant(&block)
+      return to_enum(__method__) unless block_given?
+
+      each_child_node do |child_node|
+        yield child_node
+        child_node.each_descendant(&block)
+      end
+    end
+
+    # Calls the given block for the receiver and each descendant node with depth first order.
+    # If no block is given, an `Enumerator` is returned.
+    #
+    # This method would be useful when you treat the receiver node as a root of tree and want to
+    # iterate all nodes in the tree.
+    #
+    # @yieldparam [Node] node each node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_node(&block)
+      return to_enum(__method__) unless block_given?
+      yield self
+      each_descendant(&block)
+    end
+  end
+end

data/lib/astrolabe/version.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+module Astrolabe
+  # @api private
+  # http://semver.org/
+  module Version
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 0
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/lib/astrolabe.rb

@@ -0,0 +1,3 @@
+# coding: utf-8
+
+require 'astrolabe/builder'

data/spec/.rubocop.yml

@@ -0,0 +1,5 @@
+
+inherit_from: ../.rubocop.yml
+
+Documentation:
+  Enabled: false

data/spec/astrolabe/node_spec.rb

@@ -0,0 +1,318 @@
+# coding: utf-8
+
+require 'astrolabe/node'
+
+module Astrolabe
+  describe Node, :ast do
+    describe '#parent' do
+      let(:source) { <<-END }
+        def some_method(arg_a, arg_b)
+          do_something
+        end
+      END
+
+      # (def :some_method
+      #   (args
+      #     (arg :arg_a)
+      #     (arg :arg_b))
+      #   (send nil :do_something))
+
+      context 'when the node has parent' do
+        let(:target_node) { root_node.each_node.find(&:args_type?) }
+
+        it 'returns the parent node' do
+          expect(target_node.parent).to be_def_type
+        end
+      end
+
+      context 'when the node does not have parent' do
+        it 'returns nil' do
+          expect(root_node.parent).to be_nil
+        end
+      end
+    end
+
+    describe '#root?' do
+      let(:source) { <<-END }
+        def some_method
+          do_something
+        end
+      END
+
+      subject { target_node.root? }
+
+      context 'with root node' do
+        let(:target_node) { root_node }
+        it { is_expected.to be true }
+      end
+
+      context 'with non-root node' do
+        let(:target_node) { root_node.each_child_node.to_a.first }
+        it { is_expected.to be false }
+      end
+    end
+
+    describe '#each_ancestor' do
+      let(:source) { <<-END }
+        class SomeClass
+          attr_reader :some_attr
+
+          def some_method(arg_a, arg_b)
+            do_something
+          end
+        end
+      END
+
+      # (class
+      #   (const nil :SomeClass) nil
+      #   (begin
+      #     (send nil :attr_reader
+      #       (sym :some_attr))
+      #     (def :some_method
+      #       (args
+      #         (arg :arg_a)
+      #         (arg :arg_b))
+      #       (send nil :do_something))))
+
+      let(:target_node) { root_node.each_node.find(&:args_type?) }
+      let(:expected_types) { [:def, :begin, :class] }
+
+      context 'when a block is given' do
+        it 'yields each ancestor node in order from parent to root' do
+          yielded_types = []
+
+          target_node.each_ancestor do |node|
+            yielded_types << node.type
+          end
+
+          expect(yielded_types).to eq(expected_types)
+        end
+
+        it 'returns itself' do
+          returned_value = target_node.each_ancestor {}
+          expect(returned_value).to equal(target_node)
+        end
+      end
+
+      context 'when no block is given' do
+        it 'returns an enumerator' do
+          expect(target_node.each_ancestor).to be_a Enumerator
+        end
+
+        describe 'the returned enumerator' do
+          subject(:enumerator) { target_node.each_ancestor }
+
+          it 'enumerates ancestor nodes' do
+            expected_types.each do |expected_type|
+              expect(enumerator.next.type).to eq(expected_type)
+            end
+
+            expect { enumerator.next }.to raise_error(StopIteration)
+          end
+        end
+      end
+    end
+
+    describe '#each_child_node' do
+      let(:source) { <<-END }
+        def some_method(arg_a, arg_b)
+          do_something
+        end
+      END
+
+      # (def :some_method
+      #   (args
+      #     (arg :arg_a)
+      #     (arg :arg_b))
+      #   (send nil :do_something))
+
+      let(:target_node) { root_node.each_node.find(&:def_type?) }
+      let(:expected_types) { [:args, :send] }
+
+      context 'when a block is given' do
+        it 'yields each child node' do
+          yielded_types = []
+
+          target_node.each_child_node do |node|
+            yielded_types << node.type
+          end
+
+          expect(yielded_types).to eq(expected_types)
+        end
+
+        it 'returns itself' do
+          returned_value = target_node.each_child_node {}
+          expect(returned_value).to equal(target_node)
+        end
+      end
+
+      context 'when no block is given' do
+        it 'returns an enumerator' do
+          expect(target_node.each_child_node).to be_a(Enumerator)
+        end
+
+        describe 'the returned enumerator' do
+          subject(:enumerator) { target_node.each_child_node }
+
+          it 'enumerates the child nodes' do
+            expected_types.each do |expected_type|
+              expect(enumerator.next.type).to eq(expected_type)
+            end
+
+            expect { enumerator.next }.to raise_error(StopIteration)
+          end
+        end
+      end
+    end
+
+    describe '#each_descendant' do
+      let(:source) { <<-END }
+        class SomeClass
+          attr_reader :some_attr
+
+          def some_method(arg_a, arg_b)
+            do_something
+          end
+        end
+      END
+
+      # (class
+      #   (const nil :SomeClass) nil
+      #   (begin
+      #     (send nil :attr_reader
+      #       (sym :some_attr))
+      #     (def :some_method
+      #       (args
+      #         (arg :arg_a)
+      #         (arg :arg_b))
+      #       (send nil :do_something))))
+
+      let(:target_node) { root_node }
+      let(:expected_types) { [:const, :begin, :send, :sym, :def, :args, :arg, :arg, :send] }
+
+      context 'when a block is given' do
+        it 'yields each descendant node with depth first order' do
+          yielded_types = []
+
+          target_node.each_descendant do |node|
+            yielded_types << node.type
+          end
+
+          expect(yielded_types).to eq(expected_types)
+        end
+
+        it 'returns itself' do
+          returned_value = target_node.each_descendant {}
+          expect(returned_value).to equal(target_node)
+        end
+      end
+
+      context 'when no block is given' do
+        it 'returns an enumerator' do
+          expect(target_node.each_descendant).to be_a(Enumerator)
+        end
+
+        describe 'the returned enumerator' do
+          subject(:enumerator) { target_node.each_descendant }
+
+          it 'enumerates the descendant nodes' do
+            expected_types.each do |expected_type|
+              expect(enumerator.next.type).to eq(expected_type)
+            end
+
+            expect { enumerator.next }.to raise_error(StopIteration)
+          end
+        end
+      end
+    end
+
+    describe '#each_node' do
+      let(:source) { <<-END }
+        class SomeClass
+          attr_reader :some_attr
+
+          def some_method(arg_a, arg_b)
+            do_something
+          end
+        end
+      END
+
+      # (class
+      #   (const nil :SomeClass) nil
+      #   (begin
+      #     (send nil :attr_reader
+      #       (sym :some_attr))
+      #     (def :some_method
+      #       (args
+      #         (arg :arg_a)
+      #         (arg :arg_b))
+      #       (send nil :do_something))))
+
+      let(:target_node) { root_node }
+      let(:expected_types) { [:class, :const, :begin, :send, :sym, :def, :args, :arg, :arg, :send] }
+
+      context 'when a block is given' do
+        it 'yields itself and each descendant node with depth first order' do
+          yielded_types = []
+
+          target_node.each_node do |node|
+            yielded_types << node.type
+          end
+
+          expect(yielded_types).to eq(expected_types)
+        end
+
+        it 'returns itself' do
+          returned_value = target_node.each_node {}
+          expect(returned_value).to equal(target_node)
+        end
+      end
+
+      context 'when no block is given' do
+        it 'returns an enumerator' do
+          expect(target_node.each_node).to be_a(Enumerator)
+        end
+
+        describe 'the returned enumerator' do
+          subject(:enumerator) { target_node.each_node }
+
+          it 'enumerates the origin and the descendant nodes' do
+            expected_types.each do |expected_type|
+              expect(enumerator.next.type).to eq(expected_type)
+            end
+
+            expect { enumerator.next }.to raise_error(StopIteration)
+          end
+        end
+      end
+    end
+
+    describe '#send_type?' do
+      subject { root_node.send_type? }
+
+      context 'with send type node' do
+        let(:source) { 'do_something' }
+        it { is_expected.to be true }
+      end
+
+      context 'with non-send type node' do
+        let(:source) { 'foo = 1' }
+        it { is_expected.to be false }
+      end
+    end
+
+    describe '#defined_type?' do
+      subject { root_node.defined_type? }
+
+      context 'with defined? type node' do
+        let(:source) { 'defined?(Foo)' }
+        it { is_expected.to be true }
+      end
+
+      context 'non-defined? type node' do
+        let(:source) { 'foo = 1' }
+        it { is_expected.to be false }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
+  require path
+end
+
+if ENV['TRAVIS']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/'
+  end
+end

data/spec/support/shared_contexts.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+shared_context 'AST', :ast do
+  let(:root_node) do
+    fail '#source must be defined with #let' unless respond_to?(:source)
+
+    require 'astrolabe/builder'
+    require 'parser/current'
+
+    buffer = Parser::Source::Buffer.new('(string)')
+    buffer.source = source
+
+    builder = Astrolabe::Builder.new
+    parser = Parser::CurrentRuby.new(builder)
+    parser.parse(buffer)
+  end
+end

metadata

@@ -0,0 +1,228 @@
+--- !ruby/object:Gem::Specification
+name: astrolabe
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Yuji Nakayama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: Object-oriented AST library for Parser
+email:
+- nkymyj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- astrolabe.gemspec
+- lib/astrolabe.rb
+- lib/astrolabe/builder.rb
+- lib/astrolabe/node.rb
+- lib/astrolabe/version.rb
+- spec/.rubocop.yml
+- spec/astrolabe/node_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts.rb
+homepage: https://github.com/yujinakayama/astrolabe
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: Object-oriented AST library for Parser
+test_files:
+- spec/.rubocop.yml
+- spec/astrolabe/node_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_contexts.rb
+has_rdoc: