solutious-stella 0.5.5

data/lib/stella/data/http.rb

@@ -0,0 +1,131 @@
+
+require 'utils/httputil'
+require 'base64'
+
+module Stella::Data
+  
+  # TODO: Implement HTTPHeaders. We should be printing untouched headers. 
+  # HTTPUtil should split the HTTP event lines and that's it. Replace 
+  # parse_header_body with split_header_body
+  class HTTPHeaders < Stella::Storable
+    attr_reader :raw_data
+    
+    def to_s
+      @raw_data
+    end
+    
+  end
+  
+  class HTTPRequest < Stella::Storable
+    attr_reader :raw_data
+    
+    field :time => DateTime
+    field :client_ip => String
+    field :server_ip => String
+    field :header => String
+    field :uri => String
+    field :body => String
+    field :method => String
+    field :http_version => String
+    
+    def has_body?
+      @body && !@body.nil & !@body.empty?
+    end
+    def has_request?
+      false
+    end
+    def has_response?
+      (@response && @response.status && !@response.status.nil?)
+    end
+    
+    def initialize(raw_data=nil)
+      @raw_data = raw_data
+      if @raw_data
+        @method, @http_version, @uri, @header, @body = HTTPUtil::parse_http_request(raw_data) 
+      end
+      @response = Stella::Data::HTTPResponse.new
+    end
+    
+    def uri
+      @uri.host = @server_ip.to_s if @uri && (@uri.host == 'unknown' || @uri.host.empty?)
+      @uri
+    end
+    
+    def body
+      return nil unless @body
+      @body
+      #(!header || header[:Content_Type] || header[:Content_Type] !~ /text/) ? Base64.encode64(@body) : @body
+    end
+    
+
+    
+    def inspect
+      headers = []
+      header.each_pair do |n,v|
+        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+      end
+      str = "%s %s HTTP/%s" % [method, uri.to_s, http_version]
+      str << $/ + headers.join($/)
+      str << $/ + $/ + body if body
+      str
+    end
+    
+    def to_s
+      str = "%s: %s %s HTTP/%s" % [time.strftime(NICE_TIME_FORMAT), method, uri.to_s, http_version]
+      str
+    end
+    
+  end
+  
+  class HTTPResponse < Stella::Storable
+    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
+      if @raw_data
+        @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(@raw_data)
+      end
+    end
+    
+    def has_body?
+      @body && !@body.nil & !@body.empty?
+    end
+    def has_request?
+      false
+    end
+    def has_response?
+      false
+    end
+    
+    def body
+      return nil unless @body
+      #Base64.encode64(@body)
+      (!header || !header[:Content_Type] || header[:Content_Type] !~ /text/) ? '' : @body
+    end
+    
+    def inspect
+      headers = []
+      header.each_pair do |n,v|
+        headers << "#{n.to_s.gsub('_', '-')}: #{v[0]}"
+      end
+      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
+  end
+end 

data/lib/stella/logger.rb

@@ -0,0 +1,84 @@
+
+
+module Stella
+  class Logger
+    attr_accessor :debug_level
+    
+    # +args+ is a hash of initialization arguments
+    # * <tt>:info_logger</tt> The IO class for info level logging. Default: STDOUT
+    # * <tt>:error_logger</tt> The IO class for error level logging. Default: STDERR
+    # * <tt>:debug_logger</tt> The IO class for error level logging. Default: STDERR
+    # * <tt>:debug</tt> Log debugging output, true or false (default)
+    def initialize(args={})
+      @debug_level        = args[:debug] || false
+      @info_logger  = args[:info_logger]
+      @error_logger = args[:error_logger]
+      @debug_logger = args[:debug_logger]
+    end
+    
+    # +msgs+ is an array which can contain a list of messages or a symbol and a list of values
+    # If the first element is a symbol, this will return the output of Stella::Text.msg(msgs[0],msgs[1..-1]) 
+    def info(*msgs)
+      return if !msgs || msgs.empty?
+      if msgs[0].is_a? Symbol
+        txtsym = msgs.shift
+        info_logger.puts Stella::TEXT.msg(txtsym, msgs)
+      else
+        msgs.each do |m|
+          info_logger.puts m
+        end  
+      end
+      info_logger.flush
+    end
+    
+    def info_logger
+      @info_logger || $stdout
+    end
+    def debug_logger
+      @debug_logger || $stderr
+    end
+    def error_logger
+      @error_logger || $stderr
+    end
+    
+    def flush
+      info_logger.flush
+      error_logger.flush
+      debug_logger.flush
+    end
+    
+    # Print all messages on a single line. 
+    def info_print(*msgs)
+      msgs.each do |m|
+        info_logger.print m
+      end
+      info_logger.flush
+    end
+    
+    # Print all messages on a single line. 
+    def info_printf(pattern, *vals)
+      info_logger.printf(pattern, *vals)
+      info_logger.flush
+    end
+    
+    def debug(*msgs)
+      return unless @debug_level
+      msgs.each do |m|
+        debug_logger.puts "DEBUG: #{m}"
+      end  
+      debug_logger.flush
+    end
+    def warn(ex, prefix="WARN: ")
+      error(ex, prefix)
+    end
+    
+    def error(ex, prefix="ERR: ")
+      msg = (ex.kind_of? String) ? ex : ex.message
+      error_logger.puts "#{prefix}#{msg}"
+      return unless @debug_level && ex.kind_of?(Exception)
+      error_logger.puts("#{prefix}------------------------------------------")
+      error_logger.puts("#{prefix}#{ex.backtrace.join("\n")}")
+      error_logger.puts("#{prefix}------------------------------------------")
+    end
+  end
+end

