ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/controller.rb

@@ -1,248 +1,208 @@
-#          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/helper'
-require 'ramaze/template'
-require 'ramaze/action'
-
-require 'ramaze/controller/resolve'
-require 'ramaze/controller/error'
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 
 module Ramaze
-
-  # The Controller is responsible for combining and rendering actions.
-
+  ##
+  # Ramaze::Controller is the base controller of all controllers when developing
+  # applications in Ramaze. It acts as a nice wrapper around Innate::Node and
+  # allows for a more traditional MVC approach.
+  #
+  # @example An example controller
+  #  class Posts < Ramaze::Controller
+  #    map '/posts'
+  #
+  #    def index
+  #
+  #    end
+  #  end
+  #
+  # @author Michael Fellinger
+  # @since  04-01-2009
+  #
   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("Template root: '%s' doesn't exist", Global.template_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.
-
-      def mapping
-        global_mapping = Global.mapping.invert[self]
-        return global_mapping if global_mapping
-        if ancestral_trait[:automap]
-          name = self.to_s.gsub('Controller', '').gsub('::', '/')
-          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}
+    include Innate::Traited
+    include Innate::Node
+
+    # we are no mapped node
+    Innate::Node::NODE_LIST.delete(self)
+
+    # call our setup method one startup
+    Ramaze.options.setup << self
+
+    CONTROLLER_LIST = Set.new
+
+    trait :app => :pristine
+    trait :skip_controller_map => false
+
+    ##
+    # Hash containing the names of two common controller names and the URIs they
+    # should be mapped to.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    #
+    IRREGULAR_MAPPING = {
+      'Controller'     => nil,
+      'MainController' => '/'
+    }
+
+    ##
+    # Modifies the extending class so that it's properly set up to be used as a
+    # controller.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @param  [Class] into The class that extended Ramaze::Controller (or a sub
+    #  class).
+    #
+    def self.inherited(into)
+      Innate::Node.included(into)
+      into.helper(:layout)
+      CONTROLLER_LIST << into
+      into.trait :skip_node_map => true
+    end
 
-        syms.each do |sym|
-          Global.mapping[sym.to_s] = self
+    ##
+    # Sets all the controllers up and loads a default controller in case no
+    # custom ones have been specified.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    #
+    def self.setup
+      case CONTROLLER_LIST.size
+      when 0
+        require 'ramaze/controller/default'
+      when 1
+        controller = CONTROLLER_LIST.to_a.first
+
+        begin
+          controller.mapping
+        rescue
+          controller.map '/'
         end
-      end
-
-      # Returns the Controller at a mapped path.
 
-      def at(mapping)
-        Global.mapping[mapping.to_s]
-      end
-
-      # 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.
-
-      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
+        controller.setup_procedure
+      else
+        CONTROLLER_LIST.each do |list_controller|
+          list_controller.setup_procedure
         end
       end
+    end
 
-      def deny_layout(*actions)
-        actions.each do |action|
-          layout[:deny] << action.to_s
-        end
+    ##
+    # Method that's used to setup each controller, called by
+    # Ramaze::Controller.setup.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    #
+    def self.setup_procedure
+      unless ancestral_trait[:provide_set]
+        engine(:etanni)
+        trait(:provide_set => false)
       end
 
-      # Define a template_root for Controller, returns the current template_root
-      # if no argument is given.
-      # Runs every given path through Controller::check_path
+      map(generate_mapping(name)) unless trait[:skip_controller_map]
+    end
 
