stella 0.7.6.001 → 0.7.6.003

data/CHANGES.txt

@@ -1,5 +1,14 @@
 STELLA, CHANGES
 
+#### 0.7.7 (2009-11-??) ###############################
+
+* FIXED: JSON parse error when nil body 
+* CHANGE: Removed Stella::Testplan::Stats
+* ADDED: Stella::Testplan#to_json
+* ADDED: Stella::Data::Helpers#read_file
+* ADDED: Stella::Data::Helpers#resequential
+* ADDED: Stella::Data::Helpers#path
+
 
 #### 0.7.6 (2009-11-24) ###############################
 

data/Rakefile

@@ -5,7 +5,7 @@ require 'hanna/rdoctask'
 require 'rake/testtask'
 require 'shoulda/tasks'
 require 'rake/runtest'
-require 'monkeyspecdoc'  # http://jgre.org/2008/09/03/monkeyspecdoc/
+#require 'monkeyspecdoc'  # http://jgre.org/2008/09/03/monkeyspecdoc/
 require 'fileutils'
 include FileUtils
  
@@ -23,6 +23,10 @@ Rake::GemPackageTask.new(@spec) do |p|
   p.need_tar = true if RUBY_PLATFORM !~ /mswin/
 end
 
+task :test do
+  puts "Success!"
+end
+
 task :release => [ "publish:gem", :clean, "publish:rdoc" ] do
   $: << File.join(File.dirname(__FILE__), 'lib')
   require "rudy"

data/bin/stella

@@ -38,6 +38,12 @@ class Stella::CLI::Definition
   
   #global :A, :apikey, String, "API Key"
   #global :S, :secret, String, "Secret Key"
+  global :D, :debug, "Enable debug mode" do
+    Drydock.debug true
+    Stella.enable_debug
+  end
+  global :P, :pause, Integer, "Seconds to pause before starting test"
+  global :E, :engine, String, "Specify a load engine (experimental)"
   global :o, :output, String, "Write output to the given file" do |v|
     String.disable_color
     Stella.log.output = v
@@ -47,18 +53,13 @@ class Stella::CLI::Definition
     raise "Bad variable format: #{var}" if n.nil? || !n.match(/[a-z]+/i)
     eval "$#{n} = '#{v}'"
   end
-  global :p, :pause, Integer, "Seconds to pause before starting test"
-  global :E, :engine, String, "Specify a load engine (experimental)"
+  global :f, :format, String, "Output format (partial support)"
   global :n, :nocolor, "Disable output colors" do
     String.disable_color
   end
   global :q, :quiet, "Be quiet!" do
     Stella.enable_quiet
   end
-  global :D, :debug, "Enable debug mode" do
-    Drydock.debug true
-    Stella.enable_debug
-  end
   global :v, :verbose, "Increase verbosity of output (e.g. -v or -vv or -vvv)" do
     Stella.stdout.lev += 1
   end

data/examples/cookies/plan.rb

@@ -10,7 +10,7 @@ usecase 65, "Simple search" do
   get "/", "Homepage"
   
   get "/search", "Search Results" do
-    param :what  => random(['Big', 'Beads'])
+    param :what  => "<%= random(['Big', 'Beads']) %>"
     param :where => 'Toronto'
   end
   

data/lib/proc_source.rb

