ramaze 0.1.0 → 0.1.1

data/lib/ramaze/global/dsl.rb

@@ -0,0 +1,29 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  CLIOption = Struct.new('CLIOption', :name, :default, :doc, :cli)
+  OPTIONS     = {}
+  CLI_OPTIONS = []
+
+  module GlobalDSL
+    class << self
+      def option_dsl(&block)
+        instance_eval(&block)
+      end
+
+      def o(doc, options = {})
+        cli_given = options.has_key?(:cli)
+        cli = options.delete(:cli)
+        name, default = options.to_a.flatten
+
+        if cli_given
+          option = CLIOption.new(name, default, doc, cli)
+          CLI_OPTIONS << option
+        end
+
+        OPTIONS.merge!(options)
+      end
+    end
+  end
+end

data/lib/ramaze/global/globalstruct.rb

@@ -0,0 +1,90 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class GlobalStruct < Struct.new('Global', *OPTIONS.keys)
+    ADAPTER_ALIAS = {
+      :webrick => :WEBrick,
+      :mongrel => :Mongrel,
+      :cgi     => :CGI,
+      :fcgi    => :Fcgi,
+    }
+
+    CACHE_ALIAS = {
+      :memcached => :MemcachedCache,
+      :memory    => :MemoryCache,
+      :yaml      => :YAMLStoreCache,
+    }
+
+    class << self
+      def setup options = {}
+        self.fill(options)
+      end
+    end
+
+    def startup(options = {})
+      options.each do |key, value|
+        if (method(key) rescue false)
+          self[key] = value
+        else
+          create_member(key, value)
+        end
+      end
+    end
+
+    def setup(hash = {})
+      hash.each do |key, value|
+        self.send("#{key}=", value)
+      end
+      yield(self) if block_given?
+    end
+
+    # Object wraps
+
+    def adapter
+      if internal = self[:adapter]
+        class_name = ADAPTER_ALIAS[internal.to_sym]
+        require("ramaze/adapter/"/class_name.to_s.downcase)
+        adapter = Ramaze::Adapter.const_get(class_name)
+      end
+    end
+
+    def cache
+      cache_name = self[:cache].to_sym
+      class_name = CACHE_ALIAS[cache_name] || cache_name
+      cache = Ramaze.const_get(class_name)
+    end
+
+    def ports
+      (port..(port + (spawn - 1)))
+    end
+
+    def sourcereload=(interval)
+      self[:sourcereload] = interval
+      sri = Thread.main[:sourcereload]
+      sri.interval = interval if sri
+    end
+
+    # External helpers
+
+    def values_at(*keys)
+      keys.map{|key| __send__(key)}
+    end
+
+    private # Internal helpers
+
+    def create_member key, value = nil
+      Inform.warn "Create #{key}=#{value.inspect} on Global"
+
+      @table ||= {}
+      key = key.to_sym
+
+      (class << self; self; end).class_eval do
+        define_method(key){ @table[key] }
+        define_method("#{key}="){|val| @table[key] = val }
+      end
+
+      @table[key] = value
+    end
+  end
+end

data/lib/ramaze/helper.rb

@@ -23,7 +23,7 @@ module Ramaze
     def helper *syms
       syms.each do |sym|
         mod_name = sym.to_s.capitalize + 'Helper'
-        require "ramaze/helper/#{sym}"
+        require("ramaze/helper/"/sym)
         include ::Ramaze.const_get(mod_name)
         extend ::Ramaze.const_get(mod_name)
       end

data/lib/ramaze/helper/aspect.rb

@@ -13,202 +13,62 @@ module Ramaze
   # want this feature it shouldn't have too large impact ;)
 
   module AspectHelper
-
-    # define the trait[:aspects] for the class that includes us
-    # also prepare hijacking of the :render method
-
     def self.included(klass)
-      # if we haven't been included yet...
-      unless defined?(Traits[klass][:aspects]) and Traits[klass][:aspects]
-        klass.trait :aspects => {:pre => {}, :post => {}, :wrap => {}}
-        unless defined?(klass.old_render)
-          klass.class_eval do
-            class << self
-              include AspectHelperMixin
-              alias_method :old_render, :render
-              alias_method :render, :new_render
-
-              public :render
-            end
-          end
-        end
-      end
+      klass.trait[:aspects] ||= { :before => {}, :after => {} }
     end
-  end
-
-  # This is the actual Module to be included into the Controller you call
-  #   helper :aspect
-  # from.
-  #
-  # The reason for that is to avoid recursion of inclusion in AspectHelper
-  # which does the aliasing and predefinition of the traits for the aspects.
 
-  module AspectHelperMixin
     private
 
-    # define pre-aspect which calls render(:your_pre_aspect)
-    # and appends it on your default action
-    # please note, that if you give can define
-    #   pre :all, :all_, :except => [:action1, :action2]
-    #   pre :all, :all_, :except => :action
-    # however, due to the nature of this helper, only action that have been
-    # defined so far are wrapped by the :all.
-    # methods that are in the :except (which is not mandatory) are ignored.
-    #
-    # the notion :all_ is a nice reminder that it is a pre-wrapper, you don't
-    # have to use the underscore, it's just my way to do it.
-    #
-    # Also, be careful, since :all will wrap other wraps that have been defined
-    # so far as well.
-    # Usually i don't think it's a good thing that order defines
-    # behaviour, but in this case it gives you quite powerful control
-    # over the whole process. Just watch out:
-    #   With great power comes great responsibility
-    #
-    # Example:
-    #   class FooController < Controller
-    #
-    #     def index
-    #       'foo'
-    #     end
-    #     pre :index, :_index
-    #
-    #     def other
-    #       'foo'
-    #     end
-    #     pre :all, :all_, :except => :index
-    #
-    #     def _index
-    #       'I will be put before your action'
-    #     end
-    #
-    #     def _all
-    #       '<pre>'
-    #     end
-    #   end
-
-    def pre(*opts)
-      enwrap(:pre, *opts)
-    end
-    alias before pre
-
-    # define post-aspect which calls render(:your_post_aspect)
-    # and appends it on your default action
-    # please note, that if you give can define
-    #   post :all, :all_, :except => [:action1, :action2]
-    #   post :all, :all_, :except => :action
-    # however, due to the nature of this helper, only action that have been
-    # defined so far are wrapped by the :all.
-    # methods that are in the :except (which is not mandatory) are ignored.
-    #
-    # the notion :all_ is a nice reminder that it is a post-wrapper, you don't
-    # have to use the underscore, it's just my way to do it.
-    #
-    # Also, be careful, since :all will wrap other wraps that have been defined
-    # so far as well.
-    # Usually i don't think it's a good thing that order defines
-    # behaviour, but in this case it gives you quite powerful control
-    # over the whole process. Just watch out:
-    #   With great power comes great responsibility
-    #
-    # Example:
-    #   class FooController < Controller
-    #
-    #     def index
-    #       'foo'
-    #     end
-    #     post :index, :index_
-    #
-    #     def other
-    #       'foo'
-    #     end
-    #     pre :all, :all_, :except => :index
-    #
-    #     def index_
-    #       'I will be put after your action'
-    #     end
-    #
-    #     def all_
-    #       '</pre>'
-    #     end
-    #   end
-
-    def post(*opts)
-      enwrap(:post, *opts)
+    def before(*meths, &block)
+      aspects = trait[:aspects][:before]
+      meths.each do |meth|
+        aspects[meth.to_s] = block
+      end
     end
-    alias after post
-
-    # a shortcut that combines pre and post
-    # same syntax as pre/post, just a linesaver
+    alias pre before
 
-    def wrap(*opts)
-      pre(*opts)
-      post(*opts)
+    def before_all(&block)
+      meths = instance_methods(false)
+      before(*meths, &block)
     end
+    alias pre_all before_all
 
-    # you shouldn't have to call this method directly
-    # however, if you really, really want to:
-    #
-    # enwrap(:post, :index, :my_post_method, :except => :bar
-
-    def enwrap(kind, key, meths, hash = {})
-      wrapping =
-      if key == :all
-        instance_methods(false).map{|im| im.to_sym}
-      else
-        if ([] + key rescue nil)
-          key.map{|k| k.to_sym}
-        else
-          [key.to_sym]
-        end
-      end
-
-      if hash[:except]
-        wrapping -= [hash[:except]].flatten.map{|m| m.to_sym}
-      end
-
-      wrapping.each do |meth|
-        ancestral_trait[:aspects][kind][meth] = meths
+    def after(*meths, &block)
+      aspects = trait[:aspects][:after]
+      meths.each do |meth|
+        aspects[meth.to_s] = block
       end
     end
+    alias post after
 
-    # find the post and pre actions for the current class
-
-    def resolve_aspect(action)
-      action = action.to_sym
-      aspects = ancestral_trait[:aspects]
-      {
-        :pre  => aspects[:pre][action],
-        :post => aspects[:post][action]
-      }
+    def after_all(&block)
+      meths = instance_methods(false)
+      after(*meths, &block)
     end
+    alias post_all after_all
 
-    # this will be exchanged for the :render method which is aliased
-    # to old_render
-    # it just searches for post and pre wrappers, calls them
-    # before/after your action and joins the results
-
-    def new_render(action)
-      arity_for = lambda{|meth| method(meth).arity rescue -1 }
-      post, pre = resolve_aspect(action.method).values_at(:post, :pre)
-
-      if pre
-        arity = arity_for[pre].abs
-        pre_action = resolve_action(pre, *action.params[0,arity])
-        pre_content = old_render(pre_action)
-      end
+    def wrap(*meths, &block)
+      before(*meths, &block)
+      after(*meths, &block)
+    end
 
-      unless (pre_content.delete(:skip_next_aspects) rescue false)
-        content = old_render(action)
+    def wrap_all(&block)
+      meths = instance_methods(false)
+      wrap(*meths, &block)
+    end
 
-        if post
-          arity = arity_for[post].abs
-          post_action = resolve_action(post, *action.params[0,arity])
-          post_content = old_render(post_action)
-        end
-      end
+    def before_process(action)
+      block = ancestral_trait[:aspects][:before][action.method]
+      before = action.controller.instance_eval(&block) if block
+      before
+    end
 
-      [pre_content, content, post_content].join
+    def after_process(action)
+      block = ancestral_trait[:aspects][:after][action.method]
+      after = action.controller.instance_eval(&block) if block
+      after
     end
+
+    module_function :before_process, :after_process
   end
 end

data/lib/ramaze/helper/cache.rb

@@ -2,15 +2,14 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module CacheHelper
-
-    # Cache for single key/value pairs
-
-    trait :value_cache  => Global.cache.new
 
-    # Cache for values returned from actions
+  # This helper is providing easy access to a couple of Caches to use for
+  # smaller amounts of data.
 
-    trait :action_cache => Controller.trait[:action_cache]
+  module CacheHelper
+    def self.included(klass)
+      Cache.add(:value_cache) unless Cache::CACHES.has_key?(:value_cache)
+    end
 
     private
 
@@ -18,7 +17,7 @@ module Ramaze
     # for example heavy calculations or time-consuming queries.
 
     def value_cache
-      ancestral_trait[:value_cache]
+      Cache.value_cache
     end
 
     # holds the values returned on the first call to a cached action.
@@ -38,7 +37,7 @@ module Ramaze
     #   action_cache.delete_if{|key, value| key =~ /"index",/}
 
     def action_cache
-      Controller.trait[:action_cache]
+      Cache.actions
     end
 
     # This refers to the class-trait of cached actions, you can

data/lib/ramaze/helper/cgi.rb

@@ -0,0 +1,23 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Shortcuts to some CGI methods
+
+  module CgiHelper
+    private
+
+    # shortcut for CGI.escape
+
+    def escape(*args)
+      CGI.escape(*args)
+    end
+
+    # shortcut for CGI.unescape
+
+    def unescape(*args)
+      CGI.escape(*args)
+    end
+  end
+end

data/lib/ramaze/helper/file.rb

@@ -5,6 +5,9 @@ module Ramaze
   module FileHelper
     private
 
+    # Sets Content-Type to the mimetype of the file and opens the file you pass
+    # it, then throws :respond to finish off the request.
+
     def send_file(file, mime_type = Tool::MIME.type_for(file))
       response.header["Content-Type"] = mime_type
       response.body = File.open(file)

data/lib/ramaze/helper/inform.rb

@@ -2,6 +2,9 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+
+  # Easy access to Inform
+
   module InformHelper
 
     private