haml 1.0.5 → 1.5.0

data/lib/haml/error.rb

@@ -0,0 +1,43 @@
+module Haml
+  # The abstract type of exception raised by Haml code.
+  # Haml::SyntaxError includes this module,
+  # as do all exceptions raised by Ruby code within Haml.
+  #
+  # Haml::Error encapsulates information about the exception,
+  # such as the line of the Haml template it was raised on
+  # and the Haml file that was being parsed (if applicable).
+  # It also provides a handy way to rescue only exceptions raised
+  # because of a faulty template.
+  module Error
+    # The line of the Haml template on which the exception was thrown.
+    attr_reader :haml_line
+
+    # The name of the file that was being parsed when the exception was raised.
+    # This will be nil unless Haml is being used as an ActionView plugin.
+    attr_reader :haml_filename
+
+    # Adds a properly formatted entry to the exception's backtrace.
+    # +lineno+ should be the line on which the error occurred.
+    # +filename+ should be the file in which the error occurred,
+    # if applicable (defaults to "(haml)").
+    def add_backtrace_entry(lineno, filename = nil) # :nodoc:
+      @haml_line = lineno
+      @haml_filename = filename
+      self.backtrace ||= []
+      self.backtrace.unshift "#{filename || '(haml)'}:#{lineno}"
+    end
+  end
+
+  # SyntaxError is the type of exception raised when Haml encounters an
+  # ill-formatted document.
+  # It's not particularly interesting, except in that it includes Haml::Error.
+  class SyntaxError < StandardError
+    include Haml::Error
+  end
+
+  # HamlError is the type of exception raised when Haml encounters an error
+  # not of a syntactical nature, such as an undefined Filter.
+  class HamlError < StandardError
+    include Haml::Error
+  end
+end

data/lib/haml/exec.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/../haml'
+require 'optparse'
+
+module Haml
+  # This module contains code for working with the
+  # haml, sass, and haml2html executables,
+  # such as command-line parsing stuff.
+  # It shouldn't need to be invoked by client code.
+  module Exec # :nodoc:
+    # A class that encapsulates the executable code
+    # for all three executables.
+    class Generic # :nodoc:
+      def initialize(args)
+        @args = args
+        @options = {}
+      end
+
+      def parse!
+        @opts = OptionParser.new(&(method(:set_opts).to_proc))
+        @opts.parse!(@args)
+
+        process_result
+
+        @options
+      end
+
+      def to_s
+        @opts.to_s
+      end
+      
+      private
+
+      def set_opts(opts)
+        opts.on('--stdin', :NONE, 'Read input from standard input instead of an input file') do
+          @options[:input] = $stdin
+        end
+
+        opts.on('--stdout', :NONE, 'Print output to standard output instead of an output file') do
+          @options[:output] = $stdout
+        end
+
+        opts.on_tail("-?", "-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          puts("Haml " + File.read(File.dirname(__FILE__) + '/../../VERSION'))
+          exit
+        end
+      end
+
+      def process_result
+        input = @options[:input]
+        output = @options[:output]
+
+        if input
+          output ||= ARGV[0]
+        else
+          input ||= ARGV[0]
+          output ||= ARGV[1]
+        end
+
+        unless input && output
+          puts @opts
+          exit 1
+        end
+
+        if input.is_a?(String) && !File.exists?(input)
+          puts "File #{input} doesn't exist!"
+          exit 1
+        end
+
+        unless input.is_a? IO
+          input = File.open(input)
+          input_file = true
+        end
+
+        unless output.is_a? IO
+          output = File.open(output, "w")
+          output_file = true
+        end
+
+        @options[:input] = input
+        @options[:output] = output
+      end
+    end
+
+    # A class encapsulating the executable functionality
+    # specific to Haml and Sass.
+    class HamlSass < Generic # :nodoc:
+      private
+
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: #{@name.downcase} [options] (#{@name.downcase} file) (output file)
+
+Description:
+  Uses the #{@name} engine to parse the specified template
+  and outputs the result to the specified file.
+
+Options:
+END
+       
+        super
+      end
+
+      def process_result
+        super
+        require File.dirname(__FILE__) + "/../#{@name.downcase}"
+      end
+    end
+
+    # A class encapsulating executable functionality
+    # specific to Sass.
+    class Sass < HamlSass # :nodoc:
+      def initialize(args)
+        super
+        @name = "Sass"
+      end
+
+      def process_result
+        super
+        input = @options[:input]
+        output = @options[:output]
+
+        template = input.read()
+        input.close() if input.is_a? File
+        result = ::Sass::Engine.new(template).render
+        output.write(result)
+        output.close() if output.is_a? File
+      end
+    end
+
+    # A class encapsulating executable functionality
+    # specific to Haml.
+    class Haml < HamlSass # :nodoc:
+      def initialize(args)
+        super
+        @name = "Haml"
+      end
+
+      def process_result
+        super
+        input = @options[:input]
+        output = @options[:output]
+
+        template = input.read()
+        input.close() if input.is_a? File
+        result = ::Haml::Engine.new(template).to_html
+        output.write(result)
+        output.close() if output.is_a? File
+      end
+    end
+
+    # A class encapsulating executable functionality
+    # specific to the html2haml executable.
+    class HTML2Haml < Generic # :nodoc:
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: html2haml [options] (html file) (output file)
+
+Description: Transforms an HTML file into corresponding Haml code.
+
+Options:
+END
+
+        super
+      end
+
+      def process_result
+        super
+
+        input = @options[:input]
+        output = @options[:output]
+
+        output.write(Hpricot(input).to_haml)
+      end
+    end
+  end
+end

data/lib/haml/filters.rb

@@ -0,0 +1,89 @@
+# This file contains redefinitions of and wrappers around various text
+# filters so they can be used as Haml filters.
+
+# :stopdoc:
+
+require 'erb'
+require 'sass/engine'
+require 'stringio'
+
+volatile_requires = ['rubygems', 'redcloth', 'bluecloth']
+NOT_LOADED = [] unless defined?(NOT_LOADED)
+volatile_requires.each do |file|
+  begin
+    require file
+  rescue LoadError
+    NOT_LOADED.push file
+  end
+end
+
+class ERB; alias_method :render, :result; end
+
+unless NOT_LOADED.include? 'bluecloth'
+  class BlueCloth; alias_method :render, :to_html; end
+end
+
+module Haml
+  module Filters
+    class Plain
+      def initialize(text)
+        @text = text
+      end
+
+      def render
+        @text
+      end
+    end
+
+    class Ruby
+      def initialize(text)
+        @text = text
+      end
+
+      def render
+        old_stdout = $stdout
+        $stdout = StringIO.new
+        Object.new.instance_eval(@text)
+        old_stdout, $stdout = $stdout, old_stdout
+        old_stdout.pos = 0
+        old_stdout.read
+      end
+    end
+
+    class Preserve
+      def initialize(text)
+        @text = text
+      end
+
+      def render
+        Haml::Helpers.preserve(@text)
+      end
+    end
+
+    unless NOT_LOADED.include? 'bluecloth'
+      Markdown = BlueCloth unless defined?(Markdown)
+    end
+
+    unless NOT_LOADED.include? 'redcloth'
+      class ::RedCloth; alias_method :render, :to_html; end
+      
+      # Uses RedCloth to provide only Textile (not Markdown) parsing
+      class Textile < RedCloth
+        def render
+          self.to_html(:textile)
+        end
+      end
+
+      unless defined?(Markdown)
+        # Uses RedCloth to provide only Markdown (not Textile) parsing
+        class Markdown < RedCloth
+          def render
+            self.to_html(:markdown)
+          end
+        end
+      end
+    end
+  end
+end
+
+# :startdoc:

data/lib/haml/helpers.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helpers/action_view_mods'
+require 'haml/helpers/action_view_mods'
 
 module Haml
   # This module contains various helpful methods to make it easier to do
@@ -16,13 +16,25 @@ module Haml
       @@action_view
     end
 
+    # Isolates the whitespace-sensitive tags in the string and uses preserve
+    # to convert any endlines inside them into HTML entities for endlines.
+    def find_and_preserve(input)
+      input = input.to_s
+      input.scan(/<(textarea|code|pre)[^>]*>(.*?)<\/\1>/im) do |tag, contents|
+        input = input.gsub(contents, preserve(contents))
+      end
+      input
+    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)
+    def preserve(input)      
       input.gsub(/\n/, '&#x000A;').gsub(/\r/, '')
     end
 
