stella 0.8.8.001 → 2.0.1.001

data/lib/stella/common.rb

@@ -1,363 +0,0 @@
-#encoding: utf-8
-
-$KCODE = "u" if RUBY_VERSION =~ /^1.8/
-
-
-
-# A hash with indifferent access and magic predicates.
-#
-#   hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
-#
-#   hash[:foo]  #=> 'bar'
-#   hash['foo'] #=> 'bar'
-#   hash.foo?   #=> true
-#
-class HashWithIndifferentAccess < ::Hash #:nodoc:
-
-  def initialize(hash={})
-    super()
-    hash.each do |key, value|
-      self[convert_key(key)] = value
-    end
-  end
-
-  def [](key)
-    super(convert_key(key))
-  end
-
-  def []=(key, value)
-    super(convert_key(key), value)
-  end
-
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  def values_at(*indices)
-    indices.collect { |key| self[convert_key(key)] }
-  end
-
-  def merge(other)
-    dup.merge!(other)
-  end
-
-  def merge!(other)
-    other.each do |key, value|
-      self[convert_key(key)] = value
-    end
-    self
-  end
-
-  protected
-
-    def convert_key(key)
-      key.is_a?(Symbol) ? key.to_s : key
-    end
-
-    # Magic predicates. For instance:
-    #
-    #   options.force?                  # => !!options['force']
-    #   options.shebang                 # => "/usr/lib/local/ruby"
-    #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
-    #
-    def method_missing(method, *args, &block)
-      method = method.to_s
-      if method =~ /^(\w+)\?$/
-        if args.empty?
-          !!self[$1]
-        else
-          self[$1] == args.first
-        end
-      else 
-        self[method]
-      end
-    end
-
-end
-
-
-# Assumes Time::Units and Numeric mixins are available. 
-
-class String
-  
-  def drydock_stub(*args)
-    self
-  end
-  
-  unless method_defined? :color
-    alias_method :att, :drydock_stub
-    alias_method :bright, :drydock_stub
-    alias_method :color, :drydock_stub
-    alias_method :colour, :drydock_stub
-  end
-  
-  def in_seconds
-    # "60m" => ["60", "m"]
-    q,u = self.scan(/([\d\.]+)([s,m,h])?/).flatten
-    q &&= q.to_f and u ||= 's'
-    q &&= q.in_seconds(u)
-  end
-  
-end
-
-class Symbol
-  
-  def downcase
-    self.to_s.downcase.to_sym
-  end
-  def upcase
-    self.to_s.upcase.to_sym
-  end
-
-end
-
-class MatchData
-  include Gibbler::String
-end
-
-class Thread
-  extend Attic
-  attic :stats
-end
-
-# Fix for eventmachine in Ruby 1.9
-class Thread
-  unless method_defined? :kill!
-    def kill!(*args) kill( *args) end
-  end
-end
-
-
-class Time
-  module Units
-    PER_MICROSECOND = 0.000001.freeze
-    PER_MILLISECOND = 0.001.freeze
-    PER_MINUTE = 60.0.freeze
-    PER_HOUR = 3600.0.freeze
-    PER_DAY = 86400.0.freeze
-    
-    def microseconds()    seconds * PER_MICROSECOND     end
-    def milliseconds()    seconds * PER_MILLISECOND    end
-    def seconds()         self                         end
-    def minutes()         seconds * PER_MINUTE          end
-    def hours()           seconds * PER_HOUR             end
-    def days()            seconds * PER_DAY               end
-    def weeks()           seconds * PER_DAY * 7           end
-    def years()           seconds * PER_DAY * 365        end 
-            
-    def in_years()        seconds / PER_DAY / 365      end
-    def in_weeks()        seconds / PER_DAY / 7       end
-    def in_days()         seconds / PER_DAY          end
-    def in_hours()        seconds / PER_HOUR          end
-    def in_minutes()      seconds / PER_MINUTE         end
-    def in_milliseconds() seconds / PER_MILLISECOND    end
-    def in_microseconds() seconds / PER_MICROSECOND   end
-
-    def in_seconds(u=nil)
-      case u.to_s
-      when /\A(y)|(years?)\z/
-        years
-      when /\A(w)|(weeks?)\z/
-        weeks
-      when /\A(d)|(days?)\z/
-        days
-      when /\A(h)|(hours?)\z/
-        hours
-      when /\A(m)|(minutes?)\z/
-        minutes
-      when /\A(ms)|(milliseconds?)\z/
-        milliseconds
-      when /\A(us)|(microseconds?)|(μs)\z/
-        microseconds
-      else
-        self
-      end
-    end
-    
-    ## JRuby doesn't like using instance_methods.select here. 
-    ## It could be a bug or something quirky with Attic 
-    ## (although it works in 1.8 and 1.9). The error:
-    ##  
-    ##  lib/attic.rb:32:in `select': yield called out of block (LocalJumpError)
-    ##  lib/stella/mixins/numeric.rb:24
-    ##
-    ## Create singular methods, like hour and day. 
-    # instance_methods.select.each do |plural|
-    #   singular = plural.to_s.chop
-    #   alias_method singular, plural
-    # end
-    
-    alias_method :ms, :milliseconds
-    alias_method :'μs', :microseconds
-    alias_method :second, :seconds
-    alias_method :minute, :minutes
-    alias_method :hour, :hours
-    alias_method :day, :days
-    alias_method :week, :weeks
-    alias_method :year, :years
-
-  end
-end
-
-class Numeric
-  include Time::Units
-  # TODO: Use 1024?
-  def to_bytes
-    args = case self.abs.to_i
-    when 0..1000
-      [(self).to_s, 'B']
-    when (1000)..(1000**2)
-      [(self / 1000.to_f).to_s, 'KB']
-    when (1000**2)..(1000**3)
-      [(self / (1000**2).to_f).to_s, 'MB']
-    when (1000**3)..(1000**4)
-      [(self / (1000**3).to_f).to_s, 'GB']
-    when (1000**4)..(1000**6)
-      [(self / (1000**4).to_f).to_s, 'TB']
-    else
-      [self, 'B']
-    end
-    '%3.2f%s' % args
-  end
-end
-
-
-
-
-
-class Stella::Config < Storable
-  include Gibbler::Complex
-  
-  field :source
-  field :apikey
-  field :secret
-  
-   # Returns true when the current config matches the default config
-  def default?; to_hash.gibbler == DEFAULT_CONFIG_HASH; end
-  
-  def self.each_path(&blk)
-    [PROJECT_PATH, USER_PATH].each do |path|
-      Stella.ld "Loading #{path}"
-      blk.call(path) if File.exists? path
-    end
-  end
-  
-  def self.refresh
-    conf = {}
-    Stella::Config.each_path do |path| 
-      tmp = YAML.load_file path
-      conf.merge! tmp if tmp
-    end
-    a = from_hash conf
-    a || new
-  end
-  
-  def self.init
-    raise AlreadyInitialized, PROJECT_PATH if File.exists? PROJECT_PATH
-    dir = File.dirname USER_PATH
-    Dir.mkdir(dir, 0700) unless File.exists? dir
-    unless File.exists? USER_PATH
-      Stella.stdout.info "Creating #{USER_PATH} (Add your credentials here)"
-      Stella::Utils.write_to_file(USER_PATH, DEFAULT_CONFIG, 'w', 0600)
-    end
-    
-    dir = File.dirname PROJECT_PATH
-    Dir.mkdir(dir, 0700) unless File.exists? dir
-    
-    Stella.stdout.info "Creating #{PROJECT_PATH}"
-    Stella::Utils.write_to_file(PROJECT_PATH, 'target:', 'w', 0600)
-  end
-  
-  def self.blast
-    if File.exists? USER_PATH
-      Stella.stdout.info "Blasting #{USER_PATH}"
-      FileUtils.rm_rf File.dirname(USER_PATH)
-    end
-    if File.exists? PROJECT_PATH
-      Stella.stdout.info "Blasting #{PROJECT_PATH}"
-      FileUtils.rm_rf File.dirname(PROJECT_PATH)
-    end
-  end
- 
-  def self.project_dir
-    File.join(Dir.pwd, DIR_NAME)
-  end
-  
-  private 
-  
-  def self.find_project_config
-    dir = Dir.pwd.split File::SEPARATOR
-    path = nil
-    while !dir.empty?
-      tmp = File.join(dir.join(File::SEPARATOR), DIR_NAME, 'config')
-      Stella.ld " -> looking for #{tmp}"
-      path = tmp and break if File.exists? tmp
-      dir.pop
-    end
-    path ||= File.join(Dir.pwd, DIR_NAME, 'config')
-    path
-  end
-  
-  
-  unless defined?(DIR_NAME)
-    if Stella.sysinfo.os == :windows
-      DIR_NAME = 'Stella'
-      USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config.txt')
-    else
-      DIR_NAME = '.stella'
-      USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config')
-    end
-    PROJECT_PATH = Stella::Config.find_project_config
-    DEFAULT_CONFIG = ""
-    DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
-  end
-    
-  class AlreadyInitialized < Stella::Error; end
-end
-
-
-
-module Stella
-  class Hand
-    attr_accessor :force_stop
-    attr_reader :dthread
-    
-    def initialize(freq=4, rest=1, &routine)
-      @freq, @rest, @routine = freq, rest, routine
-    end
-  
-    def stop()  
-      @force_stop = true  
-      @dthread.join
-      @routine.call
-      @finally.call unless @finally.nil?
-    end
-    def stop?() @force_stop == true end
-    
-    def stopped?() @stopped end
-      
-    # Execute yield every FREQUENCY seconds.
-    def start
-      @dthread ||= Thread.new do
-        prev_ptime = Time.now
-        loop do
-          @stopped = true and break if Stella.abort? || stop?
-          if (Time.now - prev_ptime).to_i >= @freq
-            @routine.call
-            prev_ptime = Time.now
-          end
-          sleep @rest
-        end
-      end
-      @dthread.abort_on_exception = true
-    end
-  
-    def finally(&blk)
-      @finally = blk
-    end
-  end
-  
-  
-end
-
-