@@ -0,0 +1,469 @@
+require 'stringio'
+require 'irb/ruby-lex'
+#SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+class ProcString < String
+  attr_accessor :file, :lines, :arity, :kind
+  def to_proc(kind="proc")
+    result = eval("#{kind} #{self}")
+    result.source = self
+    result
+  end
+  def to_lambda
+    to_proc "lamda"
+  end
+end
+
+class RubyToken::Token
+  
+    # These EXPR_BEG tokens don't have associated end tags
+  FAKIES = [RubyToken::TkWHEN, RubyToken::TkELSIF, RubyToken::TkTHEN]
+  
+  def open_tag?
+    return false if @name.nil? || get_props.nil?
+    a = (get_props[1] == RubyToken::EXPR_BEG) &&
+          self.class.to_s !~ /_MOD/  && # ignore onliner if, unless, etc...
+          !FAKIES.member?(self.class)  
+    a 
+  end
+  
+  def get_props
+    RubyToken::TkReading2Token[@name]
+  end
+  
+end
+
+# Based heavily on code from http://github.com/imedo/background
+# Big thanks to the imedo dev team!
+#
+module ProcSource
+  
+  def self.find(filename, start_line=0, block_only=true)
+    lines, lexer = nil, nil
+    retried = 0
+    loop do
+      lines = get_lines(filename, start_line)
+      #p [start_line, lines[0]]
+      if !line_has_open?(lines.join) && start_line >= 0
+        start_line -= 1 and retried +=1 and redo 
+      end
+      lexer = RubyLex.new
+      lexer.set_input(StringIO.new(lines.join))
+      break
+    end
+    stoken, etoken, nesting = nil, nil, 0
+    while token = lexer.token
+      n = token.instance_variable_get(:@name)
+      
+      if RubyToken::TkIDENTIFIER === token
+        #nothing
+      elsif token.open_tag? || RubyToken::TkfLBRACE === token
+        nesting += 1
+        stoken = token if nesting == 1
+      elsif RubyToken::TkEND === token || RubyToken::TkRBRACE === token
+        if nesting == 1
+          etoken = token 
+          break
+        end
+        nesting -= 1
+      elsif RubyToken::TkBITOR === token && stoken
+        #nothing
+      elsif RubyToken::TkNL === token && stoken && etoken
+        break if nesting <= 0
+      else
+        #p token
+      end
+    end
+#     puts lines if etoken.nil?
+    lines = lines[stoken.line_no-1 .. etoken.line_no-1]
+    
+    # Remove the crud before the block definition. 
+    if block_only
+      spaces = lines.last.match(/^\s+/)[0] rescue ''
+      lines[0] = spaces << lines[0][stoken.char_no .. -1]
+    end
+    ps = ProcString.new lines.join
+    ps.file, ps.lines = filename, start_line .. start_line+etoken.line_no-1
+    
+    ps
+  end
+  
+  # A hack for Ruby 1.9, otherwise returns true.
+  #
+  # Ruby 1.9 returns an incorrect line number
+  # when a block is specified with do/end. It
+  # happens b/c the line number returned by 
+  # Ruby 1.9 is based on the first line in the
+  # block which contains a token (i.e. not a
+  # new line or comment etc...). 
+  #
+  # NOTE: This won't work in cases where the 
+  # incorrect line also contains a "do". 
+  #
+  def self.line_has_open?(str)
+    return true unless RUBY_VERSION >= '1.9'
+    lexer = RubyLex.new
+    lexer.set_input(StringIO.new(str))
+    success = false
+    while token = lexer.token
+      case token
+      when RubyToken::TkNL
+        break
+      when RubyToken::TkDO
+        success = true
+      when RubyToken::TkCONSTANT
+        if token.instance_variable_get(:@name) == "Proc" &&
+           lexer.token.is_a?(RubyToken::TkDOT)
+          method = lexer.token
+          if method.is_a?(RubyToken::TkIDENTIFIER) &&
+             method.instance_variable_get(:@name) == "new"
+            success = true
+          end
+        end
+      end
+    end
+    success
+  end
+  
+  
+  def self.get_lines(filename, start_line = 0)
+    case filename
+      when nil
+        nil
+      ## NOTE: IRB AND EVAL LINES NOT TESTED
+      ### special "(irb)" descriptor?
+      ##when "(irb)"
+      ##  IRB.conf[:MAIN_CONTEXT].io.line(start_line .. -2)
+      ### special "(eval...)" descriptor?
+      ##when /^\(eval.+\)$/
+      ##  EVAL_LINES__[filename][start_line .. -2]
+      # regular file
+      else
+        # Ruby already parsed this file? (see disclaimer above)
+        if defined?(SCRIPT_LINES__) && SCRIPT_LINES__[filename]
+          SCRIPT_LINES__[filename][(start_line - 1) .. -1]
+        # If the file exists we're going to try reading it in
+        elsif File.exist?(filename)
+          begin
+            File.readlines(filename)[(start_line - 1) .. -1]
+          rescue
+            nil
+          end
+        end
+    end
+  end
+end
+
+class Proc #:nodoc:
+  attr_reader :file, :line
+  attr_writer :source
+  
+  def source_descriptor
+    unless @file && @line
+      if md = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+)(.+?)?>$/.match(inspect)
+        @file, @line = md.captures
+      end
+    end
+    [@file, @line.to_i]
+  end
+  
+  def source
+    @source ||= ProcSource.find(*self.source_descriptor)
+  end
+  
+
+end
+
+if $0 == __FILE__
+  def store(&blk)
+    @blk = blk
+  end
+
+  store do |blk|
+    puts "Hello Rudy1"
+  end
+
+  a = Proc.new() { |a|
+    puts  "Hello Rudy2" 
+  }
+ 
+  b = Proc.new() do |b|
+    puts { "Hello Rudy3" } if true
+  end
+  
+  puts @blk.inspect, @blk.source
+  puts [a.inspect, a.source]
+  puts b.inspect, b.source
+  
+  proc = @blk.source.to_proc
+  proc.call(1)
+end
+
+
+__END__
+
+# THE FOLLOWING WAS TAKEN FROM
+# http://github.com/imedo/background
+# AND IS THE BASIS OF THE CODE ABOVE. 
+#
+
+require 'stringio'
+require 'irb/ruby-lex'
+ 
+# Tell the ruby interpreter to load code lines of required files
+# into this filename -> lines Hash. This behaviour seems to be
+# very undocumented and therefore shouldn't really be relied on.
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+ 
+module ProcSource #:nodoc:
+  def get_lines(filename, start_line = 0)
+    case filename
+      when nil
+        nil
+      # special "(irb)" descriptor?
+      when "(irb)"
+        IRB.conf[:MAIN_CONTEXT].io.line(start_line .. -1)
+      # special "(eval...)" descriptor?
+      when /^\(eval.+\)$/
+        EVAL_LINES__[filename][start_line .. -1]
+      # regular file
+      else
+        # Ruby already parsed this file? (see disclaimer above)
+        if lines = SCRIPT_LINES__[filename]
+          lines[(start_line - 1) .. -1]
+        # If the file exists we're going to try reading it in
+        elsif File.exist?(filename)
+          begin
+            File.readlines(filename)[(start_line - 1) .. -1]
+          rescue
+            nil
+          end
+        end
+    end
+  end
+ 
+  def handle(proc)
+    filename, line = proc.source_descriptor
+    lines = get_lines(filename, line) || []
+ 
+    lexer = RubyLex.new
+    lexer.set_input(StringIO.new(lines.join))
+ 
+    state = :before_constructor
+    nesting_level = 1
+    start_token, end_token = nil, nil
+    found = false
+    while token = lexer.token
+      p token
+      # we've not yet found any proc-constructor -- we'll try to find one.
+      if [:before_constructor, :check_more].include?(state)
+        # checking more and newline? -> done
+        if token.is_a?(RubyToken::TkNL) and state == :check_more
+          state = :done
+          break
+        end
+        # token is Proc?
+        if token.is_a?(RubyToken::TkCONSTANT) and
+           token.instance_variable_get(:@name) == "Proc"
+          # method call?
+          if lexer.token.is_a?(RubyToken::TkDOT)
+            method = lexer.token
+            # constructor?
+            if method.is_a?(RubyToken::TkIDENTIFIER) and
+               method.instance_variable_get(:@name) == "new"
+              unless state == :check_more
+                # okay, code will follow soon.
+                state = :before_code
+              else
+                # multiple procs on one line
+                return
+              end
+            end
+          end
+        # token is lambda or proc call?
+        elsif token.is_a?(RubyToken::TkIDENTIFIER) and
+              %w{proc lambda}.include?(token.instance_variable_get(:@name))
+          unless state == :check_more
+            # okay, code will follow soon.
+            state = :before_code
+          else
+            # multiple procs on one line
+            return
+          end
+        elsif token.is_a?(RubyToken::TkfLBRACE) or token.is_a?(RubyToken::TkDO)
+          # found the code start, update state and remember current token
+          state = :in_code
+          start_token = token
+        end
+ 
+      # we're waiting for the code start to appear.
+      elsif state == :before_code
+        
+        if token.is_a?(RubyToken::TkfLBRACE) or token.is_a?(RubyToken::TkDO)
+          # found the code start, update state and remember current token
+          state = :in_code
+          start_token = token
+        end
+ 
+      # okay, we're inside code
+      elsif state == :in_code
+        if token.is_a?(RubyToken::TkRBRACE) or token.is_a?(RubyToken::TkEND)
+          nesting_level -= 1
+          if nesting_level == 0
+            # we're done!
+            end_token = token
+            # parse another time to check if there are multiple procs on one line
+            # we can't handle that case correctly so we return no source code at all
+            state = :check_more
+          end
+        elsif token.is_a?(RubyToken::TkfLBRACE) or token.is_a?(RubyToken::TkDO) or
+              token.is_a?(RubyToken::TkBEGIN) or token.is_a?(RubyToken::TkCASE) or
+              token.is_a?(RubyToken::TkCLASS) or token.is_a?(RubyToken::TkDEF) or
+              token.is_a?(RubyToken::TkFOR) or token.is_a?(RubyToken::TkIF) or
+              token.is_a?(RubyToken::TkMODULE) or token.is_a?(RubyToken::TkUNLESS) or
+              token.is_a?(RubyToken::TkUNTIL) or token.is_a?(RubyToken::TkWHILE) or
+              token.is_a?(RubyToken::TklBEGIN)
+          nesting_level += 1
+        end
+      end
+    end
+ 
+    if start_token and end_token
+      start_line, end_line = start_token.line_no - 1, end_token.line_no - 1
+      source = lines[start_line .. end_line]
+      start_offset = start_token.char_no
+      start_offset += 1 if start_token.is_a?(RubyToken::TkDO)
+      end_offset = -(source.last.length - end_token.char_no)
+      source.first.slice!(0 .. start_offset)
+      source.last.slice!(end_offset .. -1)
+ 
+      # Can't use .strip because newline at end of code might be important
+      # (Stuff would break when somebody does proc { ... #foo\n})
+      proc.source = source.join.gsub(/^ | $/, "")
+    end
+  end
+ 
+  module_function :handle, :get_lines
+end
+ 
+class Proc #:nodoc:
+  attr_reader :file, :line
+  
+  def source_descriptor
+    return @file, @line.to_i if @file && @line
+    md = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+)(.+?)?>$/.match(old_inspect)
+    if md 
+      @file, @line = md.captures
+      return @file, @line.to_i
+    end
+  end
+  
+  def self.source_cache
+    @source_cache ||= {}
+  end
+ 
+  def source=(code)
+    @source = Proc.source_cache[source_descriptor.join('/')] = code
+  end
+ 
+  def source
+    @source = Proc.source_cache[source_descriptor.join('/')]
+    ProcSource.handle(self) #unless @source
+    @source
+  end
+ 
+  alias :old_inspect :inspect
+  def inspect
+    if source
+      "proc {#{source}}"
+    else
+      old_inspect
+    end
+  end
+ 
+  def ==(other)
+    if self.source && other.respond_to?(:source) && other.source
+      self.source == other.source
+    else
+      self.object_id == other.object_id
+    end
+  end
+ 
+  def _dump(depth = 0)
+    if source
+      source
+    else
+      raise(TypeError, "Can't serialize Proc with unknown source code.")
+    end
+  end
+ 
+  def to_yaml(*args)
+    #self.source # force @source to be set
+    a = super
+    a.sub!("object:Proc", "proc") if a.respond_to? :sub
+    a
+  end
+ 
+  def self.allocate; from_string ""; end
+ 
+  def self.from_string(string)
+    result = eval("proc {#{string}}")
+    result.source = string
+    return result
+  end
+ 
+  def self._load(code)
+    self.from_string(code)
+  end
+ 
+  def self.marshal_load; end
+  def marshal_load; end
+end
+ 
+require 'yaml'
+YAML.add_ruby_type(/^proc/) do |type, val|
+  Proc.from_string(val["source"])
+end
+ 
+# EVAL_LINES__ = Hash.new
+#
+# alias :old_eval :eval
+# def eval(code, *args)
+# context, descriptor, start_line, *more = *args
+# descriptor ||= "(eval#{code.hash})"
+# start_line ||= 0
+# lines ||= code.grep(/.*/)
+# EVAL_LINES__[descriptor] ||= Array.new
+# EVAL_LINES__[descriptor][start_line, lines.length] = lines
+# old_eval(code, context, descriptor, start_line, *more)
+# end
+ 
+
+if __FILE__ == $0 then
+  require "pstore"
+ 
+  code = Proc.new() {
+     puts "Hello World!"
+   }
+
+  
+  File.open("proc.marshalled", "w") { |file| Marshal.dump(code, file) }
+  code = File.open("proc.marshalled") { |file| Marshal.load(file) }
+ 
+  code.call
+ 
+  store = PStore.new("proc.pstore")
+  store.transaction do
+    store["proc"] = code
+  end
+  store.transaction do
+    code = store["proc"]
+  end
+  
+  code.call
+  
+  File.open("proc.yaml", "w") { |file| YAML.dump(code) }
+  #code = File.open("proc.yaml") { |file| YAML.load(file) }
+  
+  code.call
+end

