scoot 0.0.4 → 0.0.6

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/timed_value_metric_spec.rb

@@ -1,171 +0,0 @@
-require 'spec_helper'
-
-describe Hitimes::TimedValueMetric do
-  before( :each ) do
-    @tm = Hitimes::TimedValueMetric.new( 'test-timed-value-metric' )
-  end
-
-  it "knows if it is running or not" do
-    @tm.running?.must_equal false
-    @tm.start
-    @tm.running?.must_equal true
-    @tm.stop( 1 )
-    @tm.running?.must_equal false
-  end
-
-  it "#split returns the last duration and the timer is still running" do
-    @tm.start
-    d = @tm.split( 1 )
-    @tm.running?.must_equal true
-    d.must_be :>, 0
-    @tm.value_stats.count.must_equal 1
-    @tm.timed_stats.count.must_equal 1
-    @tm.duration.must_equal d
-  end
-
-  it "#stop returns false if called more than once in a row" do
-    @tm.start
-    @tm.stop( 1 ).must_be :>, 0
-    @tm.stop( 1 ).must_equal false
-  end
-
-  it "does not count a currently running interval as an interval in calculations" do
-    @tm.start
-    @tm.value_stats.count.must_equal 0
-    @tm.timed_stats.count.must_equal 0
-    @tm.split( 1 )
-    @tm.value_stats.count.must_equal 1
-    @tm.timed_stats.count.must_equal 1
-  end
-
-  it "#split called on a stopped timer does nothing" do
-    @tm.start
-    @tm.stop( 1 )
-    @tm.split( 1 ).must_equal false
-  end
-
-  it "calculates the mean of the durations" do
-    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop(x) }
-    @tm.timed_stats.mean.must_be_close_to(0.05, 0.01)
-    @tm.value_stats.mean.must_equal 1.00
-  end
-
-  it "calculates the rate of the counts " do
-    5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.rate.must_be_close_to(40.0, 1.0)
-  end
-
-
-  it "calculates the stddev of the durations" do
-    3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop(x) }
-    @tm.timed_stats.stddev.must_be_close_to(0.05, 0.001)
-    @tm.value_stats.stddev.must_equal 1.0
-  end
-
-  it "returns 0.0 for stddev if there is no data" do
-    @tm.timed_stats.stddev.must_equal 0.0
-    @tm.value_stats.stddev.must_equal 0.0
-  end
-
-  it "keeps track of the min value" do
-    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.min.must_be_close_to( 0.05, 0.003 )
-    @tm.value_stats.min.must_equal 0
-  end
-
-  it "keeps track of the max value" do
-    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.max.must_be_close_to( 0.05, 0.003 )
-    @tm.value_stats.max.must_equal 2
-  end
-
-  it "keeps track of the sum value" do
-    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sum.must_be_close_to( 0.15, 0.01 )
-    @tm.value_stats.sum.must_equal 3
-  end
-  
-  it "keeps track of the sum of squares value" do
-    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sumsq.must_be_close_to(0.0075, 0.0005)
-    @tm.value_stats.sumsq.must_equal 5
-  end
-
-  it "keeps track of the minimum start time of all the intervals" do
-    f1 = Time.now.gmtime.to_f * 1000000
-    5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
-    f2 = Time.now.gmtime.to_f * 1000000
-    @tm.sampling_start_time.must_be :>=, f1
-    @tm.sampling_start_time.must_be :<, f2
-    # distance from now to start time should be greater than the distance from
-    # the start to the min start_time
-    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
-  end
-
-  it "keeps track of the last stop time of all the intervals" do
-    f1 = Time.now.gmtime.to_f * 1_000_000
-    5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
-    sleep 0.05
-    f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_stop_time.must_be :>, f1
-    @tm.sampling_stop_time.must_be :<=, f2
-    # distance from now to max stop time time should be less than the distance
-    # from the start to the max stop time
-    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
-  end
-
-  it "can create an already running timer" do
-    t = Hitimes::TimedValueMetric.now( 'already-running' )
-    t.running?.must_equal true
-  end
-
-  it "can measure a block of code from an instance" do
-    t = Hitimes::TimedValueMetric.new( 'measure a block' )
-    3.times { t.measure( 1 ) { sleep 0.05 } }
-    t.duration.must_be_close_to(0.15, 0.004)
-    t.timed_stats.count.must_equal 3
-    t.value_stats.count.must_equal 3
-  end
-
-  it "returns the value of the block when measuring" do
-    t = Hitimes::TimedValueMetric.new( 'measure a block' )
-    x = t.measure( 42 ) { sleep 0.05; 42 }
-    t.duration.must_be_close_to(0.05, 0.002)
-    x.must_equal 42
-  end
-
-  describe "#to_hash" do
-
-    it "has name value" do
-      h = @tm.to_hash
-      h['name'].must_equal "test-timed-value-metric"
-    end
-
-    it "has an empty has for additional_data" do
-      h = @tm.to_hash
-      h['additional_data'].must_equal Hash.new
-      h['additional_data'].size.must_equal 0
-    end
-
-    it "has a rate" do
-      5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-      h = @tm.to_hash
-      h['rate'].must_be_close_to(40.0, 1.0)
-    end
-
-    it "has a unit_count" do
-      5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-      h = @tm.to_hash
-      h['unit_count'].must_equal  10
-    end
-
-    fields = %w[ name additional_data sampling_start_time sampling_stop_time value_stats timed_stats rate unit_count ]
-    fields.each do |f|
-      it "has a value for #{f}" do
-        3.times { |x| @tm.measure(x) { sleep 0.001 } }
-        h = @tm.to_hash
-        h[f].wont_be_nil
-      end
-    end
-  end 
-end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/value_metric_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-describe Hitimes::ValueMetric do
-  before( :each ) do
-    @metric = Hitimes::ValueMetric.new( "testing" )
-    10.times { |x| @metric.measure( x ) }
-  end
-
-  it 'has a name' do
-    @metric.name.must_equal "testing"
-  end
-
-  it "has associated data from initialization" do
-    m = Hitimes::ValueMetric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
-    m.additional_data['foo'].must_equal 'bar'
-    m.additional_data['this'].must_equal 'that'
-    
-    m = Hitimes::ValueMetric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
-    m.additional_data['foo'].must_equal 'bar'
-    m.additional_data['this'].must_equal 'that'
-  end
-
-  it "calculates the mean of the measurements" do
-    @metric.mean.must_equal 4.5
-  end
-
-  it "calculates the stddev of the measurements" do
-    @metric.stddev.must_be :>, 0.0
-  end
-
-  it "returns 0.0 for stddev if there is no data" do
-    m = Hitimes::ValueMetric.new('0-data')
-    m.stddev.must_equal 0.0
-  end
-
-  it "keeps track of the sum of data" do
-    @metric.sum.must_equal 45.0
-  end
-
-  it "keeps track of the sum of squars of data" do
-    @metric.sumsq.must_equal 285.0
-  end
-
-  it "retuns 0.0 for mean if there is no data" do
-    Hitimes::ValueMetric.new('0-data').mean.must_equal 0.0
-  end
-
-  it "keeps track of the min value" do
-    @metric.min.must_equal 0
-  end
-
-  it "keeps track of the max value" do
-    @metric.max.must_equal 9
-  end
-
-  it "keeps track of the first start time of all the measurements" do
-    m = Hitimes::ValueMetric.new( "first-start-time" )
-    f1 = Time.now.gmtime.to_f * 1_000_000
-    10.times{ |x| m.measure( x ); sleep 0.1 }
-    f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_start_time.must_be :>=, f1
-    m.sampling_start_time.must_be :<, f2
-    # distance from now to start time should be greater than the distance from
-    # the start to the min start_time
-    (f2 - m.sampling_start_time).must_be :>, ( m.sampling_start_time - f1 )
-  end
-
-  it "keeps track of the last stop time of all the intervals" do
-    m = Hitimes::ValueMetric.new( "last-stop-time" )
-    f1 = Time.now.gmtime.to_f * 1_000_000
-    10.times {|x| m.measure( x ); sleep 0.1  }
-    f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_stop_time.must_be :>, f1
-    m.sampling_stop_time.must_be :<=, f2
-    # distance from now to max stop time time should be less than the distance
-    # from the start to the max stop time
-    (f2 - m.sampling_stop_time).must_be :<, ( m.sampling_stop_time - f1 )
-  end
-
-  describe "#to_hash" do
-
-    it "has name value" do
-      h = @metric.to_hash
-      h['name'].must_equal "testing"
-    end
-
-    it "has an empty has for additional_data" do
-      h = @metric.to_hash
-      h['additional_data'].must_equal Hash.new
-      h['additional_data'].size.must_equal 0
-    end
-
-    it "has the right sum" do
-      h = @metric.to_hash
-      h['sum'].must_equal 45
-    end
-
-    fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
-    fields = fields - [ 'rate' ]
-    fields.each do |f|
-      it "has a value for #{f}" do
-        h = @metric.to_hash
-        h[f].wont_be_nil
-      end
-    end
-  end
-end
-

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/version_spec.rb

