manveru-ramaze 2009.06.12 → 2009.07

data/examples/misc/css.rb

@@ -10,15 +10,10 @@ module Ramaze::SourceReloadHooks
 end
 
 class CSSController < Ramaze::Controller
-  engine :Sass
-
-  helper :aspect
-  before_all do
-    response['Content-Type'] = 'text/css'
-    nil
-  end
+  helper :cache
+  provide :css, :type => 'text/css', :engine => :Sass
 
-  define_method('style.css') do
+  def style
     %(
 body
   font:
@@ -29,9 +24,8 @@ body
     )
   end
 
-  helper :cache
-  cache 'style.css'
+  cache_action :method => 'style'
 end
 
-# http://localhost:81/css/style.css
-Ramaze.start :adapter => :mongrel, :port => 81
+# http://localhost:7000/css/style.css
+Ramaze.start :adapter => :mongrel, :port => 7000

data/lib/proto/app.rb

@@ -6,10 +6,9 @@
 require 'rubygems'
 require 'ramaze'
 
-# Add the directory this file resides in to the load path, so you can run the
-# app from any other working directory
-$LOAD_PATH.unshift(__DIR__)
+# Make sure that Ramaze knows where you are
+Ramaze.options.roots = [__DIR__]
 
 # Initialize controllers and models
-require 'model/init'
-require 'controller/init'
+require __DIR__('model/init')
+require __DIR__('controller/init')

data/lib/proto/controller/init.rb

@@ -8,4 +8,4 @@ class Controller < Ramaze::Controller
 end
 
 # Here go your requires for subclasses of Controller:
-require 'controller/main'
+require __DIR__('main')

data/lib/proto/spec/main.rb

@@ -1,11 +1,10 @@
 require 'ramaze'
-require 'ramaze/spec'
+require 'ramaze/spec/bacon'
 
-require __DIR__('../start')
-Ramaze.options.roots = __DIR__('../')
+require __DIR__('../app')
 
 describe MainController do
-  behaves_like :mock
+  behaves_like :rack_test
 
   should 'show start page' do
     get('/').status.should == 200

data/lib/ramaze.rb

@@ -66,7 +66,6 @@ module Ramaze
     m.use Rack::ShowExceptions
     m.use Rack::ShowStatus
     m.use Rack::RouteExceptions
-    m.use Rack::ContentLength
     m.use Rack::ConditionalGet
     m.use Rack::ETag
     m.use Rack::Head
@@ -78,7 +77,6 @@ module Ramaze
     m.use Rack::CommonLogger, Ramaze::Log
     m.use Rack::RouteExceptions
     m.use Rack::ShowStatus
-    m.use Rack::ContentLength
     m.use Rack::ConditionalGet
     m.use Rack::ETag
     m.use Rack::Head

data/lib/ramaze/app.rb

@@ -70,10 +70,10 @@ module Ramaze
 
     attr_reader :name, :location, :url_map, :options
 
-    def initialize(name, location)
+    def initialize(name, location = nil)
       @name = name.to_sym
       @url_map = Innate::URLMap.new
-      self.location = location
+      self.location = location if location
 
       APP_LIST[@name] = self
 
@@ -113,7 +113,8 @@ module Ramaze
       roots.map{|root| publics.map{|public| ::File.join(root, public) }}.flatten
     end
 
-    def self.find_or_create(name, location = '/')
+    def self.find_or_create(name, location = nil)
+      location = '/' if location.nil? && name == :pristine
       self[name] || new(name, location)
     end
 

data/lib/ramaze/cache.rb

@@ -7,6 +7,7 @@ module Ramaze
   Cache = Innate::Cache
 
   class Cache
+    autoload :LRU,           'ramaze/cache/lru'
     autoload :LocalMemCache, 'ramaze/cache/localmemcache'
     autoload :MemCache,      'ramaze/cache/memcache'
     autoload :Sequel,        'ramaze/cache/sequel'

data/lib/ramaze/cache/lru.rb

@@ -0,0 +1,42 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Cache
+    class LRU
+      include Cache::API
+
+      OPTIONS = {
+        # expiration in seconds
+        :expiration => nil,
+        # maximum elements in the cache
+        :max_count => 10000,
+        # maximum total memory usage of the cache
+        :max_total => nil,
+        # maximum memory usage of an element of the cache
+        :max_value => nil,
+      }
+
+      # Connect to localmemcache
+      def cache_setup(host, user, app, name)
+        @store = Ramaze::LRUHash.new(OPTIONS)
+      end
+
+      def cache_clear
+        @store.clear
+      end
+
+      def cache_store(*args)
+        super{|key, value| @store[key] = value }
+      end
+
+      def cache_fetch(*args)
+        super{|key| @store[key] }
+      end
+
+      def cache_delete(*args)
+        super{|key| @store.delete(key) }
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/addressable_route.rb

@@ -18,25 +18,22 @@ module Ramaze
   # @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)
+    def initialize(app, routes = {})
       @app = app
+      @routes = {}
+
+      routes.each{|from, to| map(from, to) }
     end
 
     def call(env)
       path_info = env['PATH_INFO']
 
-      ROUTES.each do |template, target|
+      @routes.each do |template, target|
         extracted = template.extract(path_info)
         return dispatch(env, target, extracted) if extracted
       end
@@ -44,6 +41,10 @@ module Ramaze
       @app.call(env)
     end
 
+    def map(from, to)
+      @routes[Addressable::Template.new(from)] = to
+    end
+
     def dispatch(env, target, extracted)
       env['PATH_INFO'] = target
       original = Rack::Utils.parse_query(env['QUERY_STRING'])

data/lib/ramaze/controller.rb

@@ -51,9 +51,7 @@ module Ramaze
         trait(:provide_set => false)
       end
 
-      return if trait[:skip_controller_map]
-
-      map(generate_mapping(name))
+      map(generate_mapping(name)) unless trait[:skip_controller_map]
     end
 
     def self.engine(name)

data/lib/ramaze/helper/blue_form.rb

