gohanlonllc-haml 2.1.0

data/lib/haml/exec.rb

@@ -0,0 +1,403 @@
+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
+        opts.on('--cache-location', 'The path to put cached Sass files. Defaults to .sass-cache.') do |loc|
+          @options[:for_engine][:cache_location] = path
+        end
+        opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
+          @options[:for_engine][:cache] = false
+        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]
+
+        tree =
+          if input.is_a?(File) && !@options[:check_syntax]
+            ::Sass::Files.tree_for(input.path, @options[:for_engine])
+          else
+            # 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.
+            ::Sass::Engine.new(input.read(), @options[:for_engine]).to_tree
+          end
+
+        input.close() if input.is_a?(File)
+
+        output.write(tree.render)
+        output.close() if output.is_a? File
+      rescue ::Sass::SyntaxError => e
+        raise e if @options[:trace]
+        raise "Syntax error on line #{get_line e}: #{e.message}"
+      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

data/lib/haml/filters.rb

@@ -0,0 +1,275 @@
+module Haml
+  # The module containing the default filters,
+  # as well as the base module,
+  # Haml::Filters::Base.
+  module Filters
+    # Returns a hash of defined filters.
+    def self.defined
+      @defined ||= {}
+    end
+
+    # The base module for Haml filters.
+    # User-defined filters should be modules including this module.
+    #
+    # A user-defined filter should override either Base#render or Base #compile.
+    # Base#render is the most common.
+    # It takes a string, the filter source,
+    # and returns another string,
+    # the result of the filter.
+    # For example:
+    #
+    #   module Haml::Filters::Sass
+    #     include Haml::Filters::Base
+    #
+    #     def render(text)
+    #       ::Sass::Engine.new(text).render
+    #     end
+    #   end
+    #
+    # For details on overriding #compile, see its documentation.
+    #
+    module Base
+      def self.included(base) # :nodoc:
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
+      end
+
+      # Takes a string, the source text that should be passed to the filter,
+      # and returns the string resulting from running the filter on <tt>text</tt>.
+      #
+      # This should be overridden in most individual filter modules
+      # to render text with the given filter.
+      # If compile is overridden, however, render doesn't need to be.
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
+      end
+
+      # Same as render, but takes the Haml options hash as well.
+      # It's only safe to rely on options made available in Haml::Engine#options_for_buffer.
+      def render_with_options(text, options)
+        render(text)
+      end
+
+      def internal_compile(*args) # :nodoc:
+        resolve_lazy_requires
+        compile(*args)
+      end
+
+      # compile should be overridden when a filter needs to have access
+      # to the Haml evaluation context.
+      # Rather than applying a filter to a string at compile-time,
+      # compile uses the Haml::Precompiler instance to compile the string to Ruby code
+      # that will be executed in the context of the active Haml template.
+      #
+      # Warning: the Haml::Precompiler interface is neither well-documented
+      # nor guaranteed to be stable.
+      # If you want to make use of it,
+      # you'll probably need to look at the source code
+      # and should test your filter when upgrading to new Haml versions.
+      def compile(precompiler, text)
+        resolve_lazy_requires
+        filter = self
+        precompiler.instance_eval do
+          if contains_interpolation?(text)
+            return if options[:suppress_eval]
+
+            push_script <<RUBY
+find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
+RUBY
+            return
+          end
+
+          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, precompiler.options), precompiler.options[:preserve])
+
+          if !options[:ugly]
+            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
+          else
+            push_text(rendered.rstrip)
+          end
+        end
+      end
+
+      # This becomes a class method of modules that include Base.
+      # It allows the module to specify one or more Ruby files
+      # that Haml should try to require when compiling the filter.
+      #
+      # The first file specified is tried first,
+      # then the second, etc.
+      # If none are found, the compilation throws an exception.
+      #
+      # For example:
+      #
+      #   module Haml::Filters::Markdown
+      #     lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+      #
+      #     ...
+      #   end
+      #
+      def lazy_require(*reqs)
+        @lazy_requires = reqs
+      end
+
+      private
+
+      def resolve_lazy_requires
+        return unless @lazy_requires
+
+        @lazy_requires[0...-1].each do |req|
+          begin
+            @required = req
+            require @required
+            return
+          rescue LoadError; end # RCov doesn't see this, but it is run
+        end
+
+        begin
+          @required = @lazy_requires[-1]
+          require @required
+        rescue LoadError => e
+          classname = self.name.match(/\w+$/)[0]
+
+          if @lazy_requires.size == 1
+            raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
+          else
+            raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
+          end
+        end
+      end
+    end
+  end
+end
+
+# :stopdoc:
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+module Haml
+  module Filters
+    module Plain
+      include Base
+
+      def render(text); text; end
+    end
+
+    module Javascript
+      include Base
+
+      def render_with_options(text, options)
+        <<END
+<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>
+  //<![CDATA[
+    #{text.rstrip.gsub("\n", "\n    ")}
+  //]]>
+</script>
+END
+      end
+    end
+
+    module Cdata
+      include Base
+
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    module Escaped
+      include Base
+
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
+    module Ruby
+      include Base
+      lazy_require 'stringio'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        precompiler.instance_eval do
+          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
+            _haml_old_stdout = $stdout
+            $stdout = StringIO.new(_hamlout.buffer, 'a')
+          FIRST
+            _haml_old_stdout, $stdout = $stdout, _haml_old_stdout
+            _haml_old_stdout.close
+          LAST
+        end
+      end
+    end
+
+    module Preserve
+      include Base
+
+      def render(text)
+        Haml::Helpers.preserve text
+      end
+    end
+
+    module Sass
+      include Base
+      lazy_require 'sass/plugin'
+
+      def render(text)
+        ::Sass::Engine.new(text, ::Sass::Plugin.engine_options).render
+      end
+    end
+
+    module ERB
+      include Base
+      lazy_require 'erb'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        src = ::ERB.new(text).src.sub(/^#coding:.*?\n/, '').
+          sub(/^_erbout = '';/, "").gsub("\n", ';')
+        precompiler.send(:push_silent, src)
+      end
+    end
+
+    module Textile
+      include Base
+      lazy_require 'redcloth'
+
+      def render(text)
+        ::RedCloth.new(text).to_html(:textile)
+      end
+    end
+    RedCloth = Textile
+    Filters.defined['redcloth'] = RedCloth
+
+    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
+    module Markdown
+      include Base
+      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
+
+      def render(text)
+        engine = case @required
+                 when 'rdiscount'
+                   ::RDiscount
+                 when 'peg_markdown'
+                   ::PEGMarkdown
+                 when 'maruku'
+                   ::Maruku
+                 when 'bluecloth'
+                   ::BlueCloth
+                 end
+        engine.new(text).to_html
+      end
+    end
+
+    module Maruku
+      include Base
+      lazy_require 'maruku'
+
+      def render(text)
+        ::Maruku.new(text).to_html
+      end
+    end
+  end
+end
+
+# :startdoc:

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