typo 5.0.2 → 5.0.3.98

data/vendor/plugins/haml/lib/haml/helpers.rb

@@ -1,220 +0,0 @@
-require File.dirname(__FILE__) + '/helpers/action_view_mods'
-
-module Haml
-  # This module contains various helpful methods to make it easier to do
-  # various tasks. Haml::Helpers is automatically included in the context
-  # that a Haml template is parsed in, so all these methods are at your
-  # disposal from within the template.
-  module Helpers
-    self.extend self
-    
-    @@action_view = false
-    @@force_no_action_view = false
-
-    # Returns whether or not ActionView is installed on the system.
-    def self.action_view?
-      @@action_view
-    end
-
-    # Takes any string, finds all the endlines and converts them to
-    # HTML entities for endlines so they'll render correctly in
-    # whitespace-sensitive tags without screwing up the indentation.
-    def flatten(input)
-      input.gsub(/\n/, '
').gsub(/\r/, '')
-    end
-
-    # Takes an Enumerable object and a block
-    # and iterates over the object,
-    # yielding each element to a Haml block
-    # and putting the result into <tt><li></tt> elements.
-    # This creates a list of the results of the block.
-    # For example:
-    #
-    #   = list_of([['hello'], ['yall']]) do |i|
-    #     = i[0]
-    #
-    # Produces:
-    #
-    #   <li>hello</li>
-    #   <li>yall</li>
-    #
-    # And
-    #
-    #   = list_of({:title => 'All the stuff', :description => 'A book about all the stuff.'}) do |key, val|
-    #     %h3= key.humanize
-    #     %p= val
-    #
-    # Produces:
-    #
-    #   <li>
-    #     <h3>Title</h3>
-    #     <p>All the stuff</p>
-    #   </li>
-    #   <li>
-    #     <h3>Description</h3>
-    #     <p>A book about all the stuff.</p>
-    #   </li>
-    #
-    def list_of(array, &block) # :yields: item
-      to_return = array.collect do |i|
-        result = capture_haml(i, &block)
-        
-        if result.count("\n") > 1
-          result.gsub!("\n", "\n  ")
-          result = "\n  #{result.strip}\n"
-        else
-          result.strip!
-        end
-        
-        "<li>#{result}</li>"
-      end
-      to_return.join("\n")
-    end
-
-    # Increments the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    # For example:
-    #
-    #   %h1 foo
-    #   - tab_up
-    #   %p bar
-    #   - tab_down
-    #   %strong baz
-    #
-    # Produces:
-    #
-    #   <h1>foo</h1>
-    #     <p>bar</p>
-    #   <strong>baz</strong>
-    #
-    def tab_up(i = 1)
-      buffer.tabulation += i
-    end
-
-    # Increments the number of tabs the buffer automatically adds
-    # to the lines of the template.
-    #
-    # See tab_up.
-    def tab_down(i = 1)
-      buffer.tabulation -= i
-    end
-    
-    # Surrounds the given block of Haml code with the given characters,
-    # with no whitespace in between.
-    # For example:
-    #
-    #   = surround '(', ')' do
-    #     %a{:href => "food"} chicken
-    #
-    # Produces:
-    #
-    #   (<a href='food'>chicken</a>)
-    #
-    # and
-    #
-    #   = surround '*' do
-    #     %strong angry
-    #
-    # Produces:
-    #
-    #   *<strong>angry</strong>*
-    #
-    def surround(front, back = nil, &block)
-      back ||= front
-      output = capture_haml(&block)
-      
-      "#{front}#{output.chomp}#{back}\n"
-    end
-    
-    # Prepends the given character to the beginning of the Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #   = precede '*' do
-    #     %span.small Not really
-    #
-    # Produces:
-    #
-    #   *<span class='small'>Not really</span>
-    #
-    def precede(char, &block)
-      "#{char}#{capture_haml(&block).chomp}\n"
-    end
-    
-    # Appends the given character to the end of the Haml block,
-    # with no whitespace between.
-    # For example:
-    #
-    #   click
-    #   = succeed '.' do
-    #     %a{:href=>"thing"} here
-    #
-    # Produces:
-    #
-    #   click
-    #   <a href='thing'>here</a>.
-    #
-    def succeed(char, &block)
-      "#{capture_haml(&block).chomp}#{char}\n"
-    end
-    
-    # Captures the result of the given block of Haml code,
-    # gets rid of the excess indentation,
-    # and returns it as a string.
-    # For example, after the following,
-    #
-    #   .foo
-    #     - foo = capture_haml(13) do |a|
-    #       %p= a
-    #
-    # the local variable <tt>foo</tt> would be assigned to "<p>13</p>\n".
-    #
-    def capture_haml(*args, &block)
-      capture_haml_with_buffer(buffer.buffer, *args, &block)
-    end
-    
-    private
-    
-    # Sets whether or not ActionView is installed on the system.
-    def self.action_view(value) # :nodoc:
-      @@action_view = value
-    end
-
-    # Gets a reference to the current Haml::Buffer object.
-    def buffer
-      @haml_stack[-1]
-    end
-    
-    # Gives a proc the same local "_hamlout" and "_erbout" variables
-    # that the current template has.
-    def bind_proc(&proc)
-      _hamlout = buffer
-      _erbout = _hamlout.buffer
-      proc { |*args| proc.call(*args) }
-    end
-    
-    # Performs the function of capture_haml, assuming <tt>local_buffer</tt>
-    # is where the output of block goes.
-    def capture_haml_with_buffer(local_buffer, *args, &block)
-      position = local_buffer.length
-      
-      block.call(*args)
-      
-      captured = local_buffer.slice!(position..-1)
-      
-      min_tabs = nil
-      captured.each do |line|
-        tabs = line.index(/[^ ]/)
-        min_tabs ||= tabs
-        min_tabs = min_tabs > tabs ? tabs : min_tabs
-      end
-      
-      result = captured.map do |line|
-        line[min_tabs..-1]
-      end
-      result.to_s
-    end
-    
-    include ActionViewMods if self.const_defined?  "ActionViewMods"
-  end
-end

data/vendor/plugins/haml/lib/haml/helpers/action_view_mods.rb

@@ -1,54 +0,0 @@
-begin
-  require 'rubygems'
-  require 'active_support'
-  require 'action_controller'
-  require 'action_view'
-  action_view_included = true
-rescue LoadError
-  action_view_included = false
-end
-
-if action_view_included
-  class ActionView::Base
-    alias_method :old_concat, :concat unless instance_methods.include? "old_concat"
-    alias_method :old_form_tag, :form_tag unless instance_methods.include? "old_form_tag"
-  end
-  
-  module Haml
-    module Helpers
-      # This module overrides various helpers in ActionView to make them
-      # work more effectively with Haml. It's not available unless ActionView
-      # is installed.
-      #
-      #--
-      # Methods in this module should be nodoc'd.
-      #++
-      module ActionViewMods
-        def self.included(othermod) # :nodoc:
-          othermod.class_eval do
-            action_view(true)
-            alias_method :capture_erb_with_buffer, :capture_haml_with_buffer
-          end
-        end
-        
-        def concat(string, binding = nil) # :nodoc:
-          buffer.buffer.concat(string)
-        end
-        
-        def form_tag(url_for_options = {}, options = {}, *parameters_for_url, &proc) # :nodoc:
-          if block_given?
-            oldproc = proc 
-            proc = bind_proc do |*args|
-              concat "\n"
-              tab_up
-              oldproc.call(*args)
-              tab_down
-            end
-          end
-          old_form_tag(url_for_options, options, *parameters_for_url, &proc)
-        end
-      end
-    end
-  end
-end
-

data/vendor/plugins/haml/lib/haml/template.rb

@@ -1,138 +0,0 @@
-require File.dirname(__FILE__) + '/engine'
-require 'rubygems'
-require 'active_support'
-require 'action_view'
-
-module Haml
-  # This class interfaces with ActionView
-  # to make Haml usable as a Ruby on Rails plugin.
-  # It usually shouldn't need to be used by end users.
-  # Just in case, though, here's what you might do to render
-  # <tt>templates/index.haml</tt>:
-  #
-  #   ActionView::Base.register_template_handler("haml", Haml::Template)
-  #   base = ActionView::Base.new("templates")
-  #   base.render("index")
-  #
-  # Or, if you want to really get into the nitty-gritty:
-  #
-  #   base = ActionView::Base.new
-  #   template = Haml::Template.new(base)
-  #   template.render("templates/index.haml")
-  #
-  class Template
-
-    class << self
-      @@options = {}
-
-      # Gets various options for HAML. See REFERENCE for details.
-      def options
-        @@options
-      end
-
-      # Sets various options for HAML. See REFERENCE for details.
-      def options=(value)
-        @@options = value
-      end
-    end
-
-    # Creates a new Haml::Template object that uses <tt>view</tt>
-    # to render its templates.
-    def initialize(view)
-      @view = view
-      @@precompiled_templates ||= {}
-    end
-
-    # Renders the file at the location <tt>template</tt>,
-    # with <tt>local_assigns</tt> available as local variables within the template.
-    # Returns the result as a string.
-    def render(template, local_assigns={})
-      unless @view.instance_variable_get("@assigns_added")
-        assigns = @view.assigns.dup
-      
-        # Get inside the view object's world
-        @view.instance_eval do
-          # Set all the instance variables
-          assigns.each do |key,val|
-            instance_variable_set "@#{key}", val
-          end
-        end
-        
-        @view.instance_variable_set("@assigns_added", true)
-      end
-
-      options = @@options.dup
-      locals = options[:locals] || {}
-      locals.merge! local_assigns
-      options[:locals] = locals
-
-      if @view.haml_inline
-        engine = Haml::Engine.new(template, options)
-      elsif @precompiled = get_precompiled(template)
-        options[:precompiled] ||= @precompiled
-        engine = Haml::Engine.new("", options)
-      else
-        engine = Haml::Engine.new(File.read(template), options)
-        set_precompiled(template, engine.precompiled)
-      end
-
-      yield_proc = @view.instance_eval do
-        proc { |*name| instance_variable_get("@content_for_#{name.first || 'layout'}") }
-      end
-
-      engine.to_html(@view) { |*args| yield_proc.call(*args) }
-
-    end
-    
-    private
-
-    # Gets the cached, precompiled version of the template at location <tt>filename</tt>
-    # as a string.
-    def get_precompiled(filename)
-      # Do we have it on file? Is it new enough?
-      if (precompiled, precompiled_on = @@precompiled_templates[filename]) &&
-             (precompiled_on == File.mtime(filename).to_i)
-        precompiled
-      end
-    end
-
-    # Sets the cached, precompiled version of the template at location <tt>filename</tt>
-    # to <tt>precompiled</tt>.
-    def set_precompiled(filename, precompiled)
-      @@precompiled_templates[filename] = [precompiled, File.mtime(filename).to_i]
-    end
-  end
-end
-
-# This module refers to the ActionView module that's part of Ruby on Rails.
-# Haml can be used as an alternate templating engine for it,
-# and includes several modifications to make it more Haml-friendly.
-# The documentation can be found
-# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
-module ActionView
-  class Base # :nodoc:
-    attr :haml_filename, true
-    attr :haml_inline
-
-    alias_method :haml_old_render_file, :render_file
-    def render_file(template_path, use_full_path = true, local_assigns = {})
-      @haml_filename = File.basename(template_path)
-      haml_old_render_file(template_path, use_full_path, local_assigns)
-    end
-
-    alias_method :read_template_file_old, :read_template_file
-    def read_template_file(template_path, extension)
-      if extension =~ /haml/i
-        template_path
-      else
-        read_template_file_old(template_path, extension)
-      end
-    end
-
-    alias_method :render_template_old, :render_template
-    def render_template(template_extension, template, file_path = nil, local_assigns = {})
-      @haml_inline = !template.nil?
-      render_template_old(template_extension, template, file_path, local_assigns)
-    end
-  end
-end

data/vendor/plugins/haml/test/benchmark.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/haml/template'
-require 'rubygems'
-require 'active_support'
-require 'action_view'
-require 'benchmark'
-require 'stringio'
-
-module Haml
-  class Benchmarker
-  
-    # Creates a new benchmarker that looks for templates in the base
-    # directory.
-    def initialize(base = File.dirname(__FILE__))
-      ActionView::Base.register_template_handler("haml", Haml::Template)
-      unless base.class == ActionView::Base
-        @base = ActionView::Base.new(base)
-      else
-        @base = base
-      end
-    end
-    
-    # Benchmarks HAML against ERb. If <tt>template_name</tt> is specified,
-    # looks for a haml template in ./templates and an rhtml template in
-    # ./rhtml with the name <tt>template_name</tt>. Otherwise, uses
-    # <tt>haml_template</tt> and <tt>rhtml_template</tt> as the location of
-    # the templates.
-    # 
-    # Returns the results of the benchmarking as a string.
-    # 
-    # :call-seq:
-    # benchmark(runs = 100, template_name = 'standard')
-    # benchmark(runs = 100, haml_template, rhtml_template)
-    # 
-    def benchmark(runs = 100, template_name = 'standard', other_template = nil)
-      if other_template.nil?
-        haml_template = "templates/#{template_name}"
-        rhtml_template = "rhtml/#{template_name}"
-      else
-        haml_template = template_name
-        rhtml_template = other_template
-      end
-      
-      old_stdout = $stdout
-      $stdout = StringIO.new
-      
-      times = Benchmark.bmbm do |b|
-        b.report("haml:") { runs.times { @base.render haml_template } }
-        b.report("erb:") { runs.times { @base.render rhtml_template } }
-      end
-      
-      #puts times.inspect
-      ratio = sprintf("%g", times[0].to_a[5] / times[1].to_a[5])
-      puts "Haml/ERB: " + ratio
-      
-      $stdout.pos = 0
-      to_return = $stdout.read
-      $stdout = old_stdout
-      
-      to_return
-    end
-  end
-end