jwhitmire-haml 2.1.0.1

data/lib/haml/engine.rb

@@ -0,0 +1,268 @@
+require 'haml/helpers'
+require 'haml/buffer'
+require 'haml/precompiler'
+require 'haml/filters'
+require 'haml/error'
+
+module Haml
+  # This is the class where all the parsing and processing of the Haml
+  # template is done. It can be directly used by the user by creating a
+  # new instance and calling <tt>to_html</tt> to render the template. For example:
+  #
+  #   template = File.read('templates/really_cool_template.haml')
+  #   haml_engine = Haml::Engine.new(template)
+  #   output = haml_engine.to_html
+  #   puts output
+  class Engine
+    include Precompiler
+
+    # Allow reading and writing of the options hash
+    attr :options, true
+
+    # This string contains the source code that is evaluated
+    # to produce the Haml document.
+    attr :precompiled, true
+
+    # A string containing the indentation used for the Haml document.
+    # nil if the indentation is ambiguous
+    # (for example, for a single-level document).
+    attr :indentation, true
+
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
+    # Creates a new instace of Haml::Engine that will compile the given
+    # template string when <tt>render</tt> is called.
+    # See the Haml module documentation for available options.
+    #
+    #--
+    # When adding options, remember to add information about them
+    # to lib/haml.rb!
+    #++
+    #
+    def initialize(template, options = {})
+      @options = {
+        :suppress_eval => false,
+        :attr_wrapper => "'",
+
+        # Don't forget to update the docs in lib/haml.rb if you update these
+        :autoclose => %w[meta img link br hr input area param col base],
+        :preserve => %w[textarea pre],
+
+        :filename => '(haml)',
+        :line => 1,
+        :ugly => false,
+        :format => :xhtml,
+        :escape_html => false
+      }
+      @options.merge! options
+      @index = 0
+
+      unless [:xhtml, :html4, :html5].include?(@options[:format])
+        raise Haml::Error, "Invalid format #{@options[:format].inspect}"
+      end
+
+      # :eod is a special end-of-document marker
+      @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
+      @template_index = 0
+      @to_close_stack = []
+      @output_tabs = 0
+      @template_tabs = 0
+      @flat = false
+      @newlines = 0
+      @precompiled = ''
+      @to_merge = []
+      @tab_change  = 0
+      @temp_count = 0
+
+      if @options[:filters]
+        warn <<END
+DEPRECATION WARNING:
+The Haml :filters option is deprecated and will be removed in version 2.2.
+Filters are now automatically registered.
+END
+      end
+
+      precompile
+    rescue Haml::Error => e
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
+      raise
+    end
+
+    # Processes the template and returns the result as a string.
+    #
+    # +scope+ is the context in which the template is evaluated.
+    # If it's a Binding or Proc object,
+    # Haml uses it as the second argument to Kernel#eval;
+    # otherwise, Haml just uses its #instance_eval context.
+    #
+    # Note that Haml modifies the evaluation context
+    # (either the scope object or the "self" object of the scope binding).
+    # It extends Haml::Helpers, and various instance variables are set
+    # (all prefixed with "haml").
+    # For example:
+    #
+    #   s = "foobar"
+    #   Haml::Engine.new("%p= upcase").render(s) #=> "<p>FOOBAR</p>"
+    #
+    #   # s now extends Haml::Helpers
+    #   s.responds_to?(:html_attrs) #=> true
+    #
+    # +locals+ is a hash of local variables to make available to the template.
+    # For example:
+    #
+    #   Haml::Engine.new("%p= foo").render(Object.new, :foo => "Hello, world!") #=> "<p>Hello, world!</p>"
+    #
+    # If a block is passed to render,
+    # that block is run when +yield+ is called
+    # within the template.
+    #
+    # Due to some Ruby quirks,
+    # if scope is a Binding or Proc object and a block is given,
+    # the evaluation context may not be quite what the user expects.
+    # In particular, it's equivalent to passing <tt>eval("self", scope)</tt> as scope.
+    # This won't have an effect in most cases,
+    # but if you're relying on local variables defined in the context of scope,
+    # they won't work.
+    def render(scope = Object.new, locals = {}, &block)
+      buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
+
+      if scope.is_a?(Binding) || scope.is_a?(Proc)
+        scope_object = eval("self", scope)
+        scope = scope_object.instance_eval{binding} if block_given?
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
+
+      scope_object.instance_eval do
+        extend Haml::Helpers
+        @haml_buffer = buffer
+      end
+
+      eval(@precompiled, scope, @options[:filename], @options[:line])
+
+      # Get rid of the current buffer
+      scope_object.instance_eval do
+        @haml_buffer = buffer.upper
+      end
+
+      buffer.buffer
+    end
+    alias_method :to_html, :render
+
+    # Returns a proc that, when called,
+    # renders the template and returns the result as a string.
+    #
+    # +scope+ works the same as it does for render.
+    #
+    # The first argument of the returned proc is a hash of local variable names to values.
+    # However, due to an unfortunate Ruby quirk,
+    # the local variables which can be assigned must be pre-declared.
+    # This is done with the +local_names+ argument.
+    # For example:
+    #
+    #   # This works
+    #   Haml::Engine.new("%p= foo").render_proc(Object.new, :foo).call :foo => "Hello!"
+    #     #=> "<p>Hello!</p>"
+    #
+    #   # This doesn't
+    #   Haml::Engine.new("%p= foo").render_proc.call :foo => "Hello!"
+    #     #=> NameError: undefined local variable or method `foo'
+    #
+    # The proc doesn't take a block;
+    # any yields in the template will fail.
+    def render_proc(scope = Object.new, *local_names)
+      if scope.is_a?(Binding) || scope.is_a?(Proc)
+        scope_object = eval("self", scope)
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
+           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
+    end
+
+    # Defines a method on +object+
+    # with the given name
+    # that renders the template and returns the result as a string.
+    #
+    # If +object+ is a class or module,
+    # the method will instead by defined as an instance method.
+    # For example:
+    #
+    #   t = Time.now
+    #   Haml::Engine.new("%p\n  Today's date is\n  .date= self.to_s").def_method(t, :render)
+    #   t.render #=> "<p>\n  Today's date is\n  <div class='date'>Fri Nov 23 18:28:29 -0800 2007</div>\n</p>\n"
+    #
+    #   Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
+    #   "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
+    #
+    # The first argument of the defined method is a hash of local variable names to values.
+    # However, due to an unfortunate Ruby quirk,
+    # the local variables which can be assigned must be pre-declared.
+    # This is done with the +local_names+ argument.
+    # For example:
+    #
+    #   # This works
+    #   obj = Object.new
+    #   Haml::Engine.new("%p= foo").def_method(obj, :render, :foo)
+    #   obj.render(:foo => "Hello!") #=> "<p>Hello!</p>"
+    #
+    #   # This doesn't
+    #   obj = Object.new
+    #   Haml::Engine.new("%p= foo").def_method(obj, :render)
+    #   obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
+    #
+    # Note that Haml modifies the evaluation context
+    # (either the scope object or the "self" object of the scope binding).
+    # It extends Haml::Helpers, and various instance variables are set
+    # (all prefixed with "haml").
+    def def_method(object, name, *local_names)
+      method = object.is_a?(Module) ? :module_eval : :instance_eval
+
+      object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end",
+                  @options[:filename], @options[:line])
+    end
+
+    private
+
+    def set_locals(locals, scope, scope_object)
+      scope_object.send(:instance_variable_set, '@_haml_locals', locals)
+      set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")
+      eval(set_locals, scope)
+    end
+
+    # Returns a hash of options that Haml::Buffer cares about.
+    # This should remain loadable from #inspect.
+    def options_for_buffer
+      {
+        :autoclose => @options[:autoclose],
+        :preserve => @options[:preserve],
+        :attr_wrapper => @options[:attr_wrapper],
+        :ugly => @options[:ugly],
+        :format => @options[:format]
+      }
+    end
+  end
+end

data/lib/haml/error.rb

@@ -0,0 +1,22 @@
+module Haml
+  # An exception raised by Haml code.
+  class Error < StandardError
+    # :stopdoc:
+
+    # By default, an error is taken to refer to the line of the template
+    # that was being processed when the exception was raised.
+    # However, if line is non-nil, it + 1 is used instead.
+    attr_reader :line
+
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+    # :startdoc:
+  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 < Haml::Error; end
+end

data/lib/haml/exec.rb

@@ -0,0 +1,395 @@
+require 'optparse'
+require 'fileutils'
+
+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!
+        begin
+          @opts = OptionParser.new(&method(:set_opts))
+          @opts.parse!(@args)
+
+          process_result
+
+          @options
+        rescue Exception => e
+          raise e if @options[:trace] || e.is_a?(SystemExit)
+
+          $stderr.puts e.message
+          exit 1
+        end
+        exit 0
+      end
+
+      def to_s
+        @opts.to_s
+      end
+
+      protected
+
+      def get_line(exception)
+        # SyntaxErrors have weird line reporting
+        # when there's trailing whitespace,
+        # which there is for Haml documents.
+        return exception.message.scan(/:(\d+)/).first.first if exception.is_a?(::SyntaxError)
+        exception.backtrace[0].scan(/:(\d+)/).first.first
+      end
+
+      private
+
+      def set_opts(opts)
+        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
+          @options[:input] = $stdin
+        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
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          puts("Haml #{::Haml.version[:string]}")
+          exit
+        end
+      end
+
+      def process_result
+        input, output = @options[:input], @options[:output]
+        input_file, output_file = if input
+                                    [nil, open_file(ARGV[0], 'w')]
+                                  else
+                                    @options[:filename] = ARGV[0]
+                                    [open_file(ARGV[0]), open_file(ARGV[1], 'w')]
+                                  end
+
+        input  ||= input_file
+        output ||= output_file
+        input  ||= $stdin
+        output ||= $stdout
+
+        @options[:input], @options[:output] = input, output
+      end
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        File.open(filename, flag)
+      end
+    end
+
+    # A class encapsulating the executable functionality
+    # specific to Haml and Sass.
+    class HamlSass < Generic # :nodoc:
+      def initialize(args)
+        super
+        @options[:for_engine] = {}
+      end
+
+      private
+
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: #{@name.downcase} [options] [INPUT] [OUTPUT]
+
+Description:
+  Uses the #{@name} engine to parse the specified template
+  and outputs the result to the specified file.
+
+Options:
+END
+
+        opts.on('--rails RAILS_DIR', "Install Haml and Sass 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)
+            print "Directory #{dir} already exists, overwrite [y/N]? "
+            exit if gets !~ /y/i
+            FileUtils.rm_rf(dir)
+          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 "require 'rubygems'"
+            file << File.read(File.dirname(__FILE__) + "/../../init.rb")
+          end
+
+          puts "Haml plugin added to #{original_dir}"
+          exit
+        end
+
+        opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
+          require 'stringio'
+          @options[:check_syntax] = true
+          @options[:output] = StringIO.new
+        end
+
+        super
+      end
+
+      def process_result
+        super
+        @options[:for_engine][:filename] = @options[:filename] if @options[:filename]
+        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"
+        @options[:for_engine][:load_paths] = ['.'] + (ENV['SASSPATH'] || '').split(File::PATH_SEPARATOR)
+      end
+
+      def set_opts(opts)
+        super
+
+        opts.on('-t', '--style NAME',
+                'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
+          @options[:for_engine][:style] = name.to_sym
+        end
+        opts.on('-l', '--line-comments',
+                'Line Comments. Emit comments in the generated CSS indicating the corresponding sass line.') do
+          @options[:for_engine][:line_comments] = true
+        end
+        opts.on('-i', '--interactive',
+                'Run an interactive SassScript shell.') do
+          @options[:interactive] = true
+        end
+        opts.on('-I', '--load-path PATH', 'Add a sass import path.') do |path|
+          @options[:for_engine][:load_paths] << path
+        end
+      end
+
+      def process_result
+        if @options[:interactive]
+          require 'sass'
+          require 'sass/repl'
+          ::Sass::Repl.new(@options).run
+          return
+        end
+
+        super
+        input = @options[:input]
+        output = @options[:output]
+
+        template = input.read()
+        input.close() if input.is_a? File
+
+        begin
+          # We don't need to do any special handling of @options[:check_syntax] here,
+          # because the Sass syntax checking happens alongside evaluation
+          # and evaluation doesn't actually evaluate any code anyway.
+          result = ::Sass::Engine.new(template, @options[:for_engine]).render
+        rescue ::Sass::SyntaxError => e
+          raise e if @options[:trace]
+          raise "Syntax error on line #{get_line e}: #{e.message}"
+        end
+
+        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"
+        @options[:requires] = []
+        @options[:load_paths] = []
+      end
+
+      def set_opts(opts)
+        super
+
+        opts.on('-t', '--style NAME',
+                'Output style. Can be indented (default) or ugly.') do |name|
+          @options[:for_engine][:ugly] = true if name.to_sym == :ugly
+        end
+
+        opts.on('-f', '--format NAME',
+                'Output format. Can be xhtml (default), html4, or html5.') do |name|
+          @options[:for_engine][:format] = name.to_sym
+        end
+
+        opts.on('-e', '--escape-html',
+                'Escape HTML characters (like ampersands and angle brackets) by default.') do
+          @options[:for_engine][:escape_html] = true
+        end
+
+        opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
+          @options[:requires] << file
+        end
+
+        opts.on('-I', '--load-path PATH', "Same as 'ruby -I'.") do |path|
+          @options[:load_paths] << path
+        end
+
+        opts.on('--debug', "Print out the precompiled Ruby source.") do
+          @options[:debug] = true
+        end
+      end
+
+      def process_result
+        super
+        input = @options[:input]
+        output = @options[:output]
+
+        template = input.read()
+        input.close() if input.is_a? File
+
+        begin
+          engine = ::Haml::Engine.new(template, @options[:for_engine])
+          if @options[:check_syntax]
+            puts "Syntax OK"
+            return
+          end
+
+          @options[:load_paths].each {|p| $LOAD_PATH << p}
+          @options[:requires].each {|f| require f}
+
+          if @options[:debug]
+            puts engine.precompiled
+            puts '=' * 100
+          end
+
+          result = engine.to_html
+        rescue Exception => e
+          raise e if @options[:trace]
+
+          case e
+          when ::Haml::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}"
+          when ::Haml::Error;       raise "Haml error on line #{get_line e}: #{e.message}"
+          else raise "Exception on line #{get_line e}: #{e.message}\n  Use --trace for backtrace."
+          end
+        end
+
+        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 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] [INPUT] [OUTPUT]
+
+Description: Transforms an HTML file into corresponding Haml code.
+
+Options:
+END
+
+        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
+          @module_opts[:rhtml] = true
+        end
+
+        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
+          @options[:no_rhtml] = true
+        end
+
+        opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
+          @module_opts[:xhtml] = true
+        end
+
+        super
+      end
+
+      def process_result
+        super
+
+        input = @options[:input]
+        output = @options[:output]
+
+        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
+
+        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
+
+        @module_opts = {}
+
+        require 'sass/css'
+      end
+
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: css2sass [options] [INPUT] [OUTPUT]
+
+Description: Transforms a CSS file into corresponding Sass code.
+
+Options:
+END
+
+        opts.on('-a', '--alternate', 'Output using alternative Sass syntax (margin: 1px)') do
+          @module_opts[:alternate] = true
+        end
+
+        super
+      end
+
+      def process_result
+        super
+
+        input = @options[:input]
+        output = @options[:output]
+
+        output.write(::Sass::CSS.new(input, @module_opts).render)
+      end
+    end
+  end
+end