benchmark-spec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be460326ecac3098408c326aa2b2dc8ec6362ed5
+  data.tar.gz: 4fb8619aa143c22645513048380e2a7c1c5ca177
+SHA512:
+  metadata.gz: 665bc58fba734fae65fb9bad218a37212303827d4d40d80c152c16bb82e5b36576fdc49947e05702c561c05bc8e010afded91035fca5725ea323d71fe89c4515
+  data.tar.gz: 7ed88e28f5df29d509f6c9fbd00687db44593c454ca799efe1101e59e52f6b7b65c6779df48004a8f6ba3d55b80f8c858e1d0b08cdb68b4fcb113f7f7f46c5c1

data/bin/benchmark_spec

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'benchmark_spec'
+BenchmarkSpec.run

data/lib/benchmark_spec.rb

@@ -0,0 +1,160 @@
+require 'benchmark'
+require 'colorize'
+require 'rack/test'
+require 'active_support/core_ext/class/attribute'
+
+require_relative 'benchmark_spec/dsl'
+require_relative 'benchmark_spec/shared_context'
+require_relative 'benchmark_spec/output_formatter'
+require_relative 'benchmark_spec/report_presenter'
+
+class BenchmarkSpec
+  include Rack::Test::Methods
+
+  include DSL
+  include SharedContext
+
+  class_attribute :config_proc
+
+  attr_accessor :description, :execution, :tasks, :nested_specs, :before_hooks,
+    :after_hooks, :config, :reports, :formatter
+
+
+  def initialize(description, opts = {})
+    @description = description
+    @execution   = opts[:execution]
+
+    @before_hooks = opts[:before_hooks] || {}
+    @after_hooks  = opts[:after_hooks]  || {}
+
+    @tasks        = []
+    @nested_specs = []
+    @reports      = []
+
+    @formatter = opts[:formatter] || OutputFormatter.new
+
+    @config ||= {}
+    instance_exec @config, &config_proc
+  end
+
+  class << self
+    def configure(&block)
+      BenchmarkSpec.config_proc = block
+    end
+
+    def load_files_recursively(path)
+      Dir[path].each do |file|
+        if File.directory? file
+          load_files_recursively file + "/*"
+        else
+          require file if File.basename(file).match /benchmark\.rb$/
+        end
+      end
+    end
+
+    def describe(description, &block)
+      @benchmarks ||= []
+      @benchmarks << BenchmarkSpec.new(description, execution: block)
+    end
+
+    def evaluate_all
+      return unless @benchmark
+
+      @benchmarks.each {|b| b.evaluate}
+    end
+
+    def run(args = [])
+      base_path = Dir.pwd
+
+      files_to_run = args.map{|path| "#{base_path}/#{path}"}
+      files_to_run = ["#{base_path}/benchmark"] if files_to_run.empty?
+
+      files_to_run.each do |f|
+        load_files_recursively(f)
+      end
+
+      OutputFormatter.title("Benchmark Spec")
+
+      evaluate_all
+
+      OutputFormatter.title("Results")
+    ensure
+      ReportPresenter.print_results(@benchmarks)
+    end
+  end
+
+  def before(hook = :each, &block)
+    before_hooks[hook] ||= []
+    before_hooks[hook] << block
+  end
+
+  def after(hook = :each, &block)
+    after_hooks[hook] ||= []
+    after_hooks[hook] << block
+  end
+
+  def describe(description, &block)
+    spec_options = {}
+    spec_options[:execution]    = block if block
+    spec_options[:before_hooks] = before_hooks.dup
+    spec_options[:after_hooks]  = after_hooks.dup
+    spec_options[:formatter]    = OutputFormatter.new(indent_level: formatter.indent_level + 1)
+
+    nested_specs << BenchmarkSpec.new(description, spec_options)
+  end
+
+  def benchmark(description, &block)
+    tasks << { description: description, execution: block }
+  end
+
+  def run_all_tasks
+    return if tasks.empty?
+
+    tasks.each do |t|
+      begin
+        pending t[:description] if t[:execution].nil?
+
+        formatter.print "running #{t[:description]} ..."
+
+        before_each_hooks.each {|b| b.call}
+        reports << Benchmark.measure(t[:description]) { t[:execution].call }
+        after_each_hooks.each {|a| a.call}
+      rescue => e
+        formatter.print "Error: #{e.message}".colorize(:red)
+      end
+    end
+  end
+
+  def evaluate
+    if execution
+      formatter.print "#{description}".colorize(:light_blue)
+
+      instance_eval &execution
+
+      run_all_tasks
+
+      nested_specs.each do |ns|
+        ns.evaluate
+      end
+    else
+      pending(description)
+    end
+  end
+
+private
+
+  def pending(description)
+    formatter.print "Pending: #{description}".colorize(:yellow)
+  end
+
+  def before_each_hooks
+    before_hooks[:each] || []
+  end
+
+  def after_each_hooks
+    after_hooks[:each] || []
+  end
+
+end
+
+BenchmarkSpec.expose_methods_to_context([:describe, :shared_context], self)

data/lib/benchmark_spec/dsl.rb

@@ -0,0 +1,26 @@
+class BenchmarkSpec
+  module DSL
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def change_global_dsl(context, &changes)
+        (class << context; self; end).class_exec(&changes)
+      end
+
+      def expose_method_dsl_to_context(method, context)
+        change_global_dsl(context) do
+          remove_method(method) if method_defined?(method)
+          define_method(method) do |*a, &b|
+            BenchmarkSpec.__send__(method, *a, &b)
+          end
+        end
+      end
+
+      def expose_methods_to_context(methods, context)
+        methods.each {|meth| expose_method_dsl_to_context(meth, context)}
+      end
+    end
+  end
+end

