onemorehill-lame 0.0.4 → 0.1.1

data/lib/initializer.rb

@@ -9,37 +9,45 @@ module Lame
     
     attr_reader :database, :system
 
-    CONTROLLER = "Controller"
+    #CONTROLLER = "Controller"
 
-    def initialize
-      self.options
-      self.read_config if File.exists?($ROOT + '/conf/config.yml')
+    def initialize(root)
+      @root = root
+      @options = {
+        :env => (ENV['RACK_ENV'] || :development).to_sym,
+        :config => @root + '/conf/',
+        :log_path => @root + '/logs',
+        :verbose => false
+      }
+      self.set_options
+      self.read_config if File.exists?(@root + '/conf/config.yml')
+      self.read_database_config if File.exists?(@root + '/conf/database.yml')
       self.set_log
       # Load all common ruby files in lib, and ext directories
-      Dir[ $ROOT + "/lib/*.rb"].each {|f| require f}
+      Dir[ @root + "/lib/*.rb"].each {|f| require f}
       # Load modules and classes for controller
-      self.instantiate_controller($ROOT + '/ext/controller', '.rb')
+      self.instantiate_controller(@root + '/ext/controller', '.rb')
       # Load models
-      Dir[ $ROOT + "/ext/record/*.rb"].each {|f| require f}
+      Dir[ @root + "/ext/record/*.rb"].each {|f| require f}
       # Load views
     end
     
-    def options
+    def set_options
       OptionParser.new do |opts|
-        opts.banner = "Usage: reco_ctrl.rb [options] [action]"
+        opts.banner = "Usage: lame [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.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.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""
@@ -50,50 +58,39 @@ module Lame
     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}
+        @system = YAML.load_file(@options[:config] + "config.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
+      log_path = @system[:log_path] || @options[:log_path] 
+      @options[:log_path] = log_path + '/' + @options[:env].to_s + ".log"
+      @options[:rotate] = !@system.nil? ? @system[:rotate] : nil
+      # Set up logging
+      if File.exists?(@root + "/logs")
+        $logger = Logger.new(@options[:log_path], @options[:rotate])
+
+        case @options[:env]
+        when :development
+          $logger.level = Logger::DEBUG
+        when :test
+          $logger.level = Logger::DEBUG
+        when :staging
+          $logger.level = Logger::DEBUG
+        when :production
+          $logger.level = Logger::WARN
         end
+
+        $logger.warn("The logging level is set to #{$logger.level}")
       end
     end
     
+    def read_database_config
+      # Convert key strings to symbols
+      @database = YAML.load_file(@options[:config] + "database.yml")[@options[:env].to_s].inject({}) {|h,(k,v)| h[k.intern] = v; h}
+    end
+    
     def instantiate_controller(path, extname)
       pre = File.join(path.split("/").delete_if { |p| p == "controller" })
       dir = path.chomp("/")

data/lib/lame.rb

@@ -1,15 +1,7 @@
 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
+Controller = Class.new

data/lib/main.rb

@@ -1,36 +1,73 @@
-OPTIONS = {
-  :config => $ROOT + '/conf/',
-  :env => :development,
-  :logs => $ROOT + '/logs',
-  :verbose => false,
-  :daemon => false
-}
-    
-# Load it all up
-$CONFIG = Lame::Initializer.new
-dbconn = $CONFIG.database
+require 'rack'
+require 'rack/builder'
+require 'initializer'
+require 'cgi'
 
-# 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
+module Lame
+    
+  class Request < Rack::Request
+    
+    def uri
+      begin
+        @uri = (@env["PATH_INFO"].split("/").collect {|r| r.intern unless r.empty?}).compact
+      rescue NoMethodError
+        @uri = {}
+      end
+    end
+    
+    def params
+      begin
+        @params = @env["QUERY_STRING"].split('&').inject({}) {|h,(k,v) | h[k.split('=')[0].intern] = CGI.unescape(k.split('=')[1]); h}
+      rescue
+        @params = {}
+      end
     end
+    
+  end
+  
+  class Response < Rack::Response
+    
   end
+  
+  class NotFound < NameError
+    def code ; 404 ; end
+  end
+  
+  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
+        uri = Hash.new
+      end
+      return uri
+    end
 
-  $logger.warn("The logging level is set to #{$logger.level}")
-end
-Record::BASE.new(dbconn)
+    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
+        params = Hash.new
+      end
+      return params
+    end
+    
+    def call(env)
+      env[:query] = self.parse_query_string(env['QUERY_STRING'])
+      env[:path] = self.parse_uri(env['PATH_INFO'])
+      resp = response(env)
+      status_code = resp[:status_code] || 200
+      content_type = resp[:content_type] || "text/plain"
+      [status_code, {"Content-Type" => content_type}, [resp[:body]]]
+    end
+    
+  end
+  
+end

data/lib/record/record.rb

@@ -1,6 +1,3 @@
-require 'mysqlplus'
-require 'record/crazy_time.rb'
-
 module Record
   
   class BASE

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: onemorehill-lame
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.1.1
 platform: ruby
 authors: 
 - Lee Chang
@@ -38,7 +38,6 @@ files:
 - TODO
 - bin/lame
 - lib/call_parser.rb
-- lib/controller.rb
 - lib/initializer.rb
 - lib/lame.rb
 - lib/log_blaster.rb

data/lib/controller.rb

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