onemorehill-lame 0.0.3

data/README

@@ -0,0 +1,48 @@
+= lame
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Lee Chang
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'hoe'
+
+VERSION = "0.0.1"
+
+Hoe.spec 'lame' do
+  developer "Lee Chang", "leetchang@gmail.com"
+  self.rubyforge_name = "onemorehill"
+  history_file = "CHANGELOG"
+  readme_file = "README"
+  name = "Lame"
+end

data/bin/lame

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'fileutils'
+require 'lame'
+
+

data/lib/call_parser.rb

@@ -0,0 +1,42 @@
+require 'cgi'
+
+module CallParser
+  
+  class Parser
+    
+    attr_accessor :query, :path
+    
+    def initailize(env)
+      @env = env
+    end
+    
+    def parse_uri(request_path)
+      begin
+        uri = (request_path.split("/").collect {|r| r.intern unless r.empty?}).compact
+      rescue NoMethodError
+        $logger.debug("No URI found for this request")
+        uri = Hash.new
+      end
+      return uri
+    end
+
+    def parse_query_string(query_string)
+      begin
+        params = query_string.split('&').inject({}) {|h,(k,v)| h[k.split('=')[0].intern] = CGI.unescape(k.split('=')[1]); h}
+      rescue NoMethodError
+        $logger.debug("No Query String found for this request")
+        params = Hash.new
+      end
+      return params
+    end
+    
+    def call(env)
+      env[:query] = parse_query_string(env["QUERY_STRING"])
+      env[:path] = parse_uri(env["PATH_INFO"])
+      resp = response(env)
+      [200, {"Content-Type" => "text/plain"}, [resp]]
+    end
+    
+  end
+  
+end

data/lib/controller.rb

@@ -0,0 +1,44 @@
+
+require 'cgi'
+
+module Controller
+  
+  class Base
+    
+    attr_accessor :query, :path
+    
+    def initailize(env)
+      @env = env
+    end
+    
+    def parse_uri(request_path)
+      begin
+        uri = (request_path.split("/").collect {|r| r.intern unless r.empty?}).compact
+      rescue NoMethodError
+        $logger.debug("No URI found for this request")
+        uri = Hash.new
+      end
+      return uri
+    end
+
+    def parse_query_string(query_string)
+      begin
+        params = query_string.split('&').inject({}) {|h,(k,v)| h[k.split('=')[0].intern] = CGI.unescape(k.split('=')[1]); h}
+      rescue NoMethodError
+        $logger.debug("No Query String found for this request")
+        params = Hash.new
+      end
+      return params
+    end
+    
+    def call(env)
+      env[:query] = parse_query_string(env["QUERY_STRING"])
+      env[:path] = parse_uri(env["PATH_INFO"])
+      resp = response(env)
+      content_type = resp[:content_type] || "text/plain"
+      [200, {"Content-Type" => resp[:content_type]}, [resp[:body]]]
+    end
+    
+  end
+  
+end

data/lib/initializer.rb

