haml-i18n-extractor 0.0.5

data/test/extractor_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+module Haml
+  class ExtractorTest < MiniTest::Unit::TestCase
+
+    def setup
+      @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
+    end
+
+    test "it can process the haml and replace it with other text!" do
+      @ex1.run
+    end
+
+    test "can not initialize if the haml is not valid syntax" do
+      begin
+        Haml::I18n::Extractor.new(file_path("bad.haml"))
+        assert false, "should not get here"
+      rescue Haml::I18n::Extractor::InvalidSyntax
+        assert true, "it should fail with invalid syntax"
+      end
+    end
+
+    test "can initialize if the haml is valid syntax" do
+      # setup method initializes
+      assert true, "extractor can initialize"
+    end
+
+    test "it can replace a string body and have expected output" do
+      expected_output = File.read(file_path("ex1.output.haml"))
+      assert_equal @ex1.new_body, expected_output
+    end
+
+    test "it writes the haml to an out file if valid haml output" do
+      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
+      assert_equal File.exists?(@ex1.yaml_tool.locale_file), false
+      @ex1.run
+      assert_equal File.exists?(@ex1.yaml_tool.locale_file), true
+      assert_equal YAML.load(File.read(@ex1.yaml_tool.locale_file)), @ex1.yaml_tool.yaml_hash
+    end
+
+    test "it raises if there is nothing to translate" do
+      begin
+        @nothing_to_translate = Haml::I18n::Extractor.new(file_path("nothing_to_translate.haml"))
+        assert_equal @ex1.yaml_tool.locale_hash, nil
+        @nothing_to_translate.run
+      rescue Haml::I18n::Extractor::NothingToTranslate
+        assert true, "NothingToTranslate raised"
+      end
+    end
+
+    test "sends a hash over of replacement info to its yaml tool when run" do
+      @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
+      assert_equal @ex1.yaml_tool.locale_hash, 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
+    end
+
+    test "it fails before it writes to an out file if it is not valid" do
+      begin
+        @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
+        @ex1.stub(:assign_new_body, nil) do #nop
+          @ex1.haml_writer.body = File.read(file_path("bad.haml"))
+          @ex1.run
+        end
+      rescue Haml::I18n::Extractor::InvalidSyntax
+        assert true, "it should not allow invalid output to be written"
+      end
+    end
+    
+  end
+end

data/test/haml_reader_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'fileutils'
+
+module Haml
+  class HamlReaderTest < MiniTest::Unit::TestCase
+    
+    TEMP_FILE_PATH = "/tmp/foo_haml_extractor_test"
+    
+    def setup
+      FileUtils.rm_rf(TEMP_FILE_PATH)
+      10.times do |index|
+        File.open(TEMP_FILE_PATH, "a+") do |f|
+          f.puts "line #{index}"
+        end
+      end
+      @reader = Haml::I18n::Extractor::HamlReader.new(TEMP_FILE_PATH)
+    end
+
+    test "has a body and a path" do
+      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
+      assert_equal @reader.lines.size, 10
+    end
+
+  end
+end

data/test/haml_writer_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+require 'fileutils'
+
+module Haml
+  class HamlWriterTest < MiniTest::Unit::TestCase
+
+    ORIG_TEMP_FILE_PATH = "/tmp/foo_haml_extractor_test.haml"
+
+    def setup
+      File.open(ORIG_TEMP_FILE_PATH, "w") do |f|
+        10.times do |i|
+          f.puts "line #{i}"
+        end
+      end
+    end
+
+    def teardown
+      FileUtils.rm_rf(ORIG_TEMP_FILE_PATH)
+    end
+
+    test "is initialized with an array of lines, an original path and constructs a body and path with it" do
+      @writer = Haml::I18n::Extractor::HamlWriter.new(ORIG_TEMP_FILE_PATH)
+      assert_equal @writer.path, "/tmp/foo_haml_extractor_test.i18n-extractor.haml"
+    end
+    
+    test "it can write the file" do
+      @writer = Haml::I18n::Extractor::HamlWriter.new(ORIG_TEMP_FILE_PATH)
+      @writer.body = "This is what it is"
+      @writer.write_file
+      assert_equal File.read(@writer.path), "This is what it is\n"
+    end
+
+  end
+end

data/test/support/bad.haml

@@ -0,0 +1,12 @@
+#clz
+  - else
+      'foo'
+-this is
+     -not correct_haml
+     
+    = in
+    kljlk
+     lkjl
+ ~invliz     
+ ~invliz     
+  

data/test/support/ex1.haml

@@ -0,0 +1,28 @@
+#header.page
+  %p#brand= link_to "Some place", '/'
+  #menu
+    %ul.header-links
+      - if true
+        - if false
+          %li
+            %a#cheese-rice{:href => url_for([:admin, :dashboard])}
+              %span.thing-ok Admin
+            #bla
+              %ul#admin-dropdown-box
+                %li
+                  %a{:href => url_for([:admin, :dashboard])}
+                    %span Admin Dashboard
+                %li
+                  %a{:href => url_for([:admin, :stacks])}
+                    %span Stacks
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span= t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :accounts])}
+                    %span Accounts
+        - if true
+          What is@ supposed to be, is supposed to be! ~

data/test/support/ex1.i18n-extractor.haml

@@ -0,0 +1,28 @@
+#header.page
+  %p#brand= link_to t('.some_place'), '/'
+  #menu
+    %ul.header-links
+      - if true
+        - if false
+          %li
+            %a#cheese-rice{:href => url_for([:admin, :dashboard])}
+              %span.thing-ok= t('.admin')
+            #bla
+              %ul#admin-dropdown-box
+                %li
+                  %a{:href => url_for([:admin, :dashboard])}
+                    %span= t('.admin_dashboard')
+                %li
+                  %a{:href => url_for([:admin, :stacks])}
+                    %span= t('.stacks')
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span= t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :accounts])}
+                    %span= t('.accounts')
+        - if true
+          = t('.what_is_supposed_to_be_is_supp')

data/test/support/ex1.output.haml

@@ -0,0 +1,28 @@
+#header.page
+  %p#brand= link_to t('.some_place'), '/'
+  #menu
+    %ul.header-links
+      - if true
+        - if false
+          %li
+            %a#cheese-rice{:href => url_for([:admin, :dashboard])}
+              %span.thing-ok= t('.admin')
+            #bla
+              %ul#admin-dropdown-box
+                %li
+                  %a{:href => url_for([:admin, :dashboard])}
+                    %span= t('.admin_dashboard')
+                %li
+                  %a{:href => url_for([:admin, :stacks])}
+                    %span= t('.stacks')
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :environments])}
+                    %span= t('.alerts')
+                %li
+                  %a{:href => url_for([:admin, :accounts])}
+                    %span= t('.accounts')
+        - if true
+          = t('.what_is_supposed_to_be_is_supp')

data/test/support/nothing_to_translate.haml

@@ -0,0 +1,2 @@
+#menu
+  .whatever

data/test/support/nothing_to_translate.i18n-extractor.haml

@@ -0,0 +1,2 @@
+#menu
+  .whatever

data/test/test_helper.rb