+    alias_method :flatten, :preserve
+
     # Takes an Enumerable object and a block
     # and iterates over the object,
     # yielding each element to a Haml block
@@ -228,8 +240,10 @@ module Haml
   end
 end
 
-class ActionView::Base # :nodoc:
-  def is_haml?
-    false
+module ActionView
+  class Base # :nodoc:
+    def is_haml?
+      false
+    end
   end
 end

data/lib/haml/helpers/action_view_mods.rb

@@ -12,13 +12,18 @@ 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"
+
+    alias_method :old_form_for, :form_for unless instance_methods.include? "old_form_for"
   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.
+      # This module overrides various helpers in ActionView
+      # to make them work more effectively with Haml.
+      # It also defines several helper methods,
+      # available from a Haml template,
+      # which are only useful within the context of ActionView.
+      # It's not available unless ActionView is installed.
       #
       #--
       # Methods in this module should be nodoc'd.
@@ -49,7 +54,26 @@ if action_view_included
               tab_down
             end
           end
-          old_form_tag(url_for_options, options, *parameters_for_url, &proc)
+          res = old_form_tag(url_for_options, options, *parameters_for_url, &proc) + "\n"
+          concat "\n" if block_given? && is_haml?
+          res
+        end
+
+        def form_for(object_name, *args, &proc) # :nodoc:
+          if block_given? && is_haml?
+            oldproc = proc 
+            proc = bind_proc do |*args|
+              tab_up
+              oldproc.call(*args)
+              tab_down
+            end            
+          end
+          old_form_for(object_name, *args, &proc)
+          concat "\n" if block_given? && is_haml?
+        end
+
+        def generate_content_class_names
+          controller.controller_name + " " + controller.action_name
         end
       end
     end

data/lib/haml/template.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/engine'
+require 'haml/engine'
 require 'rubygems'
 require 'active_support'
 require 'action_view'
@@ -25,12 +25,12 @@ module Haml
     class << self
       @@options = {}
 
-      # Gets various options for HAML. See REFERENCE for details.
+      # Gets various options for Haml. See README for details.
       def options
         @@options
       end
 
-      # Sets various options for HAML. See REFERENCE for details.
+      # Sets various options for Haml. See README for details.
       def options=(value)
         @@options = value
       end
@@ -47,18 +47,8 @@ module Haml
     # 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)
+      @view.instance_eval do
+        evaluate_assigns
       end
 
       options = @@options.dup
@@ -68,12 +58,15 @@ module Haml
 
       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)
+        options[:filename] ||= template
+        if @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
       end
 
       yield_proc = @view.instance_eval do
@@ -111,15 +104,8 @@ end
 # 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