astrolabe 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46c2d6149556152034a1102c6a17a722068b7d05
-  data.tar.gz: 89ff885e03757862cd9d5345bfae9127cd5665c0
+  metadata.gz: 9b3016609691bcb111bfe66a66ff77da7e533aab
+  data.tar.gz: f3314ca723a831d03df024b7e5be1539a5483f76
 SHA512:
-  metadata.gz: b76199cb0b7abcab33a57187876733b87eac1e88f0c1db2f96954b99c13b2f707481bfdb71778eac70c02e180bc65a35508b11dceadc46c9bc41aa3be28a7839
-  data.tar.gz: 3cee02d4725f5ed4a98a3b7ba49818855480a2cdcbd241855dabeb37dea5fe6aaa697544ff8da485f91e5acd9433d24d41a57f435ef9ad9db73b32740a1bdbe0
+  metadata.gz: 59af596675bb9815ee963ab92275f636034031c2ec1e245163af0a77b3602a82cdf01072191e958d1faa746d1248a7737fe27907eae741225858d172eaf6c854
+  data.tar.gz: c200880804038aa30c87fe8d64f0c50d51823ef5c7c878d7bb3ad6d319238557dd47c2e8585e988efc0a18c8ba3f7a62b451739919ad5a95da1125bb0a4dc3d9

data/Guardfile

@@ -7,6 +7,7 @@ group :red_green_refactor, halt_on_fail: true do
     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

data/Rakefile

@@ -5,7 +5,20 @@ 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)
-task ci: %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/benchmark/.rubocop.yml

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

data/benchmark/benchmark_helper.rb

@@ -0,0 +1,107 @@
+# coding: utf-8
+
+class Benchmarking
+  class << self
+    attr_accessor :warm_up
+    alias_method :warm_up?, :warm_up
+    attr_writer :loop_count
+
+    def loop_count
+      @loop_count ||= 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 run
+    @process.call
+  end
+
+  def time
+    return @time if @time
+
+    self.class.loop_count.times { run } if self.class.warm_up?
+    GC.start # https://github.com/ruby/ruby/blob/v2_1_2/lib/benchmark.rb#L265
+
+    beginning = Time.now
+    self.class.loop_count.times { run }
+    ending = Time.now
+
+    @time = ending - beginning
+  end
+
+  def pretty_time
+    self.class.pretty_time(time)
+  end
+
+  def inspect
+    "#{name} (#{pretty_time})"
+  end
+
+  alias_method :to_s, :inspect
+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
+
+  {
+          twice: 2,
+    three_times: 3,
+     four_times: 4,
+     five_times: 5,
+      six_times: 6,
+    seven_times: 7
+  }.each do |name, value|
+    chain name do
+      @times = value
+    end
+  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/benchmark/performance_spec.rb

@@ -0,0 +1,342 @@
+# coding: utf-8
+
+require_relative 'benchmark_helper'
+require 'astrolabe/node'
+require 'parser/current'
+
+describe 'performance' do
+  Benchmarking.warm_up = true
+  Benchmarking.loop_count = 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?
+
+            each_child_node do |child_node|
+              yield child_node
+              child_node.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?
+
+            each_child_node do |child_node|
+              yield child_node
+              child_node.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
+
+            each_child_node do |child_node|
+              proc_object.call(child_node)
+              child_node.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 5 times) faster than nested-yield' do
+        expect(block_pass).to be_faster_than(nested_yield).five_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/lib/astrolabe/node.rb

@@ -69,12 +69,14 @@ module Astrolabe
     # @yieldparam [Node] node each ancestor node
     # @return [self] if a block is given
     # @return [Enumerator] if no block is given
-    def each_ancestor(&block)
+    def each_ancestor
       return to_enum(__method__) unless block_given?
 
-      if parent
-        yield parent
-        parent.each_ancestor(&block)
+      last_node = self
+
+      while (current_node = last_node.parent)
+        yield current_node
+        last_node = current_node
       end
 
       self
@@ -108,11 +110,8 @@ module Astrolabe
     # @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
+      visit_descendants(&block)
+      self
     end
 
     # Calls the given block for the receiver and each descendant node with depth first order.
@@ -129,5 +128,15 @@ module Astrolabe
       yield self
       each_descendant(&block)
     end
+
+    protected
+
+    def visit_descendants(&block)
+      children.each do |child|
+        next unless child.is_a?(Node)
+        yield child
+        child.visit_descendants(&block)
+      end
+    end
   end
 end

data/lib/astrolabe/version.rb

@@ -5,7 +5,7 @@ module Astrolabe
   # http://semver.org/
   module Version
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
 
     def self.to_s

data/spec/astrolabe/node_spec.rb

@@ -17,7 +17,7 @@ module Astrolabe
       #     (arg :arg_b))
       #   (send nil :do_something))
 
-      context 'when the node has parent' do
+      context 'with a non-root node' do
         let(:target_node) { root_node.each_node.find(&:args_type?) }
 
         it 'returns the parent node' do
@@ -25,7 +25,7 @@ module Astrolabe
         end
       end
 
-      context 'when the node does not have parent' do
+      context 'with a root node' do
         it 'returns nil' do
           expect(root_node.parent).to be_nil
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: astrolabe
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Yuji Nakayama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-04 00:00:00.000000000 Z
+date: 2014-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -188,6 +188,9 @@ files:
 - README.md
 - Rakefile
 - astrolabe.gemspec
+- benchmark/.rubocop.yml
+- benchmark/benchmark_helper.rb
+- benchmark/performance_spec.rb
 - lib/astrolabe.rb
 - lib/astrolabe/builder.rb
 - lib/astrolabe/node.rb