stella 0.7.3.002 → 0.7.4.001

data/lib/stella/client/modifiers.rb

@@ -1,20 +0,0 @@
-
-
-class Stella::Client
-  
-  class ResponseModifier; end
-  class Repeat < ResponseModifier; 
-    attr_accessor :times
-    def initialize(times)
-      @times = times
-    end
-  end
-  class Quit < ResponseModifier; 
-    attr_accessor :message
-    def initialize(msg=nil)
-      @message = msg
-    end
-  end
-  class Fail < Quit; end
-  
-end

data/lib/stella/config.rb

@@ -1,87 +0,0 @@
-
-
-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
-    from_hash conf
-  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.li "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.li "Creating #{PROJECT_PATH}"
-    Stella::Utils.write_to_file(PROJECT_PATH, 'target:', 'w', 0600)
-  end
-  
-  def self.blast
-    if File.exists? USER_PATH
-      Stella.li "Blasting #{USER_PATH}"
-      FileUtils.rm_rf File.dirname(USER_PATH)
-    end
-    if File.exists? PROJECT_PATH
-      Stella.li "Blasting #{PROJECT_PATH}"
-      FileUtils.rm_rf File.dirname(PROJECT_PATH)
-    end
-  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)
-    DIR_NAME = Stella.sysinfo.os == :windows ? 'Stella' : '.stella'
-    USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config')
-    PROJECT_PATH = Stella::Config.find_project_config
-    DEFAULT_CONFIG = <<CONF
-apikey: ''
-secret: ''
-remote: stella.solutious.com:443
-CONF
-    DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
-  end
-    
-  class AlreadyInitialized < Stella::Error; end
-end
-

data/lib/stella/data/http/body.rb

@@ -1,15 +0,0 @@
-module Stella::Data::HTTP
-  class Body < Storable
-    include Gibbler::Complex
-    
-    field :content_type
-    field :form_param
-    field :content
-    
-    def has_content?
-      !@content.nil?
-    end
-    
-  end
-  
-end

data/lib/stella/data/http/request.rb

@@ -1,129 +0,0 @@
-
-
-module Stella::Data::HTTP
-  class Request < Storable
-    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 :desc
-    field :header 
-    field :uri
-    field :wait
-    field :params
-    field :body 
-    field :http_method
-    field :http_version
-    field :content_type
-    field :http_auth
-    
-    def has_body?
-      !@body.nil?
-    end
-    
-    def initialize (method, uri_str, version="1.1", &definition)
-      @uri = uri_str
-      @http_method, @http_version = method, version
-      @headers, @params, @response_handler = {}, {}, {}
-      @resources = {}
-      @wait = 0
-      @desc = "Request"
-      @body = Stella::Data::HTTP::Body.new
-      instance_eval &definition unless definition.nil?
-    end
-    
-    def auth(user=nil, pass=nil, kind=:basic)
-      @http_auth ||= Stella::Testplan::Usecase::Auth.new
-      @http_auth.user, @http_auth.pass, @http_auth.kind = user, pass, kind
-    end
-    
-    def desc(*args)
-      @desc = args.first unless args.empty?
-      @desc
-    end
-    
-    def content_type(*args)
-      @content_type = args.first unless args.empty?
-      @content_type
-    end
-    
-    def wait(*args)
-      @wait = args.first unless args.empty?
-      @wait
-    end
-    alias_method :sleep, :wait
-    
-    def headers(*args)
-      unless args.empty?
-        h = Hash === args[0] ? args[0] : {args[0]=> args[1]}
-        @headers.merge! h unless h.empty?
-      end
-      @headers
-    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)
-      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)
-      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
-    
-  end
-  
-end

data/lib/stella/data/http/response.rb

@@ -1,92 +0,0 @@
-
-
-module Stella::Data::HTTP
-  
-  class Response < Storable
-    include Gibbler::Complex
-    
-    attr_reader :raw_data
-    
-    field :time => DateTime
-    field :client_ip => String
-    field :server_ip => String
-    field :header => String
-    field :body => String
-    field :status => String
-    field :message => String
-    field :http_version => String
-    
-    def initialize(raw_data=nil)
-      @raw_data = raw_data
-      parse(@raw_data)
-    end
-    
-    def parse(raw)
-      return unless raw
-      @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(raw)
-    end
-    
-    def has_body?
-      !@body.nil? && !@body.empty?
-    end
-    def has_request?
-      false
-    end
-    def has_response?
-      false
-    end
-    
-    
-    def body
-      return nil unless @body
-      #TODO: Move to HTTPResponse::Body.to_s
-      if is_binary?
-       "[skipping binary content]"
-      elsif is_gzip?
-        #require 'zlib'
-        #Zlib::Inflate.inflate(@body)
-         "[skipping gzip content]"
-      else
-        @body
-      end
-    end
-    
-    def headers
-      headers = []
-      header.each_pair do |n,v|
-        headers << [n.to_s.gsub('_', '-'), v[0]]
-      end
-      headers
-    end
-    
-    def is_binary?
-      (!is_text?) == true
-    end
-    
-    def is_text?
-      (!header[:Content_Type].nil? && (header[:Content_Type][0].is_a? String) && header[:Content_Type][0][/text/] != nil)
-    end
-    
-    def is_gzip?
-      (!header[:Content_Encoding].nil? && (header[:Content_Encoding][0].is_a? String) && header[:Content_Encoding][0][/gzip/] != nil)
-    end
-    
-    def inspect
-      str = "HTTP/%s %s (%s)" % [@http_version, @status, @message]
-      str << $/ + headers.join($/)
-      str << $/ + $/ + body if body
-      str
-    end
-    
-    def to_s
-      str = "%s: HTTP/%s %s (%s)" % [time.strftime(NICE_TIME_FORMAT), @http_version, @status, @message]
-      str 
-    end
-    
-    
-    def cookies
-      return [] unless header.is_a?(Array) && !header[:Set_Cookie].empty?
-      header[:Set_Cookie] 
-    end
-  end
-end

data/lib/stella/exceptions.rb

@@ -1,20 +0,0 @@
-
-
-module Stella
-  class Error < RuntimeError
-    def initialize(obj=nil); @obj = obj; end
-    def message; "#{self.class}: #{@obj}"; end
-  end
-  
-  class WackyRatio < Stella::Error
-  end
-  
-  class WackyDuration < Stella::Error
-  end
-  
-  class InvalidOption < Stella::Error
-  end
-  
-  class NoHostDefined < Stella::Error
-  end  
-end

data/lib/stella/mixins.rb

@@ -1,5 +0,0 @@
-
-require 'stella/mixins/time'
-require 'stella/mixins/string'
-require 'stella/mixins/numeric'
-require 'stella/mixins/thread'

data/lib/stella/mixins/numeric.rb

@@ -1,24 +0,0 @@
-
-
-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
-

data/lib/stella/mixins/string.rb

@@ -1,16 +0,0 @@
-# Assumes Time::Units and Numeric mixins are available. 
-
-class String
-  
-  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 MatchData
-  include Gibbler::String
-end

data/lib/stella/mixins/thread.rb

@@ -1,6 +0,0 @@
-
-
-class Thread
-  extend Attic
-  attic :stats
-end

data/lib/stella/mixins/time.rb

@@ -1,75 +0,0 @@
-#encoding: utf-8
-
-$KCODE = "u" if RUBY_VERSION =~ /^1.8/
-
-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
-