benelux 0.3.2 → 0.4.1

data/lib/benelux/timeline.rb

@@ -18,18 +18,23 @@ module Benelux
   #    regions = Benelux.timeline(track_id).regions(:execute)
   #
   class Timeline < Array
+    include Selectable
+    
     attr_accessor :ranges
+    attr_accessor :counts
     attr_accessor :stats
     attr_accessor :default_tags
     attr_reader :caller
     def initialize(*args)
       @caller = Kernel.caller
-      @ranges, @default_tags = [], Benelux::Tags.new
+      @counts = SelectableArray.new
+      @ranges = SelectableArray.new
+      @default_tags = Selectable::Tags.new
       @stats = Benelux::Stats.new
       add_default_tag :thread_id => Thread.current.object_id.abs
       super
     end
-    def add_default_tags(tags=Benelux::Tags.new)
+    def add_default_tags(tags=Selectable::Tags.new)
       @default_tags.merge! tags
     end
     alias_method :add_default_tag, :add_default_tags
@@ -65,12 +70,8 @@ module Benelux
       end
     end
     
-    def [](tags={})
-      #tags = Benelux::TagHelpers.normalize tags
-      marks = self.select do |mark|
-        mark.tags >= tags
-      end
-      tl = Benelux::Timeline.new marks
+    def [](*tags)
+      tl = super
       tl.ranges = @ranges.select do |region|
         region.tags >= tags
       end
@@ -87,7 +88,7 @@ module Benelux
     #     obj.ranges(:do_request) =>
     #         [[:do_request_a, :do_request_z], [:do_request_a, ...]]
     #    
-    def ranges(name=nil, tags=Benelux::Tags.new)
+    def ranges(name=nil, tags=Selectable::Tags.new)
       return @ranges if name.nil?
       @ranges.select do |range| 
         ret = name.to_s == range.name.to_s &&
@@ -96,11 +97,19 @@ module Benelux
       end
     end
     
+    def counts(name=nil, tags=Selectable::Tags.new)
+      return @counts if name.nil?
+      @counts.select do |count| 
+        ret = name.to_s == count.name.to_s &&
+        (tags.nil? || count.tags >= tags)
+        ret
+      end
+    end
     #
-    #     obj.ranges(:do_request) =>
-    #         [[:do_request_a, :get_body, :do_request_z], [:do_request_a, ...]]
+    #     obj.regions(:do_request) =>
+    #         
     #
-    def regions(name=nil, tags=Benelux::Tags.new)
+    def regions(name=nil, tags=Selectable::Tags.new)
       return self if name.nil?
       self.ranges(name, tags).collect do |base_range|
         marks = self.sort.select do |mark|
@@ -124,46 +133,47 @@ module Benelux
       super
     end
     
+    # TODO: Remove Benelux::Count. Just use Stats!
+    def add_count(name, count, tags={})
+      tags = tags.merge self.default_tags
+      c = Benelux::Count.new(name, count)
+      c.add_tags tags
+      self.stats.add_group(name)
+      self.stats.sample(name, count, c.tags)
+      c
+    end
+    
     def add_mark(name)
       mark = Benelux::Mark.now(name)
-      mark.add_tags Benelux.thread_timeline.default_tags
       mark.add_tags self.default_tags
-      Benelux.thread_timeline << mark
       self << mark
       mark
     end
     
     def add_range(name, from, to)
       range = Benelux::Range.new(name, from, to)
-      range.add_tags Benelux.thread_timeline.default_tags
       range.add_tags self.default_tags
-      @stats.add_keeper(name)
-      @stats.send(name).sample(range.duration, range.tags)
-      @ranges << range
-      Benelux.thread_timeline.ranges << range
-      Benelux.thread_timeline.stats.add_keeper(name)
-      Benelux.thread_timeline.stats.send(name).sample(range.duration, range.tags)
+      range.add_tags from.tags
+      range.add_tags to.tags
+      self.ranges << range
+      self.stats.add_group(name)
+      self.stats.sample(name, range.duration, range.tags)
       range
     end
     
-    def to_line
-      marks = self.sort
-    end
-    
-    def to_line2
-      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
+    def merge!(*timelines)
+      timelines.each do |tl| 
+        self.push *tl
+        self.ranges.push *tl.ranges
+        self.stats += tl.stats
       end
-      str.join('; ')
+      self
     end
+    
     def +(other)
-      self << other
-      self.ranges += other.ranges
+      self.push *other
+      self.ranges.push *other.ranges
       self.stats += other.stats
-      self.flatten!
       self
     end
     # Needs to compare thread id and call id. 

data/lib/benelux/track.rb

