haml-i18n-extractor 0.4.3 → 0.5.0

data/test/extractor_test.rb

@@ -8,30 +8,30 @@ module Haml
       @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
     end
 
-    test "it can process the haml and replace it with other text" do
+    def test_it_can_process_the_haml_and_replace_it_with_other_text
       @ex1.run
     end
 
-    test "it should be able to process filters with the haml_parser now..." do
+    def test_it_should_be_able_to_process_filters_with_the_haml_parser_now
       #@FIXME
       #raise 'implment me...check the finder#filters method and make sure you process the whole file at once so the parser gets it...'
     end
 
-    test "with a type of overwrite or dump affecting haml writer" do
+    def test_with_a_type_of_overwrite_or_dump_affecting_haml_writer
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :type => :overwrite)
       assert_equal h.haml_writer.overwrite?, true
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"))
       assert_equal h.haml_writer.overwrite?, false
     end
 
-    test "with a interactive option which prompts the user-per line" do
+    def test_with_a_interactive_option_which_prompts_the_userper_line
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :interactive => true)
       assert_equal h.interactive?, true
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"))
       assert_equal h.interactive?, false
     end
 
-    test "with a interactive option takes user input into consideration for haml" do
+    def test_with_a_interactive_option_takes_user_input_into_consideration_for_haml
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :interactive => true)
       user_input = "D" # dump
       File.readlines(file_path("ex1.haml")).size.times do
@@ -44,7 +44,7 @@ module Haml
       assert_equal File.read(h.haml_writer.path), File.read(file_path("ex1.haml"))
     end
 
-    test "with a interactive option takes user input N as next and stops processing file" do
+    def test_with_a_interactive_option_takes_user_input_n_as_next_and_stops_processing_file
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :interactive => true)
       user_input = "D" # dump
       File.readlines(file_path("ex1.haml")).size.times do
@@ -57,7 +57,7 @@ module Haml
       assert_equal File.read(h.haml_writer.path), File.read(file_path("ex1.haml"))
     end
 
-    test "with a interactive option takes user input into consideration for yaml" do
+    def test_with_a_interactive_option_takes_user_input_into_consideration_for_yaml
       TestHelper.hax_shit
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :interactive => true)
       user_input = "D" # dump
@@ -68,13 +68,13 @@ module Haml
         h.run
       end
       # no changes were made cause user was all like 'uhhh, no thxk'
-      assert_equal YAML.load(File.read(h.yaml_tool.yaml_file)), {}
+      assert_equal YAML.load(File.read(h.yaml_writer.yaml_file)), {}
     end
 
-    test "with a interactive option user can tag a line for later review" do
+    def test_with_a_interactive_option_user_can_tag_a_line_for_later_review
       TestHelper.hax_shit
-      if File.exist?(Haml::I18n::Extractor::TaggingTool::DB)
-        assert_equal File.readlines(Haml::I18n::Extractor::TaggingTool::DB), []
+      if File.exist?(Haml::I18n::Extractor::TaggingWriter::DB)
+        assert_equal File.readlines(Haml::I18n::Extractor::TaggingWriter::DB), []
       end
       h = Haml::I18n::Extractor.new(file_path("ex1.haml"), :interactive => true)
       user_input = "D" # dump
@@ -84,11 +84,11 @@ module Haml
       with_highline(user_input) do
         h.run
       end
-      assert (File.readlines(Haml::I18n::Extractor::TaggingTool::DB).size != 0), "tag lines get added to file"
+      assert (File.readlines(Haml::I18n::Extractor::TaggingWriter::DB).size != 0), "tag lines get added to file"
     end
 
 
-    test "can not initialize if the haml is not valid syntax" do
+    def test_can_not_initialize_if_the_haml_is_not_valid_syntax
       begin
         Haml::I18n::Extractor.new(file_path("bad.haml"))
         assert false, "should not get here"
@@ -97,30 +97,30 @@ module Haml
       end
     end
 
-    test "it writes the haml to an out file if valid haml output" do
+    def test_it_writes_the_haml_to_an_out_file_if_valid_haml_output
       FileUtils.rm_rf(@ex1.haml_writer.path)
       assert_equal File.exists?(@ex1.haml_writer.path), false
       @ex1.run
       assert_equal File.exists?(@ex1.haml_writer.path), true
     end
 
-    test "it writes the locale info to an out file when run" do
+    def test_it_writes_the_locale_info_to_an_out_file_when_run
       TestHelper.hax_shit
-      assert_equal File.exists?(@ex1.yaml_tool.yaml_file), false
+      assert_equal File.exists?(@ex1.yaml_writer.yaml_file), false
       @ex1.run
-      assert_equal File.exists?(@ex1.yaml_tool.yaml_file), true
-      assert_equal YAML.load(File.read(@ex1.yaml_tool.yaml_file)), @ex1.yaml_tool.yaml_hash
+      assert_equal File.exists?(@ex1.yaml_writer.yaml_file), true
+      assert_equal YAML.load(File.read(@ex1.yaml_writer.yaml_file)), @ex1.yaml_writer.yaml_hash
     end
 
-    test "sends a hash over of replacement info to its yaml tool when run" do
+    def test_sends_a_hash_over_of_replacement_info_to_its_yaml_writer_when_run
       @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
-      assert_equal @ex1.yaml_tool.locale_hash, nil
+      assert_equal @ex1.yaml_writer.info_for_yaml, nil
       @ex1.run
-      assert @ex1.yaml_tool.locale_hash.is_a?(Hash), "its is hash of info about the files lines"
-      assert_equal @ex1.yaml_tool.locale_hash.size, @ex1.haml_reader.lines.size
+      assert @ex1.yaml_writer.info_for_yaml.is_a?(Hash), "its is hash of info about the files lines"
+      assert_equal @ex1.yaml_writer.info_for_yaml.size, @ex1.haml_reader.lines.size
     end
 
-    test "it fails before it writes to an out file if it is not valid" do
+    def test_it_fails_before_it_writes_to_an_out_file_if_it_is_not_valid
       begin
         @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
         @ex1.stub(:assign_new_body, nil) do #nop

data/test/haml_parser_test.rb

@@ -7,20 +7,20 @@ module Haml
       @body = "- if true\n  bar"
     end
 
-    test "it can collect metadata about lines" do
+    def test_it_can_collect_metadata_about_lines
       tree = Haml::I18n::Extractor::HamlParser.new(@body)
       line_metadatas = tree.flattened_values
       assert_equal line_metadatas.size, 2
     end
 
-    test "it can collect metadata about lines" do
+    def test_it_can_collect_metadata_about_lines
       parser = Haml::I18n::Extractor::HamlParser.new(@body)
       line_metadatas = parser.flattened_values
       assert_equal line_metadatas.size, 2
     end
 
     # easy api to use index <-> lineno
-    test "it is sorted by line numbers" do
+    def test_it_is_sorted_by_line_numbers
       parser = Haml::I18n::Extractor::HamlParser.new(@body)
       line_metadatas = parser.flattened_values
       assert_equal line_metadatas, line_metadatas.sort_by{|m| m[:line]}

data/test/haml_reader_test.rb

@@ -17,16 +17,16 @@ module Haml
       @reader = Haml::I18n::Extractor::HamlReader.new(TEMP_FILE_PATH)
     end
 
-    test "has a body and a path" do
+    def test_has_a_body_and_a_path
       assert_equal @reader.path, TEMP_FILE_PATH
       assert_equal @reader.body, File.read(TEMP_FILE_PATH)
     end
 
-    test "has an array of lines in that file" do
+    def test_has_an_array_of_lines_in_that_file
       assert_equal @reader.lines.size, LINE_COUNT
     end
 
-    test "has metadata about each line" do
+    def test_has_metadata_about_each_line
       assert_equal @reader.metadata.size, LINE_COUNT
     end
 

data/test/haml_writer_test.rb

@@ -6,6 +6,8 @@ module Haml
 
     ORIG_TEMP_FILE_PATH = File.join(TestHelper::TMPDIR, "foo_haml_extractor_test.haml")
 
+    FileUtils.mkdir_p(TestHelper::TMPDIR)
+
     def setup
       File.open(ORIG_TEMP_FILE_PATH, "w") do |f|
         10.times do |i|
@@ -18,7 +20,7 @@ module Haml
       FileUtils.rm_rf(ORIG_TEMP_FILE_PATH)
     end
 
-    test "it can dump the file and that is the default" do
+    def test_it_can_dump_the_file_and_that_is_the_default
       @writer = Haml::I18n::Extractor::HamlWriter.new(ORIG_TEMP_FILE_PATH)
       @writer.body = "This is what it is"
       @writer.write_file
@@ -26,7 +28,7 @@ module Haml
       assert_equal File.read(@writer.path), "This is what it is\n"
     end
 
-    test "it can overwrite the file" do
+    def test_it_can_overwrite_the_file
       @writer = Haml::I18n::Extractor::HamlWriter.new(ORIG_TEMP_FILE_PATH, {:type => :overwrite})
       @writer.body = "This is what it is"
       @writer.write_file

data/test/integration_test.rb

@@ -12,40 +12,42 @@ module Haml
       TestHelper.teardown_project_directory!
     end
 
-    test "it can handle namespaced views" do
+    def test_it_can_handle_namespaced_views
       namespaced_extractor = Haml::I18n::Extractor.extractors.select{|ex| ex.haml_writer.path.match /namespace/ }.last
-      assert namespaced_extractor.yaml_tool.yaml_hash["en"]["namespace"], "namespace key works"
+      assert namespaced_extractor.yaml_writer.yaml_hash["en"]["namespace"], "namespace key works"
     end
 
-    test "it can handle partial views" do
+    def test_it_can_handle_partial_views
       partial_extractor = Haml::I18n::Extractor.extractors.select{|ex| ex.haml_writer.path.match /_partial/ }.last
-      assert partial_extractor.yaml_tool.yaml_hash["en"]["view2"]["partial"], "partial filenames in yaml are w/out leading _"
+      assert partial_extractor.yaml_writer.yaml_hash["en"]["view2"]["partial"], "partial filenames in yaml are w/out leading _"
     end
 
     ## EXAMPLES
 
-    test "it can replace a string body and have expected output ex4" do
+    def test_it_can_replace_a_string_body_and_have_expected_output_ex5
+      expected_output = File.read(file_path("ex5.output.haml"))
+      assert_equal Haml::I18n::Extractor.new(file_path("ex5.haml")).new_body, expected_output
+    end
+
+    def test_it_can_replace_a_string_body_and_have_expected_output_ex4
       expected_output = File.read(file_path("ex4.output.haml"))
       assert_equal Haml::I18n::Extractor.new(file_path("ex4.haml")).new_body, expected_output
     end
 
-    test "it can replace a string body and have expected output ex3" do
+    def test_it_can_replace_a_string_body_and_have_expected_output_ex3
       expected_output = File.read(file_path("ex3.output.haml"))
       assert_equal Haml::I18n::Extractor.new(file_path("ex3.haml")).new_body, expected_output
     end
 
-    test "it can replace a string body and have expected output ex2" do
+    def test_it_can_replace_a_string_body_and_have_expected_output_ex2
       expected_output = File.read(file_path("ex2.output.haml"))
       assert_equal Haml::I18n::Extractor.new(file_path("ex2.haml")).new_body, expected_output
     end
 
-
-    test "it can replace a string body and have expected output ex1" do
+    def test_it_can_replace_a_string_body_and_have_expected_output_ex1
       expected_output = File.read(file_path("ex1.output.haml"))
       assert_equal Haml::I18n::Extractor.new(file_path("ex1.haml")).new_body, expected_output
     end
 
-
-
   end
 end

data/test/interpolation_helper_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Haml
+  class InterpolationHelperTest < MiniTest::Unit::TestCase
+
+    def test_it_takes_text_and_returns_interpolations
+      replace = "this may \#{be} the \#{dup}"
+      t_name = "this_may_be_the_dup"
+      helper = Haml::I18n::Extractor::InterpolationHelper.new(replace, t_name)
+      assert helper.interpolations == ["be", "dup"], "can catch the interpolations"
+    end
+
+
+    def test_it_takes_text_and_custom_keynames
+      replace = "this may \#{be} the \#{dup}"
+      t_name = "this_may_be_the_dup"
+      helper = Haml::I18n::Extractor::InterpolationHelper.new(replace, t_name)
+      assert helper.keyname_with_vars == "t('.this_may_be_the_dup', :be => be, :dup => dup)",
+        "returns custom t() with vars"
+    end
+
+    def test_it_takes_text_and_returns_for_str_with_no_quotes
+      replace = "\\\#{is_this_hard?} what"
+      t_name = "is_this_hard_what"
+      helper = Haml::I18n::Extractor::InterpolationHelper.new(replace, t_name)
+      assert helper.interpolations == ["is_this_hard?"], "can catch the interpolations"
+      x = helper.keyname_with_vars
+      #puts x.inspect
+      assert x == "t('.is_this_hard_what', :is_this_hard => is_this_hard?)",
+        "returns custom t() with vars"
+    end
+
+    # FIXME these don't work?
+    #%p \#{is_this_hard?} what
+    #%span I don't know if this \#{is_also} what
+    #%p= t('.what', :is_this_hard => is_this_hard?)
+    #%span= t('.i_dont_know_if_this_what', :is_also => is_also)
+
+  end
+end
+
+
+

data/test/prompter_test.rb

@@ -4,19 +4,19 @@ module Haml
   # misnomer, this is also testing UserAction
   class PrompterAndUserActionTest < MiniTest::Unit::TestCase
 
-    test "asks_to_process_line_yes" do
+    def test_asks_to_process_line_yes
       with_highline("y") do
         assert_equal Haml::I18n::Extractor::Prompter.new.ask_user("orig", "replace").replace_line?, true
       end
     end
 
-    test "asks_to_process_line_no" do
+    def test_asks_to_process_line_no
       with_highline("n") do
         assert_equal Haml::I18n::Extractor::Prompter.new.ask_user("orig", "replace").no_replace?, true
       end
     end
 
-    test "test_asks_to_process_line_tag" do
+    def test_test_asks_to_process_line_tag
       with_highline("t") do
         assert_equal Haml::I18n::Extractor::Prompter.new.ask_user("orig", "replace").tag?, true
       end

data/test/support/ex1.yml

@@ -0,0 +1,15 @@
+---
+en:
+  support:
+    ex1:
+      some_place: Some place
+      admin: Admin
+      admin_dashboard: Admin Dashboard
+      stacks: Stacks
+      alerts: t('.alerts')
+      accounts: Accounts
+      this_linkez: this_linkez
+      what_is_supposed_to_be_is_supp: What is@ supposed to be, is supposed to be!
+        ~
+      details: Details
+      random: ! '"raNdom"'

data/test/support/ex2.output.haml

@@ -8,7 +8,7 @@
     %h3
       = t('.all_invoices_billable')
       %span{:style => (@billable_invoices == @active_invoices) ? "color: #090" : "color: #900"}
-        =t('.billable_invoices_out_of_activ')
+        =t('.billable_invoices_out_of_activ', :billable_invoices => @billable_invoices, :active_invoices => @active_invoices)
     %h3
       = t('.24_hours_past_end_of_billing_m')
       %span{:style => (@billing_month.past_cutoff) ? "color: #090" : "color: #900"}

data/test/support/ex5.haml

@@ -0,0 +1,4 @@
+.class Text here
+.other-class#id= "script with quote #{with_interpolation(bub)} interpolated!"
+
+= "this may #{be} the #{dup}"

data/test/support/ex5.output.haml

@@ -0,0 +1,4 @@
+.class= t('.text_here')
+.other-class#id= t('.script_with_quote_with_interpo', :with_interpolationbub => with_interpolation(bub))
+
+=t('.this_may_be_the_dup', :be => be, :dup => dup)

data/test/support/ex5.yml

@@ -0,0 +1,8 @@
+---
+en:
+  support:
+    ex5:
+      text_here: Text here
+      script_with_quote_with_interpo: ! '"script with quote %{with_interpolationbub}
+        interpolated!"'
+      this_may_be_the_dup: ! ' "this may %{be} the %{dup}"'

data/test/{tagging_tool_test.rb → tagging_writer_test.rb}

@@ -2,23 +2,23 @@ require 'test_helper'
 require 'fileutils'
 
 module Haml
-  class TaggingToolTest < MiniTest::Unit::TestCase
+  class TaggingWriterTest < MiniTest::Unit::TestCase
 
-    FILE = Haml::I18n::Extractor::TaggingTool::DB
+    FILE = Haml::I18n::Extractor::TaggingWriter::DB
 
     def teardown
       FileUtils.rm_rf(FILE)
     end
 
-    test "It uses a file which it uses to keep track of user tagged lines" do
+    def test_it_uses_a_file_which_it_uses_to_keep_track_of_user_tagged_lines
       TestHelper.hax_shit
       assert ! File.exists?(FILE), "no tagging file should exist"
-      Haml::I18n::Extractor::TaggingTool.new
+      Haml::I18n::Extractor::TaggingWriter.new
       assert File.exists?(FILE), "tagging file should be created on init"
     end
 
-    test "It can write in a format" do
-      tag_tool = Haml::I18n::Extractor::TaggingTool.new
+    def test_it_can_write_in_a_format
+      tag_tool = Haml::I18n::Extractor::TaggingWriter.new
       tag_tool.write("/foo/bar/baz.txt", 49)
       assert File.readlines(FILE).include?("/foo/bar/baz.txt:49\n"), "should write info"
     end

data/test/test_helper.rb

@@ -114,8 +114,8 @@ module TestHelper
   def self.hax_shit
     Dir.glob("*yml").map {|p| FileUtils.rm(p) } # HAX, TODO: handle with yaml files correctly (config/en.yml)
     Dir.glob("config/locales/*yml").map {|p| FileUtils.rm(p) } # HAX, TODO: handle with yaml files correctly (config/en.yml)
-    if File.exists?(Haml::I18n::Extractor::TaggingTool::DB)
-      FileUtils.rm_rf(Haml::I18n::Extractor::TaggingTool::DB) # HAX, TODO: setup/teardown
+    if File.exists?(Haml::I18n::Extractor::TaggingWriter::DB)
+      FileUtils.rm_rf(Haml::I18n::Extractor::TaggingWriter::DB) # HAX, TODO: setup/teardown
     end
   end
 

data/test/text_finder_test.rb

@@ -4,104 +4,104 @@ module Haml
   class StringFinderTest < MiniTest::Unit::TestCase
 
     # empty line
-    test "empty lines, filters, matches with no @metadata" do
+    def test_empty_lines_filters_matches_with_nometadata
       assert_equal find_text(""), nil
       assert_equal find_type(""), nil
     end
 
     # regular text mode
-    test "regular text without whitespaces" do
+    def test_regular_text_without_whitespaces
       assert_equal find_text("iphone"), "iphone"
       assert_equal find_type("iphone"), :plain
     end
 
-    test "regular text with whitespaces" do
+    def test_regular_text_with_whitespaces
       assert_equal find_text("iphone4  "), "iphone4"
       assert_equal find_type("iphone4  "), :plain
     end
 
-    test "scripts with strings" do
+    def test_scripts_with_strings
       assert_equal find_text("= 'jessica'"), " 'jessica'"
       assert_equal find_type("= 'jessica'"), :script
     end
 
-    test "scripts with no strings" do
+    def test_scripts_with_no_strings
       assert_equal find_text("= true"), ""
       assert_equal find_type("= true"), :script
     end
 
     # html tag mode
-    test "%tag Text is an tag" do
+    def test_tag_text_is_an_tag
       assert_equal find_text("%span Text to find"), "Text to find"
       assert_equal find_type("%span Text to find"), :tag
     end
 
-    test "%tag Text with class is an tag" do
+    def test_tag_text_with_class_is_an_tag
       assert_equal find_text("%span.whatever-with-thing Text to find"), "Text to find"
       assert_equal find_type("%span.whatever-with-thing Text to find"), :tag
     end
 
-    test "%tag Text with ruby eval code is a script script" do
+    def test_tag_text_with_ruby_eval_code_is_a_script_script
       assert_equal find_text("%span= ruby_eval_code"), ""
       assert_equal find_type("%span= ruby_eval_code"), :tag
     end
 
-    test "%tag Text with ruby eval code and class is a script script" do
+    def test_tag_text_with_ruby_eval_code_and_class_is_a_script_script
       assert_equal find_text( "%span#whatever-with-thing= ruby_eval_code"), ""
       assert_equal find_type( "%span#whatever-with-thing= ruby_eval_code"), :tag
     end
 
