hayabusa 0.0.1

data/lib/hayabusa_http_session_response.rb

@@ -0,0 +1,144 @@
+require "time"
+
+#This object writes headers, trailing headers, status headers and more for HTTP-sessions.
+class Hayabusa::Http_session::Response
+  attr_accessor :chunked, :cgroup, :nl, :status, :http_version, :headers, :headers_trailing, :headers_sent, :socket
+  
+  STATUS_CODES = {
+    100 => "Continue",
+    200 => "OK",
+    201 => "Created",
+    202 => "Accepted",
+    204 => "No Content",
+    205 => "Reset Content",
+    206 => "Partial Content",
+    301 => "Moved Permanently",
+    302 => "Found",
+    303 => "See Other",
+    304 => "Not Modified",
+    307 => "Temporary Redirect",
+    400 => "Bad Request",
+    401 => "Unauthorized",
+    403 => "Forbidden",
+    404 => "Not Found",
+    500 => "Internal Server Error"
+  }
+  NL = "\r\n"
+  
+  def initialize(args)
+    @chunked = false
+    @socket = args[:socket]
+  end
+  
+  def reset(args)
+    @status = 200
+    @http_version = args[:http_version]
+    @close = args[:close]
+    @fileobj = nil
+    @close = true if @http_version == "1.0"
+    @trailers = []
+    @skip_statuscode = true if args[:mode] == :cgi
+    
+    @headers_sent = false
+    @headers_trailing = {}
+    
+    @mode = args[:mode]
+    
+    @headers = {
+      "date" => ["Date", Time.now.httpdate]
+    }
+    
+    @headers_11 = {
+      "Connection" => "Keep-Alive"
+    }
+    if args[:mode] != :cgi and (!args.key?(:chunked) or args[:chunked])
+      @headers_11["Transfer-Encoding"] = "chunked"
+    end
+    
+    #Socket-timeout is currently broken in JRuby.
+    if RUBY_ENGINE != "jruby"
+      @headers_11["Keep-Alive"] = "timeout=15, max=30"
+    end
+    
+    @cookies = []
+  end
+  
+  def header(key, val)
+    lines = val.to_s.count("\n") + 1
+    raise "Value contains more lines than 1 (#{lines})." if lines > 1
+    
+    if !@headers_sent
+      @headers[key.to_s.downcase] = [key, val]
+    else
+      raise "Headers already sent and given header was not in trailing headers: '#{key}'." if @trailers.index(key) == nil
+      @headers_trailing[key.to_s.downcase] = [key, val]
+    end
+  end
+  
+  def cookie(cookie)
+    @cookies << cookie
+  end
+  
+  def header_str
+    if @skip_statuscode
+      res = ""
+    else
+      if @http_version == "1.0"
+        res = "HTTP/1.0 #{@status}"
+      else
+        res = "HTTP/1.1 #{@status}"
+      end
+      
+      code = STATUS_CODES[@status]
+      res << " #{code}" if code
+      res << NL
+    end
+    
+    @headers.each do |key, val|
+      res << "#{val[0]}: #{val[1]}#{NL}"
+    end
+    
+    if @http_version == "1.1"
+      @headers_11.each do |key, val|
+        res << "#{key}: #{val}#{NL}"
+      end
+      
+      @trailers.each do |trailer|
+        res << "Trailer: #{trailer}#{NL}"
+      end
+    end
+    
+    @cookies.each do |cookie|
+      res << "Set-Cookie: #{Knj::Web.cookie_str(cookie)}#{NL}"
+    end
+    
+    res << NL
+    
+    return res
+  end
+  
+  def write
+    @headers_sent = true
+    @socket.write(self.header_str)
+    
+    if @status == 304
+      #do nothing.
+    else
+      if @chunked
+        @cgroup.write_to_socket
+        @socket.write("0#{NL}")
+        
+        @headers_trailing.each do |header_id_str, header|
+          @socket.write("#{header[0]}: #{header[1]}#{NL}")
+        end
+        
+        @socket.write(NL)
+      else
+        @cgroup.write_to_socket
+        @socket.write("#{NL}#{NL}") if @mode != :cgi
+      end
+    end
+    
+    @socket.close if @close and @mode != :cgi
+  end
+end

data/lib/hayabusa_models.rb

@@ -0,0 +1,8 @@
+class Hayabusa::Models
+  #Autoloader for subclasses.
+  def self.const_missing(name)
+    require "#{File.dirname(__FILE__)}/models/#{name.to_s.downcase}.rb"
+    raise "Still not defined: '#{name}'." if !Hayabusa::Models.const_defined?(name)
+    return Hayabusa::Models.const_get(name)
+  end
+end

data/lib/kernel_ext/gettext_methods.rb