data/lib/stella/response.rb

@@ -0,0 +1,85 @@
+
+
+
+module Stella
+  
+  # An object for HTTP response content
+  #
+  class Response < Storable
+    
+    field :errors => Array
+    field :content => Hash
+    field :messages => Array
+    field :success => TrueClass
+    
+    def initialize
+      @success = false
+      @errors = []
+      @messages = []
+      @content = {}
+    end
+    
+    def success?
+      @success
+    end
+    
+    def add(key, value)
+      @content[key] = value
+    end
+    
+    def get(key)
+      @content[key] if @content.has_key? key
+    end
+    
+    def message(msg)
+      @messages.push(msg)
+    end
+    
+    def error(msg)
+      @errors.push(msg)
+    end
+    
+    def output(format='yaml')
+      format = 'yaml' unless self.respond_to? "output_#{format}"
+      #STDERR.puts "OUTPUT: #{format}"
+      self.send("output_#{format}")
+    end
+    
+    def to_hash    
+      h = {}
+      h[:version] = API_VERSION
+      h[:errors] = @errors unless @errors.empty?
+      h[:messages] = @messages unless @messages.empty?
+      h[:content] = @content || {}
+      h[:success] = @success || false
+      h
+    end
+    
+    def output_zip
+      output = @content
+    end
+    
+    def output_yaml
+      to_hash.to_yaml
+    end
+    
+    # http://evang.eli.st/blog/2007/2/22/my-rails-gotcha-custom-to_xml-in-a-hash-or-array
+    # http://api.rubyonrails.org/classes/ActiveRecord/XmlSerialization.html#M000910
+    def output_xml
+      output = "<StellaResponse success=\":[\">\n"
+      output << "<todo>implement XML</todo>\n"
+      output << "</StellaResponse>\n"
+    end
+    
+    def output_json
+      to_hash.to_json
+    end
+    
+    def output_html
+     "hello!"
+    end
+    
+  end
+  
+end
+

data/lib/stella/storable.rb

@@ -0,0 +1,201 @@
+
+# TODO: Handle nested hashes and arrays. 
+
+require 'yaml'
+require 'utils/fileutil'
+
+module Stella
+  class Storable
+    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
+    
+    attr_reader :format
+    
+    def format=(v)
+      raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
+      @format = v
+    end
+    
+    def init
+      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
+      
+    def self.field(args={})
+      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)
+        
+        # NOTE: I need a way to put these in the caller's namespace... Here's they're shared by all
+        # the subclasses which is not helpful. It will likely involve Kernel#caller and binding. 
+        # Maybe class_eval, wraped around def field. 
+
+        
+        define_method(m) do instance_variable_get("@#{m}") end
+        
+        define_method("#{m}=") do |val| 
+          instance_variable_set("@#{m}",val)
+        end
+      end
+    end
+    
+    def self.field_names
+      class_variable_get(:@@field_names)
+    end
+    def self.field_types
+      class_variable_get(:@@field_types)
+    end
+    
+    def field_names
+      self.class.send(:class_variable_get, :@@field_names)
+    end
+    
+    def field_types
+      self.class.send(:class_variable_get, :@@field_types)
+    end
+    
+    def format=(v)
+      raise "Unsupported format: #{v}" unless SUPPORTED_FORMATS.member?(v)
+      @format = v
+    end
+
+    
+    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
+    
+    def self.from_file(file_path=nil, format=nil)
+      raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
+      format = format || File.extname(file_path).tr('.', '')
+      me = send("from_#{format}", FileUtil.read_file_to_array(file_path))
+      me.format = format
+      me
+    end
+    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
+      FileUtil.write_file(file_path, dump(format, with_titles))
+    end
+  
+
+    def self.from_hash(from={})
+      me = self.new
+    
+      return me if !from || from.empty?
+      
+      fnames = field_names
+      fnames.each_with_index do |key,index|
+        
+        value = from[key]
+        
+        # TODO: Correct this horrible implementation (sorry, me. It's just one of those days.)
+        
+        if field_types[index] == Time
+          value = Time.parse(from[key].to_s)
+        elsif field_types[index] == DateTime
+          value = DateTime.parse(from[key].to_s)
+        elsif field_types[index] == TrueClass
+          value = (from[key].to_s == "true")
+        elsif field_types[index] == Float
+          value = from[key].to_f
+        elsif field_types[index] == Integer
+          value = from[key].to_i
+        end
+        
+        me.send("#{key}=", value) if self.method_defined?("#{key}=")  
+      end
+      me
+    end
+    def to_hash(with_titles=true)
+      tmp = {}
+      field_names.each do |fname|
+        tmp[fname] = self.send(fname)
+      end
+      tmp
+    end
+    
+
+    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
+    
+
+    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
+    
+    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
+    def to_tsv(with_titles=false)
+      to_delimited(with_titles, "\t")
+    end
+    def to_csv(with_titles=false)
+      to_delimited(with_titles, ',')
+    end
+    def self.from_tsv(from=[])
+      self.from_delimited(from, "\t")
+    end
+    def self.from_csv(from=[])
+      self.from_delimited(from, ',')
+    end
+    
+    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
+
+  
+  end
+end