haml-edge 2.1.1

data/lib/haml/shared.rb

@@ -0,0 +1,45 @@
+require 'strscan'
+
+# :stopdoc:
+module Haml
+  # This module contains functionality that's shared across Haml and Sass.
+  module Shared
+    def self.handle_interpolation(str)
+      scan = StringScanner.new(str)
+      yield scan while scan.scan(/(.*?)(\\*)\#\{/)
+      scan.rest
+    end
+
+    def self.balance(scanner, start, finish, count = 0)
+      str = ''
+      scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
+      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+      while scanner.scan(regexp)
+        str << scanner.matched
+        count += 1 if scanner.matched[-1] == start
+        count -= 1 if scanner.matched[-1] == finish
+        return [str.strip, scanner.rest] if count == 0
+      end
+    end
+
+    def self.human_indentation(indentation, was = false)
+      if !indentation.include?(?\t)
+        noun = 'space'
+      elsif !indentation.include?(?\s)
+        noun = 'tab'
+      else
+        return indentation.inspect + (was ? ' was' : '')
+      end
+
+      singular = indentation.length == 1
+      if was
+        was = singular ? ' was' : ' were'
+      else
+        was = ''
+      end
+
+      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
+    end
+  end
+end
+# :startdoc:

data/lib/haml/template/patch.rb

@@ -0,0 +1,58 @@
+# This file makes Haml work with Rails
+# by monkeypatching the core template-compilation methods.
+# This is necessary for versions <= 2.0.1 because the template handler API
+# wasn't sufficiently powerful to deal with caching and so forth.
+
+# 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:
+    def delegate_template_exists_with_haml(template_path)
+      template_exists?(template_path, :haml) && [:haml]
+    end
+    alias_method :delegate_template_exists_without_haml, :delegate_template_exists?
+    alias_method :delegate_template_exists?, :delegate_template_exists_with_haml
+
+    def compile_template_with_haml(extension, template, file_name, local_assigns)
+      return compile_haml(template, file_name, local_assigns) if extension.to_s == "haml"
+      compile_template_without_haml(extension, template, file_name, local_assigns)
+    end
+    alias_method :compile_template_without_haml, :compile_template
+    alias_method :compile_template, :compile_template_with_haml
+
+    def compile_haml(template, file_name, local_assigns)
+      render_symbol = assign_method_name(:haml, template, file_name)
+      locals = local_assigns.keys
+
+      @@template_args[render_symbol] ||= {}
+      locals_keys = @@template_args[render_symbol].keys | locals
+      @@template_args[render_symbol] = Haml::Util.to_hash(locals_keys.map {|k| [k, true]})
+
+      options = Haml::Template.options.dup
+      options[:filename] = file_name || 'compiled-template'
+
+      begin
+        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals_keys)
+      rescue Exception => e
+        if logger
+          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+        end
+
+        base_path = if defined?(extract_base_path_from)
+                      # Rails 2.0.x
+                      extract_base_path_from(file_name) || view_paths.first
+                    else
+                      # Rails <=1.2.6
+                      @base_path
+                    end
+        raise ActionView::TemplateError.new(base_path, file_name || template, @assigns, template, e)
+      end
+
+      @@compile_time[render_symbol] = Time.now
+    end
+  end
+end

data/lib/haml/template/plugin.rb

@@ -0,0 +1,72 @@
+# :stopdoc:
+# This file makes Haml work with Rails
+# using the > 2.0.1 template handler API.
+
+module Haml
+  class Plugin < ActionView::TemplateHandler
+    include ActionView::TemplateHandlers::Compilable if defined?(ActionView::TemplateHandlers::Compilable)
+
+    def compile(template)
+      options = Haml::Template.options.dup
+
+      # template is a template object in Rails >=2.1.0,
+      # a source string previously
+      if template.respond_to? :source
+        options[:filename] = template.filename
+        source = template.source
+      else
+        source = template
+      end
+
+      Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
+    end
+
+    def cache_fragment(block, name = {}, options = nil)
+      @view.fragment_for(block, name, options) do
+        eval("_hamlout.buffer", block.binding)
+      end
+    end
+  end
+end
+
+if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+  ActionView::Template
+else
+  ActionView::Base
+end.register_template_handler(:haml, Haml::Plugin)
+
+# In Rails 2.0.2, ActionView::TemplateError took arguments
+# that we can't fill in from the Haml::Plugin context.
+# Thus, we've got to monkeypatch ActionView::Base to catch the error.
+if ActionView::TemplateError.instance_method(:initialize).arity == 5
+  class ActionView::Base
+    def compile_template(handler, template, file_name, local_assigns)
+      render_symbol = assign_method_name(handler, template, file_name)
+
+      # Move begin up two lines so it captures compilation exceptions.
+      begin
+        render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
+        line_offset = @@template_args[render_symbol].size + handler.line_offset
+      
+        file_name = 'compiled-template' if file_name.blank?
+        CompiledTemplates.module_eval(render_source, file_name, -line_offset)
+      rescue Exception => e # errors from template code
+        if logger
+          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+          logger.debug "Function body: #{render_source}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+        end
+
+        # There's no way to tell Haml about the filename,
+        # so we've got to insert it ourselves.
+        e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error)
+        
+        raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
+      end
+      
+      @@compile_time[render_symbol] = Time.now
+      # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger
+    end
+  end
+end
+# :startdoc:

data/lib/haml/template.rb

@@ -0,0 +1,42 @@
+require 'haml/engine'
+
+module Haml
+  module Template
+    extend self
+
+    @options = {}
+    attr_accessor :options
+  end
+end
+
+# Decide how we want to load Haml into Rails.
+# Patching was necessary for versions <= 2.0.1,
+# but we can make it a normal handler for higher versions.
+if defined?(ActionView::TemplateHandler)
+  require 'haml/template/plugin'
+else
+  require 'haml/template/patch'
+end
+
+if defined?(RAILS_ROOT)
+  # Update init.rb to the current version
+  # if it's out of date.
+  #
+  # We can probably remove this as of v1.9,
+  # because the new init file is sufficiently flexible
+  # to not need updating.
+  rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb')
+  haml_init_file = Haml.scope('init.rb')
+  begin
+    if File.exists?(rails_init_file)
+      require 'fileutils'
+      FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
+    end
+  rescue SystemCallError
+    warn <<END
+HAML WARNING:
+#{rails_init_file} is out of date and couldn't be automatically updated.
+Please run `haml --rails #{File.expand_path(RAILS_ROOT)}' to update it.
+END
+  end
+end

data/lib/haml/util.rb

@@ -0,0 +1,88 @@
+require 'erb'
+require 'set'
+require 'enumerator'
+
+module Haml
+  module Util
+    extend self
+
+    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
+
+    def to_hash(arr)
+      arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
+    end
+
+    def map_keys(hash)
+      to_hash(hash.map {|k, v| [yield(k), v]})
+    end
+
+    def map_vals(hash)
+      to_hash(hash.map {|k, v| [k, yield(v)]})
+    end
+
+    def map_hash(hash, &block)
+      to_hash(hash.map(&block))
+    end
+
+    def powerset(arr)
+      arr.inject([Set.new].to_set) do |powerset, el|
+        new_powerset = Set.new
+        powerset.each do |subset|
+          new_powerset << subset
+          new_powerset << subset + [el]
+        end
+        new_powerset
+      end
+    end
+
+    def merge_adjacent_strings(enum)
+      e = enum.inject([]) do |a, e|
+        if e.is_a?(String) && a.last.is_a?(String)
+          a.last << e
+        else
+          a << e
+        end
+        a
+      end
+    end
+
+    def ruby1_8?
+      Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
+    end
+
+    def has?(attr, klass, method)
+      klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
+    end
+
+    def enum_with_index(enum)
+      ruby1_8? ? enum.enum_with_index : enum.each_with_index
+    end
+
+    class StaticConditionalContext
+      def initialize(set)
+        @set = set
+      end
+
+      def method_missing(name, *args, &block)
+        super unless args.empty? && block.nil?
+        @set.include?(name)
+      end
+    end
+
+    def def_static_method(klass, name, args, *vars)
+      erb = vars.pop
+      powerset(vars).each do |set|
+        context = StaticConditionalContext.new(set).instance_eval {binding}
+        klass.class_eval(<<METHOD)
+def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
+  #{ERB.new(erb).result(context)}
+end
+METHOD
+      end
+    end
+
+    def static_method_name(name, *vars)
+      "#{name}_#{vars.map {|v| !!v}.join('_')}"
+    end
+  end
+end

data/lib/haml/version.rb

@@ -0,0 +1,47 @@
+module Haml
+  module Version
+    # Returns a hash representing the version of Haml.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # If Haml is checked out from Git,
+    # the :rev key will have the revision hash.
+    def version
+      return @@version if defined?(@@version)
+
+      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
+      @@version = {
+        :major => numbers[0],
+        :minor => numbers[1],
+        :teeny => numbers[2]
+      }
+      @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
+
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
+      end
+
+      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+
+      if rev
+        @@version[:rev] = rev
+        unless rev[0] == ?(
+          @@version[:string] << "."
+          @@version[:string] << rev[0...7]
+        end
+      end
+
+      @@version
+    end
+
+    # Returns the path of file relative to the Haml root.
+    def scope(file) # :nodoc:
+      File.expand_path File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+  end
+end