@@ -0,0 +1,176 @@
+require 'yaml'
+require 'logger'
+require 'optparse'
+
+module Lame
+  
+  # Build configurations from yaml files
+  class Initializer 
+    
+    attr_reader :database, :system
+
+    CONTROLLER = "Controller"
+
+    def initialize
+      self.options
+      self.read_config if File.exists?($ROOT + '/conf/config.yml')
+      self.set_log
+      # Load all common ruby files in lib, and ext directories
+      Dir[ $ROOT + "/lib/*.rb"].each {|f| require f}
+      # Load modules and classes for controller
+      self.instantiate_controller($ROOT + '/ext/controller', '.rb')
+      # Load models
+      Dir[ $ROOT + "/ext/record/*.rb"].each {|f| require f}
+      # Load views
+    end
+    
+    def options
+      OptionParser.new do |opts|
+        opts.banner = "Usage: reco_ctrl.rb [options] [action]"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on("-c", "--config PATH", "Path to configuration files") {|config| OPTIONS[:config] = config}
+        opts.on("-e", "--env ENVIRONMENT", "Environment to run as") {|env| OPTIONS[:env] = env.intern}
+        opts.on("-d", "--daemon", "Run as a Daemon") {OPTIONS[:daemon] = true}
+        opts.on("-p", "--port PORT", "Port for the server to listen on") {|port| OPTIONS[:port] = port}
+        opts.on("-P", "--pid PATH", "Path to store the PID file") {|pid| OPTIONS[:pid] = pid}
+        opts.on("-l", "--log PATH", "Path to log files") {|log| OPTIONS[:logs] = log}
+        opts.separator ""
+        opts.separator "Actions"
+        opts.on("--start", "Start the server") {OPTIONS[:action] = :start}
+        opts.on("--stop", "Stop the server") {OPTIONS[:action] = :stop}
+        opts.on("--restart", "Restart the server") {OPTIONS[:action] = :restart}
+        opts.separator ""
+        opts.on("-h", "--help", "Show this help message") {puts opts; exit}
+        opts.separator""
+        opts.parse!
+      end
+    end
+    
+    def read_config
+      # Convert key strings to symbols
+      begin
+        @system = YAML.load_file(OPTIONS[:config] + "config.yml")[OPTIONS[:env].to_s].inject({}) {|h,(k,v)| h[k.intern] =v; h}
+        @database = YAML.load_file(OPTIONS[:config] + "database.yml")[OPTIONS[:env].to_s].inject({}) {|h,(k,v)| h[k.intern] = v; h}
+      rescue NoMethodError
+        puts "#{OPTIONS[:env].to_s.capitalize} is not a valid Environment. Please correct the problem and try again."
+        #exit
+      end
+    end
+    
+    def set_log
+      log_path = OPTIONS[:logs] || @system[:logs]
+      OPTIONS[:log_path] = log_path + '/' + OPTIONS[:type].to_s + OPTIONS[:env].to_s + ".log"
+      OPTIONS[:rotate] = !@system.nil? ? @system[:rotate] : nil
+    end
+    
+    # Deprecated use instantiate_controller instead
+    def load_controller
+      # Include subdirectories and place the class into the module based on the subdirectory name -- ONLY TWO DEEP!
+      Dir[ ROOT  + "/ext/controller/*"].each do |d|
+        if File.file?(d) && d != '.' && d != '..'
+          require d if File.extname(d) == '.rb'
+        elsif d != '.' && d != '..'
+          # This is a subdirectory
+          sub_dir = d.split("/").last
+          module_name = camel_name(sub_dir)
+          new_module = Object.const_set(module_name,Module.new)
+          before_classes = Object.constants      # these are all the current classes and modules
+          Dir[d + "/*"].each do |f| 
+            if File.extname(f) == '.rb'
+              require f
+            end
+          end
+          # Make hash of sub_dirs
+          after_classes = Object.constants      # these are all the classes after loading the files
+          new_classes = after_classes - before_classes
+          new_classes.each do |c|
+            class_name = c.to_s
+            klass = Object.const_get(class_name)    # make class_name into a constant
+            new_module.const_set(class_name, klass)              
+            Object.instance_eval{ remove_const class_name.intern }  # Remove the class from Object
+          end
+        end
+      end
+    end
+    
+    def instantiate_controller(path, extname)
+      pre = File.join(path.split("/").delete_if { |p| p == "controller" })
+      dir = path.chomp("/")
+      while !dir.nil? do
+        dir = instantiate_class(dir, pre, extname)
+      end
+    end
+        
+    def instantiate_class(path, pre, extname)
+      pre_arr = pre.split("/")
+      Dir[path + '/*'].each do |d|
+        sub_dir_hash = get_modules(d, pre_arr)
+        nmodule = build_modules(sub_dir_hash)
+        @sub_dir_found = load_class(d, nmodule, extname)
+      end
+      dir = @sub_dir_found
+      @sub_dir_found = nil
+      return dir      
+    end
+      
+    def get_modules(path, pre)
+      sub_dir_arr = path.split("/")
+      sub_dir = sub_dir_arr - pre
+      sub_dir_hash = sub_dir.inject({}) {|h,(k,v)| h[camel_name(k).intern] = camel_name(k) if File.extname(k) != '.rb';h}
+      return sub_dir_hash
+    end
+    
+    def build_modules(sub_dir_hash)
+      nmodule = Module.new
+      sub_dir_hash.each_pair do |k,v|
+        if Object.constants.include?(k)
+          # This is the top module
+          nmodule = nmodule.const_get(v)
+          next
+        elsif nmodule.constants.include?(k)
+          # This module already exists
+          nmodule = nmodule.const_get(v)
+        else
+          # This is a new module
+          nmodule = nmodule.const_set(v, Module.new)
+        end
+      end
+      return nmodule
+    end
+    
+    def load_class(path, nmodule, extname)
+      class_before = Object.constants           # all current classes and models
+      last_item = path.split("/").last
+      #Dir.entries(path).each do |d|
+        if File.extname(path) == extname
+          require path
+        elsif last_item != '.' && last_item != '..' && File.directory?(path)
+          @sub_dir_found = path
+        end
+      #end
+      # Add the new classes
+      class_after = Object.constants
+      new_class = class_after - class_before
+      new_class.each do |c|
+        klass = Object.const_get("#{c}")
+        nmodule.const_set("#{c}", klass)
+        Object.instance_eval{ remove_const c }
+      end
+      return @sub_dir_found
+    end
+
+    def camel_name(string)
+      name = string.split("_").map {|s| s.capitalize }.join
+      return name
+    end
+    
+    def camel_path(path, ext)
+      new_path = File.join(path.split("/") - ext.split("/"))
+      camel_path = new_path.chomp(".haml").split("/").map { |a| a.capitalize }.join.intern
+      return camel_path
+    end
+    
+  end
+  
+end

data/lib/lame.rb

