benelux 0.2.0.001

data/CHANGES.txt

@@ -0,0 +1,4 @@
+BENELUX, CHANGES
+
+
+#### 0.2.0 (2009-09-??) ###############################

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Solutious Inc, Delano Mandelbaum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,36 @@
+= Benelux v0.1
+
+<b></b>
+
+
+== Features
+
+
+
+== Installation
+
+Get it in one of the following ways:
+
+     $ gem install benelux
+     $ git clone git://github.com/delano/benelux.git
+     $ gem install delano-benelux --source http://gems.github.com
+
+
+== More Information
+
+* Codes[http://github.com/delano/benelux]
+* RDocs[http://delano.github.com/benelux]
+
+== Credits
+
+* Delano Mandelbaum (http://solutious.com)
+
+
+== Thanks 
+
+* Alexis Sellier for fielding my Ruby questions
+
+
+== License
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1,73 @@
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'hanna/rdoctask'
+require 'rake/testtask'
+require 'shoulda/tasks'
+require 'rake/runtest'
+require 'monkeyspecdoc'  # http://jgre.org/2008/09/03/monkeyspecdoc/
+require 'fileutils'
+include FileUtils
+ 
+task :default => :test
+
+
+# PACKAGE =============================================================
+
+name = "benelux"
+load "#{name}.gemspec"
+
+version = @spec.version
+
+Rake::GemPackageTask.new(@spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :release => [ "publish:gem", :clean, "publish:rdoc" ] do
+  $: << File.join(File.dirname(__FILE__), 'lib')
+  require "rudy"
+  abort if Drydock.debug?
+end
+
+task :install => [ :rdoc, :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+
+# Rubyforge Release / Publish Tasks ==================================
+
+#about 'Publish website to rubyforge'
+task 'publish:rdoc' => 'doc/index.html' do
+  sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
+end
+
+#about 'Public release to rubyforge'
+task 'publish:gem' => [:package] do |t|
+  sh <<-end
+    rubyforge add_release -o Any -a CHANGES.txt -f -n README.rdoc #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
+    rubyforge add_file -o Any -a CHANGES.txt -f -n README.rdoc #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
+  end
+end
+
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	t.title    = @spec.summary
+	t.options << '--line-numbers' <<  '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('LICENSE.txt')
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('CHANGES.txt')
+	#t.rdoc_files.include('Rudyfile')  # why is the formatting f'd?
+	t.rdoc_files.include('bin/*')
+	t.rdoc_files.include('lib/**/*.rb')
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config', 'doc', 'coverage*' ]
+
+
+

data/benelux.gemspec

@@ -0,0 +1,34 @@
+@spec = Gem::Specification.new do |s|
+  s.name = "benelux"
+  s.rubyforge_project = 'benelux'
+  s.version = "0.2.0.001"
+  s.summary = "Benelux: Little freakin' timers for your Ruby codes"
+  s.description = s.summary
+  s.author = "Delano Mandelbaum"
+  s.email = "delano@solutious.com"
+  s.homepage = "http://github.com/delano/benelux"
+  
+  s.extra_rdoc_files = %w[README.rdoc LICENSE.txt CHANGES.txt]
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
+  s.require_paths = %w[lib]
+  
+  s.add_dependency 'hexoid'
+  
+  # = MANIFEST =
+  # git ls-files
+  s.files = %w(
+  CHANGES.txt
+  LICENSE.txt
+  README.rdoc
+  Rakefile
+  benelux.gemspec
+  lib/benelux.rb
+  lib/benelux/mark.rb
+  lib/benelux/mixins/thread.rb
+  lib/benelux/timeline.rb
+  tryouts/basic_tryouts.rb
+  )
+
+  
+end

data/lib/benelux.rb

@@ -0,0 +1,130 @@
+require 'attic'
+require 'thread'
+require 'hexoid'
+
+module Benelux
+  NOTSUPPORTED = [Class, Object, Kernel]
+  SUFFIX_START = :a.freeze
+  SUFFIX_END   = :z.freeze
+  
+  require 'benelux/timeline'
+  require 'benelux/mark'
+  require 'benelux/mixins/thread'
+  
+  @@timed_methods = {}
+  @@thread_timelines = []
+  @@timeline = Benelux::Timeline.new
+  @@mutex = Mutex.new
+  
+  class BeneluxError < RuntimeError; end
+  class NotSupported < BeneluxError; end
+  
+  def benelux_timers
+    Benelux.timed_methods[self.class]
+  end
+  
+  def Benelux.supported?(klass)
+    !NOTSUPPORTED.member?(klass)
+  end
+  
+  def Benelux.store_thread_reference
+    return if Benelux.thread_timelines.member? Thread.current
+    @@mutex.synchronize do
+      Benelux.thread_timelines << Thread.current
+    end
+  end
+  
+  def Benelux.timed_methods
+    @@timed_methods
+  end
+  
+  def Benelux.thread_timelines
+    @@thread_timelines
+  end
+  
+  def Benelux.timeline
+    @@timeline = Benelux.generate_timeline if @@timeline.empty?
+    @@timeline
+  end
+  
+  def Benelux.generate_timeline
+    @@mutex.synchronize do
+      timeline = Benelux::Timeline.new
+      Benelux.thread_timelines.each { |t| timeline << t.benelux }
+      timeline.flatten.sort
+    end
+  end
+  
+  def Benelux.thread_timeline(thread_id=nil)
+    Thread.current.benelux ||= Benelux::Timeline.new
+    Thread.current.benelux
+  end
+  
+  
+  def Benelux.included(klass)
+    timed_methods[klass] = [] unless timed_methods.has_key? klass
+  end
+  
+  def Benelux.timed_method? klass, meth
+    !timed_methods[klass].nil? && timed_methods[klass].member?(meth)
+  end
+  
+  def Benelux.add_timer klass, meth
+    raise NotSupported, klass unless Benelux.supported? klass
+    raise AlreadyTimed, klass if Benelux.timed_method? klass, meth
+    prepare_object klass
+    meth_alias = rename_method klass, meth
+    timed_methods[klass] << meth
+    klass.module_eval generate_timer_str(meth_alias, meth)
+  end
+  
+  def Benelux.add_tally obj, meth
+  end
+  
+  def Benelux.name(*names)
+    names.flatten.collect { |n| n.to_s }.join('_')
+  end
+  
+  private
+  def Benelux.prepare_object obj
+    obj.extend Attic  unless obj.kind_of?(Attic)
+    unless obj.kind_of?(Benelux)
+      obj.attic :benelux
+      obj.send :include, Benelux
+    end
+  end
+  
+  def Benelux.rename_method(obj, meth)
+    ## NOTE: This is commented out so we can include  
+    ## Benelux definitions before all classes are loaded. 
+    ##unless obj.respond_to? meth
+    ##  raise NoMethodError, "undefined method `#{meth}' for #{obj}:Class"
+    ##end
+    thread_id, call_id = Thread.current.object_id.abs, obj.object_id.abs
+    meth_alias = "__benelux_#{meth}_#{thread_id}_#{call_id}"
+    obj.module_eval do
+      alias_method meth_alias, meth
+    end
+    meth_alias
+  end
+  
+  def Benelux.generate_timer_str(meth_alias, meth)
+    %Q{
+    def #{meth}(*args, &block)
+      # We only need to do these things once.
+      if self.benelux.nil?
+        self.benelux = Benelux::Timeline.new
+        Benelux.store_thread_reference
+      end
+      ref = self.object_id.abs.to_s << args.object_id.abs.to_s
+      self.benelux.add_mark_open ref, :'#{meth}'
+      ret = #{meth_alias}(*args, &block)
+      self.benelux.add_mark_close ref, :'#{meth}'
+      ret
+    end
+    }
+  end
+  
+end
+
+

data/lib/benelux/mark.rb

@@ -0,0 +1,37 @@
+module Benelux
+  class Mark < Time
+    attr_accessor :name
+    attr_accessor :thread_id
+    attr_accessor :call_id
+    def self.now(n=nil,c=nil,t=nil)
+      v = super()
+      v.name, v.call_id, v.thread_id = n, c, t
+      v
+    end
+    def inspect(reftime=nil)
+      val = reftime.nil? ? self.to_f : (self.to_f - reftime.to_f)
+      args = [self.class, self.hexoid, self.name, val, thread_id, call_id]
+      "#<%s:%s name=%s at=%f thread_id=%s call_id=%s>" % args
+    end
+    def to_s(reftime=nil)
+      val = reftime.nil? ? self.to_f : (self.to_f - reftime.to_f)
+      val.to_s
+    end
+    def ==(other)
+      return false unless other.respond_to? :call_id
+      self.name == other.name &&
+      self.thread_id == other.thread_id &&
+      self.call_id == other.call_id &&
+      self.to_f == self.to_f
+    end
+    def same_timeline?(other)
+      return false unless other.respond_to? :thread_id
+      self.thread_id == other.thread_id
+    end
+    def same_call?(other)
+      return false unless other.respond_to? :call_id
+      self.thread_id == other.thread_id &&
+      self.call_id == other.call_id
+    end
+  end
+end

data/lib/benelux/mixins/thread.rb

@@ -0,0 +1,6 @@
+
+
+class Thread
+  extend Attic
+  attic :benelux
+end

data/lib/benelux/timeline.rb

@@ -0,0 +1,84 @@
+
+module Benelux
+  # 
+  # |------+----+--+----+----|
+  #        |
+  #       0.02  
+  class Timeline < Array
+    
+    def each(*args, &blk)
+      if args.empty? 
+        super(&blk) 
+      else 
+        self.marks(*args).each(&blk)
+      end
+    end
+    
+    ##def between(*names)
+    ##  name_s, name_e = *names.collect { |n| Benelux.name n }
+    ##  time_s, time_e = at(name_s), at(name_e)
+    ##  time_e.first.to_f - time_s.first.to_f
+    ##end
+    ##def duration(*names)
+    ##  name = Benelux.name *names
+    ##  name_s, name_e = "#{name}_a", "#{name}_z"
+    ##  between(name_s, name_e)
+    ##end
+    
+    #
+    #     obj.region(:execute) =>
+    #         [[:execute_a, :execute_z], [:execute_a, :execute_z]]
+    #
+    def regions(*names)
+      
+    end
+    
+    #
+    #      obj.marks(:execute_a, :execute_z, :do_request_a) => 
+    #          [:execute_a, :do_request_a, :do_request_a, :execute_z]
+    #
+    def marks(*names)
+      names = names.flatten.collect { |n| n.to_s }
+      self.benelux.select do |mark| 
+        names.member? mark.name.to_s
+      end
+    end
+    
+    def duration(name)
+      name_s = Benelux.name name, SUFFIX_START 
+      name_e = Benelux.name name, SUFFIX_END
+    end
+    
+    def add_mark(call_id, name)
+      thread_id = Thread.current.object_id.abs
+      mark = Benelux::Mark.now(name, call_id, thread_id)
+      Benelux.thread_timeline << mark
+      self << mark
+    end
+
+    def add_mark_open(call_id, name)
+      add_mark call_id, Benelux.name(name, SUFFIX_START)
+    end
+
+    def add_mark_close(call_id, name)
+      add_mark call_id, Benelux.name(name, SUFFIX_END)
+    end
+
+    def to_line
+      marks = self.sort
+      str, prev = [], marks.first
+      marks.each do |mark|
+        str << "%s(%s):%.4f" % [mark.name, mark.thread_id, mark.to_s(prev)]
+        prev = mark
+      end
+      str.join('; ')
+    end
+    def +(other)
+      self << other
+      self.flatten
+    end
+    # Needs to compare thread id and call id. 
+    #def <=>(other)
+    #end
+  end
+end

data/tryouts/basic_tryouts.rb

@@ -0,0 +1,69 @@
+
+group "Benelux"
+
+library :benelux, 'lib'
+
+tryouts "Basics" do
+  
+  setup do
+    class ::Sleeper
+      def do_something() sleep rand/3 end
+    end
+  end
+  
+  drill "Add timers to existing objects", true do
+    Benelux.add_timer Sleeper, :do_something
+    Sleeper.new.respond_to? :benelux
+  end
+  
+  dream :class, Hash
+  dream { Hash[ Sleeper => [:do_something] ] }
+  drill "Benelux keeps track of timed objects" do
+    Benelux.timed_objects
+  end
+  
+  dream [:do_something]
+  drill "A Benelux object has a benelux_timers method" do
+    Sleeper.new.benelux_timers
+  end
+  
+  dream :class, Benelux::Timeline
+  dream :size, 10 # 5 * 2 = 10 (marks are stored for the method start and end)
+  drill "Creates a timeline" do
+    sleeper = Sleeper.new
+    5.times { sleeper.do_something }
+    sleeper.benelux
+  end
+  
+  dream :size, 4
+  drill "Timelines are stored per object" do
+    sleeper = Sleeper.new
+    Thread.new do
+      2.times { sleeper.do_something }
+    end.join
+    sleeper.benelux
+  end
+  
+  dream :class, Benelux::Timeline
+  dream :size, 10
+  drill "Creates a timeline for the thread" do
+    Benelux.thread_timeline
+  end
+  
+  dream :class, Benelux::Timeline
+  dream :size, 14
+  drill "Creates a global timeline" do
+    Benelux.timeline
+  end
+  
+end
+
+
+tryouts "Not supported" do
+  
+  dream :exception, Benelux::NotSupported
+  drill "Class is not supported" do
+    Benelux.add_timer Class, :new
+  end
+  
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: benelux
+version: !ruby/object:Gem::Version 
+  version: 0.2.0.001
+platform: ruby
+authors: 
+- Delano Mandelbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-21 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hexoid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "Benelux: Little freakin' timers for your Ruby codes"
+email: delano@solutious.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+- CHANGES.txt
+files: 
+- CHANGES.txt
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- benelux.gemspec
+- lib/benelux.rb
+- lib/benelux/mark.rb
+- lib/benelux/mixins/thread.rb
+- lib/benelux/timeline.rb
+- tryouts/basic_tryouts.rb
+has_rdoc: true
+homepage: http://github.com/delano/benelux
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --title
+- "Benelux: Little freakin' timers for your Ruby codes"
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: benelux
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: "Benelux: Little freakin' timers for your Ruby codes"
+test_files: []
+