yard-bench 0.0.2

data/lib/dsl/bm_dsl.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+require 'benchmark'
+require_relative 'monkeypatches'
+
+#   ⌚ :meth1, :meth2
+# The information should be normalized and collected in a kind of knowledge base
+module YARD
+  module Bench
+    # Class to be included for benchmarking DSL.
+    #
+    # It contains `Hash` of the following structure:
+    #  — 
+    class Marks
+      include YARD::MonkeyPatches
+      
+      class Mark
+        attr_reader :times, :memory, :power, :deviation, :ok
+        def initialize(times, memory)
+          @times = times
+          @memory = memory
+          @ok = !@times.nil? && !@memory.nil?
+          normalized_times = @times.inject([]) { |agg, e| agg << (e.values[0] / (10**agg.size)) }
+          @deviation = normalized_times.standard_deviation * 100 / normalized_times.mean
+          @power = normalized_times.mean / @times[0].keys[0] * 1_000_000 if @ok && @deviation < 20
+        end
+      end
+      
+    protected
+      # Standard time for the current processor/ram to normalize benchmarks
+      STANDARD_TIME ||= Benchmark.measure { 1_000_000.times { "foo bar baz".capitalize }}.total 
+
+      # Mark specified method of a class to be benchmarkable
+      #
+      # @param clazz [Class] the class method is defined on
+      # @param meth [Symbol] the method(s) to set as benchmarkable; may be a wildcard
+      # @return [Hash] a set of methods marked benchmarkable for the desired class
+      def self.∈ clazz, meth
+        get_methods(clazz, meth).map {|m| bm…(clazz)[:methods][m] ||= nil}
+      end
+
+      # Mark specified method of a class to be benchmarkable and immediately benchmark
+      #
+      # @param clazz [Class] the class method is defined on
+      # @param meth [Symbol] the method(s) to set as benchmarkable; may be a wildcard
+      # @return [Hash] a set of methods marked benchmarkable for the desired class
+      def self.∈! clazz, meth
+        get_methods(clazz, meth).map { |m| bm…(clazz)[:methods][m] ||= self.mark(clazz, m) }
+      end
+
+      # Calculates benchmarks for all the marked methods
+      def self.⌛
+        bm… { |c, ms| # "String" => { :class => String, :methods => {…} }
+          ms[:methods].each { |m, marks| # { :capitalize => …, :split => nil }
+            ms[:methods][m] = self.mark(ms[:class], m) if marks.nil?
+            yield ms[:class], m, ms[:methods][m] if block_given?
+          }
+        }
+      end
+
+    private
+      def self.mark(clazz, m)
+        begin
+          (1..10).each { # Sometimes benchmark returns 0 for unknown reason. Ugly hack to mostly avoid.
+            mark = Mark.new(⌚(clazz, m), ☑(clazz, m))
+            break mark if mark.times[0].values[0] > 0
+            log.warn "Benchmarks returned zeroes: #{mark.times}, remeasuring…"
+          }
+        rescue
+          log.warn("Error calculating benchmarks: 〈#{$!}〉")
+          Mark.new(nil, nil)
+        end
+      end
+      # Get methods by their name with wildcards.
+      # @param clazz [Class] the class to retrieve methods for
+      # @param pattern [Symbol] the pattern to get method names for, either symbol,
+      #        representing the method, or one of the wildcards “:×”, “:××”, “:⋅”, “:⋅⋅”
+      # @return [Array<Symbol>] an array of methods
+      def self.get_methods(clazz, pattern)
+        case pattern
+          # puts all the methods, defined in this class to benchmarks
+          when :⋅ then clazz.instance_methods(false)
+          # puts all the methods, defined in this class and superclasses to benchmarks
+          when :⋅⋅ then clazz.instance_methods(true)
+          # puts all the singleton methods, defined in this class to benchmarks
+          when :× then clazz.singleton_methods(false)
+          # puts all the singleton methods, defined in this class and superclasses to benchmarks
+          when :×× then clazz.singleton_methods(true)
+          else [pattern]
+        end
+      end
+      
+      # Get all the benchmarks for the class. Lazy creates a `Set` to store
+      #   benchmarks for future use if there is no benchmarks for the given class yet.
+      #
+      # @param clazz [Class] the class to return benchmarks for
+      # @return [Hash] all the benchmarks, collected from DSL as following
+      #     benchmarks = {
+      #       "String" => <Hash: {:class => String.class, :methods => {:capitalize => {benchmarks}, :split => nil}}>,
+      #       "AClass" => <Hash: {:class => AClass.class, :methods => {:do_it => nil}}>
+      #     }
+      def self.bm… clazz = nil
+        it = (@@benchmarks ||= {}) # Hash { String => { :capitalize => {…}, :split => nil }}
+        it = (it[clazz.to_s] ||= {:class => clazz, :methods => {}}) unless clazz.nil?
+        if block_given?
+          it.each(&Proc.new)
+        else
+          it
+        end
+      end
+
+    public
+      # Returns benchmarks for the method given by spec (or the whole collection if none specified)
+      def self.get file, namespace, m
+        load "#{file}"
+        self.∈! Object.const_get(namespace), m
+      end
+      
+      # Measures the specified method of the class given
+      # @param clazz [Class] the class to measure method for
+      # @param m [Symbol] the method to measure
+      # @param iterations [Fixnum] an amount of iterations to do
+      # @return benchmarking total, normalized by STANDARD_TIME and 1_000_000 times
+      def self.⌚ clazz, m, iterations = 3
+        # Let’ calculate the applicable range
+        deg = (1..10).each { |v|
+          break v if Benchmark.measure { (10**v).times {clazz.☏ m} }.total > 0.01
+        }
+        (deg...deg+iterations).to_a.map { |d| 10**d }.map { |e|
+          { e => Benchmark.measure { e.times {clazz.☏ m} }.total / STANDARD_TIME }
+        }
+      end
+      # Measures the memory required for a method in KBytes.
+      # FIXME This is VERY inaccurate and lame.
+      # @param clazz [Class] the class to measure method for
+      # @param m [Symbol] the method to measure
+      # @param iterations [Fixnum] an amount of iterations to do
+      # @return an approximate amount of kilobytes
+      def self.☑ clazz, m, iterations = 10
+        kb = `ps -o rss= -p #{$$}`.to_i
+        iterations.times.map {
+          clazz.☏ m
+          `ps -o rss= -p #{$$}`.to_i
+        }.reduce(:+) / iterations - kb
+      end
+    end
+
+    module ::Kernel
+      # Mark the task for benchmarking
+      # @param attribs [[:rest]] the list of methods to benchmark
+      def ⌚ *attribs
+        attribs.each { |a| YARD::Bench::Marks.∈ self, a.to_sym }
+      end
+      alias benchmark ⌚
+      
+    end
+  end
+end

data/lib/dsl/monkeypatches.rb

@@ -0,0 +1,334 @@
+# encoding: utf-8
+
+module YARD
+  # Monkey patches (🐵) for shorthands.
+  #
+  # This module introduces new functionality
+  # for creation of some standard classes “samples.” It is used to emulate
+  # real data to be passed to automatic benchmarks in cases, when the methods
+  # have parameters required.
+  #
+  # @example To produce new random +String+, +Hash+, +Array+, +Fixnum+, one simply calls:
+  #   % pry
+  #   > require './lib/dsl/monkeypatches'
+  #   # ⇒ true
+  #   > String.∀ size: 30
+  #   # ⇒ "3XсO91Lпр490Rэщ Xза O нL с3VщB"
+  #   > Fixnum.∀
+  #   # ⇒ 301
+  #   > Hash.∀ size: 3
+  #   # ⇒ {
+  #   #    "aenvxgmsuqhpxgsbhrcjvyvhlrbexa" => "ьюWB4IVачъитяCи жH3O 8илыP Dц Kх",
+  #   #   "awohozdxdjzvombswswsfzsqfqfguxc" => 202,
+  #   #     "befqyvqhmrncboilgdjwbqpyvfgtp" => "ифMцGSь фъ BубITмPэIHрTJлъ9OдJщ9"
+  #   # }
+  #   > Array.∀ size: 3
+  #   # ⇒ [
+  #   #   [0] " эвъуL P 5июоCXъXе AB0 й1DьUфв",
+  #   #   [1] 800,
+  #   #   [2] 851
+  #   # ]
+  # @author Alexei Matyushkin <am@mudasobwa.ru>
+  module MonkeyPatches
+
+    class ::Array
+      # @source def … ; block_given? ? each(&Proc.new) : each ; end
+      alias … each
+      # def ≠ ; block_given? ? reject(&Proc.new) : reject ; end
+      alias ≠ reject
+      # def ≡ ; block_given? ? select(&Proc.new) : select ; end
+      alias ≡ select
+    end
+    class ::Hash
+      # def … ; block_given? ? each(&Proc.new) : each ; end
+      alias … each
+    end
+
+    # Enchancement of +String+ class to generate random sample based on the pattern given.
+    class ::String
+      # Generates random sample of +String+.
+      # @example To create the string of length 12, consisting of lowercased latin letters:
+      #   s1 = ('a'..'z').to_chars.∀ 12   # ⇒ fughtksnewqp
+      #   s2 = "".∀(12, ('a'..'z'))       # ⇒ jiuuoiqwbjty
+      # @see Range#to_chars
+      # @todo Possible wanna use {http://faker.rubyforge.org Faker} here
+      # @param size [Fixnum] the size of the sample to generate.
+      # @param symbols [Array<Char>] the list of characters used to generate the sample.
+      # @return [String] the string of the given length, consisting of random characters from the given set.
+      def ∀(size: 32, symbols: [*('A'..'Z'), *('а'..'я'), *('0'..'9'), *[' ']*10])
+        syms = case
+               when !self.empty? then self.scan('.')
+               when !(Array === symbols) && symbols.respond_to?(:to_a) then symbols.to_a
+               else symbols
+               end
+        raise ArgumentError.new("`:symbols` argument class must support `#sample` method (given #{symbols})") \
+          unless syms.respond_to? :sample
+        "".tap { |v| size.times { v << syms.sample } }.squeeze
+      end
+      alias any ∀
+    end
+
+    # Enchancement of +Fixnum+ class to generate random number in the interval [0, Fixnum).
+    class ::Fixnum
+      # Generates random +Fixnum+ in the given interval.
+      # @example To create the positive number not greater than 1000:
+      #   num = 1000.∀   # ⇒ 634
+      # @return a random number in the given interval.
+      def ∀
+        rand(self)
+      end
+      alias any ∀
+      
+      # Generates random +Fixnum+ in the given interval. We need +Fixnum+ implementing
+      # +new+ method for instantiating it as parameter in common way.
+      # @example To create the positive number not greater than 1000:
+      #   num = Fixnum.new 1000   # ⇒ 48
+      def self.new val = 1024
+        val.∀
+      end
+    end
+
+    # Enchancement of +Array+ class to generate random array of the given size. The array elements
+    # are instances of the samples given. E. g. by default, there is an array of strings and fixnums
+    # produced.
+    class ::Array
+      # Generates random sample of +Array+.
+      # @example To create an array of three string elements:
+      #   [""].∀ size: 3
+      #   # ⇒ [
+      #   #   [0] " пт64AVAэеыGN еCйдчDLFUL еPTюQL ",
+      #   #   [1] "лW1O Cи 4TZ Yиз моBи2 AзмсU5г о ",
+      #   #   [2] "70ZIзQOMXC0нXLPMкGдлэY7Bщ7Eх ой4"
+      #   # ]
+      # @param size [Fixnum] the size of the sample array to generate.
+      # @param samples [Array] the array of samples used to generate the sample array.
+      # @return [Array] the array of the given length, consisting of random elements from the given set.
+      def ∀(size: 64, samples: ["", 1000])
+        samples = self unless self.empty?
+        [].tap { |v| size.times { v << ::Kernel::random(:samples => samples) } }
+      end
+      alias any ∀
+    end
+
+    # Enchancement of +Hash+ class to generate random hash of the given size. The hash elements
+    # are instances of the samples given. The keys are in the range +(‘a’..‘z’)+.
+    # By default, there is a hash having strings and fixnums as values.
+    class ::Hash
+      # Generates random sample of +Hash+.
+      # @note When called on non-empty hash, the random elements are _added_ to the existing.
+      # @todo Do we really need to append randoms? Isn’t +{}.∀ | {:foo ⇒ 42}+ clearer?
+      # @example To create a hash of three elements:
+      #   {}.∀ size: 3
+      #   # ⇒ {
+      #   #   "pcnoljbhibgjywosztzheuimqfawzi" => 821,
+      #   # "rjdrhidkhrowsonpsmaskdjfbhpuwunh" => " рлшеALя н нмкж0отDщ5 MеьFKB1Mъ5",
+      #   # "zbalqtiqysdfbartnebvkmwzvudxkzmk" => "Dе904KшNщуO7EывхJбMUV йN Zч энж"
+      #   # }
+      # @param size [Fixnum] the size of the sample hash to generate.
+      # @param samples [Array] the array of samples used to generate the values of the sample hash.
+      # @return [Hash] the hash of the given length, consisting of random elements from the given set.
+      def ∀(size: 64, samples: ["", 1000])
+        self.dup.tap { |v|
+          size.times {
+            v["".∀(:symbols => [*('a'..'z')])] = ::Kernel::random(:samples => samples)
+          }
+        }
+      end
+      alias any ∀
+    end
+
+    # Enchancement of +Range+ class to join range elements into string.
+    class ::Range
+      # Joins range elements into string.
+      # @return [String] string representation of the range
+      def to_chars
+        self.to_a.join
+      end
+    end
+
+    # @private
+    module ::Enumerable
+      def sum
+        self.inject(0){|accum, i| accum + i }
+      end
+  
+      def mean
+        self.sum/self.length.to_f
+      end
+  
+      def sample_variance
+        m = self.mean
+        sum = self.inject(0){|accum, i| accum +(i-m)**2 }
+        sum/(self.length - 1).to_f
+      end
+  
+      def standard_deviation
+        return Math.sqrt(self.sample_variance)
+      end
+    end
+    
+    # Helper for parsing argument errors in machine-readable collection.
+    class ::ArgumentError
+      # Parses the error string and returns the machine-readable argument count contract.
+      # @return [Hash] consisting of an amount of arguments given,
+      # minimal required and (if makes sense) maximal.
+      def argument_data
+        # ⇒ wrong number of arguments (1 for 2..3)
+        /\((?<given>\d+)\s+\w+\s+(?<min_required>\d+)(?<modifier>\+|\.\.)?(?<max_required>\d+)\)/.match(self.to_s) { |m|
+          { :given => m[:given],
+            :min_required => m[:min_required],
+            :max_required => case m[:modifier]
+                             when '+' then '∞'
+                             when '..' then h[:max_required]
+                             else h[:min_required]
+                             end
+          }
+        }
+      end
+    end
+    
+    # Helper for parsing type errors in machine-readable format.
+    class ::TypeError
+      # Parses the error string and returns the machine-readable expected arguments classes.
+      # @return [Hash] consisting of two strings representing _given_ and _required_ argument types.
+      def type_data
+        # ⇒ can't convert Hash into Integer
+        # There are two ways to match: either rely on us locale, or find the uppercased classes
+        /[^[A-Z]]*(?<given>[A-Z]\w*)[^[A-Z]]*(?<required>[A-Z]\w*)/.match(self.to_s) { |m|
+          { :given => m[:given], :required => m[:required] }
+        }
+      end
+    end
+
+    # Some aestetics in aliasing:
+    # @example
+    #   my_proc = λ { |e| puts e } # ⇒ lambda, strict parameters list
+    #   my_proc = Λ { |e| puts e } # ⇒ proc, not strict parameters list
+    module ::Kernel
+      # Alias for lambda
+      alias λ lambda
+      # Alias for proc
+      alias Λ proc
+      # default set of classes, supporting `random` feature
+      DEFAULT_SAMPLES ||= ["", 1024, {}, []].freeze
+      # @private
+      # The stub class for determining parameter list
+      class RandomVoid ; def ∀ ; NotImplementedError.new('RandomVoid class is not intended to use.') ; end ; end
+
+    protected
+      # Random instance of random class
+      # @param samples [Array] the instances of classes supporting +#random+ method.
+      # Those will vbe used as initial parameters for calls to `random` on them.
+      # @return [Object] random instance of one of the classes given as parameters
+      def random(samples: DEFAULT_SAMPLES)
+        samples.dup.sample.∀
+      end
+    end
+
+    # Helpers for calling methods and instantiate class silently, even if there are
+    # arguments to be passed to constructor/method. The main idea is to try to guess
+    # the parameters, awaited by method, generate randoms for them and finally call
+    # the method on the singleton instance of this class.
+    class ::Class
+      # Instance of a class, lazy initialized with guessed parameters. Cached.
+      # @note There is a possibility to explicitely set the singleton instance, in which case all the methods will be called on it.
+      # @todo Maybe we need to overwrite setter for this variable to avoid weird settings like +String.★ = Fixnum.new+
+      # @see ☎
+      attr_accessor :★
+      # The result of last call to method with with fake params. Cached.
+      # @see ☏
+      attr_reader :☆
+      
+      # Tries to make a new instance of a class
+      def ☎
+        fake_parameters unless @★
+        @★
+      end
+
+      # Tries to call a method +m+ on a class.
+      # @param m [Symbol] the method to be called.
+      # @return [Object] the result of call to method +m+
+      def ☏ m = :to_s
+        ☎.send(m, *fake_parameters(:m => m))
+      end
+
+      # Instantiates the class with applicable random value.
+      # @param args [Array] if passed, used as sceleton for a call to {#∀} method.
+      # @return [Instance] a random value of this Class class.
+      def ∀ *args
+        begin
+          inst = self.☎
+          raise NotImplementedError.new("The class should implement `∀` instance method") \
+            unless inst.respond_to? :∀
+          inst.∀ *args
+        rescue Exception => e
+          raise NotImplementedError.new("No way: #{e}")
+        end
+      end
+
+private
+      # First of all, let′s try to determine parameters needed:
+      #
+      # method(__method__).parameters.inject([]) { |res, v| (res << v[1]) if v[0] == :req; res }
+      # method(__method__).parameters.select { |a| a[0] == :req }.map { |a| a[1] }
+      #
+      # Rehearsal ----------------------------------------------
+      # inject       0.510000   0.000000   0.510000 (  0.507843)
+      # select+map   0.470000   0.000000   0.470000 (  0.472166)
+      # ------------------------------------- total: 0.980000sec
+      # user     system      total        real
+      # inject       0.520000   0.000000   0.520000 (  0.518626)
+      # select+map   0.470000   0.000000   0.470000 (  0.473081)
+      #
+      # That’s why we are to use `select+map` version.
+      def required_parameters(m: :initialize)
+        param_selector = λ{ |type|
+          self.instance_method(m).parameters.select { |p| p[0] == type }.map { |p| p[1] }
+        }
+        { :req  => param_selector.call(:req), :rest => param_selector.call(:rest) }
+      end
+      # Suggests random parameters for instance method of a class
+      # Usage: `String.fake_parameters :method`
+      # @param m [Symbol] the method to suggest parameters for
+      # @return [Array] an array of parameters suggested
+      def fake_parameters(m: nil)
+        if (@☆ ||= {})[m].nil?
+          # We need an instance first of all
+          if m.nil? || !@★
+            params = required_parameters
+            guessed = [].∀(:size => params[:req].size, :samples => [RandomVoid.new])
+            guessed.map! { |elem|
+              begin
+                elem if @★ ||= self.new(*guessed)
+              rescue TypeError => e
+                ::Kernel.const_get(e.type_data[:required]).new.∀
+              end
+            }
+            @★ ||= self.new(*guessed)
+            @☆[nil] = guessed.map(&:class)
+          end
+          
+          # Let’s proceed with method
+          unless m.nil?
+            params = required_parameters :m => m
+            
+            guessed = [].∀(:size => params[:req].size, :samples => [RandomVoid.new])
+            guessed.map! { |elem|
+              begin
+                elem if @☆=@★.send(m, *guessed)
+              rescue TypeError => e
+                ::Kernel.const_get(e.type_data[:required]).new.∀
+              end
+            }
+            @☆[m] = guessed.map(&:class)
+          end
+          
+          guessed
+        else
+          @☆[m].map(&:∀)
+        end
+      end
+    end
+
+  end
+end

