stella 0.8.8.001 → 2.0.1.001

data/lib/stella/guidelines.rb

@@ -1,18 +0,0 @@
-
-
-module Stella
-  module Guidelines
-    extend self
-    AFE = "Always fail early"
-    ABA = "Always be accurate"
-    CBC = "Consistency before cuteness"
-    NDP = "No defensive programming"
-    def inspect
-      all = Stella::Guidelines.constants
-      g = all.collect { |c| '%s="%s"' % [c, const_get(c)] }
-      %q{#<Stella::Guidelines:0x%s %s>} % [self.object_id, g.join(' ')]
-    end
-  end
-end
-
-p Stella::Guidelines if __FILE__ == $0

data/lib/stella/logger.rb

@@ -1,150 +0,0 @@
-
-
-module Stella
-  
-
-  class Logger
-        
-    attr_accessor :lev
-    attr_reader :templates
-    
-    @@disable = false
-    class << self
-      def disable!()  @@disable = true  end
-      def enable!()  @@disable = true  end
-      def disabled?()  @@disable == true end
-    end
-      
-    def initialize(output=STDOUT)
-      @mutex, @buffer = Mutex.new, StringIO.new
-      @lev, @offset = 1, 0
-      @templates = {}
-      @autoflush = false
-      self.output = output
-    end
-      
-    def autoflush!()  @autoflush = true   end
-    def autoflush?()  @autoflush == true  end
-      
-    def add_template(name, str)
-      @templates[name.to_sym] = str
-    end
-    
-    def template(name)
-      @templates[name]
-    end
-    
-    def template?(name)
-      @templates.has_key? name
-    end
-    
-    def print(level, *msg)
-      return if level > @lev || self.class.disabled?
-      @buffer.print *msg
-      flush if autoflush?
-      true
-    end
-    
-    def puts(level, *msg)
-      return if level > @lev || self.class.disabled?
-      @buffer.puts *msg
-      flush if autoflush?
-      true
-    end
-    
-    def info(*msg)   puts 1, *msg end
-    def info1(*msg)  puts 1, *msg end
-    def info2(*msg)  puts 2, *msg end
-    def info3(*msg)  puts 3, *msg end
-    def info4(*msg)  puts 4, *msg end
-    
-    def debug(*msg)  
-      return unless Stella.debug?
-      puts 1, *msg 
-    end
-      
-    def tinfo(templ, *args)
-      info template(templ) % args
-    end
-    
-    def twarn(templ, *args)
-      warn template(templ) % args
-    end
-    
-    class UnknownTemplate < Stella::Error
-    end
-    
-    def method_missing(meth, *args)
-      raise UnknownTemplate.new(meth.to_s) unless template? meth
-      tinfo meth, *args
-    end
-    
-    def output=(o)
-      return if self.class.disabled?
-      @mutex.synchronize do
-        if o.kind_of? String
-          o = File.open(o, File::CREAT|File::TRUNC|File::RDWR, 0644)
-        end
-        @output = o
-      end
-    end
-    
-    # TODO: There's a big when using print (no newline)
-    def flush
-      return if self.class.disabled?
-      @mutex.synchronize do
-        #return if @offset == @output.tell
-        @buffer.seek @offset
-        @output.print @buffer.read unless @buffer.eof?
-        @offset = @buffer.tell
-        @output.flush
-      end
-      true
-    end
-    
-    def path
-      @output.path if @output.respond_to? :path
-    end
-    
-    def clear
-      return if self.class.disabled?
-      flush
-      @mutex.synchronize do
-        @buffer.rewind
-        @offset = 0
-      end
-    end
-    
-    def close
-      return if self.class.disabled?
-      flush
-      @buffer.close
-      @output.close
-    end
-  
-  end
-  
-  # Prints to a buffer. 
-  # Must call flush to send to output. 
-  class SyncLogger < Logger
-    def print(level, *msg)
-      return if level > @lev || self.class.disabled?
-      @mutex.synchronize { 
-        @buffer.print *msg 
-        flush if autoflush?
-      }
-      true
-    end
-
-    def puts(level, *msg)
-      #Stella.ld [level, @lev, msg]
-      return if level > @lev || self.class.disabled?
-      @mutex.synchronize { 
-        @buffer.puts *msg 
-        flush if autoflush?
-      }
-      true
-    end
-  end
-
-end

data/lib/stella/utils/httputil.rb

@@ -1,266 +0,0 @@
-
-require 'uri'
-require 'timeout'
-require 'net/http'
-
-module HTTPUtil
-  VALID_METHODS = %w{GET HEAD POST PUT DELETE}
-  @@timeout = 20
-  
-  # Takes a string. See WEBrick::parse_header(string).
-  def HTTPUtil.parse_header(raw)
-    header = Hash.new([].freeze)
-    raw.each_line do |line|
-      case line
-      when /\A(.+?):\s+(.+)\z/om
-        name, value = $1, $2 
-        name = name.tr('-', '_').to_sym
-        value.strip!
-        
-        header[name] = [] unless header.has_key?(name)
-        header[name] << value
-      end
-    end
-    header
-  end
-  
-  # Takes a string or array. See parse_header_body for further info.
-  # Returns +method+, +http_version+, +uri+, +header+, +body+
-  def HTTPUtil.parse_http_request(data, host=:unknown, port=80)
-    return unless data && !data.empty?
-    data = data.split(/\r?\n/) unless data.kind_of? Array
-    data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-    request_line = data.shift                           # i.e. GET /path HTTP/1.1
-    method, path, http_version = nil
-    
-    # With WEBrick and other proxies, the entire URI is included in HTTP requests. 
-    # i.e. GET http://stellaaahhhh.com/streetcar.png HTTP/1.1
-    # The parser is expecting just the absolute path. 
-    if request_line =~ /^(\S+)\s+(http:\/\/.+)\s+(HTTP.+)?/mo
-      uri = URI.parse($2)
-      request_line = "#{$1} #{uri.request_uri} #{$3}"
-      host = uri.host
-    end
-    
-    if request_line =~ /^(\S+)\s+(\S+)(?:\s+HTTP\/(\d+\.\d+))?/mo
-      method = $1
-      http_version = $3 # Comes before $2 b/c the split resets the numbered vars
-      path, query_string   = $2.split('?')
-      
-      # We only process the header and body data when we know we're
-      # starting from the beginning of a request string. We don't
-      # want no partials. 
-      header, body = HTTPUtil.parse_header_body(data)
-      query = HTTPUtil.parse_query(method, query_string)
-      
-      
-      # TODO: Parse username/password
-      uri = URI::HTTP.build({
-        :scheme => 'http',
-        :host => header[:Host][0] || host.to_s, 
-        :port => port, 
-        :path => path, 
-        :query => query_string
-      })
-      
-    else
-      rl = request_line.sub(/\x0d?\x0a\z/o, '')
-      raise "Bad Request-Line `#{rl}'."
-    end
-    
-    return method, http_version, uri, header, body
-  end
-  
-  
-  # Takes a string or array. See parse_header_body for further info. 
-  # Returns +status+, +http_version+, +message+, +header+, +body+
-  def HTTPUtil.parse_http_response(data=[])
-    return unless data && !data.empty?
-    data = data.split(/\r?\n/) unless data.kind_of? Array
-    data.shift while (data[0].empty? || data[0].nil?)   # Remove leading empties
-    status_line = data.shift                            # ie. HTTP/1.1 200 OK
-    http_version, status, message = nil
-    
-    if status_line =~ /^HTTP\/(\d.+?)(\s+(\d\d\d)\s+(.+))?$/mo
-      http_version = $1
-      status   = $2
-      message   = $4
-      
-      header, body, query = HTTPUtil.parse_header_body(data)
-      
-    else  
-      raise "Bad Response-Line `#{status_line}'."
-    end
-    
-    return status, http_version, message, header, body
-  end
-  
-  # Process everything after the first line of an HTTP request or response:
-  # GET / HTTP/1.1
-  # HTTP/1.1 200 OK
-  # etc...
-  # Used by parse_http_request and parse_http_response but can be used separately. 
-  # Takes a string or array of strings. A string should be formatted like an HTTP 
-  # request or response. If a body is present it should be separated by two newlines.
-  # An array of string should contain an empty or nil element between the header 
-  # and body content. This will happen naturally if the raw lines were split by 
-  # a single line terminator. (i.e. /\n/ rather than /\n\n/)
-  # Returns header (hash), body (string)
-  def HTTPUtil.parse_header_body(data=[])
-    header, body = {}, nil
-    data = data.split(/\r?\n/) unless data.kind_of? Array
-    data.shift while (data[0].nil? || data[0].empty?)   # Remove leading empties
-    
-    return header, body unless data && !data.empty?
-    
-    #puts data.to_yaml
-    
-    # Skip that first line if it exists
-    data.shift if data[0].match(/\AHTTP|GET|POST|DELETE|PUT|HEAD/mo)
-    
-    header_lines = []
-    header_lines << data.shift while (!data[0].nil? && !data[0].empty?)
-    header = HTTPUtil::parse_header(header_lines.join($/))
-    
-    # We omit the blank line that delimits the header from the body
-    body = data[1..-1].join($/) unless data.empty? 
-    
-    return header, body
-  end
-  
-  def HTTPUtil.parse_query(request_method, query_string, content_type='', body='')
-    query = Hash.new([].freeze)
-
-      if request_method == "GET" || request_method == "HEAD"
-        query = HTTPUtil::parse_query_from_string(query_string)
-      elsif content_type =~ /^application\/x-www-form-urlencoded/
-        query = HTTPUtil::parse_query_from_string(body)
-      elsif content_type =~ /^multipart\/form-data; boundary=(.+)/
-        boundary = $1.tr('"', '')
-        query = HTTPUtil::parse_form_data(body, boundary)
-      else
-        query
-      end
-
-    query
-  end
-  
-  def HTTPUtil.validate_method(meth='GET')
-    (VALID_METHODS.member? meth.upcase) ? meth : VALID_METHODS[0]
-  end
-  
-  # Parses a query string by breaking it up at the '&'
-  # and ';' characters.  You can also use this to parse
-  # cookies by changing the characters used in the second
-  # parameter (which defaults to '&;'.
-  # Stolen from Mongrel
-  def HTTPUtil.parse_query_from_string(qs, d = '&;')
-    params = {}
-    (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
-      k, v=unescape(p).split('=',2)
-      next unless k
-      k = k.tr('-', '_').to_sym
-      if cur = params[k]
-        if cur.class == Array
-          params[k] << v
-        else
-          params[k] = [cur, v]
-        end
-      else
-        params[k] = v
-      end
-    }
-
-    return params
-  end
-
-  
-  
-  # Based on WEBrick::HTTPutils::parse_form_data
-  def HTTPUtil.parse_form_data(io, boundary)
-    boundary_regexp = /\A--#{boundary}(--)?#{$/}\z/
-    form_data = Hash.new
-    return form_data unless io
-    data = nil
-    io.each_line{|line|
-      if boundary_regexp =~ line
-        if data
-          data.chop!
-          key = data.name.tr('-', '_').to_sym
-          if form_data.has_key?(key)
-            form_data[key].append_data(data)
-          else
-            form_data[key] = data 
-          end
-        end
-        data = FormData.new
-        next
-      else
-        if data
-          data << line
-        end
-      end
-    }
-    return form_data
-  end
-  
-  
-  # Extend the basic query string parser provided by the cgi module.
-  # converts single valued params (the most common case) to
-  # objects instead of arrays
-  #
-  # Input:
-  # the query string
-  #
-  # Output:
-  # hash of parameters, contains arrays for multivalued parameters
-  # (multiselect, checkboxes , etc)
-  # If no query string is provided (nil or "") returns an empty hash.
-  def HTTPUtil.query_to_hash(query_string)
-    return {} unless query_string
-
-    query_parameters = HTTPUtil.parse_query(query_string)
-
-    query_parameters.each { |key, val|
-      # replace the array with an object
-      query_parameters[key] = val[0] if 1 == val.length
-    }
-
-    # set default value to nil! cgi sets this to []
-    query_parameters.default = nil
-
-    return query_parameters
-  end
-  
-  def HTTPUtil.hash_to_query(parameters)
-    return '' unless parameters
-    pairs = []
-    parameters.each do |param, value|
-      pairs << "#{param}=#{URI.escape(value.to_s)}"
-    end
-    return pairs.join('&')
-    #return pairs.join(";")
-  end
-  
-
-  
-  # Performs URI escaping so that you can construct proper
-  # query strings faster.  Use this rather than the cgi.rb
-  # version since it's faster.  (Stolen from Mongrel/Camping).
-  def HTTPUtil.escape(s)
-    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-      '%'+$1.unpack('H2'*$1.size).join('%').upcase
-    }.tr(' ', '+')
-  end
-
-
-  # Unescapes a URI escaped string. (Stolen from Mongrel/Camping).
-  def HTTPUtil.unescape(s)
-    s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
-      [$1.delete('%')].pack('H*')
-    }
-  end
-  
-  
-end
-

