rubyjobbuilderdsl 0.0.0 → 0.0.1

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

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

@@ -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/vendor/bundle/ruby/2.1.0/gems/astrolabe-1.3.0/lib/astrolabe/node.rb

@@ -0,0 +1,270 @@
+# 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?`
+  #
+  #   # Find the first lvar node under the receiver node.
+  #   lvar_node = node.each_descendant.find(&: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
+
+    # Returns the index of the receiver node in its siblings.
+    #
+    # @return [Integer] the index of the receiver node in its siblings
+    def sibling_index
+      parent.children.index { |sibling| sibling.equal?(self) }
+    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.
+    #
+    # @overload each_ancestor
+    #   Yield all nodes.
+    # @overload each_ancestor(type)
+    #   Yield only nodes matching the type.
+    #   @param [Symbol] type a node type
+    # @overload each_ancestor(type_a, type_b, ...)
+    #   Yield only nodes matching any of the types.
+    #   @param [Symbol] type_a a node type
+    #   @param [Symbol] type_b a node type
+    # @overload each_ancestor(types)
+    #   Yield only nodes matching any of types in the array.
+    #   @param [Array<Symbol>] types an array containing node types
+    # @yieldparam [Node] node each ancestor node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_ancestor(*types, &block)
+      return to_enum(__method__, *types) unless block_given?
+
+      types.flatten!
+
+      if types.empty?
+        visit_ancestors(&block)
+      else
+        visit_ancestors_with_types(types, &block)
+      end
+
+      self
+    end
+
+    # Returns an array of ancestor nodes.
+    # This is a shorthand for `node.each_ancestor.to_a`.
+    #
+    # @return [Array<Node>] an array of ancestor nodes
+    def ancestors
+      each_ancestor.to_a
+    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.
+    #
+    # @overload each_child_node
+    #   Yield all nodes.
+    # @overload each_child_node(type)
+    #   Yield only nodes matching the type.
+    #   @param [Symbol] type a node type
+    # @overload each_child_node(type_a, type_b, ...)
+    #   Yield only nodes matching any of the types.
+    #   @param [Symbol] type_a a node type
+    #   @param [Symbol] type_b a node type
+    # @overload each_child_node(types)
+    #   Yield only nodes matching any of types in the array.
+    #   @param [Array<Symbol>] types an array containing node types
+    # @yieldparam [Node] node each child node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_child_node(*types)
+      return to_enum(__method__, *types) unless block_given?
+
+      types.flatten!
+
+      children.each do |child|
+        next unless child.is_a?(Node)
+        yield child if types.empty? || types.include?(child.type)
+      end
+
+      self
+    end
+
+    # Returns an array of child nodes.
+    # This is a shorthand for `node.each_child_node.to_a`.
+    #
+    # @return [Array<Node>] an array of child nodes
+    def child_nodes
+      each_child_node.to_a
+    end
+
+    # Calls the given block for each descendant node with depth first order.
+    # If no block is given, an `Enumerator` is returned.
+    #
+    # @overload each_descendant
+    #   Yield all nodes.
+    # @overload each_descendant(type)
+    #   Yield only nodes matching the type.
+    #   @param [Symbol] type a node type
+    # @overload each_descendant(type_a, type_b, ...)
+    #   Yield only nodes matching any of the types.
+    #   @param [Symbol] type_a a node type
+    #   @param [Symbol] type_b a node type
+    # @overload each_descendant(types)
+    #   Yield only nodes matching any of types in the array.
+    #   @param [Array<Symbol>] types an array containing node types
+    # @yieldparam [Node] node each descendant node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_descendant(*types, &block)
+      return to_enum(__method__, *types) unless block_given?
+
+      types.flatten!
+
+      if types.empty?
+        visit_descendants(&block)
+      else
+        visit_descendants_with_types(types, &block)
+      end
+
+      self
+    end
+
+    # Returns an array of descendant nodes.
+    # This is a shorthand for `node.each_descendant.to_a`.
+    #
+    # @return [Array<Node>] an array of descendant nodes
+    def descendants
+      each_descendant.to_a
+    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.
+    #
+    # @overload each_node
+    #   Yield all nodes.
+    # @overload each_node(type)
+    #   Yield only nodes matching the type.
+    #   @param [Symbol] type a node type
+    # @overload each_node(type_a, type_b, ...)
+    #   Yield only nodes matching any of the types.
+    #   @param [Symbol] type_a a node type
+    #   @param [Symbol] type_b a node type
+    # @overload each_node(types)
+    #   Yield only nodes matching any of types in the array.
+    #   @param [Array<Symbol>] types an array containing node types
+    # @yieldparam [Node] node each node
+    # @return [self] if a block is given
+    # @return [Enumerator] if no block is given
+    def each_node(*types, &block)
+      return to_enum(__method__, *types) unless block_given?
+
+      types.flatten!
+
+      yield self if types.empty? || types.include?(type)
+
+      if types.empty?
+        visit_descendants(&block)
+      else
+        visit_descendants_with_types(types, &block)
+      end
+
+      self
+    end
+
+    protected
+
+    def visit_descendants(&block)
+      children.each do |child|
+        next unless child.is_a?(Node)
+        yield child
+        child.visit_descendants(&block)
+      end
+    end
+
+    def visit_descendants_with_types(types, &block)
+      children.each do |child|
+        next unless child.is_a?(Node)
+        yield child if types.include?(child.type)
+        child.visit_descendants_with_types(types, &block)
+      end
+    end
+
+    private
+
+    def visit_ancestors
+      last_node = self
+
+      while (current_node = last_node.parent)
+        yield current_node
+        last_node = current_node
+      end
+    end
+
+    def visit_ancestors_with_types(types)
+      last_node = self
+
+      while (current_node = last_node.parent)
+        yield current_node if types.include?(current_node.type)
+        last_node = current_node
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+require 'astrolabe/node'
+
+module Astrolabe
+  # This module provides a shorthand method to create a {Node} like `AST::Sexp`.
+  #
+  # @see http://rubydoc.info/gems/ast/AST/Sexp
+  module Sexp
+    # Creates a {Node} with type `type` and children `children`.
+    def s(type, *children)
+      Node.new(type, children)
+    end
+  end
+end

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

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

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

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