rubyjobbuilderdsl 0.0.2 → 0.0.3

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/README.md

@@ -1,130 +0,0 @@
-[![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 { |ancestor_node| ... }
-
-# This is different from `node.children.each { |child| ... }`
-# which yields all children including non-node element.
-node.each_child_node { |child_node| ... }
-
-# These iteration methods can be chained by Enumerable methods.
-# Find the first lvar node under the receiver node.
-lvar_node = node.each_descendant.find(&:lvar_type?)
-
-# Iterate the receiver node itself and the descendant nodes.
-# This would be useful when you treat the receiver node as a root of tree
-# and want to iterate all nodes in the tree.
-ast.each_node { |node| ... }
-
-# Yield only specific type nodes.
-ast.each_node(:send) { |send_node| ... }
-# This is equivalent to:
-ast.each_node.select(&:send_type?).each { |send_node| ... }
-
-# Yield only nodes matching any of the types.
-ast.each_node(:send, :block) { |send_or_block_node| ... }
-ast.each_node([:send, :block]) { |send_or_block_node| ... }
-# These are equivalent to:
-ast.each_node
-  .select { |node| [:send, :block].include?(node.type) }
-  .each { |send_or_block_node| ... }
-```
-
-## 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/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/Rakefile

@@ -1,24 +0,0 @@
-# coding: utf-8
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-desc 'Run benchmark specs'
-RSpec::Core::RakeTask.new(:benchmark) do |task|
-  task.pattern = 'benchmark/**/*_spec.rb'
-  task.rspec_opts = '--format documentation'
-end
-
-RuboCop::RakeTask.new(:style)
-
-task default: %w(spec style)
-
-if RUBY_ENGINE == 'ruby'
-  task ci: %w(spec style benchmark)
-else
-  # Benchmarks on JRuby and Rubinius are not as stable as CRuby...
-  task ci: %w(spec style)
-end

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/astrolabe.gemspec

@@ -1,34 +0,0 @@
-# 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       = 'An object-oriented AST extension 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.2.0.pre.3', '< 3.0'
-
-  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/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/benchmark/benchmark_helper.rb

@@ -1,122 +0,0 @@
-# coding: utf-8
-
-class Benchmarking
-  class << self
-    attr_accessor :warm_up
-    alias_method :warm_up?, :warm_up
-    attr_writer :trial_count, :loop_count_in_trial
-
-    def trial_count
-      @trial_count ||= 3
-    end
-
-    def loop_count_in_trial
-      @loop_count_in_trial ||= 100
-    end
-
-    def pretty_time(time)
-      format('%0.05f sec', time)
-    end
-  end
-
-  attr_reader :name
-
-  def initialize(name, &block)
-    @name = name
-    @process = block
-  end
-
-  def average_time
-    measure if times.empty?
-    times.reduce(:+) / self.class.trial_count
-  end
-
-  alias_method :time, :average_time
-
-  def pretty_time
-    self.class.pretty_time(time)
-  end
-
-  def times
-    @times ||= []
-  end
-
-  def inspect
-    "#{name} (#{pretty_time})"
-  end
-
-  alias_method :to_s, :inspect
-
-  private
-
-  def measure
-    fail 'Already measured!' unless times.empty?
-
-    self.class.loop_count.times { run } if self.class.warm_up?
-
-    self.class.trial_count.times do
-      GC.start # https://github.com/ruby/ruby/blob/v2_1_2/lib/benchmark.rb#L265
-
-      beginning = Time.now
-      self.class.loop_count_in_trial.times { run }
-      ending = Time.now
-
-      times << (ending - beginning)
-    end
-  end
-
-  def run
-    @process.call
-  end
-end
-
-RSpec::Matchers.define :be_faster_than do |other|
-  match do |subject|
-    if @times
-      subject.time < (other.time / @times)
-    else
-      subject.time < other.time
-    end
-  end
-
-  chain :at_least do |times|
-    @times = times
-  end
-
-  # Just a syntax sugar.
-  chain :times do
-  end
-
-  failure_message do |subject|
-    other_label = other.name
-    other_label << " / #{@times}" if @times
-
-    label_width = [subject.name, other_label].map { |label| label.length }.max
-
-    message = "#{subject.name.rjust(label_width)}: #{subject.pretty_time}\n"
-
-    if @times
-      message << "#{other_label.rjust(label_width)}: "
-      shortened_other_time = Benchmarking.pretty_time(other.time / @times)
-      message << "#{shortened_other_time} (#{other.pretty_time} / #{@times})"
-    else
-      message << "#{other_label.rjust(label_width)}: #{other.pretty_time}"
-    end
-  end
-end
-
-RSpec::Matchers.define :be_as_fast_as do |other|
-  margin = 1.2
-
-  match do |subject|
-    subject.time < (other.time * margin)
-  end
-
-  failure_message do |subject|
-    label_width = [subject, other].map { |b| b.name.length }.max
-
-    [subject, other].map do |benchmark|
-      "#{benchmark.name.rjust(label_width)}: #{benchmark.pretty_time}"
-    end.join("\n")
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/benchmark/performance_spec.rb

@@ -1,346 +0,0 @@
-# coding: utf-8
-
-require_relative 'benchmark_helper'
-require 'astrolabe/node'
-require 'parser/current'
-
-describe 'performance' do
-  Benchmarking.warm_up = true
-  Benchmarking.trial_count = 3
-  Benchmarking.loop_count_in_trial = 1000
-
-  def generate_source(max, current_nest_level = 1)
-    <<-END
-    class SomeClass#{current_nest_level}
-      def some_method(foo)
-        do_something do |bar|
-        end
-      end
-
-      #{generate_source(max, current_nest_level + 1) if current_nest_level < max}
-    end
-    END
-  end
-
-  let(:source) { generate_source(100) }
-
-  def create_builder_class(node_class)
-    Class.new(Parser::Builders::Default) do
-      define_method(:n) do |type, children, source_map|
-        node_class.new(type, children, location: source_map)
-      end
-    end
-  end
-
-  def ast_with_node_class(node_class)
-    buffer = Parser::Source::Buffer.new('(string)')
-    buffer.source = source
-    builder = create_builder_class(node_class).new
-    parser = Parser::CurrentRuby.new(builder)
-    parser.parse(buffer)
-  end
-
-  describe 'Node#each_descendant' do
-    class EachDescendantBenchmark < Benchmarking
-      def initialize(name, root_node)
-        @name = name
-        @root_node = root_node
-      end
-
-      def run
-        count = 0
-
-        @root_node.each_descendant do
-          count += 1
-        end
-
-        fail if count == 0
-      end
-    end
-
-    let(:current_implementation) do
-      EachDescendantBenchmark.new('current implementation', ast_with_node_class(Astrolabe::Node))
-    end
-
-    describe 'nested-yield vs. block-pass vs. proc-pass' do
-      let(:nested_yield) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant
-            return to_enum(__method__) unless block_given?
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant { |node| yield node }
-            end
-          end
-        end
-
-        EachDescendantBenchmark.new('nested-yield', ast_with_node_class(node_class))
-      end
-
-      let(:block_pass) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant(&block)
-            end
-          end
-        end
-
-        EachDescendantBenchmark.new('block-pass', ast_with_node_class(node_class))
-      end
-
-      let(:proc_pass) do
-        node_class = Class.new(Astrolabe::Node) do
-          # Yeah, this is ugly interface, but just for reference.
-          def each_descendant(proc_object = nil, &block)
-            return to_enum(__method__) if !block_given? && !proc_object
-
-            proc_object ||= block
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              proc_object.call(child)
-              child.each_descendant(proc_object)
-            end
-          end
-        end
-
-        EachDescendantBenchmark.new('proc-pass', ast_with_node_class(node_class))
-      end
-
-      specify 'block-pass is obviously (at least 4 times) faster than nested-yield' do
-        expect(block_pass).to be_faster_than(nested_yield).at_least(4).times
-      end
-
-      specify 'block-pass is a bit faster than proc-pass' do
-        expect(block_pass).to be_faster_than(proc_pass)
-      end
-
-      describe 'current implementation' do
-        it 'is as fast as block-pass' do
-          expect(current_implementation).to be_as_fast_as(block_pass)
-        end
-      end
-    end
-
-    describe 'inline code vs. delegation to #each_child_node' do
-      let(:inline_code) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant(&block)
-            end
-
-            self
-          end
-        end
-
-        EachDescendantBenchmark.new('inline code', ast_with_node_class(node_class))
-      end
-
-      let(:delegation) do
-        node_class = Class.new(Astrolabe::Node) do
-          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
-        end
-
-        EachDescendantBenchmark.new('delegation', ast_with_node_class(node_class))
-      end
-
-      specify 'inline code is relatively faster than delegation' do
-        expect(inline_code).to be_faster_than(delegation)
-      end
-
-      describe 'current implementation' do
-        it 'is as fast as inline code' do
-          expect(current_implementation).to be_as_fast_as(inline_code)
-        end
-      end
-    end
-
-    describe 'Array#each vs. for-loop' do
-      let(:array_each) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant(&block)
-            end
-
-            self
-          end
-        end
-
-        EachDescendantBenchmark.new('Array#each', ast_with_node_class(node_class))
-      end
-
-      let(:for_loop) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-
-            for child in children # rubocop:disable For
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant(&block)
-            end
-
-            self
-          end
-        end
-
-        EachDescendantBenchmark.new('for-loop', ast_with_node_class(node_class))
-      end
-
-      specify "there's no obvious difference between them" do
-        expect(array_each).to be_as_fast_as(for_loop)
-      end
-
-      describe 'current implementation' do
-        it 'is as fast as Array#each' do
-          expect(current_implementation).to be_as_fast_as(array_each)
-        end
-      end
-    end
-
-    describe 'pure recursion vs. combination of entry and recursion methods' do
-      let(:pure_recursion) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.each_descendant(&block)
-            end
-
-            self
-          end
-        end
-
-        EachDescendantBenchmark.new('pure recursion', ast_with_node_class(node_class))
-      end
-
-      let(:combination) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_descendant(&block)
-            return to_enum(__method__) unless block_given?
-            visit_descendants(&block)
-            self
-          end
-
-          def visit_descendants(&block)
-            children.each do |child|
-              next unless child.is_a?(self.class)
-              yield child
-              child.visit_descendants(&block)
-            end
-          end
-        end
-
-        EachDescendantBenchmark.new('combination', ast_with_node_class(node_class))
-      end
-
-      specify 'combination is faster than pure recursion' do
-        expect(combination).to be_faster_than(pure_recursion)
-      end
-
-      describe 'current implementation' do
-        it 'is as fast as combination' do
-          expect(current_implementation).to be_as_fast_as(combination)
-        end
-      end
-    end
-  end
-
-  describe 'Node#each_ancestor' do
-    class EachAncestorBenchmark < Benchmarking
-      def initialize(name, root_node)
-        @name = name
-        @deepest_node = root_node.each_node.max_by { |node| node.each_ancestor.count }
-      end
-
-      def run
-        count = 0
-
-        @deepest_node.each_ancestor do
-          count += 1
-        end
-
-        fail if count == 0
-      end
-    end
-
-    let(:current_implementation) do
-      EachAncestorBenchmark.new('current implementation', ast_with_node_class(Astrolabe::Node))
-    end
-
-    describe 'recursion vs. while-loop' do
-      let(:while_loop) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_ancestor
-            return to_enum(__method__) unless block_given?
-
-            last_node = self
-
-            while (current_node = last_node.parent)
-              yield current_node
-              last_node = current_node
-            end
-
-            self
-          end
-        end
-
-        EachAncestorBenchmark.new('while-loop', ast_with_node_class(node_class))
-      end
-
-      let(:recursion) do
-        node_class = Class.new(Astrolabe::Node) do
-          def each_ancestor(&block)
-            return to_enum(__method__) unless block_given?
-
-            if parent
-              yield parent
-              parent.each_ancestor(&block)
-            end
-
-            self
-          end
-        end
-
-        EachAncestorBenchmark.new('recursion', ast_with_node_class(node_class))
-      end
-
-      specify 'while-loop is faster than recursion' do
-        expect(while_loop).to be_faster_than(recursion)
-      end
-
-      describe 'current implementation' do
-        it 'is as fast as while-loop' do
-          expect(current_implementation).to be_as_fast_as(while_loop)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/lib/astrolabe/builder.rb

@@ -1,28 +0,0 @@
-# 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