data/lib/stella/data.rb

@@ -1,59 +0,0 @@
-
-module Stella::Data
-  extend self
-    
-  module Helpers
-    
-    def resource(args)   to_templ(:resource, *args)   end
-    
-    # Can include glob
-    #
-    # e.g.
-    #    random_file('avatar*')
-    def random_file(*args)  to_templ(:random_file, *args)    end
-    
-    def read_file(*args) to_templ(:read_file, *args)    end
-    
-    def path(*args)   to_templ(:path, *args)     end
-    
-    def file(*args)   to_templ(:file, *args)    end
-    
-    def random(*args)
-      to_templ(:random, *args)
-    end
-    
-    
-    # NOTE: This is global across all users
-    def sequential(*args)
-      to_templ(:sequential, *args)
-    end
-    
-    # NOTE: This is global across all users
-    def rsequential(*args)
-      to_templ(:rsequential, *args)
-    end
-    
-    private 
-
-    def args_to_str(*args)
-      args.collect! do |el|
-        if el.kind_of?(Enumerable) || el.kind_of?(Numeric)
-          el.inspect
-        elsif el.is_a?(Symbol)
-          ":#{el.to_s}"
-        else
-          "'#{el.to_s}'"
-        end 
-      end
-      args.join(', ')
-    end
-    
-    def to_templ(meth, *args)
-      "<%= #{meth}(#{args_to_str(*args)}) %>"
-    end
-    
-  end
-      
-end
-
-Stella::Utils.require_glob(STELLA_LIB_HOME, 'stella', 'data', '*.rb')

