ramaze 0.1.4 → 0.2.0

data/lib/ramaze/adapter.rb

@@ -24,7 +24,7 @@ module Ramaze
 
   # This module holds all classes and methods related to the adapters like
   # webrick or mongrel.
-  # It's responsible to start and stop them.
+  # It's responsible for starting and stopping them.
 
   module Adapter
     class << self

data/lib/ramaze/adapter/cgi.rb

@@ -13,9 +13,6 @@ module Ramaze::Adapter
       # to make it compatible with other adapters but have no influence and
       # can be omitted
       def start host = nil, ports = nil
-        global = Ramaze::Global
-        global.inform_to = :stderr if global.inform_to == $stdout
-
         Thread.new do
           Thread.current[:task] = :cgi
           Rack::Handler::CGI.run(self)

data/lib/ramaze/adapter/evented_mongrel.rb

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

data/lib/ramaze/adapter/mongrel.rb

@@ -1,20 +1,11 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-module Ramaze
-  if ENV['SWIFT']
-    require 'swiftcore/swiftiplied_mongrel'
-    Inform.debug "Using Swiftiplied Mongrel"
-  elsif ENV['EVENT']
-    require 'swiftcore/evented_mongrel'
-    Inform.debug "Using Evented Mongrel"
-  else
-    require 'mongrel'
-  end
-
-  require 'ramaze/adapter'
-  require 'rack/handler/mongrel'
+require 'mongrel'
+require 'ramaze/adapter'
+require 'rack/handler/mongrel'
 
+module Ramaze
   module Adapter
 
     # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.

data/lib/ramaze/adapter/swiftiplied_mongrel.rb

@@ -0,0 +1,7 @@
+#          Copyright (c) 2006 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"
+
+require 'swiftcore/swiftiplied_mongrel'
+require 'ramaze/adapter/mongrel'

data/lib/ramaze/cache.rb

@@ -36,14 +36,19 @@ module Ramaze
       #+++
 
       def add *keys
-        keys.each do |key|
-          CACHES[key] = new
-          CACHES[key].instance_variable_set("@cache_name", key)
-          self.class.class_eval do
-            define_method(key){ CACHES[key] }
-          end
+        keys.each{|key|
+          klass = Global.cache_alternative.fetch(key, self)
+          add_on(key, klass)
+        }
+        Inform.dev("Added caches for: #{keys.join(', ')}")
+      end
+
+      def add_on(key, cache_class)
+        CACHES[key] = new(cache_class)
+        CACHES[key].instance_variable_set("@cache_name", key)
+        self.class.class_eval do
+          define_method(key){ CACHES[key] }
         end
-        Inform.debug("Added caches for: #{keys.join(', ')}")
       end
 
     end

data/lib/ramaze/contrib.rb

@@ -0,0 +1,22 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  def self.contrib(*args)
+    Ramaze::Contrib.load *args
+  end
+
+  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
+          const.startup if const.respond_to?(:startup)
+          Inform.dev "Loaded contrib: #{const}"
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/auto_params.rb

@@ -0,0 +1,128 @@
+# auto_params.rb
+#
+# AutoParams implements action parameterization ala merb 0.4 and Nitro
+# using ruby2ruby and ParseTree
+#
+# Usage:
+#   require 'ramaze/contrib'
+#   Ramaze.contrib :auto_params
+#
+# For example,
+#
+#   def search(query) end
+#
+# can be accessed via
+#
+#   - /search?query=findthis, which calls search('findthis')
+#   - /search/findthis                    search('findthis')
+#   - /search/findthis?query=andthis      search(['findthis', 'andthis'])
+#
+# For more examples, take a look at spec/contrib/auto_params.rb
+#
+# Note: A simpler alternative for similar functionality would be:
+#
+#   def search(query = request['query']) end
+#
+
+require __DIR__/:auto_params/:get_args
+
+module Ramaze
+
+  module Contrib
+    class AutoParams
+      def self.startup
+        Ramaze::Cache.add :args
+      end
+    end
+  end
+
+  class Action
+
+    # with parameterization, params may include
+    #   arrays: /num?n=1&n=2 becomes [['1','2']] for def num(n) end
+    #   nil: /calc?w=10&d=2 becomes ['10', nil, '2'] for def calc(w, h, d) end
+
+    def params=(*par)
+      par = *par
+      self[:params] = par.map{ |pa|
+        case pa
+        when Array
+          pa.map{|p| CGI.unescape(p.to_s)}
+        when nil
+          nil
+        else
+          CGI.unescape(pa.to_s)
+        end
+      } unless par.nil?
+      self[:params] ||= []
+    end
+
+  end
+
+  class Controller
+
+    # ignore cache when request.params is interesting
+
+    def self.cached(path)
+      if found = Cache.resolved[path]
+        if found.respond_to?(:relaxed_hash)
+
+          # don't use cache if we need to add request.params entries to the Action
+          if args = Cache.args[found.method]
+            param_keys = request.params.keys
+            return nil if args.find{|k,v| param_keys.include?(k.to_s) }
+          end
+
+          return found.dup
+        else
+          Inform.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+          Cache.resolved.delete path
+        end
+      end
+
+      nil
+    end
+
+    # use Method#get_args to insert values from request.params into Action#params
+
+    def self.resolve_method(name, *params)
+      if method = action_methods.delete(name)
+        meth = instance_method(method)
+        arity = meth.arity
+
+        if meth.respond_to? :get_args
+          Cache.args[name] ||= meth.get_args.select{|e| e.to_s !~ /^\*/} || []
+          args = Cache.args[name]
+
+          param_keys = request.params.keys
+
+          # if there are missing args, or keys in request.params that match expected args
+          if args.size > params.size or args.find{|k,v| param_keys.include?(k.to_s) }
+            args.each_with_index do |(name, val), i|
+              r_params = request.params[name.to_s]
+              if params[i] and r_params.size > 0
+                params[i] = [params[i], r_params].flatten
+              else
+                params[i] ||= r_params
+              end
+            end
+
+            # strip trailing nils so default argument values are used
+            params.reverse.each{|e| if e.nil? then params.pop else break end }
+          end
+
+          argity = args.select{|e| e.size==1}.size..args.size
+        else
+          argity = arity..arity
+        end
+
+        if arity < 0 or argity.include? params.size
+          return method, params
+        end
+      end
+      return nil, []
+    end
+
+  end
+
+end

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -0,0 +1,56 @@
+# from merb/core_ext/get_args.rb
+begin
+  require 'ruby2ruby'
+
+  class ParseTreeArray < Array
+    def self.translate(*args)
+      self.new(ParseTree.translate(*args))
+    end
+
+    def deep_array_node(type = nil)
+      each do |node|
+        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
+        next unless node.is_a?(Array)
+        return ParseTreeArray.new(node).deep_array_node(type)
+      end
+      nil
+    end
+
+    def arg_nodes
+      self[1..-1].inject([]) do |sum,item|
+        sum << [item] unless item.is_a?(Array)
+        sum
+      end
+    end
+
+    def get_args
+      arg_node = deep_array_node(:args)
+      args = arg_node.arg_nodes
+      default_node = arg_node.deep_array_node(:block)
+      return args unless default_node
+      lasgns = default_node[1..-1]
+      lasgns.each do |asgn|
+        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
+      end
+      args
+    end
+
+  end
+
+  module GetArgs
+    def get_args
+      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
+      klass = $` if klass =~ /\(/
+      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
+    end
+  end
+
+  class UnboundMethod
+    include GetArgs
+  end
+
+  class Method
+    include GetArgs
+  end
+rescue LoadError
+end

data/lib/ramaze/contrib/gzip_filter.rb

@@ -0,0 +1,57 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# gzip_filter.rb
+#
+# Use this to compress "large" pages with gzip.  All major browsers support gzipped pages.
+# This filter brought to you by your friends in #ramaze: Pistos, manveru, rikur and Kashia.
+#
+# Usage:
+# in start.rb:
+#
+# require 'path/to/gzip-filter'
+# Ramaze::Dispatcher::Action::FILTER << Ramaze::Filter::Gzip
+
+require 'zlib'
+
+module Ramaze
+  module Filter
+    class Gzip
+
+      trait :enabled => true
+      trait :threshold => 32768 # bytes
+
+      class << self
+
+        include Ramaze::Trinity
+
+        # Enables being plugged into Dispatcher::Action::FILTER
+
+        def call( response, options = {} )
+          return response if not trait[ :enabled ]
+          return response if response.body.nil?
+          return response if response.body.respond_to?( :read )
+
+          accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
+          return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
+
+          if response.content_type == 'text/html' && response.body.size > trait[ :threshold ]
+            output = StringIO.new
+            def output.close
+              # Zlib closes the file handle, so we want to circumvent this
+              rewind
+            end
+            gz = Zlib::GzipWriter.new( output )
+            gz.write( response.body )
+            gz.close
+
+            response.body = output.string
+            response.header[ 'Content-encoding' ] = 'gzip'
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/route.rb

@@ -0,0 +1,40 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Contrib
+    class Route
+      class << self
+        def startup
+          trait :route => true
+          trait :routes => Dictionary.new
+          Ramaze::Controller::FILTER.put_before(:default, :routed)
+        end
+
+        def [](key)
+          trait[:routes][key]
+        end
+
+        def []=(key, value)
+          trait[:routes][key] = value
+        end
+      end
+    end
+  end
+
+  class Controller
+    class << self
+      def routed(path)
+        routes = Contrib::Route.trait[:routes]
+        routes.each do |regex, pattern|
+          if md = path.match(regex)
+            new_path = pattern % md.to_a[1..-1]
+            return resolve(new_path, :routed)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/sequel/fill.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Sequel
+  class Model
+    class << self
+      def fill request_object = Ramaze::Request.current
+        create(request_object.params)
+      end
+    end
+  end
+end

data/lib/ramaze/controller.rb

@@ -42,11 +42,11 @@ module Ramaze
       # Global.controllers and a new trait :actions_cached is set on it.
 
       def inherited controller
-        controller.trait :actions_cached => Set.new
+        controller.trait :actions_cached => {}
         controller.trait :layout => {:all => nil, :deny => Set.new}
         Global.controllers << controller
         if map = controller.mapping
-          Inform.debug("mapping #{map} => #{controller}")
+          Inform.dev("mapping #{map} => #{controller}")
           Global.mapping[map] ||= controller
         end
       end
@@ -56,7 +56,7 @@ module Ramaze
       # they are not assigned yet.
 
       def startup options = {}
-        Inform.debug("found Controllers: #{Global.controllers.inspect}")
+        Inform.dev("found Controllers: #{Global.controllers.inspect}")
         tr, pr = Global.template_root, Global.public_root
         Inform.warn("Template root: #{tr} doesn't exist") unless File.directory?(tr)
         Inform.warn("Public root: #{pr} doesn't exist") unless File.directory?(pr)
@@ -118,15 +118,17 @@ module Ramaze
       #  the layout-action where @content may or may not be used, returning
       #  whatever the layout returns.
 
-      def layout(meth_or_hash, &block)
+      def layout(meth_or_hash)
         if meth_or_hash.respond_to?(:to_hash)
           meth_or_hash.each do |layout_name, *actions|
+            layout_name = R(self, layout_name) if layout_name.to_s !~ /\A\//
             actions.flatten.each do |action|
-              trait[:layout][action.to_s] = R(self, layout_name)
+              trait[:layout][action.to_s] = layout_name
             end
           end
         else
-          trait[:layout][:all] = R(self, meth_or_hash)
+          layout_name = R(self, meth_or_hash) if meth_or_hash.to_s !~ /\A\//
+          trait[:layout][:all] = layout_name || meth_or_hash
         end
       end
 
@@ -172,6 +174,15 @@ module Ramaze
         trait "#{this}_template" => [from, that.to_s]
       end
 
+      def engine(name)
+        name = Ramaze::Template.const_get(name)
+      rescue NameError => ex
+        Inform.warn ex
+        Inform.warn "Try to use passed engine directly"
+      ensure
+        trait :engine => name
+      end
+
       # Return Controller of current Action
 
       def current