haml-i18n-extractor 0.4.3 → 0.5.0

data/.gitignore

@@ -17,7 +17,7 @@ test/version_tmp
 tmp
 
 # hacks, these should not appear where thye are.
-*.yml
+./*.yml
 test/support/*i18n-extractor.haml
 config
 .tags.haml-i18n-extractor

data/TODO

@@ -23,6 +23,12 @@
 
 https://github.com/shaiguitar/haml-i18n-extractor/issues/2
 
+  Refactor out text_replacer? it's pretty simple. we can:
+    return a result class like Finder
+    and refactor the main modified_line method so it's not dumb?!
+  Change naive implementation!
+  right now it gets full_line, replace_this. just does a simple gsub.
+
   Now we are able to have internal access to Haml::Parser internals, we can deal with...
 
     ExceptionText needs to be responsible for knowing if needed to interpolate?

data/lib/haml-i18n-extractor/extraction/extractor.rb

@@ -20,11 +20,9 @@ module Haml
       LINE_TYPES_ADD_EVAL = [:plain, :tag]
 
       attr_reader :haml_reader, :haml_writer
-      attr_reader :locale_hash, :yaml_tool, :type
+      attr_reader :info_for_yaml, :yaml_writer, :type
       attr_reader :current_line
 
-      DEFAULT_LINE_LOCALE_HASH = { :modified_line => nil,:keyname => nil,:replaced_text => nil, :path => nil }
-
       def initialize(haml_path, opts = {})
         @options = opts
         @type = @options[:type]
@@ -33,12 +31,12 @@ module Haml
         @haml_reader = Haml::I18n::Extractor::HamlReader.new(haml_path)
         validate_haml(@haml_reader.body)
         @haml_writer = Haml::I18n::Extractor::HamlWriter.new(haml_path, {:type => @type})
-        @yaml_tool = Haml::I18n::Extractor::YamlTool.new(@options[:i18n_scope], @options[:yaml_file])
-        @tagging_tool ||= Haml::I18n::Extractor::TaggingTool.new
+        @yaml_writer = Haml::I18n::Extractor::YamlWriter.new(@options[:i18n_scope], @options[:yaml_file])
+        @tagging_writer ||= Haml::I18n::Extractor::TaggingWriter.new
         # hold all the processed lines
         @body = []
         # holds a line_no => {info_about_line_replacemnts_or_not}
-        @locale_hash = {}
+        @info_for_yaml = {}
 
         self.class.extractors << self
       end
@@ -46,7 +44,7 @@ module Haml
       def run
         assign_replacements
         validate_haml(@haml_writer.body)
-        @yaml_tool.write_file
+        @yaml_writer.write_file
         @haml_writer.write_file
       end
 
@@ -55,7 +53,7 @@ module Haml
       end
 
       def assign_yaml
-        @yaml_tool.locale_hash = @locale_hash
+        @yaml_writer.info_for_yaml = @info_for_yaml
       end
 
       def assign_replacements
@@ -78,16 +76,19 @@ module Haml
       end
 
       # this is the bulk of it:
-      # where we end up setting body info and locale_hash.
+      # where we end up setting body info and info_for_yaml.
       # not _write_, just set that info in memory in correspoding locations.
       # refactor more?
       def process_line(orig_line, line_no)
         orig_line.chomp!
         orig_line, whitespace = handle_line_whitespace(orig_line)
-        line_type, line_match = handle_line_finding(orig_line, line_no)
-        should_be_replaced, text_to_replace, line_locale_hash = gather_replacement_info(orig_line, line_match, line_type, line_no)
+        finder_result = finding_result(orig_line, line_no)
+        replacer_result = replacement_result(orig_line, finder_result.match, finder_result.type, line_no)
+        should_be_replaced = replacer_result.should_be_replaced
+        text_to_replace = replacer_result.modified_line
+
+        user_action = should_be_replaced ? user_action_yes : user_action_no
 
-        user_action = Haml::I18n::Extractor::UserAction.new('y') # default if no prompting: just do it.
         if should_be_replaced
           if interactive?
             user_action = @prompter.ask_user(orig_line,text_to_replace)
@@ -95,15 +96,15 @@ module Haml
         end
 
         if user_action.tag?
-          @tagging_tool.write(line_locale_hash[:path], line_no)
+          @tagging_writer.write(@haml_reader.path, line_no)
           add_to_body("#{whitespace}#{orig_line}")
         elsif user_action.next?
           raise AbortFile, "stopping to process the rest of the file"
        elsif user_action.replace_line?
-          append_to_locale_hash(line_no, line_locale_hash)
+          add_to_yaml_info(line_no, replacer_result.info)
           add_to_body("#{whitespace}#{text_to_replace}")
         elsif user_action.no_replace?
-          append_to_locale_hash(line_no, DEFAULT_LINE_LOCALE_HASH)
+          add_to_yaml_info(line_no, Haml::I18n::Extractor::ReplacerResult.new(nil,nil,nil,false,nil).info)
           add_to_body("#{whitespace}#{orig_line}")
         end
 
@@ -122,22 +123,19 @@ module Haml
         end
       end
 
-      def gather_replacement_info(orig_line, line_match, line_type, line_no)
+      def replacement_result(orig_line, line_match, line_type, line_no)
         if line_match && !line_match.empty?
-          replacer = Haml::I18n::Extractor::TextReplacer.new(orig_line, line_match, line_type, line_metadata(line_no))
-          hash = replacer.replace_hash.dup.merge!({:path => @haml_reader.path })
-          [ true, hash[:modified_line], hash ]
+          Haml::I18n::Extractor::TextReplacer.new(orig_line, line_match, line_type, @haml_reader.path, line_metadata(line_no)).result
         else
-          hash = DEFAULT_LINE_LOCALE_HASH
-          [ false, orig_line, hash ]
+          Haml::I18n::Extractor::ReplacerResult.new(orig_line, nil,line_match, false, "")
         end
       end
 
-      def append_to_locale_hash(line_no, hash)
-        @locale_hash[line_no] = hash
+      def add_to_yaml_info(line_no, hash)
+        @info_for_yaml[line_no] = hash
       end
 
-      def handle_line_finding(orig_line,lineno)
+      def finding_result(orig_line,lineno)
         Haml::I18n::Extractor::TextFinder.new(orig_line,line_metadata(lineno)).process_by_regex
       end
 
@@ -156,11 +154,23 @@ module Haml
         @body << ln
       end
 
+      def user_action_yes
+        Haml::I18n::Extractor::UserAction.new('y') # default if no prompting: just do it.
+      end
+
+      def user_action_no
+        Haml::I18n::Extractor::UserAction.new('n') # don't replace
+      end
+
+
       def validate_haml(haml)
         parser = Haml::Parser.new(haml, Haml::Options.new)
         parser.parse
-      rescue Haml::SyntaxError
-        raise InvalidSyntax, "invalid syntax for haml #{@haml_reader.path}"
+      rescue Haml::SyntaxError => e
+        message = "invalid syntax for haml #{@haml_reader.path}\n"
+        message << "original error:\n"
+        message << e.message
+        raise InvalidSyntax, message
       end
 
     end

data/lib/haml-i18n-extractor/extraction/{text_finder.rb → finder/text_finder.rb}

@@ -16,20 +16,26 @@ module Haml
 
         def process_by_regex
           # [ line_type, text_found ]
-          if Haml::I18n::Extractor.debug?
-            puts @metadata && @metadata[:type]
-            puts @metadata.inspect
-            puts @orig_line
-          end
-          @metadata && send("#{@metadata[:type]}", @metadata)
+          #output_debug if Haml::I18n::Extractor.debug?
+          result = @metadata && send("#{@metadata[:type]}", @metadata)
+          result = FinderResult.new(nil,nil) if result.nil?
+          result
         end
 
+        class FinderResult < Struct.new(:type, :match); end
+
         private
 
+        def output_debug
+          puts @metadata && @metadata[:type]
+          puts @metadata.inspect
+          puts @orig_line
+        end
+
         def plain(line)
           txt = line[:value][:text]
           return nil if html_comment?(txt)
-          [:plain, txt]
+          FinderResult.new(:plain, txt)
         end
 
         def tag(line)
@@ -38,21 +44,21 @@ module Haml
             has_script_in_tag = line[:value][:parse] # %element= foo
             has_exception = link_to?(txt)
             if has_script_in_tag && !has_exception
-              [:tag, ""]
+              FinderResult.new(:tag, "")
             else
-              [:tag, ExceptionFinder.new(txt).find]
+              FinderResult.new(:tag, ExceptionFinder.new(txt).find)
             end
           else
-            [:tag, ""]
+            FinderResult.new(:tag, "")
           end
         end
 
         def script(line)
           txt = line[:value][:text]
           if could_match_script?(txt)
-            [:script, ExceptionFinder.new(txt).find]
+            FinderResult.new(:script, ExceptionFinder.new(txt).find)
           else
-            [:script, ""]
+            FinderResult.new(:script, "")
           end
         end
 

data/lib/haml-i18n-extractor/extraction/replacer/interpolation_helper.rb

@@ -0,0 +1,51 @@
+module Haml
+  module I18n
+    class Extractor
+      class InterpolationHelper
+
+        include Helpers::StringHelpers
+
+        # takes an original_line and text_to_replace, keyname_name and gives back the result for that...
+        def initialize(text_to_replace, t_name)
+          if Extractor.debug?
+            puts "<interpolationhelper>#{text_to_replace.inspect} #{t_name.inspect}</interpolationhelper>"
+          end
+          @t_name = t_name
+          @text_to_replace = text_to_replace
+        end
+
+        def keyname_with_vars()
+          "t('.#{@t_name}', #{interpolated_vars})"
+        end
+
+        def interpolated_vars
+          interpolations.map{|v|
+            ":#{normalized_name(v.dup)} => #{v}"
+          }.join(", ")
+        end
+
+        # matches multiple
+        def interpolations(arr = [], str = @text_to_replace)
+          # recurse scanner until no interpolations or string left
+          return arr if str.nil? || str.empty? || !interpolated?(str)
+          scanner = StringScanner.new(str)
+          scanner.scan_until(/\#{.*?}/)
+          so_far = scanner.pre_match + scanner.matched
+          arr << extract_interpolation(so_far)
+          arr = interpolations(arr, scanner.rest)
+        end
+
+        def extract_interpolation(str)
+          scanner = StringScanner.new(str)
+          scanner.scan_until /\#{/
+          rest_scanner = StringScanner.new(scanner.rest)
+          rest_scanner.scan_until(/}/)
+          interpolated = rest_scanner.pre_match
+        end
+
+
+      end
+    end
+  end
+end
+

data/lib/haml-i18n-extractor/extraction/replacer/replacer_result.rb

@@ -0,0 +1,24 @@
+module Haml
+  module I18n
+    class Extractor
+      class ReplacerResult
+
+        attr_accessor :modified_line, :t_name, :replaced_text, :should_be_replaced, :path
+
+        def initialize(modified_line, t_name, replaced_text, should_be_replaced, path)
+          @modified_line = modified_line
+          @t_name = t_name
+          @replaced_text = replaced_text
+          @should_be_replaced = should_be_replaced
+          @path = path
+        end
+
+        def info
+          { :modified_line => @modified_line, :t_name => @t_name, :replaced_text => @replaced_text, :path => @path}
+        end
+      end
+
+    end
+  end
+end
+

data/lib/haml-i18n-extractor/extraction/{text_replacer.rb → replacer/text_replacer.rb}

@@ -3,15 +3,14 @@ module Haml
     class Extractor
       class TextReplacer
 
+        include Helpers::StringHelpers
+
         attr_reader :full_line, :text_to_replace, :line_type
 
-        T_REGEX = /t\('\..*'\)/
-        # limit the number of chars
-        LIMIT_KEY_NAME = 30
-        # do not pollute the key space it will make it invalid yaml
-        NOT_ALLOWED_IN_KEYNAME =  %w( ~ ` ! @ # $ % ^ & * - ( ) , ? { } = ' " : )
+        T_REGEX = /t\('\.(.*?)'\)/
 
-        def initialize(full_line, text_to_replace,line_type, metadata = {})
+        def initialize(full_line, text_to_replace,line_type, path, metadata = {})
+          @path = path
           @orig_line = @full_line = full_line
           @text_to_replace = text_to_replace
           @metadata = metadata
@@ -22,48 +21,61 @@ module Haml
           end
         end
 
+        def result
+          @result ||= Haml::I18n::Extractor::ReplacerResult.new(modified_line, t_name, @text_to_replace, true, @path)
+        end
+
         def replace_hash
-          t_name = keyname(@text_to_replace, @orig_line)
-          @replace_hash ||= { :modified_line => modified_line, :keyname => t_name, :replaced_text => @text_to_replace }
+          #legacy
+          result.info
+        end
+
+        def interpolation_helper
+          Haml::I18n::Extractor::InterpolationHelper.new(@text_to_replace, t_name)
         end
 
         # the new full line, including a `t()` replacement instead of the `text_to_replace` portion.
         def modified_line
+          return @full_line if has_been_translated?(@full_line)
           full_line = @full_line.dup
-          return @full_line if has_been_translated?(full_line)
-          remove_surrounding_quotes(full_line)
+          #puts t_method.inspect if Haml::I18n::Extractor.debug?
+          keyname = interpolated?(full_line) ? interpolation_helper.keyname_with_vars : t_method
+          gsub_replacement!(full_line, @text_to_replace, @orig_line, keyname)
           apply_ruby_evaling(full_line)
           full_line
         end
-
+ 
         private
 
-        def keyname(to_replace, orig_line)
+        # the_key_to_use ( for example in t('.the_key_to_use')
+        def t_name(to_replace = @text_to_replace, orig_line = @orig_line)
           text_to_replace = to_replace.dup
           if has_been_translated?(text_to_replace)
-            text_to_replace
+            text_to_replace.match T_REGEX
+            name = $1
           else
-            name = normalize_name(text_to_replace)
-            name = normalize_name(orig_line.dup) if name.empty?
-            with_translate_method(name)
+            name = normalized_name(text_to_replace.dup)
+            name = normalized_name(orig_line.dup) if name.empty?
           end
+          name
+        end
+
+        # t('.the_key_to_use')
+        def t_method
+          with_translate_method(t_name)
         end
 
         def with_translate_method(name)
           "t('.#{name}')"
         end
 
-        # adds the = to the right place in the string ... = t() stuff.
+        # adds the = to the right place in the string ... = t()
         def apply_ruby_evaling(str)
           if LINE_TYPES_ADD_EVAL.include?(@line_type)
             if @line_type == :tag
-              #str.match /^([^\s\t]*)(.*)$/
-              t_name = keyname(@text_to_replace, @orig_line)
-              match_keyname = Regexp.new('[\s\t]*' + Regexp.escape(t_name))
+              match_keyname = Regexp.new('[\s\t]*' + Regexp.escape(t_method))
               str.match(/(.*?)(#{match_keyname})/)
               elem = $1
-              #binding.pry if str.match /color/
-              #str.gsub!(keyname, "= #{keyname.strip}")
               if elem
                 str.gsub!(Regexp.new(Regexp.escape(elem)), "#{elem}=") unless already_evaled?(elem)
               end
@@ -83,22 +95,15 @@ module Haml
           str.match T_REGEX
         end
 
-        def remove_surrounding_quotes(str)
+        def gsub_replacement!(str, text_to_replace, orig_line, keyname_method )
           # if there are quotes surrounding the string, we want them removed as well...
-          t_name = keyname(@text_to_replace, @orig_line)
-          unless str.gsub!('"' + @text_to_replace + '"', t_name )
-            unless str.gsub!("'" + @text_to_replace + "'", t_name)
-              str.gsub!(@text_to_replace, t_name)
+          unless str.gsub!('"' + text_to_replace + '"', keyname_method )
+            unless str.gsub!("'" + text_to_replace + "'", keyname_method)
+              str.gsub!(text_to_replace, keyname_method)
             end
           end
         end
 
-        def normalize_name(str)
-          NOT_ALLOWED_IN_KEYNAME.each{ |rm_me| str.gsub!(rm_me, "") }
-          str = str.gsub(/\s+/, " ").strip
-          str.downcase.tr(' ', '_')[0..LIMIT_KEY_NAME-1]
-        end
-
       end
     end
   end

data/lib/haml-i18n-extractor/extraction/{tagging_tool.rb → tagging_writer.rb}

@@ -1,7 +1,7 @@
 module Haml
   module I18n
     class Extractor
-      class TaggingTool
+      class TaggingWriter
 
         DB = ".tags.haml-i18n-extractor"
         def initialize

data/lib/haml-i18n-extractor/extraction/{yaml_tool.rb → yaml_writer.rb}

@@ -6,9 +6,11 @@ require 'active_support/hash_with_indifferent_access'
 module Haml
   module I18n
     class Extractor
-      class YamlTool
+      class YamlWriter
 
-        attr_accessor :locale_hash, :yaml_file, :i18n_scope
+        attr_accessor :info_for_yaml, :yaml_file, :i18n_scope
+
+        include Helpers::StringHelpers
 
         def initialize(i18n_scope = nil, yaml_file = nil)
           @i18n_scope = i18n_scope && i18n_scope.to_sym || :en
@@ -19,13 +21,14 @@ module Haml
           end
         end
 
+        # converts the blob of info passed into it into i18n yaml like
         # {:en => {:view_name => {:key_name => :string_name } } }
         def yaml_hash
           yml = Hash.new
-          @locale_hash.map do |line_no, info|
-            unless info[:keyname].nil?
-              keyspace = [@i18n_scope,standardized_viewnames(info[:path]), standarized_keyname(info[:keyname]),
-                          info[:replaced_text]].flatten
+          @info_for_yaml.map do |line_no, info|
+            unless info[:t_name].nil?
+              keyspace = [@i18n_scope,standardized_viewnames(info[:path]), info[:t_name],
+                          normalize_interpolation(info[:replaced_text])].flatten
               yml.deep_merge!(nested_hash({},keyspace))
             end
           end
@@ -77,12 +80,6 @@ module Haml
           hash
         end
 
-        # comes in like "t('.some_place')", return .some_place
-        def standarized_keyname(name)
-          name.match(/t\('\.(.*)'\)/)
-          $1
-        end
-
         # assuming rails format, app/views/users/index.html.haml return [users]
         # app/views/admin/users/index.html.haml return [admin, users]
         # app/views/admin/users/with_namespace/index.html.haml return [admin, users, with_namespace, index]

data/lib/haml-i18n-extractor/flow/prompter.rb

@@ -45,7 +45,7 @@ module Haml
         def end_message
           say("\n\n\n")
           say(highlight("Now run a git diff or such and see what changed!"))
-          say(highlight("Check #{Haml::I18n::Extractor::TaggingTool::DB} if you have tagged any lines."))
+          say(highlight("Check #{Haml::I18n::Extractor::TaggingWriter::DB} if you have tagged any lines."))
           say("PS: If you have any feedback or ideas how this would be better, feel free to open an issue on github. See README for more info.")
         end
 

data/lib/haml-i18n-extractor/helpers.rb

@@ -4,9 +4,47 @@ module Haml
       module Helpers
 
         module StringHelpers
+
+          # do not pollute the key space it will make it invalid yaml
+          NOT_ALLOWED_IN_KEYNAME =  %w( ~ ` ! @ # $ % ^ & * - ( ) , ? { } = ' " : \ / )
+          # limit the number of chars
+          LIMIT_KEY_NAME = 30
+
+          def interpolated?(str)
+            str.match(/\#{/)
+          end
+
+          def normalized_name(str)
+            NOT_ALLOWED_IN_KEYNAME.each{ |rm_me| str.gsub!(rm_me, "") }
+            str = str.gsub(/\s+/, " ").strip
+            str.downcase.tr(' ', '_')[0..LIMIT_KEY_NAME-1]
+          end
+
+          def normalize_interpolation(str)
+            ret = change_one_interpolation(str)
+            if ret && interpolated?(ret)
+              ret = normalize_interpolation(ret)
+            end
+            ret
+          end
+
+          def change_one_interpolation(str)
+            if interpolated?(str)
+              scanner = StringScanner.new(str)
+              scanner.scan_until(/\#{(.*?)}/)
+              ret = "#{scanner.pre_match}"
+              ret << "%{#{normalized_name(scanner.matched)}}"
+              ret << "#{scanner.post_match}"
+            else
+              ret = str
+            end
+            ret
+          end
+
           def html_comment?(txt)
             txt.match(/<!--/) || txt.match(/-->\s*$/)
           end
+
           def link_to?(txt)
             txt.match(/link_to/) || txt.match(/^\s*['"]/) # %element= 'foo'
           end

data/lib/haml-i18n-extractor/version.rb

@@ -1,7 +1,7 @@
 module Haml
   module I18n
     class Extractor
-      VERSION = "0.4.3"
+      VERSION = "0.5.0"
     end
   end
 end

data/lib/haml-i18n-extractor.rb

@@ -3,14 +3,17 @@ require "trollop"
 require "haml-i18n-extractor/version"
 require "haml-i18n-extractor/helpers"
 
-require "haml-i18n-extractor/extraction/text_finder"
-require "haml-i18n-extractor/extraction/exception_finder"
+require "haml-i18n-extractor/extraction/finder/text_finder"
+require "haml-i18n-extractor/extraction/finder/exception_finder"
+require "haml-i18n-extractor/extraction/replacer/text_replacer"
+require "haml-i18n-extractor/extraction/replacer/replacer_result"
+require "haml-i18n-extractor/extraction/replacer/interpolation_helper"
+
 require "haml-i18n-extractor/extraction/haml_parser"
 require "haml-i18n-extractor/extraction/haml_reader"
-require "haml-i18n-extractor/extraction/tagging_tool"
-require "haml-i18n-extractor/extraction/text_replacer"
+require "haml-i18n-extractor/extraction/tagging_writer"
 require "haml-i18n-extractor/extraction/haml_writer"
-require "haml-i18n-extractor/extraction/yaml_tool"
+require "haml-i18n-extractor/extraction/yaml_writer"
 require "haml-i18n-extractor/extraction/extractor"
 
 

data/scripts/renew_test_syntax

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby 
+
+# git co .; for f in test/*.rb; do mkdir -p /tmp/test; cp $f /tmp/$f; scripts/renew_test_syntax /tmp/$f > $f ; done; b rake
+def replace(str)
+  str.match(/^(\s*)test/)
+  whitespace = $1
+  str = str.strip.downcase.gsub(/ do$/,"")
+  not_allowed = %w([ } = # > ' " % : - { ] . / \ @ , ( ) )
+  not_allowed.each {|c|
+    str = str.gsub(Regexp.new(Regexp.escape(c)),"")
+  }
+  str = str.gsub(" ","_")
+  str = str.gsub(/^(\s*)/,"#{whitespace}def ")
+  str
+end
+
+new_body = File.readlines(ARGV[0]).map{|l| l.match(/test.*do$/) ? replace(l) : l }
+puts new_body

data/test/cli_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 module Haml
   class CLITest < MiniTest::Unit::TestCase
 
-    test "it needs an explicit interactive or non-interactive option" do
+    def test_it_needs_an_explicit_interactive_or_noninteractive_option
       opts = {:non_interactive => nil, :interactive => nil}
       with_highline do
         begin
@@ -14,7 +14,7 @@ module Haml
       end
     end
 
-    test "with a interactive option it needs a path" do
+    def test_with_a_interactive_option_it_needs_a_path
       opts = {:non_interactive => nil, :path => nil}
        with_highline do
          begin

data/test/exception_finder_test.rb

@@ -22,14 +22,14 @@ module Haml
       %{link_to(pending_account_invoices_path(account),"http://random")} => ""
     }
 
-    test "it finds text pretty simply" do
+    def test_it_finds_text_pretty_simply
       MATCHES.each do |k,v|
         #puts "handling #{k}"
         assert_equal find(k), v
       end
     end
 
-    test "it actually needs to do something intellegent with intperolated values..." do
+    def test_it_actually_needs_to_do_something_intellegent_with_intperolated_values
       # @FIXME
       #raise "raw text matching needs to be responsible for knowing if needed to interpolate?"
     end