@@ -0,0 +1,20 @@
+
+
+module Benelux
+  class Track
+    attr_reader :name
+    attr_reader :thread_group
+    attr_reader :timeline
+    def initialize(n,g=nil)
+      @name, @thgrp = n, (g || ThreadGroup.new)
+      @timeline = Benelux::Timeline.new
+    end
+    def add_thread(t=Thread.current)
+      @thgrp.add t
+      t
+    end
+    def threads
+      @thgrp.list
+    end
+  end
+end

data/lib/selectable.rb

@@ -0,0 +1,72 @@
+
+# = Selectable
+#
+# <strong>Note: Classes that include Selectable must also
+# subclass Array</strong>
+#
+#     class Something < Array
+#       include Selectable
+#     end
+#
+module Selectable
+  
+  class SelectableError < RuntimeError; end
+  class TagsNotInitialized < SelectableError; end
+  
+  require 'selectable/tags'
+  require 'selectable/object'
+  
+  # Returns a Hash or Array
+  def Selectable.normalize(*tags)
+    tags.flatten!
+    tags = tags.first if tags.first.kind_of?(Hash) || tags.first.kind_of?(Array)
+    if tags.is_a?(Hash)
+      tags = Hash[tags.collect { |n,v| [n, v.to_s] }]
+    else
+      tags.collect! { |v| v.to_s }
+    end
+    tags
+  end
+  
+  # Return the objects that match the given tags. 
+  # This process is optimized for speed so there
+  # as few conditions as possible. One result of
+  # that decision is that it does not gracefully 
+  # handle error conditions. For example, if the
+  # tags in an object have not been initialized,
+  # you will see this error:
+  #
+  #     undefined method `>=' for nil:NilClass
+  #
+  def filter(*tags)
+    tags = Selectable.normalize tags
+    # select returns an Array. We want a Selectable.
+    items = self.select { |obj| obj.tags >= tags }
+    self.class.new items
+  end  
+    
+
+  def filter!(*tags)
+    tags = Selectable.normalize tags
+    self.delete_if { |obj|   obj.tags < tags }
+  end
+  
+  def tags
+    t = Selectable::Tags.new
+    self.each { |o| t.merge o.tags }
+    t
+  end
+  
+  # Creates an alias for +filter+ called +[]+, but 
+  # only if [] doesn't already exist in +obj+.
+  def self.included(obj)
+    alias_method :[], :filter unless obj.method_defined? :[]
+  end
+end
+
+class SelectableArray < Array
+  include Selectable
+end
+class SelectableHash < Hash
+  include Selectable
+end

data/lib/selectable/global.rb

@@ -0,0 +1,63 @@
+# 
+# module Selectable
+#   
+#   class Global
+#     attr_reader :names
+#     def initialize(*names)
+#       @names = []
+#       add_groups names
+#     end
+#     class << self
+#       def group_class
+#         @group_class || Group
+#       end
+#       attr_writer :group_class
+#     end
+#     def group(name)
+#       self.send name
+#     end
+#     # Each group
+#     def each(&blk)
+#       @names.each { |name| blk.call(group(name)) }
+#     end
+#     # Each group name, group
+#     def each_pair(&blk)
+#       @names.each { |name| blk.call(name, group(name)) }
+#     end
+#     def add_groups(*args)
+#       args.flatten.each do |meth|
+#         next if has_group? meth
+#         @names << meth
+#         self.class.send :attr_reader, meth
+#         (g = Group.new).name = meth
+#         instance_variable_set("@#{meth}", g)
+#       end
+#     end
+#     alias_method :add_group, :add_groups
+#     def has_group?(name)
+#       @names.member? name
+#     end
+#     def +(other)
+#       if !other.is_a?(Benelux::Stats)
+#         raise TypeError, "can't convert #{other.class} into Stats" 
+#       end
+#       other.names.each do |name|
+#         add_group name
+#         a = self.send(name) 
+#         a += other.send(name)
+#         a
+#       end
+#       self
+#     end
+#     
+#     
+#     class Group < Array
+#       include Selectable
+#       attr_accessor :name
+#       def self.extend(klass)
+#         p 111111111111111
+#       end
+#     end
+#     
+#   end
+# end

data/lib/selectable/object.rb

@@ -0,0 +1,42 @@
+
+module Selectable
+  
+  # Helper methods for objects with a @tags instance var
+  #
+  # e.g. 
+  #
+  #     class Something
+  #       include Selectable::Object
+  #     end
+  #
+  module Object
+    attr_accessor :tags
+    def add_tags(tags)
+      init_tags!
+      @tags.merge! Selectable.normalize tags
+    end
+    alias_method :add_tag, :add_tags
+    def add_tags_quick(tags)
+      @tags.merge! tags
+    end
+    alias_method :add_tag_quick, :add_tags_quick
+    def remove_tags(*tags)
+      raise TagsNotInitialized if @tags.nil?
+      tags.flatten!
+      @tags.delete_if { |n,v| tags.member?(n) }
+    end
+    alias_method :remove_tag, :remove_tags
+    def tag_values(*tags)
+      raise TagsNotInitialized if @tags.nil?
+      tags.flatten!
+      ret = @tags.collect { |n,v| 
+        v if tags.empty? || tags.member?(n) 
+      }.compact
+      ret
+    end
+    def init_tags!
+      @tags ||= Selectable::Tags.new
+    end
+  end
+
+end