@@ -1,7 +0,0 @@
-require "spec_helper"
-
-describe "Hitimes::Version" do
-  it "should be accessable as a constant" do
-    Hitimes::VERSION.must_match(/\d+\.\d+\.\d+/)
-  end
-end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/tasks/default.rake

@@ -1,276 +0,0 @@
-# vim: syntax=ruby
-require 'rake/clean'
-require 'digest'
-#------------------------------------------------------------------------------
-# If you want to Develop on this project just run 'rake develop' and you'll
-# have all you need to get going. If you want to use bundler for development,
-# then run 'rake develop:using_bundler'
-#------------------------------------------------------------------------------
-namespace :develop do
-
-  # Install all the development and runtime dependencies of this gem using the
-  # gemspec.
-  task :default do
-    require 'rubygems/dependency_installer'
-    installer = ::Gem::DependencyInstaller.new
-
-    This.set_coverage_gem
-
-    puts "Installing gem depedencies needed for development"
-    This.platform_gemspec.dependencies.each do |dep|
-      if dep.matching_specs.empty? then
-        puts "Installing : #{dep}"
-        installer.install dep
-      else
-        puts "Skipping   : #{dep} -> already installed #{dep.matching_specs.first.full_name}"
-      end
-    end
-    puts "\n\nNow run 'rake test'"
-  end
-
-  # Create a Gemfile that just references the gemspec
-  file 'Gemfile' => :gemspec do
-    File.open( "Gemfile", "w+" ) do |f|
-      f.puts "# DO NOT EDIT - This file is automatically generated"
-      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
-      f.puts 'source "https://rubygems.org/"'
-      f.puts 'gemspec'
-    end
-  end
-
-  desc "Create a bundler Gemfile"
-  task :using_bundler => 'Gemfile' do
-    puts "Now you can 'bundle'"
-  end
-
-  # Gemfiles are build artifacts
-  CLOBBER << FileList['Gemfile*']
-end
-desc "Boostrap development"
-task :develop => "develop:default"
-
-#------------------------------------------------------------------------------
-# Minitest - standard TestTask
-#------------------------------------------------------------------------------
-begin
-  require 'rake/testtask'
-  Rake::TestTask.new( :test ) do |t|
-    t.ruby_opts    = %w[ -w -rubygems ]
-    t.libs         = %w[ lib spec test ]
-    t.pattern      = "{test,spec}/**/{test_*,*_spec}.rb"
-  end
-
-  task :test_requirements
-  task :test => :test_requirements
-  task :default => :test
-rescue LoadError
-  This.task_warning( 'test' )
-end
-
-#------------------------------------------------------------------------------
-# RDoc - standard rdoc rake task, although we must make sure to use a more
-#        recent version of rdoc since it is the one that has 'tomdoc' markup
-#------------------------------------------------------------------------------
-begin
-  gem 'rdoc' # otherwise we get the wrong task from stdlib
-  require 'rdoc/task'
-  RDoc::Task.new do |t|
-    t.markup   = 'tomdoc'
-    t.rdoc_dir = 'doc'
-    t.main     = 'README.md'
-    t.title    = "#{This.name} #{This.version}"
-    t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
-                          FileList['lib/**/*.rb'] )
-  end
-rescue StandardError, LoadError
-  This.task_warning( 'rdoc' )
-end
-
-#------------------------------------------------------------------------------
-# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
-#            for the moment only rcov is listed.
-#------------------------------------------------------------------------------
-if RUBY_VERSION < "1.9.0"
-  begin
-   require 'rcov/rcovtask'
-   Rcov::RcovTask.new( 'coverage' ) do |t|
-     t.libs      << 'spec'
-     t.pattern   = 'spec/**/*_spec.rb'
-     t.verbose   = true
-     t.rcov_opts << "-x ^/"           # remove all the global files
-     t.rcov_opts << "--sort coverage" # so we see the worst files at the top
-   end
-  rescue LoadError
-   This.task_warning( 'rcov' )
-  end
-else
-  begin
-    require 'simplecov'
-    desc 'Run tests with code coverage'
-    task :coverage do
-      ENV['COVERAGE'] = 'true'
-      Rake::Task[:test].invoke
-    end
-    CLOBBER << FileList["coverage"] if File.directory?( "coverage" )
-  rescue LoadError
-    This.task_warning( 'simplecov' )
-  end
-end
-
-#------------------------------------------------------------------------------
-# Manifest - We want an explicit list of thos files that are to be packaged in
-#            the gem. Most of this is from Hoe.
-#------------------------------------------------------------------------------
-namespace 'manifest' do
-  desc "Check the manifest"
-  task :check => :clean do
-    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
-    files = files.select{ |f| File.file?( f ) }
-
-    tmp = "Manifest.tmp"
-    File.open( tmp, 'w' ) do |f|
-      f.puts files.join("\n")
-    end
-
-    begin
-      sh "diff -du Manifest.txt #{tmp}"
-    ensure
-      rm tmp
-    end
-    puts "Manifest looks good"
-  end
-
-  desc "Generate the manifest"
-  task :generate => :clean do
-    files = %x[ git ls-files ].split("\n").sort
-    files.reject! { |f| f =~ This.exclude_from_manifest }
-    File.open( "Manifest.txt", "w" ) do |f|
-      f.puts files.join("\n")
-    end
-  end
-end
-
-#------------------------------------------------------------------------------
-# Fixme - look for fixmes and report them
-#------------------------------------------------------------------------------
-namespace :fixme do
-  task :default => 'manifest:check' do
-    This.manifest.each do |file|
-      next if file == __FILE__
-      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
-      puts "FIXME: Rename #{file}" if file =~ /fixme/i
-      IO.readlines( file ).each_with_index do |line, idx|
-        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
-        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
-      end
-    end
-  end
-
-  def fixme_project_root
-    This.project_path( '../fixme' )
-  end
-
-  def fixme_project_path( subtree )
-    fixme_project_root.join( subtree )
-  end
-
-  def local_fixme_files
-    This.manifest.select { |p| p =~ %r|^tasks/| }
-  end
-
-  def outdated_fixme_files
-    local_fixme_files.reject do |local|
-      upstream     = fixme_project_path( local )
-      Digest::SHA256.file( local ) == Digest::SHA256.file( upstream )
-    end
-  end
-
-  def fixme_up_to_date?
-    outdated_fixme_files.empty?
-  end
-
-  desc "See if the fixme tools are outdated"
-  task :outdated => :release_check do
-    if fixme_up_to_date? then
-      puts "Fixme files are up to date."
-    else
-      outdated_fixme_files.each do |f|
-        puts "#{f} is outdated"
-      end
-    end
-  end
-
-  desc "Update outdated fixme files"
-  task :update => :release_check do
-    if fixme_up_to_date? then
-      puts "Fixme files are already up to date."
-    else
-      puts "Updating fixme files:"
-      outdated_fixme_files.each do |local|
-        upstream = fixme_project_path( local )
-        puts "  * #{local}"
-        FileUtils.cp( upstream, local )
-      end
-      puts "Use your git commands as appropriate."
-    end
-  end
-end
-desc "Look for fixmes and report them"
-task :fixme => "fixme:default"
-
-#------------------------------------------------------------------------------
-# Gem Specification
-#------------------------------------------------------------------------------
-# Really this is only here to support those who use bundler
-desc "Build the #{This.name}.gemspec file"
-task :gemspec do
-  File.open( This.gemspec_file, "wb+" ) do |f|
-    f.puts "# DO NOT EDIT - This file is automatically generated"
-    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
-    f.write This.platform_gemspec.to_ruby
-  end
-end
-
-# the gemspec is also a dev artifact and should not be kept around.
-CLOBBER << This.gemspec_file.to_s
-
-# .rbc files from ruby 2.0
-CLOBBER << FileList["**/*.rbc"]
-
-# The standard gem packaging task, everyone has it.
-require 'rubygems/package_task'
-::Gem::PackageTask.new( This.platform_gemspec ) do
-  # nothing
-end
-
-#------------------------------------------------------------------------------
-# Release - the steps we go through to do a final release, this is pulled from
-#           a compbination of mojombo's rakegem, hoe and hoe-git
-#
-# 1) make sure we are on the master branch
-# 2) make sure there are no uncommitted items
-# 3) check the manifest and make sure all looks good
-# 4) build the gem
-# 5) do an empty commit to have the commit message of the version
-# 6) tag that commit as the version
-# 7) push master
-# 8) push the tag
-# 7) pus the gem
-#------------------------------------------------------------------------------
-task :release_check do
-  unless `git branch` =~ /^\* master$/
-    abort "You must be on the master branch to release!"
-  end
-  unless `git status` =~ /^nothing to commit/m
-    abort "Nope, sorry, you have unfinished business"
-  end
-end
-
-desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
-task :release => [ :release_check, 'manifest:check', :gem ] do
-  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
-  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
-  sh "git push origin master"
-  sh "git push origin v#{This.version}"
-  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
-end