ramaze 0.3.5 → 0.3.9

data/lib/ramaze/adapter/swiftiplied_mongrel.rb

@@ -1,7 +1,7 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-Ramaze::Inform.debug "Using Swiftiplied Mongrel"
+Ramaze::Log.debug "Using Swiftiplied Mongrel"
 
 require 'swiftcore/swiftiplied_mongrel'
 require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/thin.rb

@@ -1,21 +1,20 @@
 require 'thin'
-require 'ramaze/adapter'
 require 'rack/handler/thin'
 
 module Ramaze
-  module Adapter
+  Global.test_connections = true
 
+  module Adapter
     class Thin < Base
       class << self
 
         # start server on given host and port.
         def run_server host, port
           server = ::Thin::Server.new(host, port, self)
-          server.silent = true
+          ::Thin::Logging.silent = true
           server.timeout = 3
-          server.start
 
-          thread = Thread.new{ server.listen! }
+          thread = Thread.new{ server.start }
           thread[:adapter] = server
           thread
         end

data/lib/ramaze/adapter/webrick.rb

@@ -1,13 +1,13 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/adapter'
 require 'webrick'
 require 'rack/handler/webrick'
 
 module Ramaze
-  module Adapter
+  Global.test_connections = true
 
+  module Adapter
     # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
     class WEBrick < Base
       class << self
@@ -17,10 +17,10 @@ module Ramaze
           options = {
             :Port        => port,
             :BindAddress => host,
-            :Logger      => Inform,
+            :Logger      => Log,
             :AccessLog   => [
-              [Inform, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
-              [Inform, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+              [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+              [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
             ]
           }.merge(options)
 

data/lib/ramaze/cache.rb

@@ -41,7 +41,7 @@ module Ramaze
           klass = Global.cache_alternative.fetch(key, self)
           add_on(key, klass)
         }
-        Inform.dev("Added caches for: #{keys.join(', ')}")
+        Log.dev("Added caches for: #{keys.join(', ')}")
       end
 
       def add_on(key, cache_class)

data/lib/ramaze/cache/memcached.rb

@@ -39,7 +39,7 @@ module Ramaze
     def method_missing(*args, &block)
       @cache.__send__(*args, &block)
     rescue MemCache::MemCacheError => e
-      Ramaze::Inform.error e.to_s
+      Log.error e.to_s
       nil
     end
 

data/lib/ramaze/contrib.rb

@@ -2,21 +2,81 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # Loads and sets up contrib modules.
+  #
+  # For more information @see Ramaze::Contrib.load
+  #
+  # Usage:
+  #
+  #   Ramaze.contrib :gzip_filter
+
   def self.contrib(*args)
-    Ramaze::Contrib.load *args
+    Contrib.load *args
   end
 
+  # A module used for loading contrib modules.
+
   module Contrib
-    class << self
-      def load(*contribs)
-        contribs.each do |name|
-          require 'ramaze/contrib'/name
-          const = Ramaze::Contrib.const_get(name.to_s.camel_case)
-          Ramaze::Global.contribs << const
+
+    # Loads and sets up contrib modules from /ramaze/contrib.
+    #
+    # === Usage:
+    #
+    #   Ramaze::Contrib.load :gzip_filter
+    #
+    # === Creating a contrib module:
+    #
+    #   module Ramaze::Contrib::Test
+    #     def self.setup
+    #       Log.info "Test module set up"
+    #     end
+    #   end
+    #   class TestController < Ramaze::Controller
+    #     map '/test'
+    #     def index; "Chunky Bacon!"; end
+    #   end
+    #
+    #   # Save that to your <app dir>/contrib and use like:
+    #   Ramaze.contrib :test
+
+    def self.load(*contribs)
+      contribs.each do |name|
+        mod_name = name.to_s.camel_case
+        begin
+          const = Contrib.const_get(mod_name)
+          Global.contribs << const
           const.startup if const.respond_to?(:startup)
-          Inform.dev "Loaded contrib: #{const}"
+          Log.dev "Loaded contrib: #{const}"
+        rescue NameError
+          files = Dir["{contrib,#{BASEDIR/:ramaze/:contrib}}/#{name}.{so,bundle,rb}"]
+          raise LoadError, "#{mod_name} not found" unless files.any?
+          require(files.first) ? retry : raise
         end
       end
     end
-  end
-end
+
+    # Will call .shutdown on all contrib modules which support it.
+    #---
+    # .shudown gets called by Ramaze :essentials.
+    #+++
+
+    def self.shutdown
+      Global.contribs.each do |contrib|
+        contrib.shutdown if contrib.respond_to?(:shutdown)
+      end
+    end
+
+    # Will load all contrib modules from options[:contrib]
+    #---
+    # .startup gets called by Ramaze :essentials.
+    #+++
+
+    def self.startup(options = {})
+      return unless options[:contrib]
+      [options[:contrib]].flatten.each do |contrib|
+        load(contrib)
+      end
+    end
+  end # class Contrib
+end # class Ramaze

data/lib/ramaze/contrib/auto_params.rb

@@ -75,7 +75,7 @@ module Ramaze
 
           return found.dup
         else
-          Inform.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+          Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
           Cache.resolved.delete path
         end
       end

data/lib/ramaze/contrib/email.rb

@@ -5,18 +5,18 @@
 #   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'
+#   Ramaze::EmailHelper.trait :smtp_server      => 'smtp.your-isp.com',
+#                             :smtp_helo_domain => "originating-server.com",
+#                             :smtp_username    => 'username',
+#                             :smtp_password    => 'password',
+#                             :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]"
+#   Ramaze::EmailHelper.trait :smtp_auth_type => :login,
+#                             :bcc_addresses  => [ 'admin@your-domain.com' ],
+#                             :sender_full    => 'MailBot <no-reply@your-domain.com>',
+#                             :id_generator   => lambda { "<#{Time.now.to_i}@your-domain.com>" },
+#                             :subject_prefix => "[SiteName]"
 #
 # To send an e-mail:
 #
@@ -70,15 +70,15 @@ Message-Id: #{id}
       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}'"
+          Log.info "E-mail sent to #{recipient} - '#{subject}'"
         end
       rescue => e
-        Inform.error "Failed to send e-mail to #{recipient}"
-        Inform.error e
+        Log.error "Failed to send e-mail to #{recipient}"
+        Log.error e
       end
     end
   end
-end
+end

data/lib/ramaze/contrib/facebook.rb

@@ -1,9 +1,9 @@
 require __DIR__/:facebook/:facebook
 
 module Ramaze
-  module FacebookHelper
+  module Helper::Facebook
     def self.included(klass)
-      klass.send(:helper, :aspect, :inform)
+      klass.send(:helper, :aspect)
     end
 
     def error

data/lib/ramaze/contrib/facebook/facebook.rb

@@ -47,7 +47,7 @@ module Facebook
                                                               else
                                                                 v.to_s
                                                               end
-                                               }.sort
+                                                  }.sort
 
       data = Array["sig=#{Digest::MD5.hexdigest(args.join+SECRET)}", *args].join('&')
 