-    test "Ruby style tags %a{'href' => 'http://whatever'} whatever" do
+    def test_ruby_style_tags_ahref__httpwhatever_whatever
       assert_equal find_text("%a{'href' => 'http://whatever'} whatever"), "whatever"
       assert_equal find_type("%a{'href' => 'http://whatever'} whatever"), :tag
     end
 
     # script scripts / ruby eval mode
-    test "script scripts with strings" do
+    def test_script_scripts_with_strings
       assert_equal find_text('= "bob"'), " \"bob\""
       assert_equal find_text("= 'bob'"), " 'bob'"
       assert_equal find_type("= 'bob'"), :script
     end
 
-    test "script scripts does not interpolate ruby vars in strings" do
+    def test_script_scripts_does_not_interpolate_ruby_vars_in_strings
       assert_equal find_text('= "ruby can #{var}"'), " \"ruby can \#{var}\""
       assert_equal find_type('= "ruby can #{var}"'), :script
     end
 
     # special script scripts exceptions
-    test "it finds link_to texts as an exception to the rule" do
+    def test_it_finds_link_to_texts_as_an_exception_to_the_rule
       assert_equal find_text('= link_to "This should be found", "/"'), "This should be found"
       assert_equal find_type('= link_to "This should be found", "/"'), :script
     end
 
-    test "it finds link_to texts as an exception to the rule and does not interpolate" do
+    def test_it_finds_link_to_texts_as_an_exception_to_the_rule_and_does_not_interpolate
       assert_equal find_text('= "Statistics for #{@name}"'), " \"Statistics for \#{@name}\""
       assert_equal find_type('= "Statistics for #{@name}"'), :script
     end
 
     # html tag mode with ruby evaling
-    test "html tag with ruby eval with strings" do
+    def test_html_tag_with_ruby_eval_with_strings
       assert_equal find_text('%p= "bob"'), "\"bob\""
       assert_equal find_text("%p.what= 'bob'"), "'bob'"
       assert_equal find_text("%p.what{:attr => :val}= 'bob'"), "'bob'"
       assert_equal find_type("%p.what{:attr => :val}= 'bob'"), :tag
     end
 
-    test "html tag script scripts does not interpolate ruby vars in strings" do
+    def test_html_tag_script_scripts_does_not_interpolate_ruby_vars_in_strings
       assert_equal find_text('%p= "ruby can #{var}"'), "\"ruby can \#{var}\""
       assert_equal find_text('%p.what= "ruby can #{var}"'), "\"ruby can \#{var}\""
       assert_equal find_text('%p.what{:attr => :val}= "ruby can #{var}"'), "\"ruby can \#{var}\""
       assert_equal find_type('%p.what{:attr => :val}= "ruby can #{var}"'), :tag
     end
 
-    test "html tag it finds link_to texts as an exception to the rule" do
+    def test_html_tag_it_finds_link_to_texts_as_an_exception_to_the_rule
       assert_equal find_text('%p= link_to "This should be found", "/"'), "This should be found"
       assert_equal find_text('%p.what= link_to "This should be found", "/"'), "This should be found"
       assert_equal find_text('%p.what{:attr => :val}= link_to "This should be found", "/"'), "This should be found"
       assert_equal find_type('%p.what{:attr => :val}= link_to "This should be found", "/"'), :tag
     end
 
-    test "html tag it finds link_to texts as an exception to the rule and does not interpolate" do
+    def test_html_tag_it_finds_link_to_texts_as_an_exception_to_the_rule_and_does_not_interpolate
       assert_equal find_text('%p= "Statistics for #{@name}"'), "\"Statistics for \#{@name}\""
       assert_equal find_text('%p.what= "Statistics for #{@name}"'), "\"Statistics for \#{@name}\""
       assert_equal find_text('%p.what{:attr => :val}= "Statistics for #{@name}"'), "\"Statistics for \#{@name}\""
@@ -117,12 +117,14 @@ module Haml
     end
 
     def find_type(haml)
-      type, text = process_haml(haml)
+      result = process_haml(haml)
+      type, text =  [result.type, result.match]
       type
     end
 
     def find_text(haml)
-      type, text = process_haml(haml)
+      result = process_haml(haml)
+      type, text =  [result.type, result.match]
       text
     end