cuke-step-bm 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/*

data/Gemfile

@@ -0,0 +1 @@
+source "http://rubygems.org"

data/README.rdoc

@@ -0,0 +1,32 @@
+== Cucumber steps time-consuming
+
+    figure out which steps are slow.
+
+== Configuration
+
+    * config/cuke_step_bm.rb  or  ~/.cuke_step_bm
+
+      output_mode:
+        # :bm => BenchMark(only for display)
+        # :std => SimpleTimeDiff
+        # :std_with_log => SimpleTimeDiff log
+        # :off => Cucumber default do nothing
+
+      CukeStepBm.configure do |config|
+        config.root = "/tmp"
+        config.output_mode = :std_with_log
+        config.log_file = File.join(config.root, 'steps_consuming.bms')
+        config.delimiter = "-#{[20879].pack("U*")}-"
+      end
+
+== Command
+
+    cuke-step-bm -h for help
+
+== TodoList Working in process
+
+    * add spec test
+    * add pp
+    * add color
+    * refator for something
+    * ..

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/cuke-step-bm

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+
+require "cuke-step-bm"
+
+CukeStepBm::Cli.execute(ARGV.dup)

data/cuke-step-bm.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "cuke-step-bm"
+  s.version     = "1.0.0"
+  s.authors     = ["elvuel"]
+  s.email       = ["elvuel@gmail.com"]
+  s.homepage    = "https://github.com/elvuel"
+  s.summary     = %q{cucumber steps benchmark}
+  s.description = %q{cucumber steps benchmark}
+
+  s.rubyforge_project = "cuke-step-bm"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/features/steps_consuming.bms

@@ -0,0 +1,4 @@
+1-冏-step1-冏-features/test.feature:1
+2-冏-step1-冏-features/test.feature:2
+3-冏-step3-冏-features/test.feature:3
+20-冏-step4-冏-features/test.feaDture:4

data/lib/cuke-step-bm.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+require "cuke-step-bm/cli"
+
+module CukeStepBm
+  # cuke_step_bm bm-cuke-step cuke-step-bm.rb
+  VERSION = "0.0.1".freeze
+
+  # :bm => BenchMark(only for display)
+  # :std => SimpleTimeDiff
+  # :std_with_log => SimpleTimeDiff log
+  # :off => Cucumber default do nothing
+
+  BM_SUPPORTED_OUTPUT_MODES = [:bm, :std, :std_with_log, :off]
+
+  class << self
+    attr_accessor :root, :log_file, :output_mode, :delimiter
+
+    def configure
+      yield self
+    end
+
+    def suite!
+      use_defaults!
+      paths = [
+          File.expand_path("config/cuke_step_bm.rb", root),
+          File.expand_path(".cuke_step_bm", root)
+      ]
+      paths.each { |path| load(path) if File.exist?(path) }
+      self.output_mode = :std unless BM_SUPPORTED_OUTPUT_MODES.include? output_mode
+    end
+
+    def use_defaults!
+      configure do |config|
+        config.root = File.expand_path('.', Dir.pwd)
+        config.output_mode = :std
+        config.log_file = File.join(config.root, 'features', 'steps_consuming.bms')
+        config.delimiter = "-#{[20879].pack("U*")}-"
+      end
+    end
+
+    def write_to_log(msg)
+      File.open(log_file, "a+") { |f| f.write msg }
+    rescue
+      nil
+    end
+
+    #remove log file before cuke working with :std_with_log
+    def remove_log!
+      File.delete log_file if File.exist?(log_file) && (output_mode == :std_with_log)
+    rescue Exception => e
+      warn e.message
+    end
+
+  end # class << self
+end # CucumberStepsBm
+
+CukeStepBm.suite!
+
+if defined?(Cucumber) && defined?(Cucumber::VERSION) && (Cucumber::VERSION >= "1.1.1") && (CukeStepBm.output_mode != :off)
+  CukeStepBm.remove_log!
+
+  module Cucumber
+    module Ast
+      class StepInvocation #:nodoc:
+        def invoke(step_mother, configuration)
+          exec_proc = Proc.new {
+            find_step_match!(step_mother, configuration)
+              unless @skip_invoke || configuration.dry_run? || @exception || @step_collection.exception
+                @skip_invoke = true
+                begin
+                  @step_match.invoke(@multiline_arg)
+                  step_mother.after_step
+                  status!(:passed)
+                rescue Pending => e
+                  failed(configuration, e, false)
+                  status!(:pending)
+                rescue Undefined => e
+                  failed(configuration, e, false)
+                  status!(:undefined)
+                rescue Cucumber::Ast::Table::Different => e
+                  @different_table = e.table
+                  failed(configuration, e, false)
+                  status!(:failed)
+                rescue Exception => e
+                  failed(configuration, e, false)
+                  status!(:failed)
+                end
+              end
+          }
+
+          if (CukeStepBm.output_mode == :bm) && defined?(Benchmark)
+            Benchmark.bm do |reporter|
+              reporter.report("Time consuming:") { exec_proc.call }
+            end
+          else
+            time_begin = Time.now
+            exec_proc.call
+            time_end = Time.now
+            time_for_output = "Step consume %s seconds.\n" % ["#{time_end - time_begin}"]
+            time_consuming_message = ["#{time_end - time_begin}", @name, file_colon_line].join(CukeStepBm.delimiter)
+            time_consuming_message << "\n"
+            if CukeStepBm.output_mode == :std_with_log
+              puts time_for_output
+              CukeStepBm.write_to_log time_consuming_message
+            else
+              puts time_for_output
+            end
+          end
+        end # invoke
+
+      end # StepInvocation
+    end # Ast
+  end #  Cucumber
+end

data/lib/cuke-step-bm/cli.rb

@@ -0,0 +1,271 @@
+# encoding: utf-8
+
+require 'optparse'
+#require 'ostruct'
+
+module CukeStepBm
+  class Cli
+
+    class Options
+      #SCOPES = [:step, :feature]
+      def parse!(args)
+        options = {}
+        opt_parser = OptionParser.new("", 30, '  ') do |opts|
+          opts.banner = "Usage: cuke-step-bm options"
+
+          opts.on("-f", "--feature FEATURE", String, "In specify feature") do |feature|
+            options[:feature] = feature
+          end
+
+          opts.on("-M", "--most", "Show the most time-consuming step") do
+            options[:act] = [ :most ]
+          end
+
+          opts.on("-t", "--total", "Show the total time-consuming") do
+            options[:act] = [ :total ]
+          end
+
+          opts.on("-w", "--within from,to", Array, "Show the steps time-consuming within the given range (use: -w 1,2)") do |from_to|
+            if from_to.size < 2
+              puts "wrong argument size"
+              exit
+            end
+            options[:act] = [ :within, [from_to.first, from_to.last] ]
+          end
+
+          opts.on("-l", "--less VALUE", Float, "Show the steps time-consuming less than or equal the given") do |v|
+            options[:act] = [ :less, v ]
+          end
+
+          opts.on("-m", "--more VALUE", Float, "Show the steps time-consuming more than or equal the given") do |v|
+            options[:act] = [ :more, v ]
+          end
+
+          #opts.on("-s", "--scope value", "Show messages within scope (all/feature_filepath)") do |v|
+          #  v = v.to_sym
+          #  v = :step unless SCOPES.include? v
+          #  options[:scope] = v
+          #end
+
+          opts.separator ""
+          opts.separator "Common options:"
+
+          opts.on_tail("-h", "--help", "Show this usage message") do
+            puts opts
+            exit
+          end
+
+          opts.on_tail("-v", "--version", "Show version") do
+            puts "cuke-step-bm #{CukeStepBm::VERSION}"
+            exit
+          end
+        end
+        opt_parser.parse! args
+        options
+      end
+    end # Options
+
+
+    def self.execute(args)
+      new(args).execute
+    end
+
+    #attr_reader :opt_parser
+
+    def initialize(args)
+      @config = CukeStepBm
+      @log_file = @config.log_file
+      bm_validate!
+      @options = Options.new.parse! args
+      @options = default_options.merge @options
+      @options[:act] = [ :most ] unless @options[:act]
+      #@scope = @options.delete :scope
+    end
+
+    def execute
+      parse_bms!
+      self.send *@options[:act]
+    end
+
+    private
+    def most
+      the_most = @bms.sort_by { |item| item[:consume] }.last
+      if in_feature?
+        msg = "The most time-consuming in %s:\n\tLine: %s, Step: [ %s ], take %s seconds." % [
+            msg_color(the_most[:feature], "red"),
+            the_most[:line],
+            msg_color(the_most[:step], "red"),
+            msg_color(the_most[:consume])
+        ]
+        info(msg)
+      else
+        msg = "The most time-consuming in all features:In %s, Line: %s, Step: [ %s ], take %s seconds.\n\n" % [
+            msg_color(the_most[:feature], "red"),
+            the_most[:line],
+            msg_color(the_most[:step], "red"),
+            msg_color(the_most[:consume])
+        ]
+        info(msg)
+        feature_grp_hash = @bms.group_by { |item| item[:feature] }
+        feature_grp_hash.each do |feature, value|
+          the_most = value.sort_by { |item| item[:consume] }.last
+          msg = "In feature [ %s ]\n\tLine: %s, Step: [ %s ], take %s seconds.\n\n" % [
+            msg_color(the_most[:feature] || feature, "red"),
+            the_most[:line],
+            msg_color(the_most[:step], "red"),
+            msg_color(the_most[:consume])
+          ]
+          info(msg)
+        end # grp_hash
+
+      end # in_feature?
+    end # most
+
+    def total
+      t_ary = @bms.collect { |item| item[:consume] }
+      sum = t_ary.inject(:+)
+      if in_feature?
+        feature = @bms.first[:feature]
+        info "Feature %s, %s steps total consume: %s seconds." % [msg_color(feature), msg_color(t_ary.size), msg_color(sum)]
+      else
+        msg = "Total consume: %s seconds.\n\n" % msg_color(sum)
+        info msg
+        feature_grp_hash = @bms.group_by { |item| item[:feature] }
+        feature_grp_hash.each do |feature, value|
+          t_ary = value.collect { |item| item[:consume] }
+          sum = t_ary.inject(:+)
+          msg = "\tFeature %s, %s steps total consume: %s seconds.\n\n" % [msg_color(feature), msg_color(t_ary.size), msg_color(sum)]
+          info msg
+        end
+      end # in_feature?
+    end # total
+
+    def within(args)
+      from, to = args.collect{ |arg| arg.to_f }
+      from, to = to, from if to < from
+      #grp_by = @bms.group_by { |item| in_feature? ? item[:step] : item[:feature] }
+      if in_feature?
+        grp_by_step = @bms.group_by { |item| item[:step] }
+        step_mean_hash= grp_by_step.inject({}) do |h, item|
+          key = item.shift
+          consumings = item.flatten.collect { |bm| bm[:consume] }
+          h[key] = consumings.inject(:+) / consumings.size
+          h
+        end
+        results = step_mean_hash.select { |k, v| (v >= from ) && (v <= to) }
+        feature = @bms.first[:feature]
+        unless results.empty?
+          info "In %s, Steps within %s .. %s" % [msg_color(feature), msg_color(from), msg_color(to)]
+        end
+        results.sort_by { |k, v| v }.each do |k, v|
+          info "\t Step %s, it average take %s seconds" % [msg_color(k), msg_color(v, "red")]
+        end
+      else
+        grp_by_feature = @bms.group_by { |item| item[:feature] }
+        grp_by_feature.each do |feature, all_steps|
+          grp_by_step = all_steps.group_by { |item| item[:step] }
+          step_mean_hash= grp_by_step.inject({}) do |h, item|
+            key = item.shift
+            consumings = item.flatten.collect { |bm| bm[:consume] }
+            h[key] = consumings.inject(:+) / consumings.size
+            h
+          end
+          results = step_mean_hash.select { |k, v| (v >= from ) && (v <= to) }
+          unless results.empty?
+            info "In %s, Steps within %s .. %s" % [msg_color(feature), msg_color(from), msg_color(to)]
+          end
+          results.sort_by { |k, v| v }.each do |k, v|
+            info "\t Step %s, it average take %s seconds" % [msg_color(k), msg_color(v, "red")]
+          end
+        end # grp_by_feature
+      end # in_feature?
+    end # within
+
+    def less_or_more(value, lom = "less")
+      value = value.to_f
+      if in_feature?
+        grp_by_step = @bms.group_by { |item| item[:step] }
+        step_mean_hash= grp_by_step.inject({}) do |h, item|
+          key = item.shift
+          consumings = item.flatten.collect { |bm| bm[:consume] }
+          h[key] = consumings.inject(:+) / consumings.size
+          h
+        end
+        results = step_mean_hash.select { |k, v| v.send((lom=="less") ? :<= : :>=, value) }
+        feature = @bms.first[:feature]
+        unless results.empty?
+          info "In %s, Steps %s than %s" % [msg_color(feature), msg_color(lom), msg_color(value)]
+        end
+        results.sort_by { |k, v| v }.each do |k, v|
+          info "\t Step %s, it average take %s seconds" % [msg_color(k), msg_color(v, "red")]
+        end
+      else
+        grp_by_feature = @bms.group_by { |item| item[:feature] }
+        grp_by_feature.each do |feature, all_steps|
+          grp_by_step = all_steps.group_by { |item| item[:step] }
+          step_mean_hash= grp_by_step.inject({}) do |h, item|
+            key = item.shift
+            consumings = item.flatten.collect { |bm| bm[:consume] }
+            h[key] = consumings.inject(:+) / consumings.size
+            h
+          end
+          results = step_mean_hash.select { |k, v| v.send((lom=="less") ? :<= : :>=, value) }
+          unless results.empty?
+            info "In %s, Steps %s than %s" % [msg_color(feature), msg_color(lom), msg_color(value)]
+          end
+          results.sort_by { |k, v| v }.each do |k, v|
+            info "\t Step %s, it average take %s seconds" % [msg_color(k), msg_color(v, "red")]
+          end
+        end
+      end # in_feature?
+    end # less_or_more
+
+    def less(value)
+      less_or_more(value, "less")
+    end
+
+    def more(value)
+      less_or_more(value, "more")
+    end
+
+    def default_options
+      { scope: :step, feature: :all }
+    end
+
+    def bm_validate!
+      abort "please make sure that record log file exist!" unless File.exist? @log_file
+      @bms ||= File.read(@log_file)
+      @bms.strip!
+      abort "record log file is empty!" if @bms.empty?
+    end
+
+    def parse_bms!
+      bms = @bms.split("\n")
+      bms.delete ""
+      bms.compact!
+      @bms = bms.inject([]) do |ary, item|
+        tmp_ary = item.split(@config.delimiter)
+        consume_time, step_name, file_colon_line = tmp_ary
+        feature, line = file_colon_line.split(":")
+        tmp_ary = { feature: feature, step: step_name, line: line, consume: consume_time.to_f }
+        ary << tmp_ary if @options[:feature].is_a?(Symbol) or (@options[:feature] == feature)
+        ary
+      end
+      abort msg_color("empty", "r") if @bms.empty?
+    end
+
+    def in_feature?
+      !@options[:feature].is_a?(Symbol)
+    end
+
+    def msg_color(msg, color="green")
+      color = (color == "green") ? 32 : 31
+      "\033[4;1;#{color};40m#{msg}\033[0m"
+    end
+
+    def info(msg)
+      puts msg
+    end
+
+  end
+end

data/test.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/lib') unless $:.include?(File.dirname(__FILE__) + '/lib')
+
+require "cuke-step-bm"
+
+CukeStepBm::Cli.execute(ARGV.dup)

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: cuke-step-bm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- elvuel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-18 00:00:00.000000000Z
+dependencies: []
+description: cucumber steps benchmark
+email:
+- elvuel@gmail.com
+executables:
+- cuke-step-bm
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- bin/cuke-step-bm
+- cuke-step-bm.gemspec
+- features/steps_consuming.bms
+- features/test.feature
+- lib/cuke-step-bm.rb
+- lib/cuke-step-bm/cli.rb
+- test.rb
+homepage: https://github.com/elvuel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cuke-step-bm
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: cucumber steps benchmark
+test_files: []
+has_rdoc: