manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/contrib/gzip_filter.rb

@@ -1,69 +1 @@
-#          Copyright (c) 2008 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 'ramaze/contrib/gzip_filter'
-#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Filter::Gzip
-#
-# Setting options (at any point in your code):
-#
-#   Ramaze::Filter::Gzip.trait(
-#     :threshold    => 1024,
-#     :content_type => /^text\/.+/
-#   )
-
-require 'zlib'
-
-module Ramaze
-  module Filter
-    class Gzip
-
-      trait :enabled => true,
-            :content_type => /^text\/.+/,
-            :threshold => 32768 # bytes
-
-      class << self
-
-        include Ramaze::Trinity
-
-        # Enables being plugged into Dispatcher::Action::FILTER
-
-        def call( response, options = {} )
-          return response unless trait[ :enabled ]
-          return response unless body = response.body
-          return response if body.respond_to?( :read )
-
-          accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
-          return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
-
-          acceptable_size = body.size >= trait[ :threshold ]
-          acceptable_type = response.content_type =~ trait[:content_type]
-
-          if acceptable_type and acceptable_size
-            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( body )
-            gz.close
-
-            response.body = output.string
-            response.header[ 'Content-encoding' ] = 'gzip'
-          end
-
-          response
-        end
-      end
-    end
-  end
-end
+Ramaze.deprecated('contrib/gzip_filter.rb', 'Rack::Deflater')

data/lib/ramaze/contrib/rest.rb

@@ -1,17 +1,22 @@
-Ramaze::Rewrite['REST dispatch'] = lambda do |path, request|
-  path << '/' unless path[-1] == '/'
+# Use this together with the Rack::MethodOverride middleware for best
+# behaviour.
+#
+# See spec/contrib/rest.rb for usage.
 
-  method = if request.request_method == 'POST' and request.params.has_key?('method')
-             request.params['method'].upcase
-           else
-             request.request_method
-           end
-  
-  case method
-  when 'GET' then path << 'show/'
-  when 'POST' then path << 'create/'
-  when 'PUT' then path << 'update/'
-  when 'DELETE' then path << 'destroy/'
-  else path
-  end
+module Ramaze
+  # Don't use one option per method, we don't want to turn request_method into
+  # a symbol, together with MethodOverride this could lead to a memory leak.
+  options.o "REST rewrite mapping",
+    :rest_rewrite, { 'GET'    => 'show',
+                     'POST'   => 'create',
+                     'PUT'    => 'update',
+                     'DELETE' => 'destroy'}
+
+  Rewrite['REST dispatch'] = lambda{|path, request|
+    if suffix = Ramaze.options[:rest_rewrite][request.request_method]
+      "#{path}/#{suffix}".squeeze('/')
+    else
+      path
+    end
+  }
 end

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

@@ -1,4 +1,5 @@
 require 'sequel'
+require 'sequel/extensions/inflector'
 
 module Sequel
   class Model

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

@@ -94,14 +94,14 @@ class FormField
       select(gestalt)
     else
       case db_type
-      when 'varchar', 'integer'
+      when /varchar|integer/
         input(gestalt)
-      when 'boolean'
+      when /boolean/
         checkbox(gestalt)
-      when 'string'
+      when /string/
         textarea(gestalt)
       else
-        raise "Unsupported type: (#{db_type || hint} : #{field})"
+        raise("Unsupported type: (%p : %p)" % [db_type || hint, field])
       end
     end
   end

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

@@ -7,7 +7,7 @@
 # Usage:
 #   class Avatar < Sequel::Model
 #     IMAGE = {
-#       # specifies belongs_to, will create relation and foreign key
+#       # specifies many_to_one, will create relation and foreign key
 #
 #       :owner => :User,
 #
@@ -51,8 +51,8 @@
 module SequelImage
   def self.included(model)
     args = model::IMAGE
-    set_foreign_key = args[:foreign_key] || "#{args[:owner]}_id".downcase.to_sym
-    set_belongs_to  = args[:belongs_to]  ||    args[:owner].to_s.downcase.to_sym
+    set_foreign_key = args[:foreign_key]  || "#{args[:owner]}_id".downcase.to_sym
+    set_many_to_one  = args[:many_to_one] ||    args[:owner].to_s.downcase.to_sym
 
     # Define schema
     model.set_schema do
@@ -68,21 +68,19 @@ module SequelImage
     end
 
     # Define Relations