@@ -0,0 +1,214 @@
+require 'ramaze'
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+    # This helper tries to be an even better way to build forms
+    # programmatically, see the specs for lots of examples.
+    module BlueForm
+      def form(options = {}, &block)
+        form = Form.new(options)
+        form.build(form_errors, &block)
+        form
+      end
+
+      def form_error(name, message)
+        if respond_to?(:flash)
+          old = flash[:form_errors] || {}
+          flash[:form_errors] = old.merge(name.to_s => message.to_s)
+        else
+          form_errors[name.to_s] = message.to_s
+        end
+      end
+
+      def form_errors
+        if respond_to?(:flash)
+          flash[:form_errors] ||= {}
+        else
+          @form_errors ||= {}
+        end
+      end
+
+      def form_errors_from_model(obj)
+        obj.errors.each do |key, value|
+          form_error(key.to_s, value.first % key)
+        end
+      end
+
+      # Note that an instance of this class is not thread-safe, so you should
+      # modify it only within one thread of execution
+      class Form
+        attr_reader :g
+
+        def initialize(options)
+          @form_args = options.dup
+          @g = Gestalt.new
+        end
+
+        def build(form_errors = {})
+          @form_errors = form_errors
+
+          @g.form(@form_args) do
+            if block_given?
+              @g.fieldset do
+                yield self
+              end
+            end
+          end
+        end
+
+        def legend(text)
+          @g.legend(text)
+        end
+
+        def input_text(label, name, value = nil, args = {})
+          id = id_for(name)
+          args = args.merge(:type => :text, :name => name, :class => 'text', :id => id)
+          args[:value] = value unless value.nil?
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias text input_text
+
+        def input_password(label, name)
+          id = id_for(name)
+          args = {:type => :password, :name => name, :class => 'text', :id => id}
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias password input_password
+
+        def input_submit(value = nil)
+          args = {:type => :submit, :class => 'button submit'}
+          args[:value] = value unless value.nil?
+
+          @g.p do
+            @g.input(args)
+          end
+        end
+        alias submit input_submit
+
+        def input_checkbox(label, name, checked = false)
+          id = id_for(name)
+          args = {:type => :checkbox, :name => name, :class => 'checkbox', :id => id}
+          args[:checked] = 'checked' if checked
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias checkbox input_checkbox
+
+        def input_radio(label, name, values, options = {})
+          has_checked, checked = options.key?(:checked), options[:checked]
+
+          @g.p do
+            values.each_with_index do |(value, o_name), index|
+              o_name ||= value
+              id = id_for("#{name}-#{index}")
+
+              o_args = {:type => :radio, :value => value, :id => id, :name => name}
+              o_args[:checked] = 'checked' if has_checked && value == checked
+
+              if error = @form_errors.delete(name.to_s)
+                @g.label(:for => id){
+                  @g.span(:class => :error){ error }
+                  @g.input(o_args)
+                  @g.out << o_name
+                }
+              else
+                @g.label(:for => id){
+                  @g.input(o_args)
+                  @g.out << o_name
+                }
+              end
+            end
+          end
+        end
+        alias radio input_radio
+
+        def input_file(label, name)
+          id = id_for(name)
+          args = {:type => :file, :name => name, :class => 'file', :id => id}
+
+          @g.p do
+            label_for(id, label, name)
+            @g.input(args)
+          end
+        end
+        alias file input_file
+
+        def input_hidden(name, value = nil)
+          args = {:type => :hidden, :name => name}
+          args[:value] = value.to_s unless value.nil?
+
+          @g.input(args)
+        end
+        alias hidden input_hidden
+
+        def textarea(label, name, value = nil)
+          id = id_for(name)
+          args = {:name => name, :id => id}
+
+          @g.p do
+            label_for(id, label, name)
+            @g.textarea(args){ value }
+          end
+        end
+
+        def select(label, name, values, options = {})
+          id = id_for(name)
+          multiple, size = options.values_at(:multiple, :size)
+
+          args = {:id => id}
+          args[:multiple] = 'multiple' if multiple
+          args[:size] = (size || multiple || 1).to_i
+          args[:name] = multiple ? "#{name}[]" : name
+
+          has_selected, selected = options.key?(:selected), options[:selected]
+
+          @g.p do
+            label_for(id, label, name)
+            @g.select args do
+              values.each do |value, o_name|
+                o_name ||= value
+                o_args = {:value => value}
+                o_args[:selected] = 'selected' if has_selected && value == selected
+                @g.option(o_args){ o_name }
+              end
+            end
+          end
+        end
+
+        def to_s
+          @g.to_s
+        end
+
+        private
+
+        def label_for(id, value, name)
+          if error = @form_errors.delete(name.to_s)
+            @g.label("#{value} ", :for => id){ @g.span(:class => :error){ error } }
+          else
+            @g.label(value, :for => id)
+          end
+        end
+
+        def id_for(field_name)
+          if name = @form_args[:name]
+            "#{name}-#{field_name}".downcase.gsub(/_/, '-')
+          else
+            "form-#{field_name}".downcase.gsub(/_/, '-')
+          end
+        end
+      end
+    end
+  end
+end

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
@@ -58,19 +58,54 @@ module Ramaze
         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
 
-      module SingletonMethods
-        def cache(name, hash = {})
-          Ramaze.deprecated('Helper::Cache::cache', 'Helper::Cache::cache_action')
-          cache_action(hash.merge(:method => name))
+        if key and block_given?
+          if found = cache[key]
+            found
+          else
+            cache.store(key, yield, options)
+          end
+        else
+          cache
         end
+      end
 
+      module SingletonMethods
+        # 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