@@ -0,0 +1,22 @@
+#coding: utf-8
+
+def _(str)
+  hb = _hb
+  session = _session
+  locale = nil
+  
+  if Thread.current[:locale].to_s.length > 0
+    locale = Thread.current[:locale]
+  elsif session and session[:locale].to_s.strip.length > 0
+    locale = session[:locale]
+  elsif hb and hb.config[:locale_default].to_s.strip.length > 0
+    session[:locale] = hb.config[:locale_default] if session
+    locale = hb.config[:locale_default]
+  elsif !session and !hb
+    return str
+  else
+    raise "No locale set for session and ':locale_default' not set in config."
+  end
+  
+  return hb.gettext.trans(locale, str)
+end

data/lib/kernel_ext/magic_methods.rb

@@ -0,0 +1,61 @@
+def _cookie
+  return Thread.current[:hayabusa][:cookie] if Thread.current[:hayabusa]
+end
+
+def _get
+  return Thread.current[:hayabusa][:get] if Thread.current[:hayabusa]
+end
+
+def _post
+  return Thread.current[:hayabusa][:post] if Thread.current[:hayabusa]
+end
+
+def _meta
+  return Thread.current[:hayabusa][:meta] if Thread.current[:hayabusa]
+end
+
+def _server
+  return Thread.current[:hayabusa][:meta] if Thread.current[:hayabusa]
+end
+
+def _session
+  return Thread.current[:hayabusa][:session].sess_data if Thread.current[:hayabusa] and Thread.current[:hayabusa][:session]
+end
+
+def _session_hash
+  return Thread.current[:hayabusa][:session].edata if Thread.current[:hayabusa] and Thread.current[:hayabusa][:session]
+end
+
+def _session_obj
+  return Thread.current[:hayabusa][:session] if Thread.current[:hayabusa] and Thread.current[:hayabusa][:session]
+end
+
+def _httpsession
+  return Thread.current[:hayabusa][:httpsession] if Thread.current[:hayabusa]
+end
+
+def _httpsession_var
+  return Thread.current[:hayabusa][:httpsession].httpsession_var if Thread.current[:hayabusa]
+end
+
+def _requestdata
+  return Thread.current[:hayabusa] if Thread.current[:hayabusa]
+end
+
+def _hb
+  return Thread.current[:hayabusa][:hb] if Thread.current[:hayabusa]
+end
+
+def _vars
+  return Thread.current[:hayabusa][:hb].vars if Thread.current[:hayabusa]
+end
+
+def _db
+  return Thread.current[:hayabusa][:db] if Thread.current[:hayabusa] and Thread.current[:hayabusa][:db] #This is the default use from a .rhtml-file.
+  return Thread.current[:hayabusa][:hb].db_handler if Thread.current[:hayabusa] and Thread.current[:hayabusa][:hb] #This is useually used when using autoload-argument for the appserver.
+end
+
+#This function makes it possible to define methods in ERubis-parsed files (else _buf-variable wouldnt be globally available).
+def _buf
+  return $stdout
+end

data/lib/models/log.rb