-    model.belongs_to set_belongs_to
+    model.many_to_one set_many_to_one
 
     # Define Hooks
-    model.send(:hooks).clear
-
-    model.before_create do
+    model.before_create :generate_thumbnails do
       generate_thumbnails
       self.created_at = Time.now
     end
 
-    model.before_save do
+    model.before_save :update_time do
       self.updated_at = Time.now
     end
 
-    model.before_destroy do
+    model.before_destroy :cleanup do
       cleanup if conf[:cleanup]
     end
 
@@ -110,7 +108,7 @@ module SequelImage
       tempfile = file[:tempfile]
       raise ArgumentError, 'Empty tempfile' if tempfile.size == 0
 
-      ext         = Ramaze::Tool::MIME.ext_for(type)
+      ext         = Rack::Mime::MIME_TYPES.invert[type]
       image.mime  = type
       target_name = image.next_name(File.basename(filename, File.extname(filename)), ext)
       target_path = File.join(image.public_root, image.path, target_name)
@@ -150,7 +148,7 @@ module SequelImage
     end
 
     def public_root
-      Ramaze::Global.public_root
+      Ramaze.options.roots.first
     end
 
     def filename(size)

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

@@ -1,5 +1,5 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.     
+# All files in this distribution are subject to the terms of the Ruby license.
 
 # Pretty DSL to express Sequel relations
 #
@@ -43,7 +43,8 @@ module SequelRelation
         end
       end
 
-      return # remove this line for debugging
+=begin
+     # uncomment for debugging
 
       pp TODO
 
@@ -54,6 +55,7 @@ module SequelRelation
           puts "  #{reflection[:type]} => #{key}"
         end
       end
+=end
     end
 
     def the(left_model, &block)
@@ -63,20 +65,34 @@ module SequelRelation
     end
 
     def belongs_to(model)
-      todo :belongs_to, model.to_s.downcase.to_sym
+      todo :many_to_one, singular_sym(model), :class => model
     end
 
     def has_many(model)
       todo :create_join, model
-      todo :many_to_many, model.to_s.downcase.pluralize.to_sym
+      todo :many_to_many, plural_sym(model), :class => model
     end
 
     def has_one(model)
-      todo :belongs_to, model.to_s.downcase.to_sym
+      todo :many_to_one, singular_sym(model), :class => model
     end
 
     def todo(method, *args)
       TODO[@left] << [method, *args]
     end
+
+    private
+
+    def plural_sym(obj)
+      basename(obj).pluralize.to_sym
+    end
+
+    def singular_sym(obj)
+      basename(obj).to_sym
+    end
+
+    def basename(obj)
+      obj.to_s.split('::').last.downcase
+    end
   end
 end

data/lib/ramaze/controller/default.rb

@@ -0,0 +1,12 @@
+module Ramaze
+  Log.debug "Default controller invoked"
+
+  class DefaultController < Ramaze::Controller
+    map '/'
+
+    def lobster
+      require 'rack/lobster'
+      respond Rack::Lobster::LobsterString
+    end
+  end
+end

data/lib/ramaze/controller.rb

@@ -1,288 +1,94 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/helper'
-require 'ramaze/template'
-require 'ramaze/action'
-
-require 'ramaze/controller/resolve'
-require 'ramaze/controller/error'
-
 module Ramaze
-
-  # The Controller is responsible for combining and rendering actions.
-
   class Controller
-    include Helper::Methods
-
-    helper :redirect, :link, :sendfile, :flash, :cgi, :partial
-
-    # Whether or not to map this controller on startup automatically
-
-    trait[:automap] ||= true
-
-    # Place to map the Controller to, this is something like '/' or '/foo'
-
-    trait[:map] ||= nil
-
-    # Caches patterns for the given path.
-
-    trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
-
-    class << self
-      # When Controller is subclassed the resulting class is placed in
-      # Global.controllers and a new trait :actions_cached is set on it.
-
-      def inherited controller
-        controller.trait :actions_cached => {}
-        Global.controllers << controller
-        if map = controller.mapping
-          Log.dev("mapping #{map} => #{controller}")
-          Global.mapping[map] ||= controller
-        end
-      end
-
-      # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
-      # all controllers subclassed so far and adds them to the Global.mapping if
-      # they are not assigned yet.
-
-      def startup options = {}
-        Log.dev("found Controllers: #{Global.controllers.inspect}")
-
-        check_path("Public root: '%s' doesn't exist", Global.public_root)
-        check_path("View root: '%s' doesn't exist", Global.view_root)
-
-        require 'ramaze/controller/main' if Global.mapping.empty?
-
-        Log.debug("mapped Controllers: #{Global.mapping.inspect}")
-      end
-
-      # checks paths for existance and logs a warning if it doesn't exist yet.
-
-      def check_path(message, *paths)
-        paths.each do |path|
-          Log.warn(message % path) unless File.directory?(path)
-        end
-      end
-
-      # if trait[:automap] is set and controller is not in Global.mapping yet
-      # this will build a new default mapping-point, MainController is put
-      # at '/' by default. For other Class names, String#snake_case is called,
-      # e.g. FooBarController is mapped at '/foo_bar'.
-
-      def mapping
-        global_mapping = Global.mapping.invert[self]
-
-        return global_mapping if global_mapping
+    include Innate::Traited
+    include Innate::Node
 