@@ -71,7 +71,10 @@ module Facebook
               end
             end
 
-      ret = ret.first if ret.is_a? Array and ret.size == 1 and ret.first.is_a? Hash
+      unless method == 'fql.query'
+        ret = ret.first if ret.is_a? Array and ret.size == 1 and ret.first.is_a? Hash
+      end
+
       raise Facebook::Error, ret['error_msg'] if ret.is_a? Hash and ret['error_code']
 
       ret
@@ -83,7 +86,7 @@ module Facebook
     end
 
     def valid?
-      return false unless private_methods.include? 'request' and not request['fb_sig'].empty?
+      return false unless respond_to?(:request) and not request['fb_sig'].nil?
       request['facebook.valid?'] ||= \
         request['fb_sig'] == Digest::MD5.hexdigest(request.params.map{|k,v| "#{$1}=#{v}" if k =~ /^fb_sig_(.+)$/ }.compact.sort.join+SECRET)
     end
@@ -94,7 +97,7 @@ module Facebook
 
     def redirect url
       url[0,0] = URL unless url =~ /^http/
-      if private_methods.include? 'response'
+      if respond_to?(:response)
         response.build "<fb:redirect url='#{url}'/>"
         throw :respond
       else

data/lib/ramaze/contrib/file_cache.rb

@@ -0,0 +1,65 @@
+#
+# drop-in replacement for Ramaze's built-in MemoryCache built on the
+# filesystem.  # to use with sessions do
+#
+#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
+#
+# to use with everything do
+#
+#   Ramaze::Global::cache = Ramaze::FileCache
+#
+
+module Ramaze::FileCache
+  require "fileutils"
+  require "socket"
+
+  Host = Socket.gethostname
+  Pid = Process.pid
+  Fu = FileUtils
+  Root = File.join Ramaze::APPDIR, "cache"
+
+  Fu.mkdir_p(Root) rescue nil
+
+  def self.[] key
+    path = File.join Root, key, "data"
+    Marshal.load(IO.read(path))
+  rescue
+    nil
+  end
+
+  def self.[]= key, value
+    tmp = File.join Root, key, "data.#{ Host }.#{ Pid }"
+    dirname = File.join Root, key
+    path = File.join Root, key, "data"
+    data = Marshal.dump value
+    Fu.rm_rf dirname rescue nil
+    Fu.mkdir_p dirname rescue nil
+    open(tmp, 'w'){|fd| fd.write data}
+    Fu.mv tmp, path
+  rescue
+    nil
+  end
+
+  def self.values_at *keys
+    keys.map{|key| self[key]}
+  end
+
+  def self.delete *keys
+    keys.map do |key|
+      dirname = File.join Root, key
+      Fu.rm_rf dirname rescue next 
+    end
+  end
+
+  def self.clear
+    Dir["#{ Root }/*"].each{|entry| Fu.rm_rf entry}
+  end
+
+  def self.new
+    self
+  end
+
+  def self.to_sym
+    name.split(%r/::/).last.to_sym
+  end
+end