@@ -0,0 +1,130 @@
+class Hayabusa::Models::Log < Knj::Datarow
+  has_many [
+    {:class => :Log_link, :col => :log_id, :method => :links, :depends => true, :autodelete => true}
+  ]
+  
+  def self.list(d, &block)
+    sql = "SELECT #{table}.* FROM #{table}"
+    
+    if d.args["object_lookup"]
+      data_val = d.ob.get_by(:Log_data_value, {"value" => d.args["object_lookup"].class.name})
+      return [] if !data_val #if this data-value cannot be found, nothing has been logged for the object. So just return empty array here and skip the rest.
+      
+      sql << "
+        LEFT JOIN Log_link ON
+          Log_link.log_id = #{table}.id AND
+          Log_link.object_class_value_id = '#{d.db.esc(data_val.id)}' AND
+          Log_link.object_id = '#{d.db.esc(d.args["object_lookup"].id)}'
+      "
+    end
+    
+    q_args = nil
+    return_sql = false
+    ret = self.list_helper(d)
+    
+    sql << ret[:sql_joins]
+    sql << " WHERE 1=1"
+    
+    d.args.each do |key, val|
+      case key
+        when "object_lookup"
+          sql << " AND Log_link.id IS NOT NULL"
+        when "return_sql"
+          return_sql = true
+        when "tag"
+          data_val = d.ob.get_by(:Log_data_value, {"value" => val})
+          if !data_val
+            sql << " AND false"
+          else
+            sql << " AND Log.tag_data_id = '#{d.db.esc(data_val.id)}'"
+          end
+        when :cloned_ubuf
+          q_args = {:cloned_ubuf => true}
+        else
+          raise "Invalid key: #{key}."
+        end
+    end
+    
+    sql << ret[:sql_where]
+    sql << ret[:sql_order]
+    sql << ret[:sql_limit]
+    
+    return sql if return_sql
+    
+    return d.ob.list_bysql(:Log, sql, q_args, &block)
+  end
+  
+  def self.add(d)
+    d.data[:date_saved] = Time.now if !d.data.key?(:date_saved)
+  end
+  
+  def text
+    return ob.get(:Log_data_value, self[:text_value_id])[:value]
+  end
+  
+  def comment
+    return "" if self[:comment_data_id].to_i == 0
+    log_data = ob.get(:Log_data_value, self[:comment_data_id])
+    return "" if !log_data
+    return log_data[:value]
+  end
+  
+  def tag
+    return "" if self[:tag_data_id].to_i == 0
+    log_data = ob.get(:Log_data_value, self[:tag_data_id])
+    return "" if !log_data
+    return log_data[:value]
+  end
+  
+  def get
+    ob.args[:hayabusa].log_data_hash(self[:get_keys_data_id], self[:get_values_data_id])
+  end
+  
+  def post
+    ob.args[:hayabusa].log_data_hash(self[:post_keys_data_id], self[:post_values_data_id])
+  end
+  
+  def cookie
+    ob.args[:hayabusa].log_data_hash(self[:cookie_keys_data_id], self[:cookie_values_data_id])
+  end
+  
+  def meta
+    ob.args[:hayabusa].log_data_hash(self[:meta_keys_data_id], self[:meta_values_data_id])
+  end
+  
+  def session
+    ob.args[:hayabusa].log_data_hash(self[:session_keys_data_id], self[:session_values_data_id])
+  end
+  
+  def ip
+    meta_d = self.meta
+    
+    return meta_d[:HTTP_X_FORWARDED_FOR] if meta_d.has_key?(:HTTP_X_FORWARDED_FOR)
+    return meta_d[:REMOTE_ADDR] if meta_d.has_key?(:REMOTE_ADDR)
+    return "[no ip logged]"
+  end
+  
+  def first_line
+    lines = self.text.to_s.split("\n").first.to_s
+  end
+  
+  def objects_html(ob_use)
+    html = ""
+    first = true
+    
+    self.links.each do |link|
+      obj = link.object(ob_use)
+      
+      html << ", " if !first
+      first = false if first
+      
+      if obj.respond_to?(:html)
+        html << obj.html
+      else
+        html << "#{obj.class.name}{#{obj.id}}"
+      end
+    end
+    
+    return html
+  end
+end

data/lib/models/log_access.rb

@@ -0,0 +1,88 @@
+class Hayabusa::Models::Log_access < Knj::Datarow
+  def get
+    return data_hash("get")
+  end
+  
+  def post
+    return data_hash("post")
+  end
+  
+  def meta
+    return data_hash("meta")
+  end
+  
+  def cookie
+    return data_hash("cookie")
+  end
+  
+  def ips
+    return data_array(self[:ip_data_id])
+  end
+  
+  def data_array(data_id)
+    sql = "
+      SELECT
+        value_value.value AS value
+      
+      FROM
+        Log_data_link AS value_links,
+        Log_data_value AS value_value
+      
+      WHERE
+        value_links.data_id = '#{data_id}' AND
+        value_value.id = value_links.value_id
+      
+      ORDER BY
+        key_links.no
+    "
+    
+    arr = []
+    q_array = db.query(sql)
+    while d_array = q_array.fetch
+      arr << d_array[:value]
+    end
+    
+    return arr
+  end
+  
+  def data_hash(type)
+    col_keys_id = "#{type}_keys_data_id".to_sym
+    col_values_id = "#{type}_values_data_id".to_sym
+    
+    keys_id = self[col_keys_id]
+    values_id = self[col_values_id]
+    
+    keys_data_obj = ob.get(:Log_data, keys_id)
+    values_data_obj = ob.get(:Log_data, values_id)
+    
+    sql = "
+      SELECT
+        key_value.value AS `key`,
+        value_value.value AS value
+      
+      FROM
+        Log_data_link AS key_links,
+        Log_data_link AS value_links,
+        Log_data_value AS key_value,
+        Log_data_value AS value_value
+      
+      WHERE
+        key_links.data_id = '#{keys_id}' AND
+        value_links.data_id = '#{values_id}' AND
+        key_links.no = value_links.no AND
+        key_value.id = key_links.value_id AND
+        value_value.id = value_links.value_id
+      
+      ORDER BY
+        key_links.no
+    "
+    
+    hash = {}
+    q_hash = db.query(sql)
+    while d_hash = q_hash.fetch
+      hash[d_hash[:key].to_s] = d_hash[:value]
+    end
+    
+    return hash
+  end
+end