data/lib/{benelux → selectable}/tags.rb

@@ -1,47 +1,10 @@
 
 
-module Benelux
-  
-  # Helper methods for objects with a @tags instance var
-  #
-  # e.g. 
-  #
-  #     class Something
-  #       include Benelux::TagHelpers
-  #     end
-  #
-  module TagHelpers
-    attr_accessor :tags
-    def add_tags(tags)
-      @tags ||= Benelux::Tags.new
-      @tags.merge! tags
-    end
-    alias_method :add_tag, :add_tags
-    def remove_tags(*tags)
-      tags.flatten!
-      @tags ||= Benelux::Tags.new
-      @tags.delete_if { |n,v| tags.member?(n) }
-    end
-    alias_method :remove_tag, :remove_tags
-    def tag_values(*tags)
-      tags.flatten!
-      @tags ||= Benelux::Tags.new
-      ret = @tags.collect { |n,v| 
-        p [:n, v]
-        v if tags.empty? || tags.member?(n) 
-      }.compact
-      ret
-    end
-    def self.normalize(tags={})
-      tags = tags.first if tags.kind_of?(Array) && tags.first.kind_of?(Hash)
-      tags = [tags].flatten unless tags.kind_of?(Hash)
-      tags
-    end
-  end
+module Selectable
   
   # An example of filtering an Array of tagged objects based
   # on a provided Hash of tags or Array of tag values. +obj+
-  # in this case would be an object that includes TagHelpers.
+  # in this case would be an object that includes Taggable.
   #
   #     class Something
   #       def [](tags={})
@@ -67,9 +30,8 @@ module Benelux
     end
     
     def ==(other)
-#      other = Benelux::TagHelpers.normalize other
       if other.is_a?(Array)
-        (self.values & other).sort == other.sort
+        self.values.sort == other.sort
       else
         super(other)
       end
@@ -87,13 +49,12 @@ module Benelux
     #     a > [2, 1]                         # => false
     #
     def <=>(b)
-      #other = Benelux::TagHelpers.normalize other
       return 0 if self == b
       self.send :"compare_#{b.class}", b
     end
         
-    def >(other)  (self <=> other) > 0  end
-    def <(other)  (self <=> other) < 0  end
+    def >(other)  (self <=> other)  > 0 end
+    def <(other)  (self <=> other)  < 0 end
     
     def <=(other) (self <=> other) <= 0 end
     def >=(other) (self <=> other) >= 0 end
@@ -105,12 +66,25 @@ module Benelux
       return -1 unless (a.values_at(*b.keys) & b.values).size >= b.size
       1
     end
-    alias_method :"compare_Benelux::Tags", :compare_Hash
+    alias_method :"compare_Selectable::Tags", :compare_Hash
     
     def compare_Array(b)
       return -1 unless (self.values & b).size >= b.size
       1
     end
+    
+    def method_missing(meth, *args)
+      raise SelectableError, "#{meth}: #{args.first} is not a Hash or Array"
+    end
+    
+    ## NOTE: This is helpful but defensive. Ponder!
+    ##def compare_forced_array(b)
+    ##  compare_Array([b])
+    ##end
+    ##alias_method :compare_String, :compare_forced_array
+    ##alias_method :compare_Symbol, :compare_forced_array
+    ##alias_method :compare_Fixnum, :compare_forced_array
       
   end
+
 end

data/tryouts/10_stats_tryouts.rb

@@ -3,13 +3,30 @@ group "Benelux"
 
 library :benelux, 'lib'
 tryouts "Calculator" do
-  
+  set :base, Benelux::Stats::Calculator.new
   dream :class, Benelux::Stats::Calculator
   dream :n, 10
+  dream :sum, 45
+  dream :sumsq, 285
+  dream :min, 0
+  dream :max, 9
+  dream :proc, lambda { |calc| calc.sd.to_i == 3 }
   drill "can keep stats" do
-    keeper = Benelux::Stats::Calculator.new
-    10.times { keeper.sample(rand) }
-    keeper
+    10.times { |i| base.sample(i) }
+    base
+  end
+  
+  dream true
+  drill "can add stats" do
+    by_sample = Benelux::Stats::Calculator.new
+    10.times { |i| by_sample.sample(i) }
+    by_sample += base
+    by_merge = Benelux::Stats::Calculator.new
+    by_merge.merge! base
+    by_merge.merge! base
+    stash :sample, by_sample
+    stash :merge, by_merge
+    by_sample == by_merge
   end
   
 end