merb 0.3.7 → 0.4.0

data/lib/merb/core_ext/{merb_hash.rb → hash.rb}

@@ -1,7 +1,7 @@
-require 'hpricot'
+#require 'hpricot'
 
 class Hash
-
+ 	  
   class << self
       # Converts valid XML into a Ruby Hash structure.
       # <tt>xml</tt>:: A string representation of valid XML
@@ -68,6 +68,14 @@ class Hash
       end
   end
   
+  # convert this hash into a Mash for string or symbol key access
+  def to_mash
+ 	  hash = Mash.new(self) 
+ 	  hash.default = self.default 
+ 	  hash
+ 	end
+ 	
+ 	# convert this hash to a query string param
   def to_params
     result = ''
     stack = []
@@ -104,7 +112,34 @@ class Hash
   end
   alias except block
 
-
+  # Converts the hash into xml attributes
+  # { :one => "ONE", "two"=>"TWO" }.to_xml_attributes
+  # #=> 'one="ONE" two="TWO"'
+  def to_xml_attributes
+    map do |k,v|
+      "#{k.to_s.camelize.sub(/^(.{1,1})/){|m| m.downcase}}=\"#{v}\""
+    end.join(" ")
+  end
+  
+  alias_method :to_html_attributes, :to_xml_attributes
+ 
+  # Adds the given class symbol or string to the hash in the
+  # :class key.  This will add a html class if there are already any existing
+  # or create the key and add this as the first class
+  #
+  # Example
+  # @hash[:class] #=> nil
+  # @hash.add_html_class!(:selected) #=> @hash[:class] == "selected"
+  #
+  # @hash.add_html_class!("class1 class2") #=> @hash[:class] == "selected class1 class2"
+  def add_html_class!(html_class)
+    if self[:class]
+      self[:class] = "#{self[:class]} #{html_class}"
+    else
+      self[:class] = html_class.to_s
+    end
+  end
+  
   # Destructively convert all keys to symbols recursively.
   def symbolize_keys!
     keys.each do |key|
@@ -221,14 +256,8 @@ class REXMLUtilityNode # :nodoc:
   end
 
   def to_html 
-    "<#{name}#{attributes_to_xml}>#{inner_html}</#{name}>"
+    "<#{name}#{attributes.to_xml_attributes}>#{inner_html}</#{name}>"
   end
-
-  def attributes_to_xml
-    attributes.keys.map do |key| 
-      "#{key}='#{attributes[key]}'"
-    end.join
-  end  
 end
 
 class ToHashParser # :nodoc:
@@ -256,4 +285,4 @@ class ToHashParser # :nodoc:
 		end
 		stack.pop.to_hash
 	end	
-end
+end

data/lib/merb/core_ext/{merb_inflector.rb → inflector.rb}

@@ -272,4 +272,4 @@ module Inflector
   end
 end
 
-require File.dirname(__FILE__) + '/merb_inflections'
+require File.dirname(__FILE__) + '/inflections'

data/lib/merb/core_ext/{merb_kernel.rb → kernel.rb}

@@ -1,9 +1,9 @@
 module Kernel
   # Example:
-  #   aquire 'foo/bar/*'
+  #   acquire 'foo/bar/*'
   # requires all files inside foo/bar - recursive
   # can take multiple parameters
-  def aquire(*files)
+  def acquire(*files)
     files.each do |file|
       require file if %w(rb so).any?{|f| File.file?("#{file}.#{f}")}
       $:.each do |path|
@@ -22,6 +22,38 @@ module Kernel
     puts message if message
   end
   
+  def dependencies(*args)
+    args.each do |arg|
+      case arg
+        when String : dependency(arg)
+        when Hash : arg.each { |r,v|  dependency(r, v) }
+      end
+    end
+  end
+  
+  def dependency(gem, *ver)
+    Gem.activate(gem, true, *ver)
+  end
+  
+  def use_orm(orm)
+    raise "Don't call use_orm more than once" unless 
+      Merb::GENERATOR_SCOPE.delete(:merb_default)
+    orm = orm.to_sym
+    orm_plugin = orm.to_s.match(/^merb_/) ? orm.to_s : "merb_#{orm}" 
+    Merb::GENERATOR_SCOPE.unshift(orm) unless
+      Merb::GENERATOR_SCOPE.include?(orm)
+    Kernel.dependency(orm_plugin)
+  end
+  
+  def use_test(test_framework)
+    test_framework = test_framework.to_sym
+    raise "use_test only supports :rspec and :test_unit currently" unless
+      [:rspec, :test_unit].include?(test_framework)
+    Merb::GENERATOR_SCOPE.delete(:rspec)
+    Merb::GENERATOR_SCOPE.delete(:test_unit)
+    Merb::GENERATOR_SCOPE.push(test_framework)
+  end
+  
   # Gives you back the file, line and method of the caller number i
   # Example:
   #   __caller_info__(1) # -> ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
@@ -53,7 +85,7 @@ module Kernel
   #     [ 124, "      @suspend_next = false",                       false ]
   #   ]
 
-  def __caller_lines__ file, line, size = 4
+  def __caller_lines__(file, line, size = 4)
     return [['Template Error!', "problem while rendering", false]] if file =~ /\(erubis\)/
     lines = File.readlines(file)
     current = line.to_i - 1
@@ -75,4 +107,25 @@ module Kernel
 
     area
   end
+  
+  def __profile__(name, min=1)
+    require 'ruby-prof' unless defined?(RubyProf)
+    return_result = ''
+    result = RubyProf.profile do
+      100.times{return_result = yield}
+    end
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    path = File.join(MERB_ROOT, 'log', "#{name}.html")
+    File.open(path, 'w') do |file|
+     printer.print(file, {:min_percent => min,
+                          :print_file => true})
+    end
+    return_result
+  end  
+  
+  # Extracts an options hash if it is the last item in the args array
+  def extract_options_from_args!(args)
+    args.pop if args.last.is_a?( Hash )
+  end
+  
 end

data/lib/merb/core_ext/mash.rb

@@ -0,0 +1,88 @@
+ 
+# This class has dubious semantics and we only have it so that 
+# people can write params[:key] instead of params['key'] 
+ 
+class Mash < Hash 
+  def initialize(constructor = {}) 
+    if constructor.is_a?(Hash) 
+      super() 
+      update(constructor) 
+    else 
+      super(constructor) 
+    end 
+  end 
+ 
+  def default(key = nil) 
+    if key.is_a?(Symbol) && include?(key = key.to_s) 
+      self[key] 
+    else 
+      super 
+    end 
+  end 
+ 
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
+  alias_method :regular_update, :update unless method_defined?(:regular_update) 
+ 
+  def []=(key, value) 
+    regular_writer(convert_key(key), convert_value(value)) 
+  end 
+ 
+  def update(other_hash) 
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
+    self 
+  end 
+ 
+  alias_method :merge!, :update 
+ 
+  def key?(key) 
+    super(convert_key(key)) 
+  end 
+ 
+  alias_method :include?, :key? 
+  alias_method :has_key?, :key? 
+  alias_method :member?, :key? 
+ 
+  def fetch(key, *extras) 
+    super(convert_key(key), *extras) 
+  end 
+ 
+  def values_at(*indices) 
+    indices.collect {|key| self[convert_key(key)]} 
+  end 
+ 
+  def dup 
+    Mash.new(self) 
+  end 
+ 
+  def merge(hash) 
+    self.dup.update(hash) 
+  end 
+ 
+  def delete(key) 
+    super(convert_key(key)) 
+  end 
+ 
+  def stringify_keys!; self end 
+  def symbolize_keys!; self end 
+ 
+  # Convert to a Hash with String keys. 
+  def to_hash 
+    Hash.new(default).merge(self) 
+  end 
+ 
+  protected 
+    def convert_key(key) 
+      key.kind_of?(Symbol) ? key.to_s : key 
+    end 
+ 
+    def convert_value(value) 
+      case value 
+      when Hash 
+        value.to_mash 
+      when Array 
+        value.collect { |e| e.is_a?(Hash) ? e.to_mash : e } 
+      else 
+        value 
+      end 
+    end
+end

data/lib/merb/core_ext/{merb_object.rb → object.rb}

@@ -151,12 +151,18 @@ class Object
   
   # Returns true if:
   # * it's an empty array
+  # * it's an empty string
   # * !self evaluates to true
   #
-  #    [].blank?    #=> true
-  #    nil.blank?   #=> true
-  #    false.blank? #=> true
-  #    [nil].blank? #=> false
+  #    [].blank?         #=>  true
+  #    [1].blank?        #=>  false
+  #    [nil].blank?      #=>  false
+  #    nil.blank?        #=>  true
+  #    true.blank?       #=>  false
+  #    false.blank?      #=>  true
+  #    "".blank?         #=>  true
+  #    "     ".blank?    #=>  true
+  #    " hey ho ".blank? #=>  false  
   def blank?
     if respond_to?(:empty?) && respond_to?(:strip)
       empty? or strip.empty?
@@ -173,48 +179,5 @@ class 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
-end
 
-module Merb
-  class OptionMerger #:nodoc:
-    instance_methods.each do |method| 
-      undef_method(method) if method !~ /^(__|instance_eval|class)/
-    end
-    
-    def initialize(context, options)
-      @context, @options = context, options
-    end
-    
-    private
-      def method_missing(method, *arguments, &block)
-        merge_argument_options! arguments
-        @context.send(method, *arguments, &block)
-      end
-      
-      def merge_argument_options!(arguments)
-        arguments << if arguments.last.respond_to? :to_hash
-          @options.merge(arguments.pop)
-        else
-          @options.dup
-        end  
-      end
-  end
 end

data/lib/merb/core_ext/string.rb

@@ -0,0 +1,56 @@
+require 'strscan'
+
+class String
+  class InvalidPathConversion < Exception; end
+  
+  def escape_regexp
+    Regexp.escape self
+  end
+  
+  # "FooBar".snake_case #=> "foo_bar"
+  def snake_case
+    gsub(/\B[A-Z]/, '_\&').downcase
+  end
+
+  # "foo_bar".camel_case #=> "FooBar"
+  def camel_case
+    split('_').map{|e| e.capitalize}.join
+  end
+  
+  # About 50% faster than string.split('/').map{ |s| s.camel_case }.join('::')
+  def to_const_string
+    new_string = ""
+    input = StringScanner.new(self.downcase)
+    until input.eos?
+      if input.scan(/([a-z][a-zA-Z\d]*)(_|$|\/)/)
+        new_string << input[1].capitalize
+        new_string << "::" if input[2] == '/'
+      else
+        raise InvalidPathConversion, self
+      end
+    end
+    new_string
+  end
+
+  # Concatenates a path
+  def /(o)
+    File.join(self, o.to_s)
+  end
+  
+  # Takes lines of text, removes any indentation, and
+  # adds +indentation+ number of spaces to each line
+  def indent(indentation)
+    lines = to_a
+    initial_indentation = lines.first.scan(/^(\s+)/).flatten.first
+    lines.map do |line|
+      if initial_indentation.nil?
+        " " * indentation + line
+      elsif line.index(initial_indentation) == 0
+        " " * indentation + line[initial_indentation.size..-1]
+      else
+        " " * indentation + line
+      end
+    end.join
+  end
+  
+end

data/lib/merb/dispatcher.rb

