ramaze 2009.05 → 2009.06

data/examples/app/wikore/src/model.rb

@@ -45,6 +45,12 @@ module Model
   end
 
   [Page, OldPage].each do |klass|
-    klass.create_table unless klass.table_exists?
+    begin
+      klass.create_table
+    rescue Sequel::DatabaseError => e
+      if e.message !~ /table.*already exists/
+        raise e
+      end
+    end
   end
 end

data/examples/app/wiktacular/template/html_layout.xhtml

@@ -22,6 +22,6 @@
     <div id="content">
       #@content
     </div>
-    <div id="copyright">Wiktacular is powered by <a href="http://ramaze.rubyforge.org/">Ramaze</a></div>
+    <div id="copyright">Wiktacular is powered by <a href="http://ramaze.net">Ramaze</a></div>
   </body>
 </html>

data/lib/proto/config.ru

@@ -10,7 +10,11 @@
 # rackup automatically figures out the environment it is run in, and runs your
 # application as FastCGI, CGI, or standalone with Mongrel or WEBrick -- all from
 # the same configuration.
+#
+# Do not set the adapter.handler in here, it will be ignored.
+# You can choose the adapter like `ramaze start -s mongrel` or set it in the
+# 'start.rb' and use `ruby start.rb` instead.
 
-require File.expand_path('app', File.dirname(__FILE__))
+require ::File.expand_path('app', ::File.dirname(__FILE__))
 Ramaze.start(:file => __FILE__, :started => true)
 run Ramaze

data/lib/ramaze/cache/localmemcache.rb

@@ -31,7 +31,7 @@ module Ramaze
 
       # Wipe out _all_ data in localmemcached, use with care.
       def cache_clear
-        ::LocalMemCache.clear_namespace(@namespace)
+        @store.clear
       end
 
       def cache_delete(*args)

data/lib/ramaze/cache/memcache.rb

@@ -13,7 +13,20 @@ module Ramaze
     #
     # It is highly recommended to install memcache-client_extensions for
     # a bit of speedup and more functionality
+    #
+    # NOTE: There is a big issue with persisting sessions in memcache, not only
+    #       can they be dropped at any time, essentially logging the user out
+    #       without them noticing, but there is also a low limit to the maximum
+    #       time-to-live. After 30 days, your session will be dropped, no
+    #       matter what.
+    #       Please remember that memcache is, first of all, a cache, not a
+    #       persistence mechanism.
+    #
+    # NOTE: If you try to set a higher ttl than allowed, your stored key/value
+    #       will be expired immediately.
     class MemCache
+      MAX_TTL = 2592000
+
       include Cache::API
 
       # +:multithread+: May be turned off at your own risk.
@@ -34,6 +47,7 @@ module Ramaze
         options = {:namespace => @namespace}.merge(OPTIONS)
         servers = options.delete(:servers)
         @store = ::MemCache.new(servers, options)
+        @warned = false
       end
 
       # Wipe out _all_ data in memcached, use with care.
@@ -46,7 +60,7 @@ module Ramaze
 
       #
       def cache_delete(*keys)
-        super{|key| @store.delete(key) }
+        super{|key| @store.delete(key); nil }
       rescue ::MemCache::MemCacheError => e
         Log.error(e)
         nil
@@ -65,6 +79,17 @@ module Ramaze
 
       def cache_store(key, value, options = {})
         ttl = options[:ttl] || 0
+
+        if ttl > MAX_TTL
+          unless @warned
+            Log.warn('MemCache cannot set a ttl greater than 2592000 seconds.')
+            Log.warn('Modify Ramaze.options.session.ttl to a value <= of that.')
+            @warned = true
+          end
+
+          ttl = MAX_TTL
+        end
+
         @store.set(key, value, ttl)
         value
       rescue ::MemCache::MemCacheError => e

data/lib/ramaze/cache/sequel.rb

@@ -16,19 +16,22 @@ module Ramaze
 
       class Table < ::Sequel::Model(:ramaze_cache)
         plugin :schema
-        plugin :serialization, :marshal, :value
+        plugin :serialization
+
+        serialize_attributes :marshal, :value
 
         set_schema do
           primary_key :id
-          string :key
-          string :value
-          time :expires
           index :key, :unique => true
+
+          String :key
+          String :value
+          Time :expires
         end
 
         def [](column)
           if column == :value
-            deserialized_values[column] = deserialize_value(@values[column])
+            deserialized_values[column] = deserialize_value(column, @values[column])
           else
             super
           end
@@ -38,7 +41,7 @@ module Ramaze
       # Setup the table, not suitable for multiple apps yet.
       def cache_setup(host, user, app, name)
         @namespace = [host, user, app, name].compact.join(':')
-        Table.create_table unless Table.table_exists?
+        Table.create_table?
         @store = Table
       end
 

data/lib/ramaze/contrib/addressable_route.rb

@@ -0,0 +1,55 @@
+require "addressable/template"
+
+module Ramaze
+  # This is a simple prototype-implementation of how we could do routing
+  # supported by URI templates.
+  #
+  # Please see the spec for example usage as it's not integrated yet in any way.
+  #
+  # What it does is basically that you can give it any URI template and a final
+  # mapping, and it will extract the variables from the URI and merge them into
+  # the QUERY_STRING, which is parsed again in Ramaze if you issue
+  # Request#params.
+  #
+  # @example given mapping like:
+  #
+  #     map('/customer/{customer_id}/order/{order_id}', '/order/show')
+  #
+  # @example output of request.params at '/order/show'
+  #
+  #     {'customer_id => '12', 'order_id' => '15'}
+  #     
+  # I haven't explored the full capabilities of the templates yet, but the
+  # specs of Addressable::Template suggest that there is a lot to be
+  # discovered.
+  class AddressableRoute
+    ROUTES = {}
+
+    def self.map(from, to)
+      ROUTES[Addressable::Template.new(from)] = to
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      path_info = env['PATH_INFO']
+
+      ROUTES.each do |template, target|
+        extracted = template.extract(path_info)
+        return dispatch(env, target, extracted) if extracted
+      end
+
+      @app.call(env)
+    end
+
+    def dispatch(env, target, extracted)
+      env['PATH_INFO'] = target
+      original = Rack::Utils.parse_query(env['QUERY_STRING'])
+      env['QUERY_STRING'] = Rack::Utils.build_query(original.merge(extracted))
+
+      @app.call(env)
+    end
+  end
+end

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

@@ -59,9 +59,9 @@ module Facebook
       end while ret.empty? and @server = connect
 
       ret = case
-            when ret == 'true':    true
-            when ret == 'false':   false
-            when ret[0..0] == '"': ret[1..-2]
+            when ret == 'true';    true
+            when ret == 'false';   false
+            when ret[0..0] == '"'; ret[1..-2]
             else
               begin
                 JSON::parse(ret)
@@ -168,4 +168,4 @@ module Facebook
       buf
     end
   end
-end
+end

data/lib/ramaze/controller.rb

@@ -19,23 +19,43 @@ 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.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
+
+      return if trait[:skip_controller_map]
+
+      map(generate_mapping(name))
+    end
+
     def self.engine(name)
       provide(:html, name.to_sym)
     end
@@ -50,7 +70,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 +100,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

@@ -98,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/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

@@ -65,15 +65,6 @@ module Ramaze
         Ramaze::Cache.action_value
       end
 
-
-      # @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
-      end
-
       module SingletonMethods
         def cache(name, hash = {})
           Ramaze.deprecated('Helper::Cache::cache', 'Helper::Cache::cache_action')

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

@@ -115,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/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