ramaze 0.3.0 → 0.3.5

data/lib/ramaze.rb

@@ -23,6 +23,7 @@ Thread.abort_on_exception = true
 require 'ramaze/version'
 require 'ramaze/snippets'
 require 'ramaze/inform'
+require 'ramaze/route'
 require 'ramaze/global'
 require 'ramaze/cache'
 require 'ramaze/tool'
@@ -36,7 +37,6 @@ require 'ramaze/sourcereload'
 require 'ramaze/dispatcher'
 require 'ramaze/template/ezamar'
 require 'ramaze/contrib'
-require 'ramaze/controller/main'
 
 module Ramaze
 
@@ -52,7 +52,8 @@ module Ramaze
     # each class in trait[:essentials] by calling ::startup on them.
 
     def startup options = {}
-      runner = options.delete(:runner) || caller[0].split(':').first
+      runner_from_caller = caller[0][/^(.*?):\d+/, 1]
+      runner = options.delete(:runner) || runner_from_caller
 
       if $0 == runner or options.delete(:force)
         Inform.info("Starting up Ramaze (Version #{VERSION})")

data/lib/ramaze/action.rb

@@ -80,17 +80,13 @@ module Ramaze
       default = controller.trait.fetch(:engine, Template::Ezamar)
       return default unless template
 
