solutious-stella 0.5.5 → 0.6.0

data/lib/stella/testrunner.rb

@@ -0,0 +1,64 @@
+# ---
+# See: http://codeforpeople.com/lib/ruby/flow/flow-2.0.0/sample/a.rb
+# +++
+
+#
+#
+#
+module Stella
+  module TestRunner
+    attr_accessor :name
+      # Name or instance of the testplan to execute
+    attr_accessor :testplan
+      # Determines the amount of output. Default: 0
+    attr_accessor :verbose
+    
+    def initialize(name=:default)
+      @name = name
+      @verbose = 0
+      init if respond_to? :init
+    end
+    
+    def update(*args)
+      what, *args = args
+      self.send("update_#{what}", *args) if respond_to? "update_#{what}"
+    end
+    
+  end
+  module DSL
+    module TestRunner
+      attr_accessor :current_test
+      
+      def plan(testplan)
+        raise "Unknown testplan, '#{testplan}'" unless @plans.has_key?(testplan)
+        return unless @current_test
+        @current_test.testplan = @plans[testplan]
+      end
+      
+      def run(env_name=nil, test_name=nil)
+        to_run = test_name.nil? ? @tests : [@tests[test_name]]
+        env = env_name.nil? ? @stella_environments.first : @stella_environments[env_name]
+        to_run.each do |t|
+          puts '='*60
+          puts "RUNNING TEST: #{test_name}"
+          puts " %11s: %s" % ['type', t.type]
+          puts " %11s: %s" % ['testplan', t.testplan.name]
+          puts " %11s: %s" % ['desc', t.testplan.description]
+          puts " %11s: %s" % ['env', env_name]
+           
+          
+          t.run(env, self)
+        end
+      end
+      
+      def verbose(*args)
+        @current_test.verbose += args.first || 1
+      end
+      
+    private
+      
+    end
+  end
+end
+  
+  

data/lib/storable.rb

@@ -0,0 +1,280 @@
+#--
+# TODO: Handle nested hashes and arrays. 
+# TODO: to_xml, see: http://codeforpeople.com/lib/ruby/xx/xx-2.0.0/README
+# TODO: Rename to Stuffany
+#++
+
+require 'yaml'
+require 'fileutils'
+
+
+# Storable makes data available in multiple formats and can
+# re-create objects from files. Fields are defined using the 
+# Storable.field method which tells Storable the order and 
+# name.
+class Storable
+  VERSION = 2
+  NICE_TIME_FORMAT  = "%Y-%m-%d@%H:%M:%S".freeze unless defined? NICE_TIME_FORMAT
+  SUPPORTED_FORMATS = %w{tsv csv yaml json}.freeze unless defined? SUPPORTED_FORMATS
+  
+  # This value will be used as a default unless provided on-the-fly.
+  # See SUPPORTED_FORMATS for available values.
+  attr_reader :format
+  
+  # See SUPPORTED_FORMATS for available values
+  def format=(v)
+    raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
+    @format = v
+  end
+  
+  # TODO: from_args([HASH or ordered params])
+  
+  def init
+    # NOTE: I think this can be removed
+    self.class.send(:class_variable_set, :@@field_names, []) unless class_variable_defined?(:@@field_names)
+    self.class.send(:class_variable_set, :@@field_types, []) unless class_variable_defined?(:@@field_types)
+  end
+  
+  # Accepts field definitions in the one of the follow formats:
+  #
+  #     field :product
+  #     field :product => Integer
+  #
+  # The order they're defined determines the order the will be output. The fields
+  # data is available by the standard accessors, class.product and class.product= etc...
+  # The value of the field will be cast to the type (if provided) when read from a file. 
+  # The value is not touched when the type is not provided. 
+  def self.field(args={})
+    # TODO: Examine casting from: http://codeforpeople.com/lib/ruby/fattr/fattr-1.0.3/
+    args = {args => nil} unless args.is_a? Hash
+
+    args.each_pair do |m,t|
+      
+      [[:@@field_names, m], [:@@field_types, t]].each do |tuple|
+        class_variable_set(tuple[0], []) unless class_variable_defined?(tuple[0])
+        class_variable_set(tuple[0], class_variable_get(tuple[0]) << tuple[1])
+      end
+      
+      next if method_defined?(m)
+      
+      define_method(m) do instance_variable_get("@#{m}") end
+      define_method("#{m}=") do |val| 
+        instance_variable_set("@#{m}",val)
+      end
+    end
+  end
+  
+  # Returns an array of field names defined by self.field
+  def self.field_names
+    class_variable_get(:@@field_names)
+  end
+  # Ditto.
+  def field_names
+    self.class.send(:class_variable_get, :@@field_names)
+  end
+  # Returns an array of field types defined by self.field. Fields that did 
+  # not receive a type are set to nil. 
+  def self.field_types
+    class_variable_get(:@@field_types)
+  end
+  # Ditto.
+  def field_types
+    self.class.send(:class_variable_get, :@@field_types)
+  end
+
+  # Dump the object data to the given format. 
+  def dump(format=nil, with_titles=true)
+    format ||= @format
+    raise "Format not defined (#{format})" unless SUPPORTED_FORMATS.member?(format)
+    send("to_#{format}", with_titles) 
+  end
+  
+  # Create a new instance of the object using data from file. 
+  def self.from_file(file_path, format='yaml')
+    raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
+    raise "#{self} doesn't support from_#{format}" unless self.respond_to?("from_#{format}")
+    format = format || File.extname(file_path).tr('.', '')
+    me = send("from_#{format}", read_file_to_array(file_path))
+    me.format = format
+    me
+  end
+  # Write the object data to the given file. 
+  def to_file(file_path=nil, with_titles=true)
+    raise "Cannot store to nil path" if file_path.nil?
+    format = File.extname(file_path).tr('.', '')
+    format ||= @format
+    Storable.write_file(file_path, dump(format, with_titles))
+  end
+
+  # Create a new instance of the object from a hash.
+  def self.from_hash(from={})
+    me = self.new
+  
+    return me if !from || from.empty?
+    
+    fnames = field_names
+    fnames.each_with_index do |key,index|
+      
+      stored_value = from[key] || from[key.to_s] # support for symbol keys and string keys
+      
+      # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
+      
+      if field_types[index] == Array
+        ((value ||= []) << stored_value).flatten 
+      elsif field_types[index] == Hash
+        value = stored_value
+      else
+        # SimpleDB stores attribute shit as lists of values
+        value = stored_value.first if stored_value.is_a?(Array) && stored_value.size == 1
+
+        if field_types[index] == Time
+          value = Time.parse(value)
+        elsif field_types[index] == DateTime
+          value = DateTime.parse(value)
+        elsif field_types[index] == TrueClass
+          value = (value.to_s == "true")
+        elsif field_types[index] == Float
+          value = value.to_f
+        elsif field_types[index] == Integer
+          value = value.to_i
+        else
+          value = value.first if value.is_a?(Array) && value.size == 1 # I
+        end
+      end
+      
+      me.send("#{key}=", value) if self.method_defined?("#{key}=")  
+    end
+    
+    me
+  end
+  # Return the object data as a hash
+  # +with_titles+ is ignored. 
+  def to_hash(with_titles=true)
+    tmp = {}
+    field_names.each do |fname|
+      tmp[fname] = self.send(fname)
+    end
+    tmp
+  end
+  
+  # Create a new instance of the object from YAML. 
+  # +from+ a YAML string split into an array by line. 
+  def self.from_yaml(from=[])
+    # from is an array of strings
+    from_str = from.join('')
+    hash = YAML::load(from_str)
+    hash = from_hash(hash) if hash.is_a? Hash 
+    hash
+  end
+  def to_yaml(with_titles=true)
+    to_hash.to_yaml
+  end
+  
+  # Create a new instance of the object from a JSON string. 
+  # +from+ a JSON string split into an array by line.
+  def self.from_json(from=[])
+    require 'json'
+    # from is an array of strings
+    from_str = from.join('')
+    tmp = JSON::load(from_str)
+    hash_sym = tmp.keys.inject({}) do |hash, key|
+       hash[key.to_sym] = tmp[key]
+       hash
+    end
+    hash_sym = from_hash(hash_sym) if hash_sym.is_a? Hash  
+    hash_sym
+  end
+  def to_json(with_titles=true)
+    require 'json'
+    to_hash.to_json
+  end
+  
+  # Return the object data as a delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  # +delim+ is the field delimiter.
+  def to_delimited(with_titles=false, delim=',')
+    values = []
+    field_names.each do |fname|
+      values << self.send(fname.to_s)   # TODO: escape values
+    end
+    output = values.join(delim)
+    output = field_names.join(delim) << $/ << output if with_titles
+    output
+  end
+  # Return the object data as a tab delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  def to_tsv(with_titles=false)
+    to_delimited(with_titles, "\t")
+  end
+  # Return the object data as a comma delimited string. 
+  # +with_titles+ specifiy whether to include field names (default: false)
+  def to_csv(with_titles=false)
+    to_delimited(with_titles, ',')
+  end
+  # Create a new instance from tab-delimited data.  
+  # +from+ a JSON string split into an array by line.
+  def self.from_tsv(from=[])
+    self.from_delimited(from, "\t")
+  end
+  # Create a new instance of the object from comma-delimited data.
+  # +from+ a JSON string split into an array by line.
+  def self.from_csv(from=[])
+    self.from_delimited(from, ',')
+  end
+  
+  # Create a new instance of the object from a delimited string.
+  # +from+ a JSON string split into an array by line.
+  # +delim+ is the field delimiter.
+  def self.from_delimited(from=[],delim=',')
+    return if from.empty?
+    # We grab an instance of the class so we can 
+    hash = {}
+    
+    fnames = values = []
+    if (from.size > 1 && !from[1].empty?)
+      fnames = from[0].chomp.split(delim)
+      values = from[1].chomp.split(delim)
+    else
+      fnames = self.field_names
+      values = from[0].chomp.split(delim)
+    end
+    
+    fnames.each_with_index do |key,index|
+      next unless values[index]
+      hash[key.to_sym] = values[index]
+    end
+    hash = from_hash(hash) if hash.is_a? Hash 
+    hash
+  end
+
+  def self.read_file_to_array(path)
+    contents = []
+    return contents unless File.exists?(path)
+    
+    open(path, 'r') do |l|
+      contents = l.readlines
+    end
+
+    contents
+  end
+  
+  def self.write_file(path, content, flush=true)
+    write_or_append_file('w', path, content, flush)
+  end
+  
+  def self.append_file(path, content, flush=true)
+    write_or_append_file('a', path, content, flush)
+  end
+  
+  def self.write_or_append_file(write_or_append, path, content = '', flush = true)
+    #STDERR.puts "Writing to #{ path }..." 
+    create_dir(File.dirname(path))
+    
+    open(path, write_or_append) do |f| 
+      f.puts content
+      f.flush if flush;
+    end
+    File.chmod(0600, path)
+  end
+end
+

data/lib/threadify.rb

@@ -0,0 +1,171 @@
+module Threadify
+  VERSION = '0.0.3'
+  def Threadify.version() Threadify::VERSION end
+
+  require 'thread'
+
+  @threads = 8
+  @abort_on_exception = true
+
+  class << self
+    attr_accessor :threads
+    attr_accessor :abort_on_exception
+  end
+
+  class Error < ::StandardError; end
+end
+
+module Enumerable
+  def threadify opts = {}, &block
+  # setup
+  #
+    opts = {:threads => opts} if Numeric === opts
+    threads = Integer(opts[:threads] || opts['threads'] || Threadify.threads)
+    done = Object.new.freeze
+    nothing = done
+    #jobs = Array.new(threads).map{ Queue.new }
+    jobs = Array.new(threads).map{ [] }
+    top = Thread.current
+
+  # produce jobs
+  #
+    #producer = Thread.new do
+      #this = Thread.current
+      #this.abort_on_exception = Threadify.abort_on_exception
+
+      each_with_index{|args, i| jobs[i % threads].push([args, i])}
+      threads.times{|i| jobs[i].push(done)}
+    #end
+
+  # setup consumer list
+  #
+    consumers = Array.new threads 
+
+  # setup support for short-circuit bailout via 'throw :threadify'
+  #
+    thrownv = Hash.new
+    thrownq = Queue.new
+
+    caught = false
+
+    catcher = Thread.new do
+      loop do
+        thrown = thrownq.pop
+        break if thrown == done
+        i, thrown = thrown
+        thrownv[i] = thrown
+        caught = true
+      end
+    end
+
+  # fire off the consumers
+  #
+    threads.times do |i|
+      consumers[i] = Thread.new(jobs[i]) do |jobsi|
+        this = Thread.current
+        this.abort_on_exception = Threadify.abort_on_exception
+    
+        job = nil
+
+        thrown =
+          catch(:threadify) do
+            loop{
+              break if caught
+              #job = jobsi.pop
+              job = jobsi.shift
+              break if job == done
+              args = job.first
+              jobsi << (job << block.call(*args))
+            }
+            nothing
+          end
+
+
+        unless nothing == thrown
+          args, i = job
+          thrownq.push [i, thrown]
+        end
+      end
+    end
+
+  # wait for consumers to finish
+  #
+    consumers.map{|t| t.join}
+
+  # nuke the catcher
+  #
+    thrownq.push done
+    catcher.join
+
+  # iff something(s) was thrown return the one which would have been thrown
+  # earliest in non-parallel execution
+  #
+    unless thrownv.empty?
+      key = thrownv.keys.sort.first
+      return thrownv[key]
+    end
+
+  # collect the results and return them
+  #
+=begin
+    jobs.push done
+    ret = []
+    while((job = jobs.pop) != done)
+      elem, i, value = job
+      ret[i] = value
+    end
+    ret
+  end
+=end
+
+    ret = []
+    jobs.each do |results|
+      results.each do |result|
+        break if result == done
+        elem, i, value = result
+        ret[i] = value
+      end
+    end
+    ret
+  end
+
+end
+
+class Thread
+  def Thread.ify enumerable, *args, &block
+    enumerable.send :threadify, *args, &block
+  end
+end
+
+class Object
+  def threadify! *values
+    throw :threadify, *values
+  end
+end
+
+
+if __FILE__ == $0
+  require 'open-uri'
+  require 'yaml'
+
+  uris = %w( http://google.com http://yahoo.com http://rubyforge.org/ http://ruby-lang.org)
+
+  Thread.ify uris, :threads => 6 do |uri|
+    body = open(uri){|pipe| pipe.read}
+    y uri => body.size
+  end
+end
+
+
+__END__
+
+sample output
+
+--- 
+http://yahoo.com: 9562
+--- 
+http://google.com: 6290
+--- 
+http://rubyforge.org/: 22352
+--- 
+http://ruby-lang.org: 9984