joe-merb-core 0.9.8

data/lib/merb-core/controller/template.rb

@@ -0,0 +1,254 @@
+module Merb::InlineTemplates
+end
+
+module Merb::Template
+  
+  EXTENSIONS  = {} unless defined?(EXTENSIONS)
+  METHOD_LIST = {} unless defined?(METHOD_LIST)
+  MTIMES      = {} unless defined?(MTIMES)
+  
+  class << self
+    # Get the template's method name from a full path. This replaces
+    # non-alphanumeric characters with __ and "." with "_"
+    #
+    # Collisions are potentially possible with something like:
+    # ~foo.bar and __foo.bar or !foo.bar.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to convert to a valid Ruby method name
+    #
+    # ==== Returns
+    # String:: The template name.
+    #
+    #---
+    # We might want to replace this with something that varies the
+    # character replaced based on the non-alphanumeric character
+    # to avoid edge-case collisions.
+    def template_name(path)
+      path = File.expand_path(path)      
+      path.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_")
+    end
+
+    # For a given path, get an IO object that responds to #path.
+    #
+    # This is so that plugins can override this if they provide
+    # mechanisms for specifying templates that are not just simple
+    # files. The plugin is responsible for ensuring that the fake
+    # path provided will work with #template_for, and thus the
+    # RenderMixin in general.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to find a template for. This is the
+    #   path that the RenderMixin assumes it should find the template
+    #   in.
+    # 
+    # ==== Returns
+    # IO#path:: An IO object that responds to path (File or VirtualFile).
+    #---
+    # @semipublic
+    def load_template_io(path)
+      File.open(path, "r")
+    end
+
+    # Get the name of the template method for a particular path.
+    #
+    # ==== Parameters
+    # path<String>:: A full path to find a template method for.
+    # template_stack<Array>:: The template stack. Not used.
+    #
+    # ==== Returns
+    # <String>:: name of the method that inlines the template.
+    #---
+    # @semipublic
+    def template_for(path, template_stack = [])
+      path = File.expand_path(path)
+      
+      ret = 
+      if Merb::Config[:reload_templates]
+        file = Dir["#{path}.{#{template_extensions.join(',')}}"].first
+        METHOD_LIST[path] = file ? inline_template(load_template_io(file)) : nil
+      else
+        METHOD_LIST[path] ||= begin
+          file = Dir["#{path}.{#{template_extensions.join(',')}}"].first          
+          file ? inline_template(load_template_io(file)) : nil
+        end
+      end
+      
+      ret
+    end
+    
+    # Get all known template extensions
+    #
+    # ==== Returns
+    #   Array:: Extension strings.
+    #---
+    # @semipublic
+    def template_extensions
+      EXTENSIONS.keys
+    end
+    
+    # Takes a template at a particular path and inlines it into a module and
+    # adds it to the METHOD_LIST table to speed lookup later.
+    # 
+    # ==== Parameters
+    # io<#path>::
+    #   An IO that responds to #path (File or VirtualFile)
+    # mod<Module>::
+    #   The module to put the compiled method into. Defaults to
+    #   Merb::InlineTemplates
+    #
+    # ==== Notes
+    # Even though this method supports inlining into any module, the method
+    # must be available to instances of AbstractController that will use it.
+    #---
+    # @public
+    def inline_template(io, mod = Merb::InlineTemplates)
+      path = File.expand_path(io.path)
+      ret = METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = 
+        engine_for(path).compile_template(io, template_name(path), mod)
+      io.close
+      ret
+    end
+    
+    # Finds the engine for a particular path.
+    # 
+    # ==== Parameters
+    # path<String>:: The path of the file to find an engine for.
+    #
+    # ==== Returns
+    # Class:: The engine.
+    #---
+    # @semipublic
+    def engine_for(path)
+      path = File.expand_path(path)      
+      EXTENSIONS[path.match(/\.([^\.]*)$/)[1]]
+    end
+    
+    # Registers the extensions that will trigger a particular templating
+    # engine.
+    # 
+    # ==== Parameters
+    # engine<Class>:: The class of the engine that is being registered
+    # extensions<Array[String]>:: 
+    #   The list of extensions that will be registered with this templating
+    #   language
+    #
+    # ==== Raises
+    # ArgumentError:: engine does not have a compile_template method.
+    #
+    # ==== Example
+    #   Merb::Template.register_extensions(Merb::Template::Erubis, ["erb"])
+    #---
+    # @public
+    def register_extensions(engine, extensions) 
+      raise ArgumentError, "The class you are registering does not have a compile_template method" unless
+        engine.respond_to?(:compile_template)
+      extensions.each{|ext| EXTENSIONS[ext] = engine }
+      Merb::AbstractController.class_eval <<-HERE
+        include #{engine}::Mixin
+      HERE
+    end
+  end
+  
+  require 'erubis'
+
+  class Erubis    
+    # ==== Parameters
+    # io<#path>:: An IO containing the full path of the template.
+    # name<String>:: The name of the method that will be created.
+    # mod<Module>:: The module that the compiled method will be placed into.
+    def self.compile_template(io, name, mod)
+      template = ::Erubis::BlockAwareEruby.new(io.read)
+
+      _old_verbose, $VERBOSE = $VERBOSE, nil
+      template.def_method(mod, name, File.expand_path(io.path))
+      $VERBOSE = _old_verbose
+      
+      name
+    end
+
+    module Mixin
+      
+      # ==== Parameters
+      # *args:: Arguments to pass to the block.
+      # &block:: The template block to call.
+      #
+      # ==== Returns
+      # String:: The output of the block.
+      #
+      # ==== Examples
+      # Capture being used in a .html.erb page:
+      # 
+      #   <% @foo = capture do %>
+      #     <p>Some Foo content!</p> 
+      #   <% end %>
+      def capture_erb(*args, &block)
+        _old_buf, @_erb_buf = @_erb_buf, ""
+        block.call(*args)
+        ret = @_erb_buf
+        @_erb_buf = _old_buf
+        ret
+      end
+
+      # DOC
+      def concat_erb(string, binding)
+        @_erb_buf << string
+      end
+            
+    end
+  
+    Merb::Template.register_extensions(self, %w[erb])    
+  end
+  
+end
+
+module Erubis
+  module BlockAwareEnhancer
+    def add_preamble(src)
+      src << "_old_buf, @_erb_buf = @_erb_buf, ''; "
+      src << "@_engine = 'erb'; "
+    end
+
+    def add_postamble(src)
+      src << "\n" unless src[-1] == ?\n      
+      src << "_ret = @_erb_buf; @_erb_buf = _old_buf; _ret.to_s;\n"
+    end
+
+    def add_text(src, text)
+      src << " @_erb_buf.concat('" << escape_text(text) << "'); "
+    end
+
+    def add_expr_escaped(src, code)
+      src << ' @_erb_buf.concat(' << escaped_expr(code) << ');'
+    end
+    
+    def add_stmt2(src, code, tailch)
+      src << code
+      src << " ).to_s; " if tailch == "="
+      src << ';' unless code[-1] == ?\n
+    end
+    
+    def add_expr_literal(src, code)
+      if code =~ /(do|\{)(\s*\|[^|]*\|)?\s*\Z/
+        src << ' @_erb_buf.concat( ' << code << "; "
+      else
+        src << ' @_erb_buf.concat((' << code << ').to_s);'
+      end
+    end
+  end
+
+  class BlockAwareEruby < Eruby
+    include BlockAwareEnhancer
+  end
+  
+  # module RubyEvaluator
+  # 
+  #   # DOC
+  #   def def_method(object, method_name, filename=nil)
+  #     m = object.is_a?(Module) ? :module_eval : :instance_eval
+  #     setup = "@_engine = 'erb'"
+  #     object.__send__(m, "def #{method_name}(locals={}); #{setup}; #{@src}; end", filename || @filename || '(erubis)')
+  #   end
+  #  
+  # end
+end

data/lib/merb-core/core_ext.rb

@@ -0,0 +1,9 @@
+begin
+  require "extlib"
+rescue LoadError => e
+  puts "Merb-core 0.9.4 and later uses extlib for Ruby core class extensions. Install it from github.com/sam/extlib."
+  exit
+end
+
+require File.dirname(__FILE__) / "core_ext" / "kernel"
+require File.dirname(__FILE__) / "core_ext" / "hash"

data/lib/merb-core/core_ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+  def extract!(*args)
+    args.map do |arg|
+      self.delete(arg)
+    end
+  end
+end

data/lib/merb-core/core_ext/kernel.rb

@@ -0,0 +1,345 @@
+require 'rubygems/dependency'
+
+module Kernel
+  
+  # Keep track of all required dependencies. 
+  #
+  # @param name<String> The name of the gem to load.
+  # @param *ver<Gem::Requirement, Gem::Version, Array, #to_str>
+  #   Version requirements to be passed to Gem::Dependency.new.
+  #
+  # @return <Gem::Dependency> Dependency information
+  #
+  # @api private
+  def track_dependency(name, *ver)
+    dep = Gem::Dependency.new(name, ver)
+    existing = Merb::BootLoader::Dependencies.dependencies.find { |d| d.name == dep.name }
+    if existing
+      index = Merb::BootLoader::Dependencies.dependencies.index(existing)
+      Merb::BootLoader::Dependencies.dependencies.delete(existing)
+      Merb::BootLoader::Dependencies.dependencies.insert(index, dep)
+    else
+      Merb::BootLoader::Dependencies.dependencies << dep
+    end
+    return dep
+  end
+  
+  # Loads the given string as a gem. Execution is deferred until
+  # after the logger has been instantiated and the framework directory
+  # structure is defined.
+  #
+  # If that has already happened, the gem will be activated
+  # immediately, but it will still be registered.
+  # 
+  # @param name<String> The name of the gem to load.
+  # @param *ver<Gem::Requirement, Gem::Version, Array, #to_str>
+  #   Version requirements to be passed to Gem::Dependency.new.
+  #   If the last argument is a Hash, extract the :immediate option,
+  #   forcing a dependency to load immediately.
+  #
+  # @return <Gem::Dependency> The dependency information.
+  def dependency(name, *ver)
+    immediate = ver.last.is_a?(Hash) && ver.pop[:immediate]
+    if immediate || Merb::BootLoader.finished?(Merb::BootLoader::Dependencies)
+      load_dependency(name, *ver)
+    else
+      track_dependency(name, *ver)
+    end
+  end
+
+  # Loads the given string as a gem.
+  #
+  # This new version tries to load the file via ROOT/gems first before moving
+  # off to the system gems (so if you have a lower version of a gem in
+  # ROOT/gems, it'll still get loaded).
+  #
+  # @param name<String,Gem::Dependency> 
+  #   The name or dependency object of the gem to load.
+  # @param *ver<Gem::Requirement, Gem::Version, Array, #to_str>
+  #   Version requirements to be passed to Gem.activate.
+  #
+  # @note
+  #   If the gem cannot be found, the method will attempt to require the string
+  #   as a library.
+  #
+  # @return <Gem::Dependency> The dependency information.
+  def load_dependency(name, *ver)
+    dep = name.is_a?(Gem::Dependency) ? name : track_dependency(name, *ver)
+    gem(dep)
+  rescue Gem::LoadError
+  ensure
+    require dep.name
+    Merb.logger.info!("loading gem '#{dep.name}' ...")
+    return dep # ensure needs explicit return
+  end
+
+  # Loads both gem and library dependencies that are passed in as arguments.
+  # Execution is deferred to the Merb::BootLoader::Dependencies.run during bootup.
+  #
+  # @param *args<String, Hash, Array> The dependencies to load.
+  def dependencies(*args)
+    args.map do |arg|
+      case arg
+      when String then dependency(arg)
+      when Hash   then arg.map { |r,v| dependency(r, v) }
+      when Array  then arg.map { |r|   dependency(r)    }
+      end
+    end
+  end
+
+  # Loads both gem and library dependencies that are passed in as arguments.
+  #
+  # @param *args<String, Hash, Array> The dependencies to load.
+  #
+  # @note
+  #   Each argument can be:
+  #   String:: Single dependency.
+  #   Hash::
+  #     Multiple dependencies where the keys are names and the values versions.
+  #   Array:: Multiple string dependencies.
+  #
+  # @example dependencies "RedCloth"                 # Loads the the RedCloth gem
+  # @example dependencies "RedCloth", "merb_helpers" # Loads RedCloth and merb_helpers
+  # @example dependencies "RedCloth" => "3.0"        # Loads RedCloth 3.0
+  def load_dependencies(*args)
+    args.map do |arg|
+      case arg
+      when String then load_dependency(arg)
+      when Hash   then arg.map { |r,v| load_dependency(r, v) }
+      when Array  then arg.map { |r|   load_dependency(r)    }
+      end
+    end
+  end
+
+  # Does a basic require, and prints a message if an error occurs.
+  #
+  # @param library<to_s> The library to attempt to include.
+  # @param message<String> The error to add to the log upon failure. Defaults to nil.
+  def rescue_require(library, message = nil)
+    require library
+  rescue LoadError, RuntimeError
+    Merb.logger.error!(message) if message
+  end
+
+  # Used in Merb.root/config/init.rb to tell Merb which ORM (Object Relational
+  # Mapper) you wish to use. Currently Merb has plugins to support
+  # ActiveRecord, DataMapper, and Sequel.
+  #
+  # @param orm<Symbol> The ORM to use.
+  #
+  # @example
+  #   use_orm :datamapper
+  #
+  #   # This will use the DataMapper generator for your ORM
+  #   $ merb-gen model ActivityEvent
+  #
+  # @note
+  #   If for some reason this is called more than once, latter
+  #   call takes over other.
+  # @api public
+  def use_orm(orm)
+    begin
+      Merb.orm = orm
+      orm_plugin = "merb_#{orm}"
+      Kernel.dependency(orm_plugin)
+    rescue LoadError => e
+      Merb.logger.warn!("The #{orm_plugin} gem was not found.  You may need to install it.")
+      raise e
+    end
+  end
+
+  # Used in Merb.root/config/init.rb to tell Merb which testing framework to
+  # use. Currently Merb has plugins to support RSpec and Test::Unit.
+  #
+  # @param test_framework<Symbol>
+  #   The test framework to use. Currently only supports :rspec and :test_unit.
+  #
+  # @example
+  #   use_test :rspec
+  #
+  #   # This will now use the RSpec generator for tests
+  #   $ merb-gen model ActivityEvent
+  # @api public
+  def use_test(test_framework, *test_dependencies)
+    Merb.test_framework = test_framework
+    
+    Kernel.dependencies test_dependencies if Merb.env == "test" || Merb.env.nil?
+  end
+  
+  # Used in Merb.root/config/init.rb to tell Merb which template engine to
+  # prefer.
+  #
+  # @param template_engine<Symbol>
+  #   The template engine to use.
+  #
+  # @example
+  #   use_template_engine :haml
+  #
+  #   # This will now use haml templates in generators where available.
+  #   $ merb-gen resource_controller Project 
+  # @api public
+  def use_template_engine(template_engine)
+    Merb.template_engine = template_engine
+
+    if template_engine != :erb
+      if template_engine.in?(:haml, :builder)
+        template_engine_plugin = "merb-#{template_engine}"
+      else
+        template_engine_plugin = "merb_#{template_engine}"
+      end
+      Kernel.dependency(template_engine_plugin)
+    end
+  rescue LoadError => e
+    Merb.logger.warn!("The #{template_engine_plugin} gem was not found.  You may need to install it.")
+    raise e
+  end
+
+  # @param i<Fixnum> The caller number. Defaults to 1.
+  #
+  # @return <Array[Array]> The file, line and method of the caller.
+  #
+  # @example
+  #   __caller_info__(1)
+  #     # => ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
+  def __caller_info__(i = 1)
+    file, line, meth = caller[i].scan(/(.*?):(\d+):in `(.*?)'/).first
+  end
+
+  # @param file<String> The file to read.
+  # @param line<Fixnum> The line number to look for.
+  # @param size<Fixnum>
+  #   Number of lines to include above and below the the line to look for.
+  #   Defaults to 4.
+  #
+  # @return <Array[Array]>
+  #   Triplets containing the line number, the line and whether this was the
+  #   searched line.
+  #
+  # @example
+  #   __caller_lines__('/usr/lib/ruby/1.8/debug.rb', 122, 2) # =>
+  #     [
+  #       [ 120, "  def check_suspend",                               false ],
+  #       [ 121, "    return if Thread.critical",                     false ],
+  #       [ 122, "    while (Thread.critical = true; @suspend_next)", true  ],
+  #       [ 123, "      DEBUGGER__.waiting.push Thread.current",      false ],
+  #       [ 124, "      @suspend_next = false",                       false ]
+  #     ]
+  def __caller_lines__(file, line, size = 4)
+    line = line.to_i
+    if file =~ /\(erubis\)/
+      yield :error, "Template Error! Problem while rendering", false
+    elsif !File.file?(file) || !File.readable?(file)
+      yield :error, "File `#{file}' not available", false
+    else
+      lines = File.read(file).split("\n")
+      first_line = (f = line - size - 1) < 0 ? 0 : f
+      
+      old_lines = lines
+      lines = lines[first_line, size * 2 + 1]
+
+      lines && lines.each_with_index do |str, index|
+        yield index + line - size, str.chomp
+      end
+    end
+    # 
+    # lines = File.readlines(file)
+    # current = line.to_i - 1
+    # 
+    # first = current - size
+    # first = first < 0 ? 0 : first
+    # 
+    # last = current + size
+    # last = last > lines.size ? lines.size : last
+    # 
+    # log = lines[first..last]
+    # 
+    # area = []
+    # 
+    # log.each_with_index do |line, index|
+    #   index = index + first + 1
+    #   area << [index, line.chomp, index == current + 1]
+    # end
+    # 
+    # area
+  end
+
+  # Takes a block, profiles the results of running the block
+  # specified number of times and generates HTML report.
+  #
+  # @param name<#to_s>
+  #   The file name. The result will be written out to
+  #   Merb.root/"log/#{name}.html".
+  # @param min<Fixnum>
+  #   Minimum percentage of the total time a method must take for it to be
+  #   included in the result. Defaults to 1.
+  #
+  # @return <String>
+  #   The result of the profiling.
+  #
+  # @note
+  #   Requires ruby-prof (<tt>sudo gem install ruby-prof</tt>)
+  #
+  # @example
+  #   __profile__("MyProfile", 5, 30) do
+  #     rand(10)**rand(10)
+  #     puts "Profile run"
+  #   end
+  #
+  #   Assuming that the total time taken for #puts calls was less than 5% of the
+  #   total time to run, #puts won't appear in the profile report.
+  #   The code block will be run 30 times in the example above.
+  def __profile__(name, min=1, iter=100)
+    require 'ruby-prof' unless defined?(RubyProf)
+    return_result = ''
+    result = RubyProf.profile do
+      iter.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. Used
+  # internally in methods that take *args.
+  #
+  # @param args<Array> The arguments to extract the hash from.
+  #
+  # @example
+  #   def render(*args,&blk)
+  #     opts = extract_options_from_args!(args) || {}
+  #     # [...]
+  #   end
+  def extract_options_from_args!(args)
+    args.pop if Hash === args.last
+  end
+
+  # Checks that the given objects quack like the given conditions.
+  #
+  # @param opts<Hash>
+  #   Conditions to enforce. Each key will receive a quacks_like? call with the
+  #   value (see Object#quacks_like? for details).
+  #
+  # @raise <ArgumentError>
+  #   An object failed to quack like a condition.
+  def enforce!(opts = {})
+    opts.each do |k,v|
+      raise ArgumentError, "#{k.inspect} doesn't quack like #{v.inspect}" unless k.quacks_like?(v)
+    end
+  end
+
+  unless Kernel.respond_to?(:debugger)
+
+    # Define debugger method so that code even works if debugger was not
+    # requested. Drops a note to the logs that Debugger was not available.
+    def debugger
+      Merb.logger.info! "\n***** Debugger requested, but was not " +
+        "available: Start server with --debugger " +
+        "to enable *****\n"
+    end
+  end
+  
+end