-      engines = Template::ENGINES
-      return default if engines.empty?
-
-      ext = File.extname(template).gsub(/^\./, '')
-      ext_engines = engines.reject{|k,v| not v.include?(ext) }
-
-      if ext_engines.has_key?(default)
-        self[:engine] = default
-      else
-        self[:engine] = ext_engines.keys.sort.first
+      Template::ENGINES.sort_by{|v| v.join}.each do |(engine, exts)|
+        if template =~ /\.(#{Regexp.union(*exts)})$/
+          return self[:engine] = engine
+        end
       end
+
+      self[:engine] = default
     end
 
     # Returns an instance of controller, will be cached on first access.

data/lib/ramaze/adapter/lsws.rb

@@ -0,0 +1,19 @@
+require 'ramaze/adapter'
+
+module Ramaze::Adapter
+
+  # Our Lsws adapter acts as wrapper for the Rack::Handler::LSWS.
+  class Lsws < Base
+    class << self
+
+      # start Lsws in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def run_server host = nil, ports = nil
+        Thread.new do
+          Rack::Handler::LSWS.run(self)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/email.rb

@@ -0,0 +1,84 @@
+# EmailHelper can be used as a simple way to send basic e-mails from your app.
+#
+# Usage:
+#
+#   require 'ramaze/contrib/email'
+#
+#   # Set the required traits:
+#   Ramaze::EmailHelper.trait[ :smtp_server ] = 'smtp.your-isp.com'
+#   Ramaze::EmailHelper.trait[ :smtp_helo_domain ] = "originating-server.com"
+#   Ramaze::EmailHelper.trait[ :smtp_username ] = 'username'
+#   Ramaze::EmailHelper.trait[ :smtp_password ] = 'password'
+#   Ramaze::EmailHelper.trait[ :sender_address ] = 'no-reply@your-domain.com'
+#
+#   # Optionally, set some other traits:
+#   Ramaze::EmailHelper.trait[ :smtp_auth_type ] = :login
+#   Ramaze::EmailHelper.trait[ :bcc_addresses ] = [ 'admin@your-domain.com' ]
+#   Ramaze::EmailHelper.trait[ :sender_full ] = 'MailBot <no-reply@your-domain.com>'
+#   Ramaze::EmailHelper.trait[ :id_generator ] = lambda { "<#{Time.now.to_i}@your-domain.com>" }
+#   Ramaze::EmailHelper.trait[ :subject_prefix ] = "[SiteName]"
+#
+# To send an e-mail:
+#
+#   Ramaze::EmailHelper.send(
+#     "foo@foobarmail.com",
+#     "Your fooness",
+#     "Hey, you are very fooey!"
+#   )
+
+require 'net/smtp'
+
+module Ramaze
+  class EmailHelper
+    # Required to be set
+    trait :smtp_server => 'smtp.your-isp.com'
+    trait :smtp_helo_domain => 'your.helo.domain.com'
+    trait :smtp_username => 'no-username-set'
+    trait :smtp_password => ''
+    trait :sender_address => 'no-reply@your-domain.com'
+
+    # Optionally set
+    trait :smtp_port => 25
+    trait :smtp_auth_type => :login
+    trait :bcc_addresses => []
+    trait :sender_full => nil
+    trait :id_generator => lambda { "<" + Time.now.to_i.to_s + "@" + trait[ :smtp_helo_domain ] + ">" }
+    trait :subject_prefix => ""
+
+    class << self
+      def send(recipient, subject, message)
+        {:recipient => recipient, :subject => subject, :message => message}.each do |k,v|
+          if v.nil? or v.empty?
+            raise(ArgumentError, "EmailHelper error: Missing or invalid #{k}: #{v.inspect}")
+          end
+        end
+        sender = trait[:sender_full] || "#{trait[:sender_address]} <#{trait[:sender_address]}>"
+        subject = [trait[:subject_prefix], subject].join(' ').strip
+        id = trait[:id_generator].call
+        email = %{From: #{sender}
+To: <#{recipient}>
+Date: #{Time.now.rfc2822}
+Subject: #{subject}
+Message-Id: #{id}
+
+#{message}
+}
+
+        send_smtp( email, recipient, subject )
+      end
+
+      def send_smtp( email, recipient, subject )
+        options = trait.values_at(:smtp_server, :smtp_port, :smtp_helo_domain,
+                                  :smtp_username, :smtp_password, :smtp_auth_type)
+                                  
+        Net::SMTP.start( *options ) do |smtp|
+          smtp.send_message( email, trait[ :sender_address ], Array[ recipient, *trait[ :bcc_addresses ] ] )
+          Inform.info "E-mail sent to #{recipient} - '#{subject}'"
+        end
+      rescue => e
+        Inform.error "Failed to send e-mail to #{recipient}"
+        Inform.error e
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/email.rb-darcs-backup0

@@ -0,0 +1,81 @@
+# EmailHelper can be used as a simple way to send basic e-mails from your app.
+#
+# Usage:
+#
+#   require 'ramaze/contrib/email'
+#
+#   # Set the required traits:
+#   EmailHelper.trait[ :smtp_server ] = 'smtp.your-isp.com'
+#   EmailHelper.trait[ :smtp_helo_domain ] = "originating-server.com"
+#   EmailHelper.trait[ :smtp_username ] = 'username'
+#   EmailHelper.trait[ :smtp_password ] = 'password'
+#   EmailHelper.trait[ :sender_address ] = 'no-reply@your-domain.com'
+#
+#   # Optionally, set some other traits:
+#   EmailHelper.trait[ :smtp_auth_type ] = :login
+#   EmailHelper.trait[ :bcc_addresses ] = [ 'admin@your-domain.com' ]
+#   EmailHelper.trait[ :sender_full ] = 'MailBot <no-reply@your-domain.com>'
+#   EmailHelper.trait[ :id_generator ] = lambda { "<#{Time.now.to_i}@your-domain.com>" }
+#   EmailHelper.trait[ :subject_prefix ] = "[SiteName]"
+#
+# To send an e-mail:
+#
+#   EmailHelper.send(
+#     "foo@foobarmail.com",
+#     "Your fooness",
+#     "Hey, you are very fooey!"
+#   )
+
+require 'net/smtp'
+
+module Ramaze
+  class EmailHelper
+    # Required to be set
+    trait :smtp_server => 'smtp.your-isp.com'
+    trait :smtp_helo_domain => 'your.helo.domain.com'
+    trait :smtp_username => 'no-username-set'
+    trait :smtp_password => ''
+    trait :sender_address => 'no-reply@your-domain.com'
+
+    # Optionally set
+    trait :smtp_port => 25
+    trait :smtp_auth_type => :login
+    trait :bcc_addresses => []
+    trait :sender_full => nil
+    trait :id_generator => lambda { "<" + Time.now.to_i.to_s + "@" + trait[ :smtp_helo_domain ] + ">" }
+    trait :subject_prefix => ""
+
+    class << self
+      def send(recipient, subject, message)
+        {:recipient => recipient, :subject => subject, :message => message}.each do |k,v|
+          raise(ArgumentError, "EmailHelper error: Missing or invalid #{k}: #{v.inspect}")
+        end
+        sender = trait[:sender_full] || "#{trait[:sender_address]} <#{trait[:sender_address]}>"
+        subject = [trait[:subject_prefix], subject].join(' ').strip
+        id = trait[:id_generator].call
+        email = %{From: #{sender}
+To: <#{recipient}>
+Date: #{Time.now.rfc2822}
+Subject: #{subject}
+Message-Id: #{id}
+
+#{message}
+}
+
+        send_smtp(email)
+      end
+
+      def send_smtp(email, recipient, subject, message)
+        options = trait.values_at(:smtp_server, :smtp_port, :smtp_helo_domain,
+                                  :smtp_username, :smtp_password, :smtp_auth_type)
+        Net::SMTP.start(*options) do |smtp|
+          smtp.send_message(email, sender_address, Array[recipient, *bcc_addresses])
+          Inform.info "E-mail sent to #{recipient} - '#{subject}'"
+        end
+      rescue => e
+        Inform.error "Failed to send e-mail to #{recipient}"
+        Inform.error e
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/gettext.rb

@@ -89,6 +89,7 @@ class Ramaze::Tool::Gettext < Ramaze::Tool::Localize
     dictionary.each do |locale, dict|
       keys.concat dict.keys
     end
+    keys.delete ""
 
     data = ::GetText::RGetText.generate(keys.compact.uniq.sort.map {|x| [x] })
     file = (trait[:file] % trait[:default_language]) + '.pot'

data/lib/ramaze/contrib/gettext/parser.rb

@@ -0,0 +1,46 @@
+# suppress load warning message
+verbose = $VERBOSE
+$VERBOSE = nil
+require 'gettext/rgettext'
+$VERBOSE = verbose
+
+module Ramaze::Tool::Gettext::Parser
+  module_function
+
+  TARGETS = Ramaze::Template::ENGINES.values.inject([]) do |exts, list|
+    list += exts
+  end
+
+  def target?(file)
+    TARGETS.include?(File.extname(file)[1..-1])
+  end
+
+  def parse(file, ary)
+    regex = Ramaze::Tool::Gettext.trait[:regex]
+    body = File.read(file)
+    body.gsub!(regex) do
+      msg = $1
+      unless msg.to_s.empty?
+        line_number = body[0..(body.index(msg))].split("\n").size
+        add_message(ary, msg, file, line_number)
+      end
+    end
+    return ary
+  end
+
+  def add_message(ary, msg, file, line_number)
+    loc = message_location(file, line_number)
+    if value = ary.assoc(msg)
+      value << loc
+    else
+      ary << [msg, loc]
+    end
+    return ary
+  end
+
+  def message_location(file, line_number)
+    file + ":line" + line_number.to_s
+  end
+end
+
+GetText::RGetText.add_parser(Ramaze::Tool::Gettext::Parser)

data/lib/ramaze/contrib/route.rb

@@ -1,55 +1,22 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-# Usage:
-#
-#   Ramaze.contrib :route
-#   Ramaze::Contrib::Route[ %r!^/(\d+\.\d{2})$! ] = "/price/%.2f"
-
 module Ramaze
   module Contrib
     class Route
       class << self
         def startup
-          trait :route => true
-          trait :routes => Dictionary.new
-          Ramaze::Controller::FILTER.put_before(:default, :routed)
+          warn "Ramaze::Contrib::Route is being deprecated, use Ramaze::Route instead"
         end
 
         def [](key)
-          trait[:routes][key]
+          Ramaze::Route.trait[:routes][key]
         end
 
         def []=(key, value)
-          trait[:routes][key] = value
+          Ramaze::Route.trait[:routes][key] = value
         end
       end
     end
   end
-
-  class Controller
-    class << self
-      def routed(path)
-        routes = Contrib::Route.trait[:routes]
-        routes.each do |key, val|
-          case
-          when key.is_a?(Regexp)
-            regex, pattern = key, val
-            if md = path.match(regex)
-              new_path = pattern % md.to_a[1..-1]
-              return resolve(new_path, :routed)
-            end
-          when val.respond_to?(:call)
-            if new_path = val.call(path, request)
-              return resolve(new_path, :routed)
-            end
-          else
-            Inform.error "Invalid route #{val}"
-          end
-        end
-
-        nil
-      end
-    end
-  end
 end

data/lib/ramaze/controller.rb

@@ -67,11 +67,9 @@ module Ramaze
           end
         end
 
-        if Global.mapping.empty?
-          Inform.warn("No Controllers mapped, will serve /public only.")
-        else
-          Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
-        end
+        require 'ramaze/controller/main' if Global.mapping.empty?
+
+        Inform.debug("mapped Controllers: #{Global.mapping.inspect}")
       end
 
       # checks paths for existance and logs a warning if it doesn't exist yet.
@@ -149,7 +147,7 @@ module Ramaze
       # Runs every given path through Controller::check_path
 
       def template_root path = nil
-        if path
+        if path and path = path.to_s
           message = "#{self}.template_root is #{path} which does not exist"
           check_path(path, message)
           @template_root = path

data/lib/ramaze/controller/resolve.rb

@@ -3,7 +3,7 @@
 
 module Ramaze
   class Controller
-    FILTER = [ :cached, :default ] unless defined?(FILTER)
+    FILTER = [ :cached, :routed, :default ] unless defined?(FILTER)
 
     class << self
 
@@ -43,6 +43,33 @@ module Ramaze
         nil
       end
 
+      # Routing filter
+      # Loops over Route.trait[:routes] to find a matching route
+
+      def routed(path)
+        Route.trait[:routes].each do |key, val|
+          if key.is_a?(Regexp)
+            if md = path.match(key)
+              new_path = val % md.to_a[1..-1]
+              return resolve(new_path, :routed)
+            end
+
+          elsif val.respond_to?(:call)
+            if new_path = val.call(path, request)
+              return resolve(new_path, :routed)
+            end
+
+          elsif val.is_a?(String)
+            return resolve(val, :routed) if path == key
+
+          else
+            Inform.error "Invalid route #{key} => #{val}"
+          end
+        end
+
+        nil
+      end
+
       # Default element of FILTER.
       # The default handler that tries to find the best match for the given
       # path in terms of Controller/method/template and given arguments.

data/lib/ramaze/dispatcher.rb

@@ -130,7 +130,7 @@ module Ramaze
 
       def set_cookie
         session.finalize
-        hash = {:value => session.session_id, :path => '/'}
+        hash = {:value => session.session_id}.merge(Session::COOKIE)
         response.set_cookie(Session::SESSION_KEY, hash)
       end
 

data/lib/ramaze/dispatcher/file.rb

@@ -1,6 +1,9 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
+require "time"
+require 'digest/md5'
+
 module Ramaze
   module Dispatcher
 
@@ -20,6 +23,9 @@ module Ramaze
 
         def process(path)
           return unless file = open_file(path)
+          if file == :NotModified
+            return response.build([], STATUS_CODE['Not Modified'])
+          end
           response.build(file, STATUS_CODE['OK'])
         end
 
@@ -31,6 +37,17 @@ module Ramaze
 
           if ::File.file?(file) or ::File.file?(file=file/'index')
             response['Content-Type'] = Tool::MIME.type_for(file) unless ::File.extname(file).empty?
+            mtime = ::File.mtime(file)
+            response['Last-Modified'] = mtime.httpdate
+            response['ETag']= Digest::MD5.hexdigest(file+mtime.to_s).inspect
+            if modified_since = request.env['HTTP_IF_MODIFIED_SINCE']
+              return :NotModified unless Time.parse(modified_since) < mtime
+            elsif match = request.env['HTTP_IF_NONE_MATCH']
+              # Should be a unique string enclosed in ""
+              # To avoiding more file reading we use mtime and filepath
+              # we could throw in inode and size for more uniqueness
+              return :NotModified if response['ETag']==match
+            end
             log(file)
             ::File.open(file, 'rb')
           end