rubyjobbuilderdsl 0.0.0 → 0.0.1

data/vendor/bundle/ruby/2.1.0/gems/ast-2.0.0/test/test_ast.rb

@@ -0,0 +1,243 @@
+require 'helper'
+
+describe AST::Node do
+  extend AST::Sexp
+
+  class MetaNode < AST::Node
+    attr_reader :meta
+  end
+
+  before do
+    @node = AST::Node.new(:node, [ 0, 1 ])
+    @metanode = MetaNode.new(:node, [ 0, 1 ], :meta => 'value')
+  end
+
+  it 'should have accessors for type and children' do
+    @node.type.should.equal :node
+    @node.children.should.equal [0, 1]
+  end
+
+  it 'should set metadata' do
+    @metanode.meta.should.equal 'value'
+  end
+
+  it 'should be frozen' do
+    @node.frozen?.should.be.true
+    @node.children.frozen?.should.be.true
+  end
+
+  it 'should return self when duping' do
+    @node.dup.should.equal? @node
+  end
+
+  it 'should return an updated node, but only if needed' do
+    @node.updated().should.be.identical_to @node
+    @node.updated(:node).should.be.identical_to @node
+    @node.updated(nil, [0, 1]).should.be.identical_to @node
+
+    updated = @node.updated(:other_node)
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal :other_node
+    updated.children.should.equal @node.children
+
+    updated.frozen?.should.be.true
+
+    updated = @node.updated(nil, [1, 1])
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal @node.type
+    updated.children.should.equal [1, 1]
+
+    updated = @metanode.updated(nil, nil, :meta => 'other_value')
+    updated.meta.should.equal 'other_value'
+  end
+
+  it 'should use fancy type in to_s' do
+    node = AST::Node.new(:ast_node)
+    node.to_s.should.equal '(ast-node ...)'
+  end
+
+  it 'should format to_sexp correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_sexp.should.equal '(a :sym [1, 2])'
+    AST::Node.new(:a, [ :sym, @node ]).to_sexp.should.equal "(a :sym\n  (node 0 1))"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_sexp.should.equal "(a :sym\n  (b\n    (node 0 1)\n    (node 0 1)))"
+  end
+
+  it 'should return self in to_ast' do
+    @node.to_ast.should.be.identical_to @node
+  end
+
+  it 'should only use type and children to compute #hash' do
+    @node.hash.should.equal([@node.type, @node.children, @node.class].hash)
+  end
+
+  it 'should only use type and children in #eql? comparisons' do
+    # Not identical but equivalent
+    @node.eql?(AST::Node.new(:node, [0, 1])).should.be.true
+    # Not identical and not equivalent
+    @node.eql?(AST::Node.new(:other, [0, 1])).should.be.false
+    # Not identical and not equivalent because of differend class
+    @node.eql?(@metanode).should.be.false
+  end
+
+  it 'should only use type and children in #== comparisons' do
+    @node.should.equal @node
+    @node.should.equal @metanode
+    @node.should.not.equal :foo
+
+    mock_node = Object.new.tap do |obj|
+      def obj.to_ast
+        self
+      end
+
+      def obj.type
+        :node
+      end
+
+      def obj.children
+        [ 0, 1 ]
+      end
+    end
+    @node.should.equal mock_node
+  end
+
+  it 'should allow to decompose nodes with a, b = *node' do
+    node = s(:gasgn, :$foo, s(:integer, 1))
+
+    var_name, value = *node
+    var_name.should.equal :$foo
+    value.should.equal s(:integer, 1)
+  end
+
+  it 'should concatenate with arrays' do
+    node = s(:gasgn, :$foo)
+    (node + [s(:integer, 1)]).
+        should.equal s(:gasgn, :$foo, s(:integer, 1))
+  end
+
+  it 'should append elements' do
+    node = s(:array)
+    (node << s(:integer, 1) << s(:string, "foo")).
+        should.equal s(:array, s(:integer, 1), s(:string, "foo"))
+  end
+
+  begin
+    eval <<-CODE
+    it 'should not trigger a rubinius bug' do
+      bar = [ s(:bar, 1) ]
+      baz = s(:baz, 2)
+      s(:foo, *bar, baz).should.equal s(:foo, s(:bar, 1), s(:baz, 2))
+    end
+    CODE
+  rescue SyntaxError
+    # Running on 1.8, ignore.
+  end
+end
+
+describe AST::Processor do
+  extend AST::Sexp
+
+  def have_sexp(text)
+    text = text.lines.map { |line| line.sub /^ +\|(.+)/, '\1' }.join.rstrip
+    lambda { |ast| ast.to_sexp == text }
+  end
+
+  class MockProcessor < AST::Processor
+    attr_reader :counts
+
+    def initialize
+      @counts = Hash.new(0)
+    end
+
+    def on_root(node)
+      count_node(node)
+      node.updated(nil, process_all(node.children))
+    end
+    alias on_body on_root
+
+    def on_def(node)
+      count_node(node)
+      name, arglist, body = node.children
+      node.updated(:def, [ name, process(arglist), process(body) ])
+    end
+
+    def handler_missing(node)
+      count_node(node)
+    end
+
+    def count_node(node)
+      @counts[node.type] += 1; nil
+    end
+  end
+
+  before do
+    @ast = AST::Node.new(:root, [
+      AST::Node.new(:def, [ :func,
+        AST::Node.new(:arglist, [ :foo, :bar ]),
+        AST::Node.new(:body, [
+          AST::Node.new(:invoke, [ :puts, "Hello world" ])
+        ])
+      ]),
+      AST::Node.new(:invoke, [ :func ])
+    ])
+
+    @processor = MockProcessor.new
+  end
+
+  it 'should visit every node' do
+    @processor.process(@ast).should.equal @ast
+    @processor.counts.should.equal({
+      :root    => 1,
+      :def     => 1,
+      :arglist => 1,
+      :body    => 1,
+      :invoke  => 2,
+    })
+  end
+
+  it 'should be able to replace inner nodes' do
+    def @processor.on_arglist(node)
+      node.updated(:new_fancy_arglist)
+    end
+
+    @processor.process(@ast).should have_sexp(<<-SEXP)
+    |(root
+    |  (def :func
+    |    (new-fancy-arglist :foo :bar)
+    |    (body
+    |      (invoke :puts "Hello world")))
+    |  (invoke :func))
+    SEXP
+  end
+
+  it 'should build sexps' do
+    s(:add,
+      s(:integer, 1),
+      s(:multiply,
+        s(:integer, 2),
+        s(:integer, 3))).should have_sexp(<<-SEXP)
+    |(add
+    |  (integer 1)
+    |  (multiply
+    |    (integer 2)
+    |    (integer 3)))
+    SEXP
+  end
+
+  it 'should return nil if passed nil' do
+    @processor.process(nil).should == nil
+  end
+
+  it 'should refuse to process non-nodes' do
+    lambda { @processor.process([]) }.should.raise NoMethodError, %r|to_ast|
+  end
+
+  it 'should allow to visit nodes with process_all(node)' do
+    @processor.process_all s(:foo, s(:bar), s(:integer, 1))
+    @processor.counts.should.equal({
+      :bar =>     1,
+      :integer => 1,
+    })
+  end
+end

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

@@ -0,0 +1,23 @@
+# Changelog
+
+## Development
+
+## v1.3.0
+
+* Add `Node#sibling_index`.
+
+## v1.2.1
+
+* Re-release 1.2.0 due to an error in `rubygems.org`.
+
+## v1.2.0
+
+* Add `Astrolabe::Sexp` module which provides a shorthand method to create a node like [`AST::Sexp`](http://rubydoc.info/gems/ast/AST/Sexp).
+
+## v1.1.0
+
+* Add `Node#ancestors`, `Node#child_nodes` and `Node#descendants` which return an array instead of enumerator.
+
+## v1.0.0
+
+* Initial API stable release in the Semantic Versioning.

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/Gemfile

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

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/Guardfile

@@ -0,0 +1,17 @@
+# 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' }
+    watch(%r{^benchmark/.+_spec\.rb$})
+  end
+
+  guard :rubocop, cli: '--format fuubar' do
+    watch(%r{.+\.rb$})
+    watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/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/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/README.md

@@ -0,0 +1,130 @@
+[![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

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

@@ -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       = '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

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