@@ -0,0 +1,109 @@
+module Merb
+  class Dispatcher
+    
+    DEFAULT_ERROR_TEMPLATE = Erubis::MEruby.new((File.read(
+	File.join(MERB_ROOT, 'app/views/exceptions/internal_server_error.html.erb')) rescue "Internal Server Error!"))
+        
+    class << self
+      
+      def use_mutex=(val)
+        @@use_mutex = val
+      end
+      
+      @@mutex = Mutex.new
+      @@use_mutex = ::Merb::Server.config[:use_mutex]
+      # This is where we grab the incoming request REQUEST_URI and use that in
+      # the merb RouteMatcher to determine which controller and method to run.
+      # Returns a 2 element tuple of: [controller, action]
+      #
+      # ControllerExceptions are rescued here and redispatched.
+      # Exceptions still return [controller, action]
+      def handle(http_request, response)
+        start   = Time.now
+        request = Merb::Request.new(http_request)
+        MERB_LOGGER.info("Params: #{request.params.inspect}")
+        MERB_LOGGER.info("Cookies: #{request.cookies.inspect}")
+        # user friendly error messages
+        if request.route_params.empty?
+          raise ControllerExceptions::NotFound, "No routes match the request"
+        elsif request.controller_name.nil?
+          raise ControllerExceptions::NotFound, "Route matched, but route did not specify a controller" 
+        end
+        MERB_LOGGER.debug("Routed to: #{request.route_params.inspect}")
+        # set controller class and the action to call
+        klass = request.controller_class
+        dispatch_action(klass, request.action, request, response)
+      rescue => exception
+        MERB_LOGGER.error(Merb.exception(exception))
+        exception = controller_exception(exception)
+        dispatch_exception(request, response, exception)
+      end
+        
+      private 
+      
+      # setup the controller and call the chosen action 
+      def dispatch_action(klass, action, request, response, status=200)
+        # build controller
+        controller = klass.build(request, response, status)
+        # complete setup benchmarking
+        #controller._benchmarks[:setup_time] = Time.now - start
+        if @@use_mutex
+          @@mutex.synchronize { controller.dispatch(action) }
+        else
+          controller.dispatch(action)
+        end
+        [controller, action]
+      end
+      
+      # Re-route the current request to the Exception controller
+      # if it is available, and try to render the exception nicely
+      # if it is not available then just render a simple text error
+      def dispatch_exception(request, response, exception)
+        klass = Exceptions rescue Controller
+        request.params[:original_params] = request.params.dup rescue {}
+        request.params[:original_session] = request.session.dup rescue {}
+        request.params[:original_cookies] = request.cookies.dup rescue {}
+        request.params[:exception] = exception
+        request.params[:action] = exception.name
+        dispatch_action(klass, exception.name, request, response, exception.class::STATUS)
+      rescue => dispatch_issue
+        dispatch_issue = controller_exception(dispatch_issue)  
+        # when no action/template exist for an exception, or an
+        # exception occurs on an InternalServerError the message is
+        # rendered as simple text.
+        # ControllerExceptions raised from exception actions are 
+        # dispatched back into the Exceptions controller
+        if dispatch_issue.is_a?(ControllerExceptions::NotFound)
+          dispatch_default_exception(klass, request, response, exception)
+        elsif dispatch_issue.is_a?(ControllerExceptions::InternalServerError)
+          dispatch_default_exception(klass, request, response, dispatch_issue)
+        else
+          exception = dispatch_issue
+          retry
+        end
+      end
+      
+      # if no custom actions are available to render an exception
+      # then the errors will end up here for processing
+      def dispatch_default_exception(klass, request, response, e)
+        controller = klass.build(request, response, e.class::STATUS)
+        if e.is_a? ControllerExceptions::Redirection
+          controller.headers.merge!('Location' => e.message)
+          controller.instance_variable_set("@_body", %{ }) #fix
+        else
+          @exception = e # for ERB
+          controller.instance_variable_set("@_body", DEFAULT_ERROR_TEMPLATE.result(binding))
+        end
+        [controller, e.name]
+      end
+      
+      # Wraps any non-ControllerException errors in an 
+      # InternalServerError ready for displaying over HTTP
+      def controller_exception(e)
+        e.kind_of?(ControllerExceptions::Base) ?
+          e : ControllerExceptions::InternalServerError.new(e) 
+      end
+      
+    end # end class << self
+  end
+end