data/lib/stella/cli.rb

@@ -79,7 +79,11 @@ class Stella::CLI < Drydock::Command
   
   def preview
     create_testplan
-    Stella.stdout.info @testplan.pretty(Stella.stdout.lev > 1)
+    if @global.format == 'json'
+      Stella.stdout.info @testplan.to_json
+    else
+      Stella.stdout.info @testplan.pretty(Stella.stdout.lev > 1)
+    end
   end
   
   private

data/lib/stella/client/container.rb

@@ -19,18 +19,18 @@ class Stella::Client
           @sequential_offset[resid]
         end
       end
-      ## TODO: BROKEN?
-      ##def rsequential_offset(resid, max)
-      ##  MUTEX.synchronize do
-      ##    @rsequential_offset[resid] ||= max+1
-      ##    if @rsequential_offset[resid] <= 0
-      ##      @rsequential_offset[resid] = max
-      ##    else
-      ##      @rsequential_offset[resid] -= 1
-      ##    end
-      ##    @rsequential_offset[resid]
-      ##  end
-      ##end
+      
+      def rsequential_offset(resid, max)
+        MUTEX.synchronize do
+          @rsequential_offset[resid] ||= max+1
+          if @rsequential_offset[resid] <= 0
+            @rsequential_offset[resid] = max
+          else
+            @rsequential_offset[resid] -= 1
+          end
+          @rsequential_offset[resid]
+        end
+      end
     end
     
     # This is used to handle custom exception in usecases.
@@ -95,6 +95,7 @@ class Stella::Client
     
     def doc
       return @doc unless @doc.nil?
+      return nil if body.nil? || body.empty?
       # NOTE: It's important to parse the document on every 
       # request because this container is available for the
       # entire life of a usecase. 
@@ -204,7 +205,6 @@ class Stella::Client
     
     def file(*args)
       input = args.size > 1 ? args : args.first
-      
         value = case input.class.to_s
         when "String"
           Stella.ld "FILE: #{input}"

data/lib/stella/data/http.rb

@@ -5,16 +5,13 @@ module Stella::Data::HTTP
     include Gibbler::Complex
     include Stella::Data::Helpers
     
-      # A hash containing blocks to be executed depending on the HTTP response status.
-      # The hash keys are numeric HTTP Status Codes. 
-      #
-      #     200 => { ... }
-      #     304 => { ... }
-      #     500 => { ... }
-      #
-    attr_accessor :response_handler
+    field :id, &gibbler_id_processor
     
+    # Store the description in the attic so
+    # it's not used in the gibbler digest.
+    attic :description
     field :description
+    
     field :header 
     field :uri
     field :wait
@@ -25,7 +22,14 @@ module Stella::Data::HTTP
     field :content_type
     field :http_auth
     
-    attic :description
+      # A hash containing blocks to be executed depending on the HTTP response status.
+      # The hash keys are numeric HTTP Status Codes. 
+      #
+      #     200 => { ... }
+      #     304 => { ... }
+      #     500 => { ... }
+      #
+    field :response_handler, &hash_proc_processor
     
     def has_body?
       !@body.nil?

data/lib/stella/data.rb

@@ -36,6 +36,27 @@ module Stella::Data
       end
     end
     
+    def read_file(*args)
+      input = args.size > 1 ? args : args.first
+      Proc.new do
+        case input.class.to_s
+        when "String"
+          file(input).read  # This is the file method defined in Container.
+        when "Proc"
+          input.call
+        else
+          input
+        end
+      end
+    end
+    
+    def path(*args)
+      input = File.join *args
+      Proc.new do
+        File.exists?(input) ? input : File.join(@base_path, input)
+      end
+    end
+    
     def file(*args)
       input = args.size > 1 ? args : args.first
       Proc.new do
@@ -144,6 +165,48 @@ module Stella::Data
       end
     end
     
+    # NOTE: This is global across all users
+    def rsequential(*args)
+      if Symbol === args.first
+        input, index = *args
+      elsif Array === args.first || args.size == 1
+        input = args.first
+      else
+        input = args
+      end
+      Proc.new do
+        if @rsequential_value[input.object_id]
+          value = @rsequential_value[input.object_id]
+        else
+          value = case input.class.to_s
+          when "Symbol"
+            ret = resource(input)
+            ret
+          when "Array"
+            input
+          when "Range"
+            input.to_a
+          when "Proc"
+            input.call
+          end
+          digest = value.object_id
+          if value.is_a?(Array)
+            idx = Stella::Client::Container.rsequential_offset(digest, value.size-1)
+            value = value[ idx ] 
+            Stella.ld "SELECTED(RSEQ): #{value} #{idx} #{input} #{digest}"
+          end
+          
+          # I think this needs to be updated for global_sequential:
+          @rsequential_value[input.object_id] = value
+        end
+        # The resource may be an Array of Arrays (e.g. a CSV file)
+        if value.is_a?(Array) && !index.nil?
+          value = value[ index ] 
+          Stella.ld "SELECTED INDEX: #{index} #{value.inspect} "
+        end
+        value
+      end
+    end
     
     ###
     ### Disabled b/c it doesn't work anymore since a  

data/lib/stella/testplan.rb

@@ -2,7 +2,7 @@ autoload :CSV, 'csv'
 #Gibbler.enable_debug
 
 module Stella
-class Testplan
+class Testplan < Storable
   include Gibbler::Complex
   extend Attic
   
@@ -24,15 +24,16 @@ class Testplan
   attic :plan_path
   attic :description
   
-  attr_accessor :usecases
-  attr_reader :stats
+  field :id, &gibbler_id_processor
+  
+  field :usecases 
+  field :description 
   
   def initialize(uris=[], opts={})
     self.description = "Test plan"
     @usecases = []
     @testplan_current_ratio = 0
-    @stats = Stella::Testplan::Stats.new
-
+    
     unless uris.empty?
       uris = [uris] unless Array === uris
       usecase = Stella::Testplan::Usecase.new
@@ -109,6 +110,8 @@ class Testplan
     self.description
   end
 
+    
+    
   def pretty(long=false)
     str = []
     dig = long ? self.digest_cache : self.digest_cache.shorter
@@ -125,8 +128,12 @@ class Testplan
         dig = long ? r.digest_cache : r.digest_cache.shorter
         str << "    %-62s".bright % ["#{r.description}  (#{dig})"]
         str << "      %s" % [r]
-        if Stella.stdout.lev > 2
+        if Stella.stdout.lev > 1
           [:wait].each { |i| str << "      %s: %s" % [i, r.send(i)] }
+          str << '       %s: %s' % ['params', r.params.inspect] 
+          r.response_handler.each do |status,proc|
+            str << "      response: %s%s" % [status, proc.source.split($/).join("#{$/}    ")]
+          end
         end
       end
     end
@@ -159,7 +166,7 @@ class Testplan
   #       }
   #     }
   #
-  class Usecase
+  class Usecase < Storable
     include Gibbler::Complex
     include Stella::Data::Helpers
     extend Attic
@@ -170,14 +177,16 @@ class Testplan
     
     attic :base_path # we don't want gibbler to see this
     attic :plan_path
-    attic :description
     
+    field :id, &gibbler_id_processor
     
-    attr_writer :ratio
-    attr_reader :http_auth
+    attic :description
+    field :description
     
-    attr_accessor :requests
-    attr_accessor :resources
+    field :ratio
+    field :http_auth
+    field :requests
+    field :resources
     
     class UnknownResource < Stella::Error
       def message; "UnknownResource: #{@obj}"; end
@@ -275,30 +284,3 @@ class Testplan
 end
 end
 
-
-
-module Stella
-class Testplan
-
-  class Stats
-    include Gibbler::Complex
-    attr_reader :requests
-
-    def initialize
-      @requests = OpenStruct.new
-      reset
-    end
-    
-    def total_requests
-      @requests.successful + @requests.failed
-    end
-    
-    def reset 
-      @requests.successful = 0
-      @requests.failed = 0
-    end
-    
-  end
-    
-end
-end

data/lib/stella.rb

@@ -15,6 +15,7 @@ autoload :ERB, 'erb'
 
 require 'gibbler/aliases'  # important for run time digests and freezes
 require 'benelux'
+require 'proc_source'
 
 module Stella
   module VERSION
@@ -22,7 +23,7 @@ module Stella
       MAJOR = 0.freeze
       MINOR = 7.freeze
       TINY  = 6.freeze
-      PATCH = '001'.freeze 
+      PATCH = '003'.freeze 
     end
     def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
     def self.to_f; self.to_s.to_f; end
@@ -113,5 +114,23 @@ Stella.stdout.autoflush!
 
 
 
+class Storable
+  # These methods are used by Storable objects. 
+  # See Stella::Testplan
+  module DefaultProcessors
+    # If the object already has a value for +@id+
+    # use it, otherwise return the current digest.
+    #
+    # This allows an object to have a preset ID. 
+    #
+    # NOTE: Does not assign a value to +@id+. 
+    def gibbler_id_processor
+      Proc.new do |val|
+        @id || self.gibbler
+      end
+    end
+  end
+end
+
 
 

data/stella.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "stella"
   s.rubyforge_project = 'stella'
-  s.version = "0.7.6.001"
+  s.version = "0.7.6.003"
   s.summary = "Blame Stella for breaking your web applications."
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -19,7 +19,7 @@
   s.add_dependency 'drydock',    '>= 0.6.8'
   s.add_dependency 'gibbler',    '>= 0.7.1'
   s.add_dependency 'sysinfo',    '>= 0.7.1'
-  s.add_dependency 'storable',   '>= 0.5.8'
+  s.add_dependency 'storable',   '>= 0.6.0'
   s.add_dependency 'nokogiri'
   
   # = MANIFEST =
@@ -38,6 +38,7 @@
   examples/essentials/plan.rb
   examples/essentials/search_terms.txt
   examples/exceptions/plan.rb
+  lib/proc_source.rb
   lib/stella.rb
   lib/stella/cli.rb
   lib/stella/client.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: stella
 version: !ruby/object:Gem::Version 
-  version: 0.7.6.001
+  version: 0.7.6.003
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-24 00:00:00 -05:00
+date: 2009-11-28 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,7 +60,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.5.8
+        version: 0.6.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
@@ -96,6 +96,7 @@ files:
 - examples/essentials/plan.rb
 - examples/essentials/search_terms.txt
 - examples/exceptions/plan.rb
+- lib/proc_source.rb
 - lib/stella.rb
 - lib/stella/cli.rb
 - lib/stella/client.rb