Pistos-ramaze 2009.04.08 → 2009.06.12

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

@@ -65,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.rb

@@ -19,23 +19,41 @@ module Ramaze
 
     def self.inherited(into)
       Innate::Node.included(into)
+      into.helper(:layout)
       CONTROLLER_LIST << into
       into.trait :skip_node_map => true
     end
 
     def self.setup
-      require 'ramaze/controller/default' if CONTROLLER_LIST.empty?
+      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
 
-      CONTROLLER_LIST.each do |controller|
-        unless controller.ancestral_trait[:provide_set]
-          controller.engine(:Etanni)
-          controller.trait(:provide_set => false)
+        controller.setup_procedure
+      else
+        CONTROLLER_LIST.each do |controller|
+          controller.setup_procedure
         end
-        next if controller.trait[:skip_controller_map]
-        controller.map(generate_mapping(controller.name))
       end
     end
 
+    def self.setup_procedure
+      unless ancestral_trait[:provide_set]
+        engine(:Etanni)
+        trait(:provide_set => false)
+      end
+
+      map(generate_mapping(name)) unless trait[:skip_controller_map]
+    end
+
     def self.engine(name)
       provide(:html, name.to_sym)
     end
@@ -50,7 +68,7 @@ module Ramaze
     }
 
     def self.generate_mapping(klass_name = self.name)
-      chunks = klass_name.split(/::/)
+      chunks = klass_name.to_s.split(/::/)
       return if chunks.empty?
 
       last = chunks.last
@@ -80,15 +98,5 @@ module Ramaze
       return unless app = self.app
       app.options
     end
-
-    def self.template(*args)
-      Ramaze.deprecated('Controller::template', 'Controller::alias_view')
-      alias_view(*args)
-    end
-
-    def self.view_root(*locations)
-      Ramaze.deprecated('Controller::view_root', 'Controller::map_views')
-      map_views(*locations)
-    end
   end
 end

data/lib/ramaze/gestalt.rb

@@ -84,6 +84,9 @@ module Ramaze
       if args.size == 1 and args[0].kind_of? Hash
         # args are just attributes, children in block...
         _gestalt_build_tag name, args[0], &block
+      elsif args[1].kind_of? Hash
+        # args are text and attributes ie. a('mylink', :href => '/mylink')
+        _gestalt_build_tag(name, args[1], args[0], &block)
       else
         # no attributes, but text
         _gestalt_build_tag name, {}, args, &block
@@ -95,7 +98,7 @@ module Ramaze
 
     def _gestalt_build_tag(name, attr = {}, text = [])
       @out << "<#{name}"
