stud 0.0.5 → 0.0.6

data/lib/stud/benchmark.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+# Benchmark Use Cases
+#   * Compare performance of different implementations.
+#     * run each implementation N times, compare runtimes (histogram, etc)
+
+module Stud
+  module Benchmark
+    def self.run(iterations=1, &block)
+      i = 0
+      data = []
+      full_start = Time.now
+      while i < iterations
+        start = Time.now
+        block.call
+        duration = Time.now - start
+        data << duration
+        i += 1
+      end
+      return Results.new(data)
+    end # def run
+
+    class Results
+      include Enumerable
+      # Stolen from https://github.com/holman/spark/blob/master/spark
+      TICKS = %w{▁ ▂ ▃ ▄ ▅ ▆ ▇ █}
+
+      def initialize(data)
+        @data = data
+      end # def initialize
+
+      def environment
+        # Older rubies don't have the RUBY_ENGINE defiend
+        engine = (RUBY_ENGINE rescue "ruby")
+        # Include jruby version in the engine
+        engine += (JRUBY_VERSION rescue "")
+        version = RUBY_VERSION
+
+        return "#{engine} #{version}"
+      end # def environment
+
+      def each(&block)
+        @data.each(&block)
+      end # def each
+
+      def log_distribution
+        return distribution do |value|
+          if value == 0
+            0 ... 0
+          else
+            tick = (Math.log2(value).floor).to_f rescue 0
+            (2 ** tick) ... (2 ** (tick+1))
+          end
+        end
+      end # def log_distribution
+
+      def distribution(&range_compute)
+        raise ArgumentError.new("Missing range computation block") if !block_given?
+
+        max = @data.max
+        dist = Hash.new { |h,k| h[k] = 0 }
+        each do |value| 
+          range = range_compute.call(value)
+          dist[range] += 1
+        end
+        return dist
+      end # def distribution
+
+      def mean
+        if @mean.nil?
+          total = Float(@data.count)
+          @mean = sum / total
+        end
+        return @mean
+      end # def mean
+
+      def stddev
+        # sum of square deviations of mean divided by total values
+        return Math.sqrt(inject(0) { |s, v| s + (v - mean) ** 2 } / (@data.count - 1))
+      end # def stddev
+
+      def sum
+        if @sum.nil?
+          @sum = inject(0) { |s,v| s + v }
+        end
+        return @sum
+      end # def sum
+
+      def to_s
+        return "#{environment}: avg: #{mean} stddev: #{stddev}"
+      end # def to_s
+
+      def pretty_print
+        min = @data.min
+        max = @data.max
+        zmax = Float(max - min) # "zero" at the 'min' value, offset the max.
+        incr = 0.1 # 10% increments
+        #dist = distribution do |value|
+          #percent = (value - min) / zmax
+          #if percent == 1
+            #(1 - incr ... 1.0)
+          #else
+            #start = ((percent * 10).floor / 10.0)
+            #start ... (start + incr)
+          #end
+        #end
+        dist = log_distribution
+
+        total = dist.inject(0) { |sum, (step, count)| sum + count }
+        sorted = dist.sort { |a,b| a.first.begin <=> b.first.begin }
+        puts sorted.collect { |lower_bound, count|
+          #puts lower_bound
+          percent = (count / Float(total))
+          "%40s: %s" % [lower_bound, (TICKS.last * (50 * percent).ceil)]
+        }.join("\n")
+
+      end # def pretty_print
+    end # class Stud::Benchmark::Result
+  end # module Benchmark
+end # module Stud
+
+#require "thread"
+#mutex = Mutex.new
+#results = Stud::Benchmark.run(20) { mutex.synchronize { rand; rand; rand } }
+#results.pretty_print

data/lib/stud/pool.rb

@@ -210,6 +210,6 @@ module Stud
       end
     end # def release
 
-    public(:add, :remove, :fetch, :release, :sized?, :count)
+    public(:add, :remove, :fetch, :release, :sized?, :count, :initialize)
   end # class Pool
 end # module Stud

data/lib/stud/secret.rb

@@ -0,0 +1,35 @@
+
+# A class for holding a secret. The main goal is to prevent the common mistake
+# of accidentally logging or printing passwords or other secrets.
+#
+# See
+# <https://github.com/jordansissel/software-patterns/blob/master/dont-log-secrets/ruby/>
+# for a discussion of why this implementation is useful.
+module Stud
+  class Secret
+    # Initialize a new secret with a given value.
+    #
+    # value - anything you want to keep secret from loggers, etc.
+    def initialize(secret_value)
+      # Redefine the 'value' method on this instance. This exposes no instance
+      # variables to be accidentally leaked by things like awesome_print, etc.
+      # This makes any #value call return the secret value.
+      (class << self; self; end).class_eval do
+        define_method(:value) { secret_value }
+      end
+    end # def initialize
+
+    # Emit simply "<secret>" when printed or logged.
+    def to_s
+      return "<secret>"
+    end # def to_s
+
+    alias_method :inspect, :to_s
+
+    # Get the secret value.
+    def value
+      # Nothing, this will be filled in by Secret.new
+      # But we'll still document this so rdoc/yard know the method exists.
+    end # def value
+  end # class Secret
+end # class Stud

data/lib/stud/try.rb

@@ -72,10 +72,10 @@ module Stud
     def try(enumerable=FOREVER, &block)
       if block.arity == 0
         # If the block takes no arguments, give none
-        procedure = lambda { |val| block.call }
+        procedure = lambda { |val| return block.call }
       else
         # Otherwise, pass the current 'enumerable' value to the block.
-        procedure = lambda { |val| block.call(val) }
+        procedure = lambda { |val| return block.call(val) }
       end
 
       # Track the last exception so we can reraise it on failure.
@@ -89,6 +89,9 @@ module Stud
           # If the 'procedure' (the block, really) succeeds, we'll break 
           # and return the return value of the block. Win!
           return procedure.call(val)
+        rescue NoMethodError, NameError
+          # Abort immediately on exceptions that are unlikely to recover.
+          raise
         rescue => exception
           last_exception = exception
           fail_count += 1
@@ -112,7 +115,7 @@ module Stud
 
   TRY = Try.new
   # A simple try method for the common case.
-  def try(enumerable=Stud::Try::Forever, &block)
+  def try(enumerable=Stud::Try::FOREVER, &block)
     return TRY.try(enumerable, &block)
   end # def try
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stud
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-14 00:00:00.000000000 Z
+date: 2012-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,10 +50,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/stud/try.rb
+- lib/stud/interval.rb
+- lib/stud/benchmark.rb
 - lib/stud/task.rb
+- lib/stud/secret.rb
 - lib/stud/pool.rb
-- lib/stud/interval.rb
-- lib/stud/try.rb
 - LICENSE
 - CHANGELIST
 - README.md