@@ -0,0 +1,15 @@
+lib_path = File.dirname(__FILE__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+$ROOT =File.join(File.expand_path(File.dirname(__FILE__)), "../") if $ROOT.nil?
+
+require 'rubygems'
+require 'initializer'
+require 'controller'
+require 'record/record'
+require 'main'
+
+module Lame
+  
+  VERSION = '0.0.1'
+
+end

data/lib/log_blaster.rb

@@ -0,0 +1,2 @@
+class Logger
+end

data/lib/main.rb

@@ -0,0 +1,36 @@
+OPTIONS = {
+  :config => $ROOT + '/conf/',
+  :env => :development,
+  :logs => $ROOT + '/logs',
+  :verbose => false,
+  :daemon => false
+}
+    
+# Load it all up
+$CONFIG = Lame::Initializer.new
+dbconn = $CONFIG.database
+
+# Set up logging
+if File.exists?($ROOT + "/logs")
+  $logger = Logger.new(OPTIONS[:log_path], OPTIONS[:rotate])
+
+  if OPTIONS[:verbose]
+    $logger.level = Logger::DEBUG
+  else
+    case OPTIONS[:env]
+    when :development
+      $logger.level = Logger::DEBUG
+    when :integration
+      $logger.level = Logger::DEBUG
+    when :staging
+      $logger.level = Logger::DEBUG
+    when :production_test
+      $logger.level = Logger::DEBUG
+    when :production
+      $logger.level = Logger::WARN
+    end
+  end
+
+  $logger.warn("The logging level is set to #{$logger.level}")
+end
+Record::BASE.new(dbconn)

data/lib/mapper.rb

@@ -0,0 +1,7 @@
+module Lame
+  
+  class Mapper
+    
+  end
+  
+end

data/lib/record/crazy_time.rb

@@ -0,0 +1,15 @@
+
+class CrazyTime
+    
+  def initialize
+  end
+  
+  def self.strptime(string)  
+    # Convert strings into a usable Time object.  This only works for dates from MySQL.
+    string[/(\d+)-(\d+)-(\d+)\s(\d+):(\d+):(\d+)/]
+    year = $1.to_i; month = $2.to_i; day = $3.to_i; hour = $4.to_i; min = $5.to_i; sec = $6.to_i
+    new_time = Time.local(year,month,day,hour,min,sec)
+    return new_time
+  end
+  
+end

data/lib/record/record.rb

@@ -0,0 +1,63 @@
+require 'mysqlplus'
+require 'record/crazy_time.rb'
+
+module Record
+  
+  class BASE
+    
+    attr_reader :status
+    
+    def initialize(dbconn)
+      begin
+        $db_conn = Mysql.real_connect(dbconn[:host], dbconn[:username], dbconn[:password], dbconn[:database], dbconn[:port])
+        #$logger.debug("Primary database initialized => #{dbconn[:host]}")
+        # Check to make sure there is a read db in the configs
+        if dbconn[:read_host].nil?
+          $db_conn_read = $db_conn
+        else
+          $db_conn_read = Mysql.real_connect(dbconn[:read_host], dbconn[:read_username], dbconn[:read_password], dbconn[:read_database], dbconn[:read_port])
+        end
+        #$logger.debug("Secondary database initialized => #{dbconn[:read_host]}")
+      rescue
+        # No db information include. No problem.  We just won't have a database connection
+        #$logger.warn("No database connection initialized")
+      end
+    end
+    
+    def self.query(query_string)
+      n = 0							# track how many times that the system had to reconnect to the db
+      begin
+        # Test to see if the query starts with a select which would mean it was a read query
+        if query_string.split[0].upcase == "SELECT"
+          #$logger.debug("Using read database => \"#{query_string}\"")
+          res = $db_conn_read.query(query_string)
+        else
+          #$logger.debug("Using update database => \"#{query_string}\"")
+          res = $db_conn.query(query_string)
+        end
+      rescue Mysql::Error => e
+        $logger.error("Mysql query => #{query_string}")
+        $logger.error("Mysql::Error '#{e.to_s}'")
+        case e.to_s
+          when 'MySQL server has gone away'
+            $logger.warn("Connection to database #{dbconn[:host]} has gone away.  Reconnecting.") if n == 0
+            self.new
+            n += 1
+            retry
+          when 'Lost connection to MySQL server during query'
+            $logger.warn("Lost connection #{dbconn[:host]}.  Reconnecting.") if n == 0
+            self.new
+            n += 1
+            retry
+          else
+            # Don't know what to do because of an unknown error so to play it safe we'll just break instead looping
+            $logger.warn("ERROR: #{e.to_s} Not sure what this error is from #{dbconn[:host]}.")
+        end
+      end
+      return res
+    end
+    
+  end
+  
+end
+

data/test/test_lame.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "lame"
+
+class TestLame < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: onemorehill-lame
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Lee Chang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-18 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubygems
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+    version: 
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- CHANGELOG
+- README
+- Rakefile
+- TODO
+- bin/lame
+- lib/call_parser.rb
+- lib/controller.rb
+- lib/initializer.rb
+- lib/lame.rb
+- lib/log_blaster.rb
+- lib/main.rb
+- lib/mapper.rb
+- lib/record/crazy_time.rb
+- lib/record/record.rb
+- test/test_lame.rb
+has_rdoc: false
+homepage: http://github.com/onemorehill/lame/tree/master
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Another LaMe Web Frame-work
+test_files: []
+