data/lib/yard-bench/handler.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require_relative '../dsl/bm_dsl'
+
+# FIXME Probably, that class is to be made as Proxy. Then during the methods
+#       processing we’ll have an access to it to print the benchmarks out
+#       within method scope…
+module YARD
+  module Handlers
+#    class BenchmarkObject < YARD::CodeObjects::Base
+#      def type ; :benchmark ; end
+#      def sep  ; '%'        ; end
+#    end
+    
+    class BenchmarkHandler < YARD::Handlers::Ruby::DSLHandler
+      handles method_call(:benchmark)
+      handles method_call(:⌚)
+      # we should only match method calls inside a namespace (class or module), not inside a method
+      # namespace_only
+    
+      def process
+        cos = []
+        statement.parameters.each { |astnode|
+          if astnode.respond_to? :jump
+            m = "#{astnode.jump(:string_content).source[1..-1]}" # [1..-1] is to get rid of symbol’s colon
+            if res = YARD::Bench::Marks.get("#{statement.file}", "#{namespace}", "#{m}")
+              obj = YARD::CodeObjects::MethodObject.new(namespace, "#{m}")
+              obj.benchmarks = res.map { |e| e.times }.flatten
+              obj.power = res.map { |e| e.power }.flatten[0]
+              obj.deviation = res.map { |e| e.deviation }.flatten[0]
+              obj.memory = res.map { |e| e.memory }.flatten
+              cos << obj
+#              bmo = BenchmarkObject.new(namespace, m)
+            end
+          end
+        }
+        cos
+      end
+      
+      def find_file(file)
+        
+      end
+    end
+  end
+end

data/lib/yard-bench/version.rb

@@ -0,0 +1,7 @@
+require 'yard'
+
+module YARD
+  module Bench
+    VERSION = "0.0.2"
+  end
+end

data/lib/yard-bench.rb

@@ -0,0 +1,8 @@
+YARD::Templates::Engine.register_template_path File.dirname(__FILE__) + '/../templates'
+
+require File.join(File.dirname(__FILE__), 'yard-bench', 'version')
+
+require File.join(File.dirname(__FILE__), 'dsl', 'monkeypatches')
+require File.join(File.dirname(__FILE__), 'dsl', 'bm_dsl')
+
+require File.join(File.dirname(__FILE__), 'yard-bench', 'handler')

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+
+require 'yard-bench'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/yard-bench_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe YardBench do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/templates/default/method_details/html/benchmarks.erb

@@ -0,0 +1,16 @@
+<% if object[:benchmarks] %>
+<div class="tags">
+  <h4>Benchmarks:</h4>
+  <ul class="benchmarks">
+    <% for bm in object[:benchmarks] %>
+      <% key = "#{bm.keys[0]}".length - 1 %>
+      <% val = "%.3f" % bm.values[0] %>
+      <li><span class="name">×10<sup><%= key %></sup></span> ⇒ <%= val %>
+      </li>
+    <% end %>
+  </ul>
+  <% dev = '%.2f' % object[:deviation] %>
+  <% pow = object[:power].nil? ? "unknown" : "#{'%.3f' % object[:power]}×10<sup>-6</sup>×O(N)" %>
+  <h5>Deviation: <span class="name"><%= dev %>%</span> Power: <span class="name"><%= pow %></span></h5>
+</div>
+<% end %>

data/templates/default/method_details/setup.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+def init
+  super
+  sections.last.place(:benchmarks).before(:source)
+end

data/templates/default/method_details/text/benchmarks.erb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+<% if object[:benchmarks] %>
+Benchmarks:
+-----------
+  <% for bm in object[:benchmarks] %>
+    <% key = "#{bm.keys[0]}".length - 1 %>
+    <% val = "%.2f" % bm.values[0] %>
+    <%= indent wrap("→ ×10^#{key} ⇒ #{val}" ) %>
+  <% end %>
+  <% dev = "%.2f" % object[:deviation] %>
+  <% pow = object[:power].nil? ? "unknown" : object[:power] %>
+  <%= indent wrap("→ Deviation: #{dev}" ) %>
+  <%= indent wrap("→ Power: #{pow}" ) %>
+<% end %>

data/yard-bench.gemspec

@@ -0,0 +1,36 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'yard-bench/version'
+
+Gem::Specification.new do |s|
+  s.name = 'yard-bench'
+  s.version = YARD::Bench::VERSION
+  s.license = 'MIT'
+  s.platform = Gem::Platform::RUBY
+  s.date = '2013-02-21'
+  s.authors = ['Alexei Matyushkin']
+  s.email = 'am@mudasobwa.ru'
+  s.homepage = 'http://github.com/mudasobwa/yard-bench'
+  s.summary = %Q{Add a benchmark functionality to Yard.}
+  s.description = %Q{YARD plugin, which adds a benchmarking results to YARDoc}
+  s.extra_rdoc_files = [
+    'LICENSE',
+    'README.md',
+  ]
+
+  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.7')
+  s.rubygems_version = '1.3.7'
+  s.specification_version = 3
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'bueller'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'yard-cucumber'
+  s.add_development_dependency 'redcarpet'
+end
+

data/yard-bench.komodoproject

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Komodo Project File - DO NOT EDIT -->
+<project id="d0b15997-8557-488c-afff-cce53c382e1f" kpf_version="5" name="yard-bench.komodoproject">
+</project>