merb 0.3.4 → 0.3.7

data/lib/merb/core_ext/merb_numeric.rb

@@ -1,20 +1,72 @@
 class Numeric
+  
+  # Converts a number to currency. Optionally, it allows localization of currency.
+  #
+  #   1.5.to_currency #=> "$1.50"
+  # 
+  # You can also localize the symbol that appears before the number, the 
+  # thousands delimiter, the decimal delimiter, and the symbol that appears
+  # after the number:
+  #   1.5.to_currency nil, ",", ".", "$USD" #=> "1.50$USD"
+  #   67_000.5.to_currency nil, ".", ",", "DM" #=> "67.000,50DM"
   def to_currency(pre_symbol='$', thousands=',', decimal='.', post_symbol=nil) #:nodoc:
-    "#{pre_symbol}#{("%.2f" % self ).gsub(/(\d)(?=(?:\d{3})+(?:$|\.))/,"\\1#{thousands}")}#{post_symbol}"
+    "#{pre_symbol}#{("%.2f" % self ).gsub(".", decimal).gsub(/(\d)(?=(?:\d{3})+(?:$|[\\#{decimal}]))/,"\\1#{thousands}")}#{post_symbol}"
   end
 
+  # Divides the number by 1,000,000
+  # 
+  #   2.microseconds #=> 2.0e-06
   def microseconds() Float(self  * (10 ** -6)) end
+  # Divides the number by 1,000
+  #
+  #   2.milliseconds #=> 0.002
   def milliseconds() Float(self  * (10 ** -3)) end
+  # Returns the same number as is passed in
+  #
+  #   2.seconds #=> 2
   def seconds() self end
+  # Multiplies the number by 60
+  #
+  #   2.minutes #=> 120
   def minutes() 60 * seconds end
+  # Multiplies the number by 60 minutes
+  #
+  #   2.hours #=> 7200
   def hours() 60 * minutes end
+  # Multiples the number by 24 hours
+  #
+  #   2.days #=> 172800
   def days() 24 * hours end
+  # Multiples the number by 7 days
+  #
+  #   2.weeks #=> 1209600    
   def weeks() 7 * days end
+  # Multiples the number by 30 days
+  #
+  #   2.months #=> 5184000
   def months() 30 * days end
+  # Multiplies the number by 365 days
+  #
+  #   2.years #=> 63072000
   def years() 365 * days end
+  # Multiplies the number by 10 years
+  #
+  #   2.decades #=> 630720000
   def decades() 10 * years end
-  
-  %w{ microseconds milliseconds seconds minutes hours days weeks months years decades
-  }.each{ |m| mm = m.chop; alias_method mm, m }
 
-end
+  # Each of the time extensions also works in the singular:
+  #
+  #   1.day #=> 86400
+  #   1.hour #=> 3600
+  alias_method :microsecond, :microseconds
+  alias_method :millisecond, :milliseconds
+  alias_method :second, :seconds
+  alias_method :minute, :minutes
+  alias_method :hour, :hours
+  alias_method :day, :days
+  alias_method :week, :weeks
+  alias_method :month, :months
+  alias_method :year, :years
+  alias_method :decade, :decades
+              
+end

data/lib/merb/core_ext/merb_object.rb

@@ -1,27 +1,193 @@
 class Object
 
+  # Yields <tt>value</tt> to the passed block and returns the value.
+  # The object passed in as the value parameter is also passed to the block
+  # as a parameter.
+  #
+  #   returning({}) do |hsh| 
+  #     hsh.merge!((:bar => :baz))
+  #   end #=> {:bar => :baz}
   def returning(value)
     yield(value)
     value
   end
   
+  # Extracts the singleton class, so that metaprogramming can be done on it.
+  #
+  # Let's look at two code snippets:
+  #
+  #   class MyString < String; end
+  #
+  #   MyString.instance_eval do
+  #     define_method :foo do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   MyString.meta_class.instance_eval do
+  #     define_method :bar do
+  #       puts self
+  #     end
+  #   end
+  # 
+  #   def String.add_meta_var(var)
+  #     self.meta_class.instance_eval do
+  #       define_method var do
+  #         puts "HELLO"
+  #       end
+  #     end
+  #   end
+  #
+  #   MyString.new("Hello").foo  #=> "Hello"
+  #   MyString.new("Hello").bar  #=> NoMethodError: undefined method `bar' for "Hello":MyString
+  #   MyString.foo               #=> NoMethodError: undefined method `foo' for MyString:Class
+  #   MyString.bar               #=> MyString
+  #   String.bar                 #=> NoMethodError: undefined method `bar' for String:Class
+  #
+  #   MyString.add_meta_var(:x)
+  #   MyString.x                 #=> HELLO
+  #
+  # As you can see, using #meta_class allows you to execute code (and here, define
+  # a method) on the metaclass itself. It also allows you to define class methods that can
+  # be run on subclasses, and then be able to execute code on the metaclass of the subclass
+  # (here MyString).
+  #
+  # In this case, we were able to define a class method (add_meta_var) on String that was 
+  # executable by the MyString subclass. It was then able to define a method on the subclass
+  # by adding it to the MyString metaclass.
+  #
+  # For more information, you can check out _why's excellent article at:
+  # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
   def meta_class() class << self; self end end
   
+  # Runs instance_eval on the metaclass (see Object#meta_class).
+  #
+  #   String.meta_eval do
+  #     define_method :zoo do
+  #       puts "zoo"
+  #     end
+  #   end
+  #
+  #   String.zoo # => "zoo"
   def meta_eval(&blk) meta_class.instance_eval( &blk ) end
   
+  # Defines a method on the metaclass (see Object#meta_class).
+  #
+  #   String.meta_def :zoo do
+  #     puts "zoo"
+  #   end
+  #
+  #   String.zoo #=> "zoo"
+  #
+  # If the class inherits from another class, it will only be defined
+  # on the direct class meta_def is called on.
+  #
+  #   class Foo; end
+  #   class Bar < Foo; end
+  #   class Baz < Foo; end
+  #
+  #   Bar.meta_def :q do; "Q"; end
+  #   Foo.q #=> undefined method `r' for Foo:Class
+  #   Bar.q #=> "Q"
+  #   Baz.q #=> undefined method `r' for Baz:Class
+  #
+  # See Object#class_def for a comprehensive example containing meta_def
   def meta_def(name, &blk) meta_eval { define_method name, &blk } end
   
+  # Defines a method on new instances of the class.
+  #
+  #   String.class_def :zoo do
+  #     puts "zoo"
+  #   end
+  #
+  #   "HELLO".zoo #=> "zoo"
+  #
+  # In combination with meta_def, you can do some pretty powerful
+  # things:
+  #
+  # require 'merb_object'
+  # class Foo
+  #   def self.var
+  #     @var
+  #   end
+  #   def self.make_var baz
+  #     attr_accessor baz
+  #     meta_def baz do |val|
+  #       @var = val
+  #     end
+  #     class_def :initialize do
+  #       instance_variable_set("@#{baz}", self.class.var)
+  #     end
+  #   end
+  # end
+  #
+  # It might look a bit hairy, but here are some results that
+  # may help:
+  #
+  #   class Bar < Foo
+  #     make_var :foo
+  #     foo "FOO"
+  #   end
+  #
+  #   Bar.new.foo #=> "FOO"
+  #
+  # Essentially, what's happening is that Foo.make_var has the
+  # following effects when some symbol (:foo) is passed in:
+  # * Adds a new :foo accessor (returning @foo)
+  # * Adds a new foo method on the **class**, allowing you to set
+  #   a default value.
+  # * Sets @foo to that default value when new objects are
+  #   initialized.
+  #
+  # In the case of the Bar class, the following occurred:
+  # * make_var :foo created a new :foo accessor
+  # * foo "FOO" set the default value of @foo to "FOO"
+  # * Bar.new created a new Bar object containing the
+  #   instance variable @foo containing the default value
+  #   "FOO"
   def class_def name, &blk
-    self.class.class_eval { define_method name, &blk }
+    class_eval { define_method name, &blk }
   end   
   
+  # Returns true if:
+  # * it's an empty array
+  # * !self evaluates to true
+  #
+  #    [].blank?    #=> true
+  #    nil.blank?   #=> true
+  #    false.blank? #=> true
+  #    [nil].blank? #=> false
   def blank?
-    if    respond_to? :empty? then empty?
-    elsif respond_to? :zero?  then zero?
-    else !self
-    end   
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
   end
 
+  def full_const_get(name)
+    list = name.split("::")
+    obj = Object
+    list.each {|x| obj = obj.const_get(x) }
+    obj
+  end
+  
+  # An elegant way to refactor out common options
+  # 
+  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
+  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
+  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
+  #     post.has_many :all_comments
+  #   end
+  # 
+  # Can also be used with an explicit reciever:
+  # 
+  #   map.with_options :controller => "people" do |people|
+  #     people.connect "/people",     :action => "index"
+  #     people.connect "/people/:id", :action => "show"
+  #   end
   def with_options(options)
     yield Merb::OptionMerger.new(self, options)
   end
@@ -51,4 +217,4 @@ module Merb
         end  
       end
   end
-end
+end

data/lib/merb/generators/merb_app/merb_app.rb

@@ -1,17 +1,10 @@
 require 'fileutils'
 require 'find'
 
-begin
-  require 'archive/tar/minitar'
-rescue LoadError
-  puts "You must gem install archive-tar-minitar to use the merb app generator"
-  exit!
-end
-
 module Merb
   
   class AppGenerator    
-    SKELETON = File.expand_path File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'examples/skeleton.tar')
+    SKELETON_DIR = File.expand_path File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'examples/skeleton')
     
     def self.run(path)
       @path = path
@@ -23,7 +16,20 @@ module Merb
 
       puts "Copying skeleton app to '#@path'"
       # Unpacks 'test.tar' to 'x', creating 'x' if necessary.
-      Archive::Tar::Minitar.unpack(SKELETON, @path)
+      FileUtils.cp_r(SKELETON_DIR, @path)
+      Find.find(@path) do |f|
+        FileUtils.rm_rf(f) if /\.svn$/ =~ f
+      end
+      public_path = File.expand_path(File.join(@path, "dist", "public"))
+      mailer_path = File.expand_path(File.join(@path, "dist", "app", "mailers"))
+      app_path    = File.expand_path(File.join(@path, "dist", "app"))
+      FileUtils.mkdir_p(["#{mailer_path}/helpers", 
+                         "#{mailer_path}/views", 
+                         "#{@path}/log", 
+                         "#{app_path}/models",
+                         "#{public_path}/javascripts",
+                         "#{public_path}/stylesheets",
+                         "#{public_path}/images"])
       puts 'Done' 
     end  
 

data/lib/merb/merb_abstract_controller.rb

@@ -0,0 +1,193 @@
+require File.dirname(__FILE__)+'/mixins/render_mixin'
+
+module Merb
+  
+  class AbstractController                 
+    include Merb::RenderMixin
+    
+    class_inheritable_accessor :before_filters
+    class_inheritable_accessor :after_filters
+    
+    # Holds internal execution times. Prefaced with an underscore to not 
+    # conflict with user-defined controller instance variables.
+    attr_accessor :_benchmarks
+    
+    def initialize(*args)
+      @_benchmarks = {}
+    end
+    
+    def dispatch(action=:to_s)
+      caught = catch(:halt) do
+        start = Time.now
+        result = call_filters(before_filters)
+        @_benchmarks[:before_filters_time] = Time.now - start if before_filters
+        result
+      end
+      @_body = case caught
+      when :filter_chain_completed
+        call_action(action)
+      when String
+        caught
+      when nil
+        filters_halted
+      when Symbol
+        send(caught)
+      when Proc
+        caught.call(self)  
+      else
+        raise MerbControllerError, "The before filter chain is broken dude. wtf?"
+      end
+      start = Time.now
+      call_filters(after_filters) 
+      @_benchmarks[:after_filters_time] = Time.now - start if after_filters
+    end
+    
+  protected
+    
+    def call_action(action)
+      send(action)
+    end
+    
+    # calls a filter chain according to rules.
+    def call_filters(filter_set)
+      (filter_set || []).each do |(filter, rule)|
+        ok = false
+        if rule.has_key?(:only)
+          if rule[:only].include?(params[:action].intern)
+            ok = true
+          end  
+        elsif rule.has_key?(:exclude)
+          if !rule[:exclude].include?(params[:action].intern)
+            ok = true
+          end 
+        else
+          ok = true
+        end    
+        if ok
+          case filter
+            when Symbol, String
+             send(filter)
+            when Proc
+             filter.call(self)
+          end
+        end   
+      end
+      return :filter_chain_completed
+    end 
+  
+    def finalize_session
+      # noop
+    end  
+      
+    def setup_session
+      # noop
+    end
+    
+    # override this method on your controller classes to specialize
+    # the output when the filter chain is halted.
+    def filters_halted
+      "<html><body><h1>Filter Chain Halted!</h1></body></html>"  
+    end
+    
+    
+    # #before is a class method that allows you to specify before filters in
+    # your controllers. Filters can either be a symbol or string that
+    # corresponds to a method name to call, or a proc object. if it is a method
+    # name that method will be called and if it is a proc it will be called
+    # with an argument of self where self is the current controller object.
+    # When you use a proc as a filter it needs to take one parameter.
+    # 
+    # examples:
+    #   before :some_filter
+    #   before :authenticate, :exclude => [:login, :signup]
+    #   before Proc.new {|c| c.some_method }, :only => :foo
+    #
+    # You can use either :only => :actionname or :exclude => [:this, :that]
+    # but not both at once. :only will only run before the listed actions
+    # and :exclude will run for every action that is not listed.
+    #
+    # Merb's before filter chain is very flexible. To halt the filter chain you
+    # use throw :halt. If throw is called with only one argument of :halt the
+    # return of the method filters_halted will be what is rendered to the view.
+    # You can overide filters_halted in your own controllers to control what it
+    # outputs. But the throw construct is much more powerful then just that.
+    # throw :halt can also take a second argument. Here is what that second arg
+    # can be and the behavior each type can have:
+    #
+    # * String:
+    #   when the second arg is a string then that string will be what
+    #   is rendered to the browser. Since merb's render method returns
+    #   a string you can render a template or just use a plain string:
+    #
+    #     throw :halt, "You don't have permissions to do that!"
+    #     throw :halt, render(:action => :access_denied)
+    #
+    # * Symbol:
+    #   If the second arg is a symbol then the method named after that
+    #   symbol will be called
+    #
+    #   throw :halt, :must_click_disclaimer
+    #
+    # * Proc:
+    #
+    #   If the second arg is a Proc, it will be called and its return
+    #   value will be what is rendered to the browser:
+    #
+    #     throw :halt, Proc.new {|c| c.access_denied }
+    #     throw :halt, Proc.new {|c| Tidy.new(c.index) }
+    # 
+    def self.before(filter, opts={})
+      raise(ArgumentError,
+        "You can specify either :only or :exclude but 
+         not both at the same time for the same filter."
+      ) if opts.has_key?(:only) && opts.has_key?(:exclude)
+      
+      opts = shuffle_filters!(opts)
+      
+      case filter
+      when Symbol, String, Proc
+        (self.before_filters ||= []) << [filter, opts]
+      else
+        raise(ArgumentError, 
+          'filters need to be either a Symbol, String or a Proc'
+        )        
+      end  
+    end
+    
+    # #after is a class method that allows you to specify after filters in your
+    # controllers. Filters can either be a symbol or string that corresponds to
+    # a method name or a proc object. If it is a method name that method will
+    # be called and if it is a proc it will be called with an argument of self.
+    # When you use a proc as a filter it needs to take one parameter. You can
+    # gain access to the response body like so: after Proc.new {|c|
+    # Tidy.new(c.body) }, :only => :index
+    def self.after(filter, opts={})
+      raise(ArgumentError,
+        "You can specify either :only or :exclude but 
+         not both at the same time for the same filter."
+      ) if opts.has_key?(:only) && opts.has_key?(:exclude)
+    
+      opts = shuffle_filters!(opts)
+      
+      case filter
+      when Symbol, Proc, String
+        (self.after_filters ||= []) << [filter, opts]
+      else
+        raise(ArgumentError, 
+          'After filters need to be either a Symbol, String or a Proc'
+        )        
+      end
+    end
+    
+    def self.shuffle_filters!(opts={})
+      if opts[:only] && opts[:only].is_a?(Symbol)
+        opts[:only] = [opts[:only]]
+      end 
+      if opts[:exclude] && opts[:exclude].is_a?(Symbol)
+        opts[:exclude] = [opts[:exclude]]
+      end
+      return opts
+    end
+  end  
+  
+end