data/lib/ramaze/contrib/gettext.rb

@@ -22,84 +22,85 @@ require 'ramaze/contrib/gettext/po'
 #
 #   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Gettext
 
-class Ramaze::Tool::Gettext < Ramaze::Tool::Localize
+module Ramaze
+  class Tool::Gettext < Tool::Localize
 
-  # Enable Localization
-  trait :enable => true
+    # Enable Localization
+    trait :enable => true
 
-  # Default language that is used if the browser don't suggests otherwise or
-  # the language requested is not available.
-  trait :default_language => 'en'
+    # Default language that is used if the browser don't suggests otherwise or
+    # the language requested is not available.
+    trait :default_language => 'en'
 
-  # languages supported
-  trait :languages => %w[ en ]
+    # languages supported
+    trait :languages => %w[ en ]
 
-  # YAML files the localizations are saved to and loaded from, %s is
-  # substituted by the values from trait[:languages]
-  trait :file => 'conf/locale_%s.mo'.freeze
+    # YAML files the localizations are saved to and loaded from, %s is
+    # substituted by the values from trait[:languages]
+    trait :file => 'conf/locale_%s.mo'.freeze
 
-  # The pattern that is substituted with the translation of the current locale.
-  trait :regex => /\[\[(.*?)\]\]/
+    # The pattern that is substituted with the translation of the current locale.
+    trait :regex => /\[\[(.*?)\]\]/
 
-  # Browsers may send different keys for the same language, this allows you to
-  # do some coercion between what you use as keys and what the browser sends.
-  trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
+    # Browsers may send different keys for the same language, this allows you to
+    # do some coercion between what you use as keys and what the browser sends.
+    trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
 
-  # When this is set to false, it will not save newly collected translatable
-  # strings to disk.  Disable this for production use, as it slows the
-  # application down.
-  trait :collect => true
+    # When this is set to false, it will not save newly collected translatable
+    # strings to disk.  Disable this for production use, as it slows the
+    # application down.
+    trait :collect => true
 
 
-  # Load given locales from disk and save it into the dictionary.
+    # Load given locales from disk and save it into the dictionary.
 
-  def self.load(*locales)
-    Ramaze::Inform.debug "loading locales: #{locales.inspect}"
+    def self.load(*locales)
+      Log.debug "loading locales: #{locales.inspect}"
 
-    dict = trait[:dictionary] || {}
+      dict = trait[:dictionary] || {}
 
-    locales.each do |locale|
-      begin
-        dict[locale] = ::MOFile.open(trait[:file] % locale)
-      rescue Errno::ENOENT
-        Ramaze::Inform.error "couldn't load #{trait[:file] % locale}"
-        dict[locale] = {}
+      locales.each do |locale|
+        begin
+          dict[locale] = ::MOFile.open(trait[:file] % locale)
+        rescue Errno::ENOENT
+          Log.error "couldn't load #{trait[:file] % locale}"
+          dict[locale] = {}
+        end
       end
-    end
 
-    trait[:dictionary] = dict
-  end
+      trait[:dictionary] = dict
+    end
 
-  # Reloads given locales from the disk to refresh the dictionary.
+    # Reloads given locales from the disk to refresh the dictionary.
 
-  def self.update
-    trait[:dictionary] = nil
-    dictionary.each do |locale, dict|
-      if dict.kind_of?(MOFile)
-        Ramaze::Inform.debug("Reloading #{dict.filename}")
-        dict.update!
+    def self.update
+      trait[:dictionary] = nil
+      dictionary.each do |locale, dict|
+        if dict.kind_of?(MOFile)
+          Log.debug("Reloading #{dict.filename}")
+          dict.update!
+        end
       end
     end
-  end
 
-  # Stores given locales from the dictionary to disk.
+    # Stores given locales from the dictionary to disk.
 
-  def self.store(*locales)
-    keys = []
-    dictionary.each do |locale, dict|
-      keys.concat dict.keys
-    end
-    keys.delete ""
+    def self.store(*locales)
+      keys = []
+      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'
-    File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|
-      fd.write data
+      data = ::GetText::RGetText.generate(keys.compact.uniq.sort.map {|x| [x] })
+      file = (trait[:file] % trait[:default_language]) + '.pot'
+      File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|
+        fd.write data
+      end
+    rescue Errno::ENOENT => e
+      Log.error e
     end
-  rescue Errno::ENOENT => e
-    Ramaze::Inform.error e
   end
-
 end
 
 class Ramaze::Contrib::Gettext