-      @out << attr.map{|k,v| %[ #{k}="#{_gestalt_escape_entities(v)}"] }.join
+      @out << attr.map{|(k,v)| %[ #{k}="#{_gestalt_escape_entities(v)}"] }.join
       if text != [] or block_given?
         @out << ">"
         @out << _gestalt_escape_entities([text].join)

data/lib/ramaze/helper.rb

@@ -9,4 +9,5 @@ module Ramaze
 
   require 'ramaze/helper/flash'
   require 'ramaze/helper/link'
+  require 'ramaze/helper/layout'
 end

data/lib/ramaze/helper/auth.rb

@@ -43,11 +43,6 @@ module Ramaze
         !!session[:logged_in]
       end
 
-      def check_auth(user, pass)
-        Ramaze.deprecated('Helper::User#check_auth', 'Helper::User#auth_login')
-        auth_login(user, pass)
-      end
-
       # @return
       def auth_login(user, pass)
         return unless user and pass

data/lib/ramaze/helper/cache.rb

@@ -16,7 +16,7 @@ module Ramaze
         into.extend(SingletonMethods)
         into.add_action_wrapper(6.0, :cache_wrap)
         into.trait[:cache_action] ||= Set.new
-        Ramaze::Cache.add(:action, :action_value)
+        Ramaze::Cache.add(:action, :cache_helper_value)
       end
 
       # @param [Action] action The currently wrapped action
@@ -28,46 +28,86 @@ module Ramaze
         cache = Innate::Cache.action
 
         ancestral_trait[:cache_action].each do |cache_action|
-          temp = cache_action.dup
-          ttl = temp.delete(:ttl)
+          temp  = cache_action.dup
+          block = temp.delete(:key)
+          ttl   = temp.delete(:ttl)
 
           if temp.all?{|key, value| action[key] == value }
-            if cached = cache[temp]
-              return cached
-            elsif ttl
-              return cache.store(temp, yield, :ttl => ttl)
+            cache_key = action.full_path
+            cache_key << "_#{action.instance.instance_eval(&block).to_s}" if block
+
+            if cached = cache[cache_key]
+              action.options[:content_type] = cached[:type]
             else
-              return cache.store(temp, yield)
+              cached = {
+                :body => catch(:respond) { yield },
+                :type => response['Content-Type']
+              }
+
+              if ttl
+                cache.store(cache_key, cached, :ttl => ttl)
+              else
+                cache.store(cache_key, cached)
+              end
             end
+
+            return cached[:body]
           end
         end
 
         yield
       end
 
-      # @return [Object] The cache wrapper assigned for :action_value
+      # This method is used to access Ramaze::Cache.cache_helper_value.
+      # It provides an easy way to cache long-running computations, gathering
+      # external resources like RSS feeds or DB queries that are the same for
+      # every user of an application.
+      # This method changes behaviour if a block is passed, which can be used
+      # to do lazy computation of the cached value conveniently when using a
+      # custom TTL or longer expressions that don't fit on one line with ||=.
+      #
+      # @usage Example to get the cache object directly
+      #
+      #   count = cache_value[:count] ||= Article.count
+      #
+      # @usage Example with block
+      #
+      #   count = cache_value(:count){ Article.count }
+      #   count = cache_value(:count, :ttl => 60){ Article.count }
+      #
+      # @return [Object] The cache wrapper assigned for :cache_helper_value
       # @see Innate::Cache
       # @author manveru
-      def cache_value
-        Ramaze::Cache.action_value
-      end
-
+      def cache_value(key = nil, options = {})
+        cache = Ramaze::Cache.cache_helper_value
 
-      # @deprecated Use the #cache_value method instead
-      # @author manveru
-      def value_cache
-        Ramaze::deprecated('Innate::Helper::Cache#value_cache',
-                           'Innate::Helper::Cache#cache_value')
-        cache_value
+        if key and block_given?
+          if found = cache[key]
+            found
+          else
+            cache.store(key, yield, options)
+          end
+        else
+          cache
+        end
       end
 
       module SingletonMethods
-        def cache(name, hash = {})
-          Ramaze.deprecated('Helper::Cache::cache', 'Helper::Cache::cache_action')
-          cache_action(hash.merge(:method => name))
-        end
-
-        def cache_action(hash)
+        # This method allows you to cache whole actions.
+        #
+        # @example Basic usage
+        #
+        #   class Foo < Ramaze::Controller
+        #     helper :cache
+        #     cache_action :method => :bar
+        #
+        #     def bar
+        #       rand
+        #     end
+        #   end
+        #
+        def cache_action(hash, &block)
+          hash[:key] = block if block_given?
           hash[:method] = hash[:method].to_s
           trait[:cache_action] << hash
         end

data/lib/ramaze/helper/form.rb

@@ -35,13 +35,25 @@ module Ramaze
         Ramaze::Gestalt.build{ tr{ td(:colspan => 2){ input(hash) }}}
       end
 
+      # @example usage, normal select drop-down
+      #
+      #   form_select('Favourite colors', :colors, @colors, :selected => @color)
+      #
+      # @example usage for pre-selected value
+      #
+      #   form_select('Favourite colors', :colors, @colors, :selected => @color)
+      #
+      # @example usage, allow selecting multiple
+      #
+      #   form_select('Cups', :cups, @cups, :selected => @cup, :multiple => 5)
       def form_select(label, name, values, hash = {})
         name = name.to_sym
         id = "form-#{name}"
+        multiple, size = hash.values_at(:multiple, :size)
 
         s_args = {:name => name, :id => id}.merge(form_tabindex)
-        s_args[:multiple] = :multiple if hash[:multiple]
-        s_args[:size] = hash[:size] || 1
+        s_args[:multiple] = :multiple if multiple
+        s_args[:size] = (size || multiple || 1).to_i
 
         has_selected, selected = hash.key?(:selected), hash[:selected]
         error = form_errors[name.to_s]

data/lib/ramaze/helper/formatting.rb

@@ -3,6 +3,8 @@
 
 module Ramaze
   module Helper::Formatting
+    module_function
+
     FORMATTING_NUMBER_COUNTER = { 0 => 'no', 2 => 'two', 3 => 'three',
       4 => 'four', 5 => 'five', 6 => 'six', 7 => 'seven', 8 => 'eight',
       9 => 'nine', 10 => 'ten' }
@@ -113,7 +115,7 @@ module Ramaze
                       [-\w]+                   # subdomain or domain
                       (?:\.[-\w]+)*            # remaining subdomains or domain
                       (?::\d+)?                # port
-                      (?:/(?:(?:[~\w\+@%-]|(?:[,.;:][^\s$]))+)?)* # path
+                      (?:/(?:(?:[~\w\+@%-]|(?:[,.;:][^\s$])))?)* # path
                       (?:\?[\w\+@%&=.;-]+)?     # query string
                       (?:\#[\w\-]*)?           # trailing anchor
                     )

data/lib/ramaze/helper/gestalt.rb

@@ -3,6 +3,8 @@ require 'ramaze/gestalt'
 module Ramaze
   module Helper
     module Gestalt
+      CACHE_G = {}
+
       def gestalt(&block)
         Ramaze::Gestalt.new(&block)
       end
@@ -10,6 +12,36 @@ module Ramaze
       def build(&block)
         Ramaze::Gestalt.build(&block)
       end
+
+      def g(meth = nil, view = nil)
+        meth ||= caller[0].slice(/`(.*)'?/).gsub(/[\`\']/, '')
+        view_name = (self.class.to_s.sub('Controller', '') + 'View').split('::')
+        view ||= view_name.inject(Object){ |ns, name| ns.const_get(name) }
+
+        gestalt_class = CACHE_G[view] ||= g_class
+        gestalt = gestalt_class.new
+        gestalt.extend(view)
+        instance_variables.each do |iv|
+          gestalt.instance_variable_set(iv, instance_variable_get(iv))
+        end
+        gestalt.__send__(meth)
+        gestalt.to_s
+      end
+
+      def g_class
+        ancs = self.class.ancestors
+        helpers = Ramaze::Helper.constants.map{ |c| Ramaze::Helper.const_get(c)}
+        our_helpers = ancs & helpers
+        our_helpers.delete(Ramaze::Helper::Gestalt)
+        gestalt_class = Class.new(Ramaze::Gestalt){ include(*our_helpers) }
+      end
+
+      def method_missing(sym, *args, &block)
+        @gestalt ||= gestalt
+        @gestalt.send(sym, *args, &block)
+      end
     end
   end
 end
+
+module Ramaze::Helper::Link; undef :a end

data/lib/ramaze/helper/identity.rb

@@ -26,7 +26,7 @@ module Ramaze
       # embedded into a page.
       def openid_login_form(caption="login")
         %{
-<form method="GET" action="#{Rs(:openid_begin)}">
+<form method="GET" action="#{rs(:openid_begin)}">
   Identity URL: <input type="text" name="url" />
   <input type="submit" value="#{caption}"/>
 </form>
@@ -62,7 +62,7 @@ module Ramaze
         openid_request.return_to_args['did_pape'] = 'y'
 
         root      = "http://#{request.http_host}/"
-        return_to = request.domain(Rs(:openid_complete)).to_s
+        return_to = request.domain(rs(:openid_complete)).to_s
         immediate = false
 
         if openid_request.send_redirect?(root, return_to, immediate)
@@ -75,7 +75,7 @@ module Ramaze
 
       rescue OpenID::OpenIDError => ex
         flash[:error] = "Discovery failed for #{url}: #{ex}"
-        raw_redirect Rs(:/)
+        raw_redirect rs(:/)
       end
 
       # After having authenticated at the OpenID server browsers are redirected

data/lib/ramaze/helper/layout.rb

@@ -0,0 +1,97 @@
+module Ramaze
+  module Helper
+
+    # Provides wrapper methods for a higher-level approach than the core layout
+    # method.  These are useful for simpler layout needs, particularly:
+    #
+    # * layout all actions
+    # * layout a whitelist of actions
+    # * layout all but a blacklist of actions
+    #
+    # As with the core layout method, the layout rules apply only to the
+    # controller on which they are applied.  Furthermore, multiple layout
+    # definitions are not combined; only the last definition will be used.
+    #
+    # This helper is one of the default helpers, so no explicit helper call
+    # is necessary before using it in your controllers.
+    #
+    # Usage:
+    #
+    #    class MainController < Controller
+    #      # Apply the default layout (e.g. ./layout/default.xhtml) to all
+    #      # three actions.
+    #      set_layout 'default'
+    #      def action1; end
+    #      def action2; end
+    #      def action3; end
+    #    end
+    #
+    #    class MainController < Controller
+    #      # These two layout definitions accomplish the same thing.  The
+    #      # first uses a whitelist, the second uses a blacklist.
+    #      set_layout 'default' => [:laid_out1, :laid_out2]
+    #      set_layout_except 'default' => [:not_laid_out1, :not_laid_out2]
+    #
+    #      def laid_out1; end
+    #      def laid_out2; end
+    #
+    #      def not_laid_out1; end
+    #      def not_laid_out2; end
+    #    end
+    module Layout
+      def self.included(into)
+        into.extend SingletonMethods
+      end
+
+      module SingletonMethods
+        # @param [String Hash] Either a layout name, or a single-element Hash
+        #   which maps a layout name to an Array containing a whitelist of
+        #   action names
+        # @see set_layout_except Innate::Node::layout
+        # @author Pistos, manveru
+        # @example Use a layout named 'default' on all actions of the controller:
+        #   set_layout 'default'
+        # @example Use a layout named 'default' on just the index and admin actions:
+        #   set_layout 'default' => [ :index, :admin ]
+        def set_layout(hash_or_the_layout)
+          if hash_or_the_layout.respond_to?(:to_hash)
+            f = hash_or_the_layout.first
+            the_layout = f[0]
+            whitelist = f[1].map{|action| action.to_s }
+          else
+            the_layout = hash_or_the_layout
+          end
+
+          layout do |path, wish|
+            if whitelist.nil? || whitelist.include?(path.to_s)
+              the_layout
+            end
+          end
+        end
+
+        # @param [String Hash] Either a layout name, or a single-element Hash
+        #   which maps a layout name to an Array containing a blacklist of
+        #   action names
+        # @see set_layout Innate::Node::layout
+        # @author Pistos, manveru
+        # @example Use a layout named 'default' on all actions except the user_data action:
+        #   set_layout_except 'default' => [ :user_data ]
+        def set_layout_except(hash_or_the_layout)
+          if hash_or_the_layout.respond_to?(:to_hash)
+            f = hash_or_the_layout.to_hash.first
+            the_layout = f[0]
+            blacklist = f[1].map{|action| action.to_s }
+          else
+            the_layout = hash_or_the_layout
+          end
+
+          layout do |path, wish|
+            if blacklist.nil? || !blacklist.include?(path.to_s)
+              the_layout
+            end
+          end
+        end
+      end
+    end
+  end
+end