-        if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
-          name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
-          return if name.empty?
-          name == 'Main' ? '/' : "/#{name.snake_case}"
-        end
-      end
-
-      # Map Controller to the given syms or strings.
-      # Replaces old mappings.
-      # If you want to _add_ a mapping, just modify Global.mapping.
-
-      def map(*syms)
-        Global.mapping.delete_if{|k,v| v == self}
-
-        syms.compact.each do |sym|
-          Global.mapping[sym.to_s] = self
-        end
-      end
+    # we are no mapped node
+    Innate::Node::NODE_LIST.delete(self)
 
-      # Returns the Controller at a mapped path.
+    # call our setup method one startup
+    Ramaze.options.setup << self
 
-      def at(mapping)
-        Global.mapping[mapping.to_s]
-      end
+    CONTROLLER_LIST = Set.new
 
-      # Define a layout for all actions on this controller
-      #
-      # Example:
-      #   class Foo < Ramaze::Controller
-      #     layout :foo
-      #   end
-      #
-      #  This defines the action :foo to be layout of the controller and will
-      #  render the layout after any other action has been rendered, assigns
-      #  @content to the result of the action and then goes on rendering
-      #  the layout-action where @content may or may not be used, returning
-      #  whatever the layout returns.
+    trait :app => :pristine
+    trait :skip_controller_map => false
 
-      def layout(*meth_or_hash)
-        if meth_or_hash.empty?
-          trait[:layout] ||= ( ancestral_trait[:layout] || {:all => nil, :deny => Set.new} ).dup
-        else
-          meth_or_hash = meth_or_hash.first
-          if meth_or_hash.respond_to?(:to_hash)
-            meth_or_hash.each do |layout_name, *actions|
-              actions.flatten.each do |action|
-                layout[action.to_s] = layout_name
-              end
-            end
-          else
-            layout[:all] = meth_or_hash
-          end
-        end
-      end
+    def self.inherited(into)
+      Innate::Node.included(into)
+      CONTROLLER_LIST << into
+      into.trait :skip_node_map => true
+    end
 
-      # Deny layout for passed names of actions.
-      # Name should be name of the method or template without extension, as
-      # String or Symbol
-      #
-      # Usage:
-      #   class MainController < Ramaze::Controller
-      #     deny_layout :atom
-      #
-      #     def atom
-      #       "I won't have layout"
-      #     end
-      #   end
+    def self.setup
+      require 'ramaze/controller/default' if CONTROLLER_LIST.empty?
 
-      def deny_layout(*actions)
-        actions.each do |action|
-          layout[:deny] << action.to_s
+      CONTROLLER_LIST.each do |controller|
+        unless controller.ancestral_trait[:provide_set]
+          controller.engine(:Etanni)
+          controller.trait(:provide_set => false)
         end
+        next if controller.trait[:skip_controller_map]
+        controller.map(generate_mapping(controller.name))
       end
+    end
 
-      # Define a view_root for Controller, returns the current view_root
-      # if no argument is given.
-      # Runs every given path through Controller::check_path
-
-      def view_root *args
-        return @view_root if args.empty?
-
-        check_path("#{self}.view_root: '%s' doesn't exist", *args)
-        @view_root = args.flatten
-      end
+    def self.engine(name)
+      provide(:html, name.to_sym)
+    end
 
