haml 1.5.2 → 1.7.0

data/lib/haml/exec.rb

@@ -16,12 +16,28 @@ module Haml
       end
 
       def parse!
-        @opts = OptionParser.new(&(method(:set_opts).to_proc))
-        @opts.parse!(@args)
+        begin
+          @opts = OptionParser.new(&(method(:set_opts).to_proc))
+          @opts.parse!(@args)
 
-        process_result
+          process_result
+          
+          @options
+        rescue Exception => e
+          raise e if e.is_a? SystemExit
 
-        @options
+          line = e.backtrace[0].scan(/:(.*)/)[0]
+          puts "#{e.class} on line #{line}: #{e.message}"
+
+          if @options[:trace]
+            e.backtrace[1..-1].each { |t| puts "  #{t}" }
+          else
+            puts "  Use --trace to see traceback"
+          end
+
+          exit 1
+        end
+        exit 0
       end
 
       def to_s
@@ -39,6 +55,15 @@ module Haml
           @options[:output] = $stdout
         end
 
+        opts.on('-s', '--stdio', 'Read input from standard input and print output to standard output') do
+          @options[:input] = $stdin
+          @options[:output] = $stdout
+        end
+
+        opts.on('--trace', :NONE, 'Show a full traceback on error') do
+          @options[:trace] = true
+        end
+
         opts.on_tail("-?", "-h", "--help", "Show this message") do
           puts opts
           exit
@@ -102,6 +127,47 @@ Description:
 Options:
 END
        
+        opts.on('--rails RAILS_DIR', "Install Haml from the Gem to a Rails project") do |dir|
+          original_dir = dir
+
+          dir = File.join(dir, 'vendor', 'plugins')
+
+          unless File.exists?(dir)
+            puts "Directory #{dir} doesn't exist"
+            exit
+          end
+
+          dir = File.join(dir, 'haml')
+
+          if File.exists?(dir)
+            puts "Directory #{dir} already exists."
+            exit
+          end
+
+          begin
+            Dir.mkdir(dir)
+          rescue SystemCallError
+            puts "Cannot create #{dir}"
+            exit
+          end
+
+          File.open(File.join(dir, 'init.rb'), 'w') do |file|
+            file.puts <<END
+require 'rubygems'
+require 'haml'
+require 'haml/template'
+require 'sass'
+require 'sass/plugin'
+
+ActionView::Base.register_template_handler('haml', Haml::Template)
+Sass::Plugin.update_stylesheets
+END
+          end
+
+          puts "Haml plugin added to #{original_dir}"
+          exit
+        end
+
         super
       end
 
@@ -156,12 +222,61 @@ END
     # A class encapsulating executable functionality
     # specific to the html2haml executable.
     class HTML2Haml < Generic # :nodoc:
+      def initialize(args)
+        super
+
+        @module_opts = {}
+
+        begin
+          require 'haml/html'
+        rescue LoadError => err
+          dep = err.message.scan(/^no such file to load -- (.*)/)[0]
+          puts "Required dependency #{dep} not found!"
+          exit 1
+        end
+      end
+
       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
+
+        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
+          @module_opts[:rhtml] = true
+        end
+
+        super
+      end
+
+      def process_result
+        super
+
+        input = @options[:input]
+        output = @options[:output]
+
+        output.write(::Haml::HTML.new(input, @module_opts).render)
+      end
+    end
+
+    # A class encapsulating executable functionality
+    # specific to the css2sass executable.
+    class CSS2Sass < Generic # :nodoc:
+      def initialize(args)
+        super
+
+        require 'sass/css'
+      end
+
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: css2sass [options] (css file) (output file)
+
+Description: Transforms a CSS file into corresponding Sass code.
+
 Options:
 END
 
@@ -174,7 +289,7 @@ END
         input = @options[:input]
         output = @options[:output]
 
-        output.write(Hpricot(input).to_haml)
+        output.write(::Sass::CSS.new(input).render)
       end
     end
   end

data/lib/haml/helpers.rb

@@ -1,4 +1,5 @@
 require 'haml/helpers/action_view_mods'
+require 'haml/helpers/action_view_extensions'
 
 module Haml
   # This module contains various helpful methods to make it easier to do
@@ -7,7 +8,7 @@ module Haml
   # disposal from within the template.
   module Helpers
     self.extend self
-    
+
     @@action_view_defined = defined?(ActionView)
     @@force_no_action_view = false
 
@@ -83,6 +84,22 @@ module Haml
       to_return.join("\n")
     end
 
+    # Returns a hash containing default assignments for the xmlns and xml:lang
+    # attributes of the <tt>html</tt> HTML element.
+    # It also takes an optional argument for the value of xml:lang and lang,
+    # which defaults to 'en-US'.
+    # For example,
+    #
+    #   %html{html_attrs}
+    #
+    # becomes
+    #
+    #   <html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en-US' lang='en-US'>
+    #
+    def html_attrs(lang = 'en-US')
+      {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
+    end
+
     # Increments the number of tabs the buffer automatically adds
     # to the lines of the template.
     # For example:
@@ -184,6 +201,73 @@ module Haml
     def capture_haml(*args, &block)
       capture_haml_with_buffer(buffer.buffer, *args, &block)
     end
+
+    # Outputs text directly to the Haml buffer, with the proper tabulation
+    def puts(text = "")
+      buffer.buffer << ('  ' * buffer.tabulation) << text.to_s << "\n"
+      nil
+    end
+
+    #
+    # call-seq:
+    #   open(name, attributes = {}) {...}
+    #   open(name, text, attributes = {}) {...}
+    #
+    # Creates an HTML tag with the given name and optionally text and attributes.
+    # Can take a block that will be executed
+    # between when the opening and closing tags are output.
+    # If the block is a Haml block or outputs text using puts,
+    # the text will be properly indented.
+    # 
+    # For example,
+    #
+    #   open :table do
+    #     open :tr do
+    #       open :td, {:class => 'cell'} do
+    #         open :strong, "strong!"
+    #         puts "data"
+    #       end
+    #       open :td do
+    #         puts "more_data"
+    #       end
+    #     end
+    #   end
+    #
+    # outputs
+    #
+    #   <table>
+    #     <tr>
+    #       <td class='cell'>
+    #         <strong>
+    #           strong!
+    #         </strong>
+    #         data
+    #       </td>
+    #       <td>
+    #         more_data
+    #       </td>
+    #     </tr>
+    #   </table>
+    #
+    def open(name, attributes = {}, alt_atts = {}, &block)
+      text = nil
+      if attributes.is_a? String
+        text = attributes
+        attributes = alt_atts
+      end
+
+      puts "<#{name}#{buffer.build_attributes(attributes)}>"
+      tab_up
+        # Print out either the text (using push_text) or call the block and add an endline
+        if text
+          puts(text)
+        elsif block
+          block.call
+        end
+      tab_down
+      puts "</#{name}>"
+      nil
+    end
     
     private
 
@@ -205,7 +289,7 @@ module Haml
     def capture_haml_with_buffer(local_buffer, *args, &block)
       position = local_buffer.length
       
-      block.call(*args)
+      block.call *args
       
       captured = local_buffer.slice!(position..-1)
       
@@ -221,7 +305,6 @@ module Haml
       end
       result.to_s
     end
-    alias_method :capture_erb_with_buffer, :capture_haml_with_buffer
 
     # Returns whether or not the current template is a Haml template.
     # 
@@ -231,6 +314,8 @@ module Haml
     def is_haml?
       @haml_is_haml
     end
+    
+    include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
   end
 end
 

data/lib/haml/helpers/action_view_extensions.rb

@@ -0,0 +1,45 @@
+require 'haml/helpers/action_view_mods'
+
+if defined?(ActionView)
+  module Haml
+    module Helpers
+      # This module contains various useful helper methods
+      # that either tie into ActionView or the rest of the ActionPack stack,
+      # or are only useful in that context.
+      # Thus, the methods defined here are only available
+      # if ActionView is installed.
+      module ActionViewExtensions
+        # Returns a value for the "class" attribute
+        # unique to this controller/action pair.
+        # This can be used to target styles specifically at this action or controller.
+        # For example, if the current action were EntryController#show,
+        #
+        #   %div{:class => page_class} My Div
+        #
+        # would become
+        #
+        #   <div class="entry show">My Div</div>
+        #
+        # Then, in a stylesheet
+        # (shown here as Sass),
+        # you could refer to this specific action:
+        #
+        #   .entry.show
+        #     :font-weight bold
+        #
+        # or to all actions in the entry controller:
+        #
+        #   .entry
+        #     :color #00f
+        # 
+        def page_class
+          controller.controller_name + " " + controller.action_name
+        end
+
+        # :stopdoc:
+        alias_method :generate_content_class_names, :page_class
+        # :startdoc:
+      end
+    end
+  end
+end

data/lib/haml/helpers/action_view_mods.rb

@@ -8,7 +8,7 @@ rescue LoadError
   action_view_included = false
 end
 
-if action_view_included
+if action_view_included  
   module ActionView
     class Base # :nodoc:
       def render_with_haml(*args)        
@@ -26,6 +26,18 @@ if action_view_included
     # to make them work more effectively with Haml.
     module Helpers
       # :stopdoc:
+      module CaptureHelper
+        def capture_erb_with_buffer_with_haml(*args, &block)
+          if is_haml?
+            capture_haml_with_buffer(*args, &block)
+          else
+            capture_erb_with_buffer_without_haml(*args, &block)
+          end
+        end
+        alias_method :capture_erb_with_buffer_without_haml, :capture_erb_with_buffer
+        alias_method :capture_erb_with_buffer, :capture_erb_with_buffer_with_haml
+      end
+
       module TextHelper
         def concat_with_haml(string, binding = nil)
           if is_haml?
@@ -37,26 +49,30 @@ if action_view_included
         alias_method :concat_without_haml, :concat
         alias_method :concat, :concat_with_haml
       end
-      
+
       module FormTagHelper
         def form_tag_with_haml(url_for_options = {}, options = {}, *parameters_for_url, &proc)
-          if block_given? && is_haml?
-            oldproc = proc 
-            proc = bind_proc do |*args|
-              concat "\n"
-              tab_up
-              oldproc.call(*args)
-              tab_down
+          if is_haml?
+            if block_given?
+              oldproc = proc 
+              proc = bind_proc do |*args|
+                concat "\n"
+                tab_up
+                oldproc.call(*args)
+                tab_down
+              end
             end
+            res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
+            concat "\n" if block_given? && is_haml?
+            res
+          else
+            form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc)
           end
-          res = form_tag_without_haml(url_for_options, options, *parameters_for_url, &proc) + "\n"
-          concat "\n" if block_given? && is_haml?
-          res
         end
         alias_method :form_tag_without_haml, :form_tag
         alias_method :form_tag, :form_tag_with_haml
       end
-      
+
       module FormHelper
         def form_for_with_haml(object_name, *args, &proc)
           if block_given? && is_haml?
@@ -73,11 +89,8 @@ if action_view_included
         alias_method :form_for_without_haml, :form_for
         alias_method :form_for, :form_for_with_haml
       end
-      
-      def generate_content_class_names
-        controller.controller_name + " " + controller.action_name
-      end
       # :startdoc:
     end
   end
 end
+

data/lib/haml/html.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/../haml'
+
+require 'haml/engine'
+require 'rubygems'
+require 'hpricot'
+require 'cgi'
+
+module Haml
+  # This class contains the functionality used in the +html2haml+ utility,
+  # namely converting HTML documents to Haml templates.
+  # It depends on Hpricot for HTML parsing (http://code.whytheluckystiff.net/hpricot/).
+  class HTML
+    # Creates a new instance of Haml::HTML that will compile the given template,
+    # which can either be a string containing HTML or an Hpricot node,
+    # to a Haml string when +render+ is called.
+    def initialize(template, options = {})
+      @@options = options
+
+      if template.is_a? Hpricot::Node
+        @template = template
+      else
+        if template.is_a? IO
+          template = template.read
+        end
+
+        if @@options[:rhtml]
+          match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
+          match_to_html(template, /<%(.*?)-?%>/m,  'silent')
+        end
+        @template = Hpricot(template)
+      end
+    end
+
+    # Processes the document and returns the result as a string
+    # containing the Haml template.
+    def render
+      @template.to_haml(0)
+    end
+    alias_method :to_haml, :render
+
+    module ::Hpricot::Node
+      # Returns the Haml representation of the given node,
+      # at the given tabulation.
+      def to_haml(tabs = 0)
+        parse_text(self.to_s, tabs)
+      end
+
+      private
+
+      def tabulate(tabs)
+        '  ' * tabs
+      end
+
+      def parse_text(text, tabs)
+        text.strip!
+        if text.empty?
+          String.new
+        else
+          lines = text.split("\n")
+          
+          lines.map do |line|
+            line.strip!
+            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+          end.join
+        end
+      end
+    end
+
+    # :stopdoc:
+
+    def self.options
+      @@options
+    end
+    
+    TEXT_REGEXP = /^(\s*).*$/
+
+    class ::Hpricot::Doc
+      def to_haml(tabs = 0)
+        output = ''
+        children.each { |child| output += child.to_haml(0) }
+        output
+      end
+    end
+
+    class ::Hpricot::XMLDecl
+      def to_haml(tabs = 0)
+        "#{tabulate(tabs)}!!! XML\n"
+      end
+    end
+
+    class ::Hpricot::DocType
+      def to_haml(tabs = 0)
+        attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
+        if attrs == nil
+          raise Exception.new("Invalid doctype")
+        end
+
+        type, version, strictness = attrs.map { |a| a.downcase }
+        if type == "html"
+          version = "1.0"
+          strictness = "transitional"
+        end
+
+        if version == "1.0" || version.empty?
+          version = nil
+        end
+
+        if strictness == 'transitional' || strictness.empty?
+          strictness = nil
+        end
+
+        version = " #{version}" if version
+        if strictness
+          strictness[0] = strictness[0] - 32
+          strictness = " #{strictness}"
+        end
+
+        "#{tabulate(tabs)}!!!#{version}#{strictness}\n"
+      end
+    end
+
+    class ::Hpricot::Comment
+      def to_haml(tabs = 0)
+        "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
+      end
+    end
+
+    class ::Hpricot::Elem
+      def to_haml(tabs = 0)
+        output = "#{tabulate(tabs)}"        
+        if HTML.options[:rhtml] && name[0...5] == 'haml:'
+          return output + HTML.send("haml_tag_#{name[5..-1]}", self.innerHTML)
+        end
+
+        output += "%#{name}" unless name == 'div' && (attributes.include?('id') || attributes.include?('class'))
+        
+        if attributes
+          output += "##{attributes['id']}" if attributes['id']
+          attributes['class'].split(' ').each { |c| output += ".#{c}" } if attributes['class']
+          attributes.delete("id")
+          attributes.delete("class")
+          output += attributes.inspect if attributes.length > 0
+        end
+        
+        output += "/" if children.length == 0
+        output += "\n"
+        
+        self.children.each do |child|
+          output += child.to_haml(tabs + 1)
+        end
+
+        output
+      end
+    end
+
+    def self.haml_tag_loud(text)
+      "= #{text.gsub(/\n\s*/, '; ').strip}\n"
+    end
+
+    def self.haml_tag_silent(text)
+      text.split("\n").map { |line| "- #{line.strip}\n" }.join
+    end
+
+    private
+
+    def match_to_html(string, regex, tag)
+      string.gsub!(regex) do
+        "<haml:#{tag}>#{CGI.escapeHTML($1)}</haml:#{tag}>"
+      end
+    end
+    # :startdoc:
+  end
+end