haml-edge 2.3.224 → 2.3.225

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.224
+2.3.225

data/VERSION

@@ -1 +1 @@
-2.3.224
+2.3.225

data/lib/sass/plugin/merb.rb

@@ -24,27 +24,6 @@ unless defined?(Sass::MERB_LOADED)
 
   Sass::Plugin.options.merge!(config)
 
-  if version[0] > 0 || version[1] >= 9
-
-    class Merb::Rack::Application
-      def call_with_sass(env)
-        Sass::Plugin.check_for_updates
-        call_without_sass(env)
-      end
-      alias_method :call_without_sass, :call
-      alias_method :call, :call_with_sass
-    end
-
-  else
-
-    class MerbHandler
-      def process_with_sass(request, response)
-        Sass::Plugin.check_for_updates
-        process_without_sass(request, response)
-      end
-      alias_method :process_without_sass, :process
-      alias_method :process, :process_with_sass
-    end
-
-  end
+  require 'sass/plugin/rack'
+  Merb::Config[:app].use Sass::Plugin::Rack
 end

data/lib/sass/plugin/rack.rb

@@ -31,7 +31,6 @@ module Sass
       # @param app [#call] The Rack application
       def initialize(app)
         @app = app
-        self.class.disable_native_plugin!
       end
 
       # Process a request, checking the Sass stylesheets for changes
@@ -43,23 +42,6 @@ module Sass
         Sass::Plugin.check_for_updates
         @app.call(env)
       end
-
-      # Disable the native Rails or Merb plugins, if they're enabled.
-      # This is automatically done once the Rack plugin is activated.
-      # This is done so that the stylesheets aren't checked twice for each request.
-      def self.disable_native_plugin!
-        if defined?(Merb::Rack) && defined?(Merb::Rack::Application) &&
-            Haml::Util.has?(:instance_method, Merb::Rack::Application, :call_without_sass)
-          Merb::Rack::Application.instance_eval {alias_method :call, :call_without_sass}
-        end
-
-        if defined?(ActionDispatch::Callbacks) && defined?(ActionDispatch::Callbacks.to_prepare)
-          ActionDispatch::Callbacks.skip_callback(:prepare, :__sass_process)
-        elsif defined?(ActionController::Base) &&
-            Haml::Util.has?(:instance_method, ActionController::Base, :sass_old_process)
-          ActionController::Base.instance_eval {alias_method :process, :sass_old_process}
-        end
-      end
     end
   end
 end

data/test/haml/spec/README.md

@@ -0,0 +1,97 @@
+# Haml Spec #
+
+Haml Spec provides a basic suite of tests for Haml interpreters.
+
+It is intented for developers who are creating or maintaining an implementation
+of the [Haml](http://haml-lang.com) markup language.
+
+At the moment, there are test runners for the [original Haml](http://github.com/nex3/haml)
+in Ruby, and for [Lua Haml](http://github.com/norman/lua-haml). Support for
+other versions of Haml will be added if their developers/maintainers
+are interested in using it.
+
+## The Tests ##
+
+The tests are kept in JSON format for portability across languages.  Each test
+is a JSON object with expected input, output, local variables and configuration
+parameters (see below).  The test suite only provides tests for features which
+are portable, therefore no tests for script are provided, nor for external
+filters such as :markdown or :textile.
+
+The one major exception to this are the tests for interpolation, which you may
+need to modify with a regular expression to run under PHP or Perl, which
+require a symbol before variable names. These tests are included despite being
+less than 100% portable because interpolation is an important part of Haml and
+can be tricky to implement.
+
+## Running the Tests ##
+
+### Ruby ###
+
+In order to make it as easy as possible for non-Ruby programmers to run the
+Ruby Haml tests, the Ruby test runner uses test/unit, rather than something
+fancier like Rspec.  To run them you probably only need to install `haml`, and
+possibly `ruby` if your platform doesn't come with it by default. If you're
+using Ruby 1.8.x, you'll also need to install `json`:
+
+    sudo gem install haml
+    # for Ruby 1.8.x; check using "ruby --version" if unsure
+    sudo gem install json
+
+Then, running the Ruby test suite is easy:
+
+    ruby ruby_haml_test.rb
+
+### Lua ###
+
+The Lua test depends on [Telescope](http://telescope.luaforge.net/),
+[jason4lua](http://json.luaforge.net/), and
+[Lua Haml](http://github.com/norman/lua-haml). Install and
+run `tsc lua_haml_spec.lua`.
+
+## Contributing ##
+
+### Getting it ###
+
+You can access the [Git repository](http://github.com/norman/haml-spec) at:
+
+    git://github.com/norman/haml-spec.git
+
+Patches are *very* welcome, as are test runners for your Haml implementation.
+
+As long as any test you add run against Ruby Haml and are not redundant, I'll
+be very happy to add them.
+
+### Test JSON format ###
+
+    "test name" : {
+      "haml" : "haml input",
+      "html" : "expected html output",
+      "result" : "expected test result",
+      "locals" : "local vars",
+      "config" : "config params"
+    }
+
+* test name: This should be a *very* brief description of what's being tested. It can
+  be used by the test runners to name test methods, or to exclude certain tests from being
+  run.
+* haml: The Haml code to be evaluated. Always required.
+* html: The HTML output that should be generated. Required unless "result" is "error".
+* result: Can be "pass" or "error". If it's absent, then "pass" is assumed. If it's "error",
+  then the goal of the test is to make sure that malformed Haml code generates an error.
+* locals: An object containing local variables needed for the test.
+* config: An object containing configuration parameters used to run the test.
+  The configuration parameters should be usable directly by Ruby's Haml with no
+  modification.  If your implementation uses config parameters with different
+  names, you may need to process them to make them match your implementation.
+  If your implementation has options that do not exist in Ruby's Haml, then you
+  should add tests for this in your implementation's test rather than here.
+
+## License ##
+
+  This project is released under the [WTFPL](http://sam.zoy.org/wtfpl/) in order
+  to be as usable as possible in any project, commercial or free.
+
+## Author ##
+
+  [Norman Clarke](mailto:norman@njclarke.com)

data/test/haml/spec/lua_haml_spec.lua

@@ -0,0 +1,30 @@
+require 'luarocks.require'
+require 'json'
+require 'telescope'
+require 'haml'
+
+local function get_tests(filename)
+  local self = debug.getinfo(1).short_src
+  if self:match("/") then return "./" .. self:gsub("[^/]*%.lua$", "/" .. filename)
+  elseif self:match("\\") then return self:gsub("[^\\]*%.lua$", "\\" .. filename)
+  else return filename
+  end
+end
+
+local fh = assert(io.open(get_tests("tests.json")))
+local input = fh:read '*a'
+fh:close()
+
+local contexts = json.decode(input)
+
+describe("LuaHaml", function()
+   for context, expectations in pairs(contexts) do
+     describe("When handling " .. context, function()
+      for name, exp in pairs(expectations) do
+        it(string.format("should correctly render %s", name), function()
+            assert_equal(haml.render(exp.haml, exp.config or {}, exp.locals or {}), exp.html)
+        end)
+      end
+     end)
+   end
+end)

data/test/haml/spec/ruby_haml_test.rb

@@ -0,0 +1,19 @@
+require "test/unit"
+require "json"
+require "haml"
+
+class HamlTest < Test::Unit::TestCase
+  contexts = JSON.parse(File.read(File.dirname(__FILE__) + "/tests.json"))
+  contexts.each do |context|
+    context[1].each do |name, test|
+      class_eval(<<-EOTEST)
+        def test_#{name.gsub(/\s+|[^a-zA-Z0-9_]/, "_")}
+          locals = Hash[*(#{test}["locals"] || {}).collect {|k, v| [k.to_sym, v] }.flatten]
+          options = Hash[*(#{test}["config"] || {}).collect {|k, v| [k.to_sym, v.to_sym] }.flatten]
+          engine = Haml::Engine.new(#{test}["haml"], options)
+          assert_equal(engine.render(Object.new, locals).chomp, #{test}["html"])
+        end
+      EOTEST
+    end
+  end
+end