@@ -0,0 +1,98 @@
+#######################################################################
+##    copied over from haml for this to just work. TODO Cleanup.     ##
+##                      mini  test stuff                             ##
+#######################################################################
+
+require 'rubygems'
+gem "minitest"
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'action_pack'
+require 'action_controller'
+require 'action_view'
+require 'nokogiri'
+require 'rails'
+require 'fileutils'
+
+require 'pry'
+module Declarative
+  def test(name, &block)
+    define_method("test #{name}", &block)
+  end
+end
+
+class MiniTest::Unit::TestCase
+
+  extend Declarative
+
+  def render(text, options = {}, base = nil, &block)
+    scope  = options.delete(:scope)  || Object.new
+    locals = options.delete(:locals) || {}
+    engine = Haml::Engine.new(text, options)
+    return engine.to_html(base) if base
+    engine.to_html(scope, locals, &block)
+  end
+  
+  def assert_warning(message)
+    the_real_stderr, $stderr = $stderr, StringIO.new
+    yield
+  
+    if message.is_a?(Regexp)
+      assert_match message, $stderr.string.strip
+    else
+      assert_equal message.strip, $stderr.string.strip
+    end
+  ensure
+    $stderr = the_real_stderr
+  end
+  
+  def silence_warnings(&block)
+    Haml::Util.silence_warnings(&block)
+  end
+  
+  def rails_form_opener
+    '<div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="&#x2713;" /></div>'
+  end
+  
+  def assert_raises_message(klass, message)
+    yield
+  rescue Exception => e
+    assert_instance_of(klass, e)
+    assert_equal(message, e.message)
+  else
+    flunk "Expected exception #{klass}, none raised"
+  end
+  
+  def self.error(*args)
+    Haml::Error.message(*args)
+  end
+
+end
+
+##############################
+## project specific helpers ##
+##############################
+
+require File.dirname(__FILE__) + "/../lib/" + 'haml-i18n-extractor'
+
+def file_path(name)
+  File.dirname(__FILE__) + "/support/#{name}"
+end
+
+def without_rails_mode
+  Object.send(:remove_const, :Rails) if defined?(Rails)
+  yield
+end
+
+def with_rails_mode
+  create_klass=<<EOR
+  module Rails
+    def self.root
+      "/data/current/name"
+    end
+  end
+EOR
+  eval create_klass
+  yield
+end
+

data/test/text_finder_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+
+module Haml
+  class StringFinderTest < MiniTest::Unit::TestCase
+
+    # empty line 
+    test "empty line does not explode" do
+      assert_equal find_text(""), ""
+      assert_equal find_type(""), :text
+    end
+    
+    # regular text mode
+    test "regular text without whitespaces" do
+      assert_equal find_text("iphone"), "iphone"
+      assert_equal find_type("iphone"), :text
+    end
+
+    test "regular text with whitespaces" do
+      assert_equal find_text("  iphone4"), "iphone4"
+      assert_equal find_type("  iphone4"), :text
+    end
+
+    # silent script mode
+    test "silent scripts with strings" do
+      assert_equal find_text("- 'jessica'"), "jessica"
+      assert_equal find_type("- 'jessica'"), :silent
+    end
+
+    test "silent scripts with no strings" do
+      assert_equal find_text("- if true"), ""
+      assert_equal find_type("- if true"), :silent
+    end
+
+    # html element mode
+    test "%tag Text is an element" do
+      assert_equal find_text("%span Text to find"), "Text to find"
+      assert_equal find_type("%span Text to find"), :element
+    end
+
+    test "%tag Text with class is an element" do
+      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"), :element
+    end
+
+    test "%tag Text with ruby eval code is a loud script" do
+      assert_equal find_text("%span= ruby_eval_code"), ""
+      assert_equal find_type("%span= ruby_eval_code"), :loud
+    end
+
+    test "%tag Text with ruby eval code and class is a loud script" do
+      assert_equal find_text( "%span#whatever-with-thing= ruby_eval_code"), ""
+      assert_equal find_type( "%span#whatever-with-thing= ruby_eval_code"), :loud
+    end
+    
+    test "Ruby style tags %a{'href' => 'http://whatever'} whatever" do
+      assert_equal find_text("%a{'href' => 'http://whatever'} whatever"), "whatever"
+      assert_equal find_type("%a{'href' => 'http://whatever'} whatever"), :element
+    end
+    
+    # loud scripts / ruby eval mode
+    test "loud scripts with strings" do
+      assert_equal find_text('= "bob"'), "bob"
+      assert_equal find_text("= 'bob'"), "bob"
+      assert_equal find_type("= 'bob'"), :loud
+    end
+
+    test "loud scripts does not interpolate ruby vars in strings" do
+      assert_equal find_text('= "ruby can #{var}"'), "ruby can \#{var}"
+      assert_equal find_type('= "ruby can #{var}"'), :loud
+    end
+    
+    # special loud scripts exceptions
+    test "it finds link_to texts as an exception to the rule" do
+      assert_equal find_text('= link_to "This should be found", "/"'), "This should be found"
+      assert_equal find_type('= link_to "This should be found", "/"'), :loud
+    end
+    
+    test "it finds link_to texts as an exception to the rule and does not interpolate" do
+      assert_equal find_text('= "Statistics for #{@name}"'), "Statistics for \#{@name}"
+      assert_equal find_type('= "Statistics for #{@name}"'), :loud
+    end
+
+    # html element mode with ruby evaling
+    test "html element with ruby eval with strings" do
+      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'"), :loud
+    end
+    
+    test "html element loud scripts does not interpolate ruby vars in strings" do
+      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}"'), :loud
+    end
+    
+    test "html element it finds link_to texts as an exception to the rule" do
+      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", "/"'), :loud
+    end
+    
+    test "html element it finds link_to texts as an exception to the rule and does not interpolate" do
+      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}"
+      assert_equal find_type('%p.what{:attr => :val}= "Statistics for #{@name}"'), :loud
+    end
+
+    private
+
+    def process_haml(haml)
+      text_finder = Haml::I18n::Extractor::TextFinder.new(haml)
+      text_finder.process_by_regex
+    end
+
+    def find_type(haml)
+      type, text = process_haml(haml)
+      type
+    end
+
+    def find_text(haml)
+      type, text = process_haml(haml)
+      text
+    end
+
+  end
+end