-      # This is used for template rerouting, takes action, optionally a
-      # controller and action to route to.
-      #
-      # Usage:
-      #   class MainController
-      #     template :index, OtherController, :list
-      #     template :foo, :bar
-      #     template :bar, :file => '/absolute/path'
-      #     template :baz, :file => 'relative/path'
-      #     template :abc, :controller => OtherController
-      #     template :xyz, :controller => OtherController, :action => 'list'
-      #
-      #     def index
-      #       'will use template from OtherController#list'
-      #     end
-      #
-      #     def foo
-      #       'will use template from self#bar'
-      #     end
-      #
-      #     def bar
-      #       'will use template from /absolute/path'
-      #     end
-      #
-      #     def baz
-      #       'will use template from relative/path'
-      #     end
-      #
-      #     def abc
-      #       'will use template from OtherController#index'
-      #     end
-      #
-      #     def xyz
-      #       'will use template from OtherController#list'
-      #     end
-      #   end
+    def self.mapping
+      Ramaze.to(self)
+    end
 
-      def template(this, *argv)
-        case argv.first
-        when Hash
-          options, *ignored = argv
-          controller = options[:controller] || options['controller']
-          action = options[:action] || options['action']
-          file = options[:file] || options['file']
-          info = {}
-          if file
-            file = file.to_s
-            unless Pathname(file).absolute?
-              root = [view_root || Global.view_root].flatten.first
-              file = File.join(root, file)
-            end
-            info[:file] = file
-          else
-            controller ||= self
-            action = (action || 'index').to_s
-            info[:controller] = controller
-            info[:action] = action
-          end
-          trait "#{this}_template" => info
-        else
-          # Only explicitly set the controller to use, if it was explicitly given.
-          # This helps ensure that template mappings still work in subclasses
-          # of this controller.
-          first, second, *ignored = argv
-          if second
-            trait "#{this}_template" => {:controller => first, :action => second}
-          else
-            trait "#{this}_template" => {:action => first}
-          end
-        end
-      end
+    IRREGULAR_MAPPING = {
+      'Controller' => nil,
+      'MainController' => '/'
+    }
 
-      # This is a method to specify the templating engine for your controller.
-      # It basically just is sugar for:
-      #   trait :engine => Haml
-      #
-      # Usage:
-      #   class MainController < Ramaze::Controller
-      #     engine :Haml
-      #   end
+    def self.generate_mapping(klass_name = self.name)
+      chunks = klass_name.split(/::/)
+      return if chunks.empty?
 
-      def engine(name)
-        name = Template.const_get(name)
-      rescue NameError => ex
-        Log.warn ex
-        Log.warn "Try to use passed engine directly"
-      ensure
-        trait :engine => name
-      end
+      last = chunks.last
+      return IRREGULAR_MAPPING[last] if IRREGULAR_MAPPING.key?(last)
 
-      # Return Controller of current Action
+      last.sub!(/Controller$/, '')
+      '/' << chunks.map{|chunk| chunk.snake_case }.join('/')
+    end
 
-      def current
-        action = Action.current
-        action.instance || action.controller
+    def self.map(location, app_name = nil)
+      if app_name
+        trait :app => app_name
+      else
+        app_name = ancestral_trait[:app]
       end
 
-      # Entering point for Dispatcher, first Controller::resolve(path) and then
-      # renders the resulting Action.
+      trait :skip_controller_map => true
 
-      def handle path
-        action = resolve(path)
-        STATE[:controller] = action.controller
-        action.render
-      end
-
-      # By default, returns all ancestors of current Controller that have
-      # Ramaze::Controller as their ancestor. Optional argument parent
-      # can be used return ancestors that have parent as an ancestor.
+      App.find_or_create(app_name).map(location, self)
+    end
 
-      def relevant_ancestors(parent = Ramaze::Controller)
-        ancestors.select do |anc|
-          anc.ancestors.include?(parent)
-        end
-      end
+    def self.app
+      App[ancestral_trait[:app]]
     end
 
-    private
+    def self.options
+      return unless app = self.app
+      app.options
+    end
 
-    # Simplistic render, rerouting to Controller.handle(*args)
+    def self.template(*args)
+      Ramaze.deprecated('Controller::template', 'Controller::alias_view')
+      alias_view(*args)
+    end
 
-    def render *args
-      self.class.handle(*args)
+    def self.view_root(*locations)
+      Ramaze.deprecated('Controller::view_root', 'Controller::map_views')
+      map_views(*locations)
     end
   end
 end