data/lib/stella/data/http.rb

@@ -1,189 +0,0 @@
-
-
-module Stella::Data::HTTP
-  class Request < Storable
-    include Gibbler::Complex
-    include Stella::Data::Helpers
-    
-    field :id => String, &gibbler_id_processor
-    
-      # 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, &hash_proc_processor
-    
-    # Store the description in the attic so
-    # it's not used in the gibbler digest.
-    attic :description
-    field :description
-    
-    field :header => Hash
-    field :uri
-    field :wait => Range
-    field :params => Hash
-    field :body 
-    field :http_method
-    field :http_version
-    field :content_type
-    field :http_auth
-    field :timeout => Float
-    
-    field :autofollow  # boolean. Was this an auto generated follow request. 
-
-    
-    def has_body?
-      !@body.nil?
-    end
-    
-    def id
-      Gibbler::Digest.new @id || self.digest
-    end
-    
-    def initialize (method=nil, uri_str=nil, version="1.1", &definition)
-      @uri = uri_str.to_s
-      @http_method, @http_version = method, version
-      @header, @params, @response_handler = {}, {}, {}
-      @resources = {}
-      @autofollow = false
-      @wait = 0..0
-      self.description = "Request"
-      instance_eval &definition unless definition.nil?
-    end
-    
-    def autofollow!
-      @autofollow = true
-    end
-    
-    def self.from_hash(hash={})
-      me = super(hash)
-      me.response_handler.keys.each do |status|
-        proc_str = me.response_handler[status]
-        me.response_handler[status] = eval "Proc.new #{proc_str}"
-        me.response_handler[status].source = proc_str
-      end
-      me
-    end
-    
-    def auth(user=nil, pass=nil, domain=nil)
-      @http_auth ||= Stella::Testplan::Usecase::Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.domain = user, pass, domain
-    end
-    
-    def timeout(*args)
-      @timeout = args.first unless args.empty?
-      @timeout
-    end
-    
-    def desc(*args)
-      self.description = args.first unless args.empty?
-      self.description
-    end
-    
-    def content_type(*args)
-      @content_type = args.first unless args.empty?
-      @content_type
-    end
-    
-    def wait(*args)
-      args = [args].flatten.compact
-      @wait = args.first unless args.empty?
-      @wait
-    end
-    alias_method :sleep, :wait
-    
-    def headers(*args)
-      args = [args].flatten.compact
-      unless args.empty?
-        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
-        @header.merge! h unless h.empty?
-      end
-      @header
-    end
-    alias_method :header, :headers
-    
-    # Set a resource key value pair in the get, post block.
-    # These will be process later in Stella::Client
-    def set(*args)
-      args = [args].flatten.compact
-      unless args.empty?
-        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
-        @resources.merge! h unless h.empty?
-      end
-      @resources
-    end
-    alias_method :resources, :set
-    
-    def params(*args)
-      args = [args].flatten.compact
-      unless args.empty?
-        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
-        @params.merge! h unless h.empty?
-      end
-      @params
-    end
-    alias_method :param, :params
-    
-    def response(*args, &definition)
-      if definition.nil?
-        @response_handler
-      else
-        args << /.+/ if args.empty?
-        args.each do |status|
-          @response_handler[status] = definition
-        end
-      end
-    end
-    
-    # +content+ can be literal content or a file path
-    def body(*args)
-      return @body if args.empty?
-      @body = args.first
-    end
-    
-    def inspect
-      str = "%s %s" % [http_method, uri.to_s, http_version]
-      #str << $/ + headers.join($/) unless headers.empty?
-      #str << $/ + $/ + body.to_s if body
-      str
-    end
-    
-    def to_s
-      str = "%s %s" % [http_method, uri.to_s, http_version]
-      str
-    end
-    
-    def cookies
-      return [] if !header.is_a?(Hash) || header[:Cookie].empty?
-      header[:Cookie] 
-    end
-    
-    def freeze
-      return if frozen?
-      @params = convert_values_to_templates @params
-      @header = convert_values_to_templates @header
-      super
-      self
-    end
-    
-    private 
-     def convert_values_to_templates(hash)
-       updated = {}
-       hash.each_pair { |k,v| 
-         next if Stella::Template === v
-         if Proc === v
-           msg = "As of Stella 0.8, Procs are no longer supported as values#{$/}"
-           msg << "for parameters and headers (\"#{k}\" in \"#{description}\").#{$/}"
-           msg << "Use string templates instead. See the examples/ directory."
-           raise Stella::Error, msg
-         end
-         updated[k] = Stella::Template.new( v || '')
-       }
-       updated
-     end
-  end
-  
-end