data/try/01_numeric_mixins_tryouts.rb

@@ -1,40 +0,0 @@
-
-#encoding: utf-8
-$KCODE = "u" if RUBY_VERSION =~ /^1.8/
-
-group "Numeric mixins"
-library :stella, 'lib'
-
-tryouts "Natural language" do
-  
-  drill "base == 1.hour", 1.hour, 3600
-  drill "1.milliseconds", 1.milliseconds, 0.001
-  drill "1.microseconds", 1.microseconds, 0.000001
-  drill "10.minutes / 60.seconds", 10.minutes / 60.seconds, 10
-  drill "1.day", 1.day, 86400
-  drill "1.year == 365.days", 1.year, 31536000
-  drill "1.week == 7.days", 1.week, 604800
-  drill "1.week == 186.hours", 1.week, 168.hours
-
-  drill "60.in_minutes", 60.in_minutes, 1
-  drill "3600.in_hours", 3600.in_hours, 1
-  drill "5400.in_hours", 5400.in_hours, 1.5
-  drill "604800.in_days", 604800.in_days, 7
-  
-  drill "60.hours - 1.day", 60.hours - 1.day, 129600.0
-  drill "1.year - 5.days", 1.year - 5.days, 31104000.0
-  
-  drill "100 - 90", 100 - 90, 10.seconds
-  drill "90 + 9", 51 + 9, 1.minute
-  
-end
-
-
-tryouts "Bytes" do
-  drill "1000 == 1000.00B", 1000.to_bytes, "1000.00B"
-  drill "1010", 1010.to_bytes, "1.01KB"
-  drill "1020100", (1010 ** 2).to_bytes, "1.02MB"
-  drill "1030301000", (1010 ** 3).to_bytes, "1.03GB"
-  drill "1040604010000", (1010 ** 4).to_bytes, "1.04TB"
-end
-