data/test/text_replacer_test.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Haml
+  class TextReplacerTest < MiniTest::Unit::TestCase
+    
+    test "it initializes with the line it is going to replace and the match to replace" do
+      Haml::I18n::Extractor::TextReplacer.new("this is whatever", "this is whatever", :text)
+    end
+
+    test "but it raises if passed a wrong line type" do
+      begin
+        replacer = Haml::I18n::Extractor::TextReplacer.new("regular text", "regular text", :this_is_not_defined)
+        assert false, 'should raise'
+      rescue Haml::I18n::Extractor::NotDefinedLineType
+        assert true, 'raised NotDefinedLineType'
+      end
+    end
+
+    # some text replacement examples
+    test "it can replace the body of haml with t() characters" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("this is whatever", "this is whatever", :text)
+      assert_equal replacer.replace_hash, { :modified_line => "= t('.this_is_whatever')", 
+                                          :keyname => "t('.this_is_whatever')", :replaced_text => "this is whatever"  }
+    end
+
+    test "it can replace the body of haml with t() characters example" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("%span Admin Dashboard", "Admin Dashboard", :element)
+      assert_equal replacer.replace_hash, { :modified_line => "%span= t('.admin_dashboard')",
+                                           :keyname => "t('.admin_dashboard')", :replaced_text => "Admin Dashboard" }
+    end
+
+    test "it won't replace already replaced t() characters if they are not ruby evaled" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("%span t('.admin_dashboard')", "t('.admin_dashboard')", :element)
+      assert_equal replacer.replace_hash, { :modified_line => "%span t('.admin_dashboard')",
+                                           :keyname => "t('.admin_dashboard')", :replaced_text => "t('.admin_dashboard')" }
+    end
+
+    test "it won't replace already replaced t() characters that are ruby evaled" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("%span= t('.admin_dashboard')", "t('.admin_dashboard')", :loud)
+      assert_equal replacer.replace_hash, { :modified_line => "%span= t('.admin_dashboard')",
+                                           :keyname => "t('.admin_dashboard')", :replaced_text => "t('.admin_dashboard')" }
+    end
+
+    test "it can replace the body of haml with t() characters example for link_to and removes surrounding quotes as well" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new(%{%p#brand= link_to 'Some Place', '/'}, "Some Place", :loud)
+      assert_equal replacer.replace_hash, { :modified_line => %{%p#brand= link_to t('.some_place'), '/'} , 
+                                            :keyname => "t('.some_place')", :replaced_text => "Some Place" }
+
+      replacer = Haml::I18n::Extractor::TextReplacer.new(%{%p#brand= link_to "Some Place", "/"}, "Some Place", :loud)
+      assert_equal replacer.replace_hash, { :modified_line => %{%p#brand= link_to t('.some_place'), "/"} ,
+                                            :keyname => "t('.some_place')", :replaced_text => "Some Place" }
+    end
+
+    # keyname restrictions
+    test "it limits the characters of the t namespace it provides to LIMIT_KEY_NAME" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("this is whatever" * 80, "this is whatever" * 80, :text)
+      assert_equal replacer.replace_hash[:modified_line].size, Haml::I18n::Extractor::TextReplacer::LIMIT_KEY_NAME + 8 # = t('.')
+    end
+    
+    test "it does not allow weird characters in the keyname" do
+      replacer = Haml::I18n::Extractor::TextReplacer.new("this (is `ch@racter ~ madness!", "this (is `ch@racter ~ madness!", :text)
+      assert_equal replacer.replace_hash, { :modified_line => "= t('.this_is_chracter_madness')", 
+                                            :keyname => "t('.this_is_chracter_madness')", :replaced_text => "this (is `ch@racter ~ madness!" }
+    end
+
+  end
+end

data/test/yaml_tool_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module Haml
+  class YamlToolTest < MiniTest::Unit::TestCase
+
+    def setup
+      @temp_locale_dir = File.expand_path(__FILE__) + "/tmp/"
+    end
+
+    def setup_locale_hash
+      @ex1 = Haml::I18n::Extractor.new(file_path("ex1.haml"))
+      @ex1.run
+    end
+
+    def ex1_yaml_hash
+      {"en"=>
+        {"support"=>
+          {"some_place"=>"Some place",
+           "admin"=>"Admin",
+           "admin_dashboard"=>"Admin Dashboard",
+           "stacks"=>"Stacks",
+           "alerts"=>"t('.alerts')",
+           "accounts"=>"Accounts",
+           "what_is_supposed_to_be_is_supp"=>
+            "What is@ supposed to be, is supposed to be! ~"
+            }
+          }
+        }
+    end
+
+    # test "locale dir defaults for rails if you do not pass anything" do
+    #   with_rails_mode do
+    #     yaml_tool = Haml::I18n::Extractor::YamlTool.new
+    #     assert_equal yaml_tool.locales_dir, "/data/current/name/config/locales"
+    #   end
+    # end
+
+    test "locale dir defaults to cwd if no rails" do
+      without_rails_mode do
+        yaml_tool = Haml::I18n::Extractor::YamlTool.new
+        assert_equal yaml_tool.locales_dir, File.expand_path(".")
+      end
+    end
+    
+    test "you can set the locale_dir" do
+      yaml_tool = Haml::I18n::Extractor::YamlTool.new(@temp_locale_dir)
+      assert_equal yaml_tool.locales_dir, @temp_locale_dir
+    end
+    
+    test "it relies on the locale_hash having a certain format" do
+      setup_locale_hash
+      @ex1.yaml_tool.locale_hash.each do |line_no, info_for_line|
+        assert info_for_line.has_key?(:modified_line), "hash info has :modified_line key"
+        assert info_for_line.has_key?(:keyname), "hash info has :keyname key"
+        assert info_for_line.has_key?(:replaced_text), "hash info has :replaced_text key"
+        # FIXME: since the scope right now is we're running this per file this will be the same, but keeping this right now.
+        assert info_for_line.has_key?(:path), "hash info has :path key"
+      end
+    end
+
+    test "constructs a yaml hash according to the view in rails mode" do
+      setup_locale_hash
+      yaml_tool = @ex1.yaml_tool
+      assert_equal yaml_tool.yaml_hash, ex1_yaml_hash
+    end
+
+  end
+end