lamed 0.1.3 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.3.0

data/lamed.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lamed}
-  s.version = "0.1.3"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lee Chang"]
-  s.date = %q{2010-01-19}
+  s.date = %q{2010-04-15}
   s.description = %q{Yet another LaMe Ruby Web Framework}
   s.email = %q{leetchang@gmail.com}
   s.extra_rdoc_files = [
@@ -25,6 +25,9 @@ Gem::Specification.new do |s|
      "VERSION",
      "lamed.gemspec",
      "lib/lamed.rb",
+     "lib/lamed/aws/authentication.rb",
+     "lib/lamed/aws/aws.rb",
+     "lib/lamed/aws/sqs.rb",
      "lib/lamed/controller.rb",
      "lib/lamed/helper.rb",
      "lib/lamed/initializer.rb",
@@ -44,10 +47,14 @@ Gem::Specification.new do |s|
      "spec/examples/ext/views/lamest/bar.mustache",
      "spec/examples/ext/views/lamest/foo.mustache",
      "spec/examples/lib/foo_lib.rb",
-     "spec/helpers_spec.rb",
-     "spec/initializer_spec.rb",
-     "spec/lame_spec.rb",
-     "spec/object_loader_spec.rb",
+     "spec/lamed/aws/authentication_spec.rb",
+     "spec/lamed/aws/spec.rb",
+     "spec/lamed/aws/sqs_spec.rb",
+     "spec/lamed/controller_spec.rb",
+     "spec/lamed/helper_spec.rb",
+     "spec/lamed/initializer_spec.rb",
+     "spec/lamed/model_spec.rb",
+     "spec/lamed/object_loader_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]
@@ -63,10 +70,14 @@ Gem::Specification.new do |s|
      "spec/examples/ext/models/bar_model.rb",
      "spec/examples/ext/models/foo_model.rb",
      "spec/examples/lib/foo_lib.rb",
-     "spec/helpers_spec.rb",
-     "spec/initializer_spec.rb",
-     "spec/lame_spec.rb",
-     "spec/object_loader_spec.rb",
+     "spec/lamed/aws/authentication_spec.rb",
+     "spec/lamed/aws/spec.rb",
+     "spec/lamed/aws/sqs_spec.rb",
+     "spec/lamed/controller_spec.rb",
+     "spec/lamed/helper_spec.rb",
+     "spec/lamed/initializer_spec.rb",
+     "spec/lamed/model_spec.rb",
+     "spec/lamed/object_loader_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/lib/lamed/aws/authentication.rb

@@ -0,0 +1,105 @@
+module Aws
+  module Authentication
+    
+    include AWS
+    
+    AMAZON_ACCESS_KEY_ID = ENV['AMAZON_ACCESS_KEY_ID']
+    AMAZON_SECRET_ACCESS_KEY = ENV['AMAZON_SECRET_ACCESS_KEY']
+    SIGNATURE_VERSION = '2'
+    
+    def aws_access_key_id
+      AMAZON_ACCESS_KEY_ID
+    end
+    
+    def aws_secret_access_key
+      AMAZON_SECRET_ACCESS_KEY
+    end
+    
+    def new_digest
+      OpenSSL::Digest::Digest.new('sha256')
+    end
+    
+    def sign(string)
+      Base64.encode64(OpenSSL::HMAC.digest(new_digest, aws_secret_access_key, string)).strip
+    end
+    
+    # Escape the nonreserved AWS characters. Use this instead of URI.escape or CGI.escape
+    # See String#unpack for hex nibbles: http://ruby-doc.org/core/classes/String.html#M000760
+    def aws_escape(string)
+      string.to_s.gsub(/([^a-zA-Z0-9._~-]+)/n) { '%' + $1.unpack('H2' * $1.size).join('%').upcase }
+    end
+    
+    def aws_escape_params(params, opts = {})
+      request = params.merge(opts)
+      request.inject({}) { |h,(k,v)| h[aws_escape(k)] = aws_escape(v);h }
+    end
+    
+    def uri_escape_params(params, opts = {})
+      request = params.merge(opts)
+      request.inject({}) { |h,(k,v)| h[URI.escape(k.to_s)] = URI.escape(v.to_s);h }
+    end
+    
+    # Create an AWS signature
+    # From: http://docs.amazonwebservices.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/
+    # String to sign:
+    #   HTTPVerb + "\n" +
+    #   ValueOfHostHeaderInLowercase + "\n" +
+    #   HTTPRequestURI + "\n" +         
+    #   CanonicalizedQueryString
+    # Calculate an RFC 2104-compliant HMAC with the string you just created, your Secret Access Key as the key.
+    # We use SHA256 as the hash algorithm.
+    # Do not encode the signature here.  The string will be encoded when it's included in the query string.
+    #def aws_signature(httpverb, host, requesturi, params = {})
+    #  sorted_params = params.sort.inject({}) { |h,(k,v)| h[k] = v;h }
+    #  query_string = aws_escape_params(sorted_params).collect { |k,v| k + '=' + v }.join('&')
+    #  string_to_sign = "#{httpverb.to_s.upcase}\n#{host}\n#{requesturi}\n#{query_string}"
+    #  puts "STRING TO SIGN is " + string_to_sign.inspect
+    #  sign(string_to_sign)
+    #end
+    def generate_string_to_sign(httpverb, host, uri, params = {})
+      verb = httpverb.to_s.upcase
+      sorted_params = params.sort.inject({}) { |h,(k,v)| h[k] = v;h }
+      query_string = aws_escape_params(sorted_params).collect { |k,v| k + '=' + v }.join('&')
+      "#{verb}\n#{host}\n#{uri}\n#{query_string}"
+    end
+    
+    def generate_query(action, params = {})
+      request_hash = generate_request(action, params)
+      uri = url_path || "/"
+      uri = uri + "/" unless uri == "/"
+      string_to_sign = generate_string_to_sign(:get, @host, uri, request_hash)
+      signature = aws_signature(string_to_sign)
+      generate_query_string(request_hash, 'Signature' => signature)
+    end
+    
+    def aws_signature(string_to_sign)
+      sign(string_to_sign)
+    end
+    
+    def generate_request(action, params = {})
+      request = {
+        'Action' => action,
+        'SignatureMethod' => 'HmacSHA256',
+        'AWSAccessKeyId'  => aws_access_key_id,
+        'SignatureVersion' => SIGNATURE_VERSION
+      }
+      request.merge(default_params).merge(params)
+    end
+    
+    
+    def generate_query_string(params, opts = {})
+      query_hash = params.merge(opts)
+      query_string = URI.escape(query_hash.collect { |k,v| k.to_s + '=' + v.to_s }.join('&'))
+      query_string.gsub(/\+/, "%2B")   #encode pluses correctly 
+    end
+     
+    def generate_query(action, params = {})
+      request_hash = generate_request(action, params)
+      uri = url_path || "/"
+      uri = uri + "/" unless uri == "/"
+      string_to_sign = generate_string_to_sign(:get, @host, uri, request_hash)
+      signature = aws_signature(string_to_sign)
+      generate_query_string(request_hash, 'Signature' => signature)
+    end
+  end
+end

data/lib/lamed/aws/aws.rb

@@ -0,0 +1,25 @@
+require 'base64'
+require 'openssl'
+require 'time'
+require 'typhoeus'
+require 'crack'
+require 'uri'
+require 'cgi'
+
+module AWS
+  
+  include Typhoeus
+  include Crack
+  
+  # AWS time xml format: YYYY-MM-DDThh:mm:ssZ>  Zone is set to Z or UTC
+  def time_xml
+    Time.now.utc.xmlschema
+  end
+  
+  def http_get_xml(host, path, request_params)
+    path = path == "/" ? path : path + "/"
+    req = path + "?" + request_params
+    res = Request.get(@host + req)
+    XML.parse res.body
+  end
+end

data/lib/lamed/aws/sqs.rb

@@ -0,0 +1,142 @@
+module Aws
+  module Sqs
+    
+    DEFAULT_HOST = 'queue.amazonaws.com'
+    API_VERSION = '2009-02-01'
+    
+    class Queue
+      
+      include Aws::Authentication
+      include Aws
+      include Crack
+      
+      REQUEST_TTL = 600
+      
+      attr_reader :host, :path, :expires
+      
+      def initialize(queue_name = nil)
+        @host       = DEFAULT_HOST
+        @queue_name = queue_name
+        @path = queue_name.nil? ? "/" : get_http_path if @path.nil?
+      end
+      
+      # Get the queue path using Action = +ListQueues+ and additional param +QueneNamePrefix+.
+      # Example response +/12345678012/exampleQueue+
+      def get_http_path
+        action = 'ListQueues'
+        params = { "QueueNamePrefix" => @queue_name }.merge(default_params)
+        path = url_path || ""
+        xml_doc = http_get_xml(@host, path, generate_query(action, params))
+        url = (xml_doc["ListQueuesResponse"]["ListQueuesResult"]["QueueUrl"])
+        url = url[0] if Array === url
+        URI.parse(url).path
+      end
+      
+      def url_path
+        @path || '/'
+      end
+      
+      # List all the queues that start with the prefix.
+      def list_queues(prefix = "")
+        action = "ListQueues"
+        @path = "/"
+        available_queues = Array.new
+        xml_doc = http_get_xml(@host, path, generate_query(action, default_params))
+        if xml_doc["ListQueuesResponse"]["ListQueuesResult"]["QueueUrl"]
+          xml_doc["ListQueuesResponse"]["ListQueuesResult"]["QueueUrl"].each do |url|
+            available_queues << url.split("/").last
+          end
+        end
+        available_queues
+      end
+      
+      def attributes
+        action = "GetQueueAttributes"
+        params = { "AttributeName" =>"All" }.merge(default_params)
+        http_get_xml(@host, @path, generate_query(action, params))
+      end
+      
+      def create(queue_name)
+        action = "CreateQueue"
+        params = { "QueueName" => queue_name}
+        params.merge!(default_params)
+        @path = "/"
+        http_get_xml(@host, @path, generate_query(action, params))
+      end
+      
+      def send(message, send_params = nil)
+        action = "SendMessage"
+        params = { "MessageBody" => message }.merge(default_params)
+        http_get_xml(@host, url_path, generate_query(action, params))
+      end
+      
+      def receive(receive_params = {})
+        action = "ReceiveMessage"
+        params = { 
+                  "MaxNumberOfMessages" => receive_params[:number] || 1,
+                  "AttributeName"       => "All" }
+        params["VisibilityTimeout"] = receive_params[:timeout] if receive_params[:timeout]
+        params.merge!(default_params)
+        xml = http_get_xml(@host, url_path, generate_query(action, params))
+        
+        if !xml["ReceiveMessageResponse"]["ReceiveMessageResult"].nil?
+          message = xml["ReceiveMessageResponse"]["ReceiveMessageResult"]["Message"]
+          @message_body = message["Body"]
+          @message_attribute = message["Attribute"]
+          @receipt_handle = message["ReceiptHandle"]
+          @message = message
+        else
+          nil
+        end
+      end
+      
+      def receipt_handle
+        @receipt_handle
+      end
+      
+      def message
+        @message
+      end
+      
+      def message_body
+        @message_body
+      end
+      
+      def message_attributes
+        @message_attribute
+      end
+      
+      def delete(receipt_handle)
+        action = "DeleteMessage"
+        #unescaped_handle = URI.unescape(receipt_handle)
+        params = { "ReceiptHandle" => receipt_handle }.merge(default_params)
+        http_get_xml(@host, url_path, generate_query(action, params))
+      end
+      
+      def delete_queue
+        action = "DeleteQueue"
+        params = default_params
+        http_get_xml(@host, url_path, generate_query(action, params))
+      end
+      
+      # +time+ is expressed as a string.
+      def expires(time = nil)
+        if !time
+          (Time.now.utc + REQUEST_TTL).xmlschema
+        else
+          (Time.parse(time) + REQUEST_TTL).xmlschema
+        end
+      end
+      
+      def default_params
+        request = {
+          'Expires' => expires,
+          'Version' => API_VERSION
+        }
+      end
+      
+      def create_request(uri, query_string = nil)
+      end
+    end  
+  end
+end

data/lib/lamed/controller.rb

@@ -5,64 +5,68 @@ module Lamed
     
     include Rack
     include Lamed::Helper
-    extend Lamed::Helper
+    #extend Lamed::Helper
     include Lamed::Model
-              
-    attr_accessor :query, :path, :self_path, :env
-  
-    def set_self_path(str)
+      
+    def self_path(str)
       @self_path = str
     end
-  
-    def parse_uri(request_path)
+    
+    def req_params
+      env
+    end
+    
+    def content_type(content_type)
+      req_params[:content_type] = content_type
+    end
+    
+    def user_agent
+      req_params['HTTP_USER_AGENT']
+    end
+    
+    # Find the uri's as and array of symbols from the request_path
+    def uri(request_path)
       begin
         uri = (request_path.split("/").collect {|r| r.downcase.intern unless r.empty?}).compact
       rescue NoMethodError
         uri = Array.new
       end
-      return uri
+      @uri = uri
     end
-
-    def parse_query_string(query_string)
+    
+    # Build param symbols from the query string
+    def params(query_string)
       begin
-        params = query_string.split('&').inject({}) { |h,(k,v)|
+        params_prime = query_string.split('&').inject({}) { |h,(k,v)|
           values = k.split('=')
           # Drop any query params that have blank values
           h[values[0].downcase.intern] = (CGI.unescape(values[1])).downcase if values.length == 2 
           h
         }
       rescue NoMethodError => e
-        params = Hash.new
+        params_prime = Hash.new
       end
-      return params
+      params_prime
     end
-  
-    def call(env)
-      @env = env
-      env[:query] = self.parse_query_string(env['QUERY_STRING'])
-      env[:path] = self.parse_uri(env['SCRIPT_NAME'])
-      response(env)
-      resp = @req_params
+    
+    def call
+      #@env = env unless defined?(@env)
+      env[:query] = self.params(env['QUERY_STRING'])
+      env[:path] = self.uri(env['SCRIPT_NAME'])
+      response
+      resp = req_params
       status_code = resp[:status_code] || 200
       content_type = resp[:content_type] || "text/html"
       [status_code, {"Content-Type" => content_type}, [resp[:body]]]
     end
-
+    
+    # This is just a reminder that I need to add something here
     def request(*args)
     end
   
-    def response(req_params)
-     @req_params = req_params
-     @req_params[:body] = self.render
-     return @req_params
-    end
-  
-    def content_type(content_type)
-      @req_params[:content_type] = content_type
-    end
-    
-    def user_agent
-      @env['HTTP_USER_AGENT']
+    def response
+     req_params[:body] = self.render
+     #return @req_params
     end
   end
 end

data/lib/lamed/initializer.rb

@@ -5,6 +5,9 @@ require 'memcached'
 require 'cgi'
 require 'lib/lamed/helper'
 require 'lib/lamed/object_loader'
+require 'lib/lamed/aws/aws'
+require 'lib/lamed/aws/authentication'
+require 'lib/lamed/aws/sqs'
 
 module Lamed
   
@@ -69,6 +72,10 @@ module Lamed
       @logger
     end
     
+    def opts
+      @opts = SYS_OPTIONS
+    end
+    
     def load_lib
       Dir[ROOT + '/lib/**/*.rb'].each {|f| load f}
     end

data/lib/lamed/main.rb

@@ -16,6 +16,8 @@ module Rack
     
     def run_apps
       use Rack::Lint
+      use Rack::ShowExceptions
+      use Rack::CommonLogger
       ObjectLoader.mapped_class.each_pair do |path, klass|
         map path do
           run klass.new

data/lib/lamed/model.rb

@@ -1,14 +1,38 @@
 require 'mysql'
-require 'lib/lamed/redis'
+require 'dm-core'
+require 'dm-types'
+require 'dm-aggregates'
+#require 'lib/lamed/redis'
+require 'redis'
 
 module Lamed
   
   module Model
+        
+    #LAME_ROOT = ::LAME_ROOT unless defined?(LAME_ROOT)
+  
+  end
+  
+  # Support for DataMapper
+  class DM
     
-    #include Lamed
+    #include DataMapper::Resource
+    include DataMapper
     
-    LAME_ROOT = ::LAME_ROOT unless defined?(LAME_ROOT)
-  
+    # Setup the database connection using DataMapper
+    def initialize(params = {})
+      @host          = params[:host]      || 'localhost'
+      @port          = (params[:port]     || 3306).to_i
+      @user          = params[:username]  || 'root'
+      @password      = params[:password]  || 'pwd'
+      @database      = params[:database]  || 'ithingy'
+      @adapter       = params[:adapter]   || 'mysql'
+      self.connect
+    end
+    
+    def connect(params = {})
+      DataMapper.setup(:default, "#{@adapter}://#{@user}:#{@password}@#{@host}:#{@port}/#{@database}")
+    end
   end
   
   class MySQL < Mysql
@@ -67,4 +91,31 @@ module Lamed
       return res
     end
   end
+end
+
+class Redis
+  
+  # Adding namespace or prefix keys to redis SET and GET request much like memcache.
+  
+  $SYS_OPTIONS = {} unless defined?($SYS_OPTIONS)
+  
+  REDIS_OPTIONS = {
+    :host    =>  $SYS_OPTIONS[:redis_host]     || '127.0.0.1' ,
+    :port    => ($SYS_OPTIONS[:redis_port]    || 6379).to_i,
+    :db      => ($SYS_OPTIONS[:redis_db]      || 0).to_i,
+    :timeout => ($SYS_OPTIONS[:redis_timeout] || 5).to_i,
+  }
+  
+  def initialize(host, opts={})
+    @host    = host           || REDIS_OPTIONS[:host]
+    @port    = opts[:port]    || REDIS_OPTIONS[:port]
+    @db      = opts[:db]      || REDIS_OPTIONS[:db]
+    @timeout = opts[:timeout] || REDIS_OPTIONS[:timeout]
+    $debug   = opts[:debug]
+    connect_to_server
+  end
+  
+  def load
+  end
+  
 end

data/lib/lamed/redis.rb

@@ -22,4 +22,7 @@ class Redis
     connect_to_server
   end
   
+  def load
+  end
+  
 end

data/spec/examples/conf/config.yml

@@ -1,2 +1,11 @@
 development:
+  main_cache: ['127.0.0.1:11211']
+  redis_host: '127.0.0.1'
+  redis_port: 6389
+  http_procs: 1
+  workers: 1
+  port: 3000
+  run_as: reco
+  pid: /var/run/
+  logs: /var/log/nutsie_radio
   rotate: daily

data/spec/examples/ext/controllers/hello_world.rb

@@ -1,7 +1,8 @@
 class HelloWorld < Lamed::Controller
   
   def say_hello
-    @req_params[:content_type] = 'text/html'
+    content_type = 'text/html'
+    puts env
     hello = "Hello World.  We just got LaMeD!"
     return hello
   end

data/spec/examples/ext/controllers/lamest/bar.rb

@@ -1,7 +1,7 @@
 class Bar < Lamed::Controller
   
   def say_hello
-    @req_params[:content_type] = 'text/html'
+    content_type = 'text/html'
     hello = "Hello.  This is the #{self.to_s} controller"
     return hello
   end

data/spec/examples/ext/controllers/lamest/foo.rb

@@ -1,7 +1,7 @@
 class Foo < Lamed::Controller
 
   def say_hello
-    @req_params[:content_type] = 'text/html'
+    content_type = 'text/html'
     hello = "Hello.  This is the #{self.to_s} controller"
     return hello
   end

data/spec/examples/ext/models/bar_model.rb

@@ -1,2 +1,8 @@
-class BarModel < Lamed::MySQL
+class BarModel
+  
+  include DataMapper::Resource
+  
+  property :id,    Serial, :length => 10
+  property :title, String, :length => 64, :key => true
+  
 end

data/spec/lamed/aws/authentication_spec.rb

@@ -0,0 +1,58 @@
+LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+ENV['AMAZON_ACCESS_KEY_ID'] = 'THISISTHEACCESSKEYYO'
+ENV['AMAZON_SECRET_ACCESS_KEY'] = 'THISISTHESECRETACCESSKEYYEAHBOISHOOBIDOO'
+
+require 'lib/lamed/aws/aws'
+require 'lib/lamed/aws/authentication'
+
+include Aws::Authentication
+
+describe Aws::Authentication do
+  
+  it "should get AWS access id, secret, and new digest from system" do
+    aws_access_key_id.should == 'THISISTHEACCESSKEYYO'
+    aws_secret_access_key.should == 'THISISTHESECRETACCESSKEYYEAHBOISHOOBIDOO'
+    new_digest.inspect.should =~ /\#<OpenSSL::Digest::Digest:/
+  end
+  
+  it "should escape string in an AWS friendly way" do
+    string = 'Hello World. This:is:not-what-you-want'
+    aws_escape(string).should == 'Hello%20World.%20This%3Ais%3Anot-what-you-want'
+  end
+  
+  it "should escape params in an AWS friendly way" do
+    hash = {
+      'foo'     => 'Hello World',
+      'foo:bar' => 'Rock-around-the-world'
+    }
+    aws_escape_params(hash).should == {"foo"=>"Hello%20World", "foo%3Abar"=>"Rock-around-the-world"}
+  end
+  
+  it "should URI escape params" do
+    hash = {
+      'foo'     => 'Hello World',
+      'foo:bar' => 'Rock-around-the-world'
+    }
+    uri_escape_params(hash, :ho => 'test').should == {"foo"=>"Hello%20World", "foo:bar"=>"Rock-around-the-world", "ho"=> "test"}
+  end
+  
+  it "should generate the string to sign" do
+    self.should_receive(:default_params).and_return("foo" => 'bar')
+    uri = '/123456789012/exampleQueue'
+    httpverb = "GET"
+    host = 'queue.amazonaws.com'
+    generate_string_to_sign(httpverb, host, uri, params = {}).should == ''
+  end
+  
+  it "should generate the query using action ListQueues" do
+    self.should_receive(:default_params).and_return("foo" => 'bar')
+    self.should_receive(:url_path).and_return('/123456789012/exampleQueue')
+    action = "ListQueues"
+    params = { 'QueueNamePrefix' => 'exampleQueue' } 
+    generate_query(action, params).should == ''
+  end
+  
+end

data/spec/lamed/aws/spec.rb

@@ -0,0 +1,13 @@
+LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'time'
+require 'lib/lamed/aws/aws'
+
+include AWS
+describe "Return time object in xmlschema format" do
+  it "should return a time string in xml schema format" do
+    time_xml.should == Time.now.utc.xmlschema
+  end
+end

data/spec/lamed/aws/sqs_spec.rb

@@ -0,0 +1,95 @@
+#LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+#ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+                               
+ENV['AMAZON_ACCESS_KEY_ID'] = 'THISISTHEACCESSKEYYO'
+ENV['AMAZON_SECRET_ACCESS_KEY'] = 'THISISTHESECRETACCESSKEYYEAHBOISHOOBIDOO'
+                                       
+require 'lib/lamed/aws/aws'
+require 'lib/lamed/aws/authentication'
+require 'lib/lamed/aws/sqs'
+require 'spec_helper.rb'
+
+include Aws
+
+describe Aws::Sqs::Queue do
+end
+=begin
+  #it "should initialize a queue" do
+  #  sqs = Sqs::Queue.new('prod_scs_completed_imports')
+  #end
+  
+  before(:each) do
+    @sqs = Sqs::Queue.new()
+  end
+  
+  it "should generate a request hash" do
+    @sqs.generate_request('ListQueues').should == {
+                                                   "Action"           => "ListQueues",
+                                                   "SignatureMethod"  => "HmacSHA256",
+                                                   "AWSAccessKeyId"   => ENV['AMAZON_ACCESS_KEY_ID'],
+                                                   "SignatureVersion" => "2",
+                                                   "Expires"          => @sqs.expires,
+                                                   "Version"          => "2009-02-01"
+                                                   }
+  end
+
+  it "should generate the string that will be signed" do
+    params = {
+               "Action"           => "ListQueues",
+               "SignatureMethod"  => "HmacSHA256",
+               "AWSAccessKeyId"   => ENV['AMAZON_ACCESS_KEY_ID'],
+               "SignatureVersion" => "2",
+               "Expires"          => "2010-02-10T21:24:40Z",
+               "Version"          => "2009-02-01"
+               }
+    @sqs.generate_string_to_sign(:get, 'queue.amazonaws.com', '/', params).should == "GET\nqueue.amazonaws.com\n/\nAWSAccessKeyId=" +
+                                                                                    "THISISTHEACCESSKEYYO&Action=ListQueues&Expires=" + 
+                                                                                    "2010-02-10T21%3A24%3A40Z&SignatureMethod=" + 
+                                                                                    "HmacSHA256&SignatureVersion=2&Version=2009-02-01"
+  end
+
+  it "should generate a request signature" do
+    string_to_sign = "GET\nqueue.amazonaws.com\n/\nAWSAccessKeyId=" +
+                     "1NK7GFJZMZPXRPE6S802&Action=ListQueues&Expires=" + 
+                     "2010-02-10T21%3A24%3A40Z&SignatureMethod=" + 
+                     "HmacSHA256&SignatureVersion=2&Version=2009-02-01"
+    @sqs.aws_signature(string_to_sign).should == 'UyAhOaBN7ye4GQ2lhgY3aYGUWy3Rb64S6Y6T/u/vb5o='
+  end
+
+  it "should generate a SQS query hash with queue list request" do
+    @list_queue_query_string = @sqs.generate_query("ListQueues", 'QueueNamePrefix' => 'prod')
+    @list_queue_query_string.should =~ /Action=ListQueues&SignatureMethod=HmacSHA256&AWSAccessKeyId=THISISTHEACCESSKEYYO&SignatureVersion=2&Expires=/
+  end
+
+  it "should create a new queue" do
+    @sqs.create("test_scs_completed_imports").inspect.should =~ /CreateQueueResponse/
+  end
+  
+  it "should list a queue's attribute" do
+    @sqs.attributes.inspect.should =~ /GetQueueAttributesResponse/
+  end
+  
+  it "should get a url path for a SQS queue" do
+    @sqs.path.should == '/002611861940/test_scs_completed_imports'
+  end
+  
+  it "should send a message" do
+    msg = "This is a test"
+    @sqs.send(msg).inspect.should =~ /SendMessageResponse/
+  end
+  
+  it "should receive the test message" do
+    @sqs.receive
+    message = sqs.message
+    @@receipt_handle = message["ReceiptHandle"]
+    message.inspect.should =~ /MessageId/
+  end
+  
+  it "should delete the message from the queue" do
+    receipt_handle = @@receipt_handle
+    @sqs.delete(receipt_handle).inspect.should =~ /DeleteMessageResponse/
+  end
+end
+=end

data/spec/lamed/controller_spec.rb

@@ -0,0 +1,88 @@
+LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+#ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'rack'
+require 'spec_helper'
+require 'lib/lamed/model'
+require 'lib/lamed/helper'
+require 'lib/lamed/controller'
+
+module Lamed
+  
+  describe Controller do
+    
+    it "Controller should exist" do
+      Controller.should == Lamed::Controller
+    end
+    
+    it "Controller should have instance methods" do
+      Controller.instance_methods(false).sort.should == [:call, :content_type, :params, :req_params, :request, :response, :self_path, :uri, :user_agent]
+    end
+    
+    it "Controller should have methods" do
+      Controller.methods(false).sort.should == []
+    end
+    
+    let(:controller) { Controller.new }
+    let(:env) { { "GATEWAY_INTERFACE"=>"CGI/1.1", "PATH_INFO"=>"", "QUERY_STRING"=>"hello=test&foo=bar",
+           "REMOTE_ADDR"=>"127.0.0.1", "REMOTE_HOST"=>"radio.local", "REQUEST_METHOD"=>"GET",
+           "REQUEST_URI"=>"http://localhost:9292/hello_world?hello=test&foo=bar", "SCRIPT_NAME"=>"/hello_world",
+           "SERVER_NAME"=>"localhost", "SERVER_PORT"=>"9292", "SERVER_PROTOCOL"=>"HTTP/1.1",
+           "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.1/2009-12-07)", "HTTP_HOST"=>"localhost:9292",
+           "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7",
+           "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5",
+           "HTTP_ACCEPT_ENCODING"=>"gzip,deflate", "HTTP_ACCEPT_CHARSET"=>"UTF-8,*", "HTTP_KEEP_ALIVE"=>"300",
+           "HTTP_CONNECTION"=>"keep-alive", "HTTP_CACHE_CONTROL"=>"max-age=0", "rack.version"=>[1, 0],
+           "rack.multithread"=>true, "rack.multiprocess"=>false, "rack.run_once"=>false, "rack.url_scheme"=>"http",
+           "HTTP_VERSION"=>"HTTP/1.1", "REQUEST_PATH"=>"/hello_world" } }
+    
+    before(:each) do
+      controller.stub(:env).and_return(env)
+    end
+    
+    it "request_params" do
+      controller.req_params.should == {"GATEWAY_INTERFACE"=>"CGI/1.1", "PATH_INFO"=>"", "QUERY_STRING"=>"hello=test&foo=bar",
+        "REMOTE_ADDR"=>"127.0.0.1", "REMOTE_HOST"=>"radio.local", "REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"http://localhost:9292/hello_world?hello=test&foo=bar",
+        "SCRIPT_NAME"=>"/hello_world", "SERVER_NAME"=>"localhost", "SERVER_PORT"=>"9292", "SERVER_PROTOCOL"=>"HTTP/1.1",
+        "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.1/2009-12-07)", "HTTP_HOST"=>"localhost:9292",
+        "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7",
+        "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5",
+        "HTTP_ACCEPT_ENCODING"=>"gzip,deflate", "HTTP_ACCEPT_CHARSET"=>"UTF-8,*", "HTTP_KEEP_ALIVE"=>"300", "HTTP_CONNECTION"=>"keep-alive",
+        "HTTP_CACHE_CONTROL"=>"max-age=0", "rack.version"=>[1, 0], "rack.multithread"=>true, "rack.multiprocess"=>false, "rack.run_once"=>false,
+        "rack.url_scheme"=>"http", "HTTP_VERSION"=>"HTTP/1.1", "REQUEST_PATH"=>"/hello_world"}
+    end
+    
+    it "should set content type" do
+      controller.content_type('text/html').should == 'text/html'
+    end
+    
+    it "should get user_agent" do
+      controller.user_agent.should == 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.7) Gecko/20091221 Firefox/3.5.7'
+    end
+    
+    it "get uri" do
+      controller.uri(env["REQUEST_PATH"]).should == [:hello_world]
+    end
+    
+    it "get params" do
+      controller.params(env["QUERY_STRING"]).should == {:hello=>"test", :foo=>"bar"}
+    end
+    
+    it "set path" do
+      controller.self_path('/usr/pub').should == '/usr/pub'
+    end
+    
+    before(:each) do
+      controller.stub(:render).and_return('Hello World')
+    end
+    
+    it "should return a response" do
+        controller.response.should == 'Hello World'
+    end
+    
+    it "Controller.call" do
+      controller.call.should == [200, {"Content-Type"=>"text/html"}, ["Hello World"]]
+    end
+  end
+end

data/spec/{helpers_spec.rb → lamed/helper_spec.rb}

@@ -24,7 +24,7 @@ module Lamed
       string = "foo_bar"
       cameled_string = camelize_string string
       cameled_string.should == "FooBar"
-    end
+     end
   
     it "should uncamelize a cameled string into an uncameled _ seperated string" do
       string = "FooBar"

data/spec/lamed/initializer_spec.rb

@@ -0,0 +1,42 @@
+LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'rack'
+require 'lib/lamed/initializer'
+require 'spec/examples/ext/models/bar_model'
+
+  
+describe "Initialize all Lamed Objects" do
+  it "should initialize the logger to STDERR" do
+    Lamed.logger.level.should == 0
+  end
+  
+  it "should initialize options to opts" do
+    Lamed.opts.should == {:main_cache=>["127.0.0.1:11211"], :redis_host=>"127.0.0.1", :redis_port=>6389, :http_procs=>1,
+                          :workers=>1, :port=>3000, :run_as=>"reco", :pid=>"/var/run/", :logs=>"/var/log/nutsie_radio",
+                          :rotate=>"daily"}
+  end
+  
+  it "should initialize the Controller, Lib, and Model objects" do
+    Lamed::Model.constants.should == [:BarModel, :FooModel]
+    Lamed::Controller.constants.sort.should == [:HelloWorld, :Lamest, :BarModel, :FooModel, :VERSION, :Cascade, :Chunked,
+                                           :ConditionalGet, :ContentLength, :ContentType, :File, :Deflater, :Directory,
+                                           :ForwardRequest, :Handler, :Head, :Lint, :Lock, :MethodOverride, :Mime,
+                                           :Recursive, :Reloader, :ShowStatus, :Static, :URLMap, :MockRequest,
+                                           :MockResponse, :Response, :Auth, :Session, :Adapter, :Builder, :CommonLogger,
+                                           :Utils, :Request, :ShowExceptions, :Template, :ContextMiss, :Context].sort
+    Object.constants.include?(:FooLib).should == true
+  end  
+end
+
+describe BarModel do
+  it "should load BarModel" do
+    BarModel.new.inspect.should =~ /BarModel @id=nil @title=nil/
+    BarModel.instance_variables.should == [:@valid, :@base_model, :@storage_names, :@default_order, :@descendants, :@relationships, :@properties,
+                                           :@field_naming_conventions, :@paranoid_properties, :@resource_methods]
+  end
+  
+  it "return title request" do
+  end
+end

data/spec/lamed/model_spec.rb

@@ -0,0 +1,42 @@
+LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
+ROOT = File.join(LAME_ROOT, "/spec/examples")
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+require 'spec_helper'
+require 'lib/lamed/model'
+
+module Lamed
+  describe Model do
+    
+    it "Model should exist" do
+      Model.should == Lamed::Model
+    end
+    
+    it "should have instance methods" do
+      Model.instance_methods(false).should == []
+    end
+    
+    it "should have methods" do
+      Model.methods(false).should == []
+    end
+  end
+  
+  describe DM do
+    
+    let(:dm) { DM.new(:host => 'localhost') }
+    
+    it "should intialize DM" do
+      #dm = DM.new(:host => 'localhost')
+      dm.inspect.should =~ /Lamed/
+    end
+    
+    it "should connect to the database with defaults" do
+      dm.connect.inspect.should =~ /DataMapper::Adapters::MysqlAdapter/
+    end
+  end
+  
+  describe MySQL do
+    
+    it "should initialize DM"
+  end
+end

data/spec/{object_loader_spec.rb → lamed/object_loader_spec.rb}

@@ -93,7 +93,7 @@ module Lamed
     
     it "should load up controllers" do
       ObjectLoader.load_controller_object
-      Lamed.constants.should == [:Helper, :Model, :MySQL, :Controller, :ObjectLoader]
+      Lamed.constants.should == [:Helper, :Model, :DM, :MySQL, :Controller, :ObjectLoader]
       Lamed::Controller.constants.sort.should == [:Adapter, :Auth, :Builder, :Cascade, :Chunked, :CommonLogger,
                                                   :ConditionalGet, :ContentLength, :ContentType, :Context, :ContextMiss,
                                                   :Deflater, :Directory, :File, :ForwardRequest, :Handler, :Head, 
@@ -106,10 +106,8 @@ module Lamed
     
     it "should load up models" do
       ObjectLoader.load_model_object
-      Lamed.constants.should == [:Helper, :Model, :MySQL, :Controller, :ObjectLoader]
+      Lamed.constants.should == [:Helper, :Model, :DM, :MySQL, :Controller, :ObjectLoader]
       Lamed::Model.constants.should == [:BarModel, :FooModel]
-    end
-    
-  end
-  
+    end    
+  end  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lamed
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - Lee Chang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-19 00:00:00 -08:00
+date: 2010-04-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,9 @@ files:
 - VERSION
 - lamed.gemspec
 - lib/lamed.rb
+- lib/lamed/aws/authentication.rb
+- lib/lamed/aws/aws.rb
+- lib/lamed/aws/sqs.rb
 - lib/lamed/controller.rb
 - lib/lamed/helper.rb
 - lib/lamed/initializer.rb
@@ -69,10 +72,14 @@ files:
 - spec/examples/ext/views/lamest/bar.mustache
 - spec/examples/ext/views/lamest/foo.mustache
 - spec/examples/lib/foo_lib.rb
-- spec/helpers_spec.rb
-- spec/initializer_spec.rb
-- spec/lame_spec.rb
-- spec/object_loader_spec.rb
+- spec/lamed/aws/authentication_spec.rb
+- spec/lamed/aws/spec.rb
+- spec/lamed/aws/sqs_spec.rb
+- spec/lamed/controller_spec.rb
+- spec/lamed/helper_spec.rb
+- spec/lamed/initializer_spec.rb
+- spec/lamed/model_spec.rb
+- spec/lamed/object_loader_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
@@ -110,8 +117,12 @@ test_files:
 - spec/examples/ext/models/bar_model.rb
 - spec/examples/ext/models/foo_model.rb
 - spec/examples/lib/foo_lib.rb
-- spec/helpers_spec.rb
-- spec/initializer_spec.rb
-- spec/lame_spec.rb
-- spec/object_loader_spec.rb
+- spec/lamed/aws/authentication_spec.rb
+- spec/lamed/aws/spec.rb
+- spec/lamed/aws/sqs_spec.rb
+- spec/lamed/controller_spec.rb
+- spec/lamed/helper_spec.rb
+- spec/lamed/initializer_spec.rb
+- spec/lamed/model_spec.rb
+- spec/lamed/object_loader_spec.rb
 - spec/spec_helper.rb

data/spec/initializer_spec.rb

@@ -1,26 +0,0 @@
-LAME_ROOT =  File.join(File.dirname(__FILE__), '..')
-ROOT = File.join(LAME_ROOT, "/spec/examples")
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
-
-require 'rack'
-require 'lib/lamed/initializer'
-
-  
-  describe "Initialize all Lamed Objects" do
-    it "should initialize the logger to STDERR" do
-      Lamed.logger.level.should == 0
-    end
-    
-    it "should initialize the Controller, Lib, and Model objects" do
-      Lamed::Model.constants.should == [:BarModel, :FooModel]
-      Lamed::Controller.constants.sort.should == [:HelloWorld, :Lamest, :BarModel, :FooModel, :VERSION, :Cascade, :Chunked,
-                                             :ConditionalGet, :ContentLength, :ContentType, :File, :Deflater, :Directory,
-                                             :ForwardRequest, :Handler, :Head, :Lint, :Lock, :MethodOverride, :Mime,
-                                             :Recursive, :Reloader, :ShowStatus, :Static, :URLMap, :MockRequest,
-                                             :MockResponse, :Response, :Auth, :Session, :Adapter, :Builder, :CommonLogger,
-                                             :Utils, :Request, :ShowExceptions, :Template, :ContextMiss, :Context].sort
-      Object.constants.include?(:FooLib).should == true
-    end
-    
-  end
-  

data/spec/lame_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Lamed" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end