-      def template_root *args
-        if args.empty?
-          @template_root
-        else
-          check_path("#{self}.template_root: '%s' doesn't exist", *args)
-          @template_root = args.flatten
-        end
-      end
+    ##
+    # Sets the view engine to use for pages with a content type of text/html.
+    #
+    # @example
+    #  class Posts < Ramaze::Controller
+    #    engine :etanni
+    #  end
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @param  [#to_sym] name The name of the view engine to use.
+    #
+    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 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 = [template_root || Global.template_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
-            controller, action, *ignored = argv
-            controller, action = self, controller unless action
-            trait "#{this}_template" => {:controller => controller, :action => action} 
-        end
-      end
+    ##
+    # Returns the URI a controller is mapped to.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @return [String]
+    #
+    def self.mapping
+      Ramaze.to(self)
+    end
 
-      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
+    ##
+    # Generates a URI for the full namespace of a class. If a class is named
+    # A::B::C the URI would be /a/b/c.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @param  [String] klass_name The name of the class for which to generate
+    #  the mapping, defaults to the current class.
+    # @return [String]
+    #
+    def self.generate_mapping(klass_name = self.name)
+      chunks = klass_name.to_s.split(/::/)
+      return if chunks.empty?
+
+      last = chunks.last
+
+      if IRREGULAR_MAPPING.key?(last)
+        irregular = IRREGULAR_MAPPING[last]
+        return irregular if irregular.nil?  || chunks.size == 1
+        chunks.pop
+        chunks << irregular
       end
 
-      # Return Controller of current Action
+      chunks.unshift ''
+      chunks.last.sub!(/Controller$/, '')
+      chunks.map{|chunk| chunk.snake_case }.join('/').squeeze('/')
+    end
 
-      def current
-        action = Action.current
-        action.instance || action.controller
+    ##
+    # Maps the current class to the specified location.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @param  [String] location The URI to map the controller to.
+    # @param  [String] app_name The name of the application the controller
+    #  belongs to.
+    #
+    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)
-        Thread.current[:controller] = action.controller
-        action.render
-      end
+      App.find_or_create(app_name).map(location, self)
     end
 
-    private
-
-    # Simplistic render, rerouting to Controller.handle(*args)
+    ##
+    # Returns the application to which the controller belongs to.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @return [Ramaze::App]
+    #
+    def self.app
+      App[ancestral_trait[:app]]
+    end
 
-    def render *args
-      self.class.handle(*args)
+    ##
+    # Returns all the options for the application the controller belongs to.
+    #
+    # @author Michael Fellinger
+    # @since  04-01-2009
+    # @return [Innate::Options]
+    #
+    def self.options
+      return unless app = self.app
+      app.options
     end
-  end
-end
+  end # Controller
+end # Ramaze

data/lib/ramaze/current.rb

@@ -1,70 +1,19 @@
-require 'ramaze/current/request'
-require 'ramaze/current/response'
-require 'ramaze/current/session'
-
 module Ramaze
-  module Current
-    class << self
-      include Trinity
-
-      def call(env)
-        setup(env)
-        before_call
-
-        if filter = Global.record
-          request = Current.request
-          Record << request if filter[request]
-        end
-
-        Dispatcher.handle
-
-        finish
-      ensure
-        after_call
-      end
-
-      def setup(env)
-        self.request = Request.new(env)
-        self.response = Response.new
-        self.session = Session.new
-      end
-
-      def finish
-        session.finish if session
-        response.finish
-      end
-
-      def before(&block)
-        @before = block if block
-        @before
-      end
-
-      def before_call
-        if before
-          begin
-            before.call
-          rescue Object => e
-            Ramaze::Log.error e 
-            raise
-          end
-        end
-      end
-
-      def after(&block)
-        @after = block if block
-        @after
-      end
-
-      def after_call
-        if after
-          begin
-            after.call
-          rescue Object => e
-            Ramaze::Log.error e 
-            raise
-          end
-        end
-      end
+  ##
+  # Class that's used to point to the current action. This can be useful if you
+  # want to access data such as the session() method without having to include
+  # Innate::Trinity (which can pollute your namespace and/or cause collisions).
+  #
+  # @author Michael Fellinger
+  # @since  25-03-2009
+  #
+  class Current < Innate::Current
+    ##
+    # @author Michael Fellinger
+    # @since  25-03-2009
+    # @see    Innate::Current#setup
+    def setup(env, request = Request, response = Response, session = Session)
+      super
     end
-  end
-end
+  end # Current
+end # Ramaze

data/lib/ramaze/default_middleware.rb

@@ -0,0 +1,24 @@
+Ramaze.middleware(:dev) do
+  use Rack::Lint
+  use Rack::CommonLogger, Ramaze::Log
+  use Rack::ShowExceptions
+  use Rack::ShowStatus
+  use Rack::RouteExceptions
+  use Rack::ConditionalGet
+  use Rack::ETag, 'public'
+  use Rack::Head
+  use Ramaze::Reloader
+
+  run Ramaze.core
+end
+
+Ramaze.middleware(:live) do
+  use Rack::CommonLogger, Ramaze::Log
+  use Rack::RouteExceptions
+  use Rack::ShowStatus
+  use Rack::ConditionalGet
+  use Rack::ETag, 'public'
+  use Rack::Head
+
+  run Ramaze.core
+end

data/lib/ramaze/files.rb

@@ -0,0 +1,59 @@
+module Ramaze
+  ##
+  # Class that makes it possible to easily use multiple public directories in
+  # your Ramaze application.
+  #
+  # @author Michael Fellinger
+  # @since  14-03-2009
+  #
+  class Files
+    ##
+    # Creates a new instance of the class, stores the given root directories
+    # and syncs the changes with Rack::Cascade.
+    #
+    # @author Michael Fellinger
+    # @since  14-03-2009
+    # @param  [Array] roots A set of root directories that contain a number of
+    #  public directories.
+    #
+    def initialize(*roots)
+      @roots = roots.flatten.map{|root| File.expand_path(root.to_s) }
+      sync
+    end
+
+    ##
+    # Allows this class to be called as a Rack middleware.
+    #
+    # @author Michael Fellinger
+    # @since  14-03-2009
+    # @param  [Hash] env Hash containing all the environment details.
+    #
+    def call(env)
+      @cascade.call(env)
+    end
+
+    ##
+    # Adds a new path to the list of root directories.
+    #
+    # @author Michael Fellinger
+    # @since  14-03-2009
+    # @param  [String] path The path to add to the existing root directories.
+    #
+    def <<(path)
+      @roots << File.expand_path(path.to_s)
+      @roots.uniq!
+      sync
+    end
+
+    ##
+    # Syncs the class with Rack::Cascade.
+    #
+    # @author Michael Fellinger
+    # @since  14-03-2009
+    #
+    def sync
+      file_apps = @roots.map { |root| Rack::Files.new(root) }
+      @cascade  = Rack::Cascade.new(file_apps)
+    end
+  end # Files
+end # Ramaze