data/lib/benchmark_spec/output_formatter.rb

@@ -0,0 +1,64 @@
+class BenchmarkSpec
+  class OutputFormatter
+    attr_accessor :indent_level, :space_per_indent
+
+    TITLE_LENGHT       = 100
+    TITLE_FILLER       = '-'
+    MIN_NUM_OF_FILLERS = 20
+
+    def initialize(indent_level: 0, space_per_indent: 2)
+      @indent_level = indent_level
+      @space_per_indent = space_per_indent
+    end
+
+    class << self
+      def title(content)
+        with_margins_vertically do
+          side_fillers =
+            TITLE_FILLER * ([TITLE_LENGHT - content.length, MIN_NUM_OF_FILLERS].max / 2 - 1) # -1 for the space
+
+          puts "#{side_fillers} #{content} #{side_fillers}"
+        end
+      end
+
+      def with_margins_vertically(num_of_lines = 1)
+        num_of_lines.times { new_line }
+        yield
+        num_of_lines.times { new_line }
+      end
+
+      def new_line
+        puts "\n"
+      end
+    end
+
+    def title(content)
+      self.class.title(content)
+    end
+
+    def new_line
+      self.class.new_line
+    end
+
+    def with_margins_vertically(*a, &b)
+      self.class.with_margins_vertically(*a, &b)
+    end
+
+    def print(message)
+      message = indent_message(message)
+      puts message
+    end
+
+    def indent_message(message)
+      return message unless indent_level > 0
+
+      message = message.gsub("\n", "\n" + margin)
+
+      return "#{margin}#{message}"
+    end
+
+    def margin
+      " " * indent_level * space_per_indent
+    end
+  end
+end

data/lib/benchmark_spec/report_presenter.rb

@@ -0,0 +1,79 @@
+class BenchmarkSpec
+  class ReportPresenter
+    attr_accessor :benchmark, :formatter, :nested_reports, :round_to
+
+    def initialize(benchmark, opts = {}, formatter: nil)
+      @benchmark = benchmark
+      @formatter = formatter || BenchmarkSpec::OutputFormatter.new
+
+      @round_to = opts[:round_to] || 3
+
+      @nested_reports = []
+      @benchmark.nested_specs.map do |ns|
+        child_formatter = BenchmarkSpec::OutputFormatter.new(indent_level: @formatter.indent_level + 1)
+        @nested_reports << ReportPresenter.new(ns, formatter: child_formatter)
+      end
+    end
+
+    def print
+      formatter.print "#{benchmark.description}:".colorize(:light_blue)
+      benchmark.reports.each do |r|
+        formatter.with_margins_vertically do
+          formatter.print "#{r.label}:".colorize(:cyan).underline
+          formatter.new_line
+          formatter.print "    User: #{r.utime.round(round_to)}s"
+          formatter.print "  System: #{r.stime.round(round_to)}s"
+          formatter.print "   Total: #{r.total.round(round_to)}s"
+        end
+      end
+
+      if nested_reports
+        nested_reports.each do |nr|
+          nr.print
+        end
+      end
+    end
+
+    def self.print_results(benchmarks)
+      benchmarks ||= []
+
+      reports = benchmarks.map{|b| ReportPresenter.new(b)}
+      reports.each{|r| r.print}
+      print_summary(benchmarks)
+    end
+
+    def self.print_summary(benchmarks)
+      benchmarks ||= []
+
+      num_of_examples_run = benchmarks.map{|b| calculate_num_of_examples_run(b)}.reduce(:+) || 0
+      total_time          = benchmarks.map{|b| calculate_total_time(b)}.reduce(:+) || 0
+
+      puts "--------------------------------------------------------------------"
+      puts "Examples run: #{num_of_examples_run}, Total Execution Time: #{total_time}s".colorize(:light_green)
+    end
+
+    def self.calculate_num_of_examples_run(benchmark)
+      return benchmark.reports.count if benchmark.nested_specs.empty?
+
+      num_of_examples_run = benchmark.reports.count
+      benchmark.nested_specs.each do |ns|
+        num_of_examples_run += calculate_num_of_examples_run(ns)
+      end
+
+      num_of_examples_run
+    end
+
+    def self.calculate_total_time(benchmark)
+      if benchmark.nested_specs.empty?
+        return benchmark.reports.map(&:total).reduce(:+) || 0
+      end
+
+      total_time = benchmark.reports.map(&:total).reduce(:+) || 0
+      benchmark.nested_specs.each do |ns|
+        total_time += calculate_total_time(ns)
+      end
+
+      total_time
+    end
+  end
+end

data/lib/benchmark_spec/shared_context.rb

@@ -0,0 +1,21 @@
+class BenchmarkSpec
+  module SharedContext
+    def self.included(klass)
+      klass.class_eval do
+        @@shared_context ||= {}
+
+        class << klass
+          def shared_context(context_name, &block)
+            @@shared_context[context_name] = block
+          end
+        end
+        
+      end
+    end
+
+    def include_context(context_name)
+      raise "Shared context #{context_name.to_s} does not exist!" if @@shared_context[context_name].nil?
+      instance_eval &@@shared_context[context_name]
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: benchmark-spec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Edward Tam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-07 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: etam@adparlor.com
+executables:
+- benchmark_spec
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/benchmark_spec
+- lib/benchmark_spec.rb
+- lib/benchmark_spec/dsl.rb
+- lib/benchmark_spec/output_formatter.rb
+- lib/benchmark_spec/report_presenter.rb
+- lib/benchmark_spec/shared_context.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: RSpec syntax mimicked benchmarking framework
+test_files: []
+has_rdoc: