stella 0.6.0 → 0.7.0.002

data/lib/storable.rb

@@ -1,280 +0,0 @@
-#--
-# 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/timeunits.rb

@@ -1,65 +0,0 @@
-# From: http://codeforpeople.com/lib/ruby/timeunits/timeunits-0.0.2/lib/timeunits.rb
-# ... with fix for Ruby 1.9.1
-
-unless $__timeunits__
-$__timeunits__ = File.expand_path __FILE__
-
-  class Time
-    module Units 
-      VERSION = "0.0.3" # Changed from 0.0.1 (should have been 0.0.2)
-
-      def __less__() "/" end
-      def __more__() "*" end
-      def microseconds() Float(self.send(__more__,(10 ** -6))) end
-      def milliseconds() Float(self.send(__more__,(10 ** -3))) end
-      def seconds() self end
-      def minutes() seconds.send(__more__,60) end
-      def hours() minutes.send(__more__,60) end
-      def days() hours.send(__more__,24) end
-      def weeks() days.send(__more__,7) end
-      def months() weeks.send(__more__,4) end
-      #def years() months.send(__more__,12) end
-      def years() days.send(__more__,365) end
-      def decades() years.send(__more__,10) end
-      def centuries() decades.send(__more__,10) end
-      instance_methods.select{|m| m !~ /__/}.each do |plural|
-        singular = plural.to_s.chop # Added .to_s for 
-        alias_method singular, plural
-      end
-    end
-    module DiffUnits
-      include ::Time::Units
-      def __less__() "*" end
-      def __more__() "/" end
-    end
-    alias_method "__delta__", "-" unless respond_to? "__delta__"
-    def - other
-      ret = __delta__ other
-      ret.extend DiffUnits
-      ret
-    end
-  end
-  class Numeric
-    include ::Time::Units
-  end
-
-end
-
-
-if $0 == __FILE__
-  require "yaml"
-  require "time"
-
-  now = Time::now
-
-  a = now
-  y 'a' => a
-
-  b = now + 2.hours + 2.minutes
-  y 'b' => b
-
-  d = b - a
-  %w( seconds minutes hours days ).each do |unit|
-    y "d.#{ unit }" => d.send(unit)
-  end
-end

data/tryouts/drb/drb_test.rb

@@ -1,65 +0,0 @@
-#!/usr/bin/env ruby -w
-# simple_client.rb
-# A simple DRb client
-
-require 'drb'
-
-DRb.start_service
-
-# attach to the DRb server via a URI given on the command line
-remote_array = DRbObject.new [], ARGV.shift
-
-puts remote_array.size
-
-remote_array << 1
-
-puts remote_array.size
-
-__END__
-# Fastthread patches: http://blog.phusion.nl/2009/02/02/getting-ready-for-ruby-191/
-# <link rel="canonical" href="http://www.seomoz.org/blog">
-
-require 'rubygems'
-require 'eventmachine'
-
-module Echo
-  def receive_data data
-    send_data data
-  end
-end
-
-EM.run {
-  EM.start_server "0.0.0.0", 10000, Echo
-}
-
-
-
-__END__
-class DSL
-  # Get a metaclass for this class
-  def self.metaclass; class << self; self; end; end
-  
-  metaclass.instance_eval do
-    define_method( :'POST /api/suggestions.json' ) do |val|
-      puts val
-    end
-  end
-
-  
-end
-
-class Runner
-  attr_accessor :poop
-  def hi
-    @poop = :rock
-  end
-end
-
-c=Runner.new
-
-c.instance_eval do
-  hi
-  puts @poop
-end
- 
-#DSL.send(:'POST /api/suggestions.json', :hi)

data/tryouts/drb/open4.rb

@@ -1,19 +0,0 @@
-$: << '/usr/jruby-1.1.6/lib/ruby/gems/1.8/gems/open4-0.9.6/lib/'
-
-
-require "open4"
-
-
-pid, stdin, stdout, stderr = Open4::popen4 "sh"
-
-stdin.puts "echo 42.out"
-stdin.puts "echo 42.err 1>&2"
-stdin.close
-
-ignored, status = Process::waitpid2 pid
-
-puts "pid        : #{ pid }"
-puts "stdout     : #{ stdout.read.strip }"
-puts "stderr     : #{ stderr.read.strip }"
-puts "status     : #{ status.inspect }"
-puts "exitstatus : #{ status.exitstatus }"

data/tryouts/drb/slave.rb

@@ -1,27 +0,0 @@
-
-# See: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/227105
-# See: http://jsgoecke.wordpress.com/2009/01/30/using-drb-with-adhearsion/
-# See: http://docs.adhearsion.com/display/adhearsion/Using+DRb
-
-$: << 'lib'
-
-require 'rubygems'
-require 'slave'
-#
-# simple usage is simply to stand up a server object as a slave.  you do not
-# need to wait for the server, join it, etc.  it will die when the parent
-# process dies - even under 'kill -9' conditions
-#
-  class Server
-    def add_two n
-      n + 2
-    end
-  end
-
-  slave = Slave.new :object => Server.new
-
-  server = slave.object
-  p server.add_two(40) #=> 42
-
-  slave.shutdown
-sleep 20

data/tryouts/oo_tryout.rb

@@ -1,30 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) # Make sure our local lib is first in line
-
-require 'yaml'
-
-require 'stella'
-
-
-tp = Stella::TestPlan.new(:oo_tryout)
-tp.protocol = :http
-tp.servers << "localhost:3114"
-
-# STEP 1
-req = Stella::Data::HTTPRequest.new("/upload", :POST)
-req.body = "a.pdf", "bill"
-req.add_header "X-Stella", "Yay!"
-req.add_response(200, 201) do |headers, body|
-  puts headers["Set-Cookie"]
-  puts body.inspect
-  data = YAML::load(body)
-  @product_id = data['id']
-  puts "ID: #{@product_id}"
-end
-tp.add_request(req)
-
-
-ft = Stella::FunctionalTest.new(:oo_tryout)
-ft.testplan = tp
-ft.run
-
-