haml-magic-translations 0.5.1 → 4.0.0

data/Rakefile

@@ -18,7 +18,8 @@ time with translations.
     gem.email = "jardiniers@potager.org"
     gem.homepage = "https://github.com/potager/haml-magic-translations"
     gem.authors = ["Kriss Kowalik", "potager.org"]
-    gem.add_dependency "haml", "~> 3.1"
+    gem.add_dependency "haml", "~> 4.0"
+    gem.add_development_dependency "haml-contrib", ">= 1.0"
     gem.add_development_dependency "actionpack"
     gem.add_development_dependency "gettext", ">= 2.3"
     gem.add_development_dependency "fast_gettext"

data/VERSION

@@ -1 +1 @@
-0.5.1
+4.0.0

data/haml-magic-translations.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{haml-magic-translations}
-  s.version = "0.5.1"
+  s.version = "4.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kriss Kowalik", "potager.org"]
-  s.date = %q{2013-04-03}
+  s.date = %q{2013-05-28}
   s.description = %q{This plugin provides "magical translations" in your .haml files. What does it
 mean? It's mean that all your raw texts in templates will be automatically
 translated by GetText, FastGettext or Gettext backend from I18n. No more 
@@ -51,7 +51,8 @@ time with translations.
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<haml>, ["~> 3.1"])
+      s.add_runtime_dependency(%q<haml>, ["~> 4.0"])
+      s.add_development_dependency(%q<haml-contrib>, [">= 1.0"])
       s.add_development_dependency(%q<actionpack>, [">= 0"])
       s.add_development_dependency(%q<gettext>, [">= 2.3"])
       s.add_development_dependency(%q<fast_gettext>, [">= 0"])
@@ -59,7 +60,8 @@ time with translations.
       s.add_development_dependency(%q<rdoc>, [">= 2.4.2"])
       s.add_development_dependency(%q<maruku>, [">= 0"])
     else
-      s.add_dependency(%q<haml>, ["~> 3.1"])
+      s.add_dependency(%q<haml>, ["~> 4.0"])
+      s.add_dependency(%q<haml-contrib>, [">= 1.0"])
       s.add_dependency(%q<actionpack>, [">= 0"])
       s.add_dependency(%q<gettext>, [">= 2.3"])
       s.add_dependency(%q<fast_gettext>, [">= 0"])
@@ -68,7 +70,8 @@ time with translations.
       s.add_dependency(%q<maruku>, [">= 0"])
     end
   else
-    s.add_dependency(%q<haml>, ["~> 3.1"])
+    s.add_dependency(%q<haml>, ["~> 4.0"])
+    s.add_dependency(%q<haml-contrib>, [">= 1.0"])
     s.add_dependency(%q<actionpack>, [">= 0"])
     s.add_dependency(%q<gettext>, [">= 2.3"])
     s.add_dependency(%q<fast_gettext>, [">= 0"])

data/lib/haml/magic_translations.rb

@@ -43,12 +43,65 @@ require 'json'
 # 
 module Haml::MagicTranslations
   def self.included(haml) # :nodoc:
-    haml.send(:include, EngineMethods)
     if defined? Haml::Template
       Haml::Template.send(:extend, TemplateMethods)
     end
   end
 
+  class Parser < Haml::Parser
+    # Overriden function that parses Haml tags. Injects gettext call for all plain
+    # text lines.
+    def parse_tag(line)
+      tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
+        nuke_inner_whitespace, action, value, last_line = super(line)
+
+      if !value.empty?
+        unless action && action == '=' || action == '!' && value[0] == ?= || action == '&' && value[0] == ?=
+          value, interpolation_arguments = Haml::MagicTranslations.prepare_i18n_interpolation(value)
+          value = "\#{_('#{value.gsub(/'/, "\\\\'")}') % #{interpolation_arguments}\}\n"
+        end
+      end
+      [tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
+         nuke_inner_whitespace, action, value, last_line]
+    end
+
+    # Magical translations will be also used for plain text.
+    def plain(text, escape_html = nil)
+      value, interpolation_arguments = Haml::MagicTranslations.prepare_i18n_interpolation(text, escape_html)
+      value = "_('#{value.gsub(/'/, "\\\\'")}') % #{interpolation_arguments}\n"
+      script(value, !:escape_html)
+    end
+  end
+
+  class Compiler < Haml::Compiler
+    class << self
+      attr_accessor :magic_translations_helpers
+    end
+
+    def compile_filter
+      case @node.value[:name]
+        when 'markdown', 'maruku'
+          @node.value[:text] = "\#{_(<<-'END_OF_TRANSLATABLE_MARKDOWN'.rstrip
+#{@node.value[:text].rstrip.gsub(/\n/, '\n')}
+END_OF_TRANSLATABLE_MARKDOWN
+)}"
+        when 'javascript'
+          @node.value[:text].gsub!(/_\(('(([^']|\\')+)'|"(([^"]|\\")+)")\)/) do |m|
+            to_parse = $1[1..-2].gsub(/"/, '\"')
+            parsed_string = JSON.parse("[\"#{to_parse}\"]")[0]
+            parsed_string.gsub!(/'/, "\\\\'")
+            "\#{_('#{parsed_string}').to_json}"
+          end
+      end
+      super
+    end
+
+    def compile_root
+      @precompiled << "extend #{Compiler.magic_translations_helpers};"
+      super
+    end
+  end
+
   # It discovers all fragments of code embeded in text and replacing with
   # simple string interpolation parameters.
   #
@@ -72,13 +125,13 @@ module Haml::MagicTranslations
       gsub(/\"/, '\"').
       gsub(/\\/, '\\\\')
 
-    rest = Haml::Shared.handle_interpolation '"' + str + '"' do |scan|
+    rest = Haml::Util.handle_interpolation '"' + str + '"' do |scan|
       escapes = (scan[2].size - 1) / 2
       res << scan.matched[0...-3 - escapes]
       if escapes % 2 == 1
         res << '#{'
       else
-        content = eval('"' + Haml::Shared.balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+        content = eval('"' + Haml::Util.balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
         content = "Haml::Helpers.html_escape(#{content.to_s})" if escape_html
         args << content
         res  << '%s'
@@ -103,30 +156,42 @@ module Haml::MagicTranslations
   # +:gettext+:: Use GetText from 'gettext'
   # +:fast_gettext+:: Use FastGettext::Translation from 'fast_gettext'
   def self.enable(backend = :i18n)
+    return if @enabled
+
     case backend
     when :i18n
       require 'i18n'
       require 'i18n/backend/gettext'
       require 'i18n/gettext/helpers'
       I18n::Backend::Simple.send(:include, I18n::Backend::Gettext)
-      EngineMethods.magic_translations_helpers = I18n::Gettext::Helpers
+      Compiler.magic_translations_helpers = I18n::Gettext::Helpers
     when :gettext
       require 'gettext'
-      EngineMethods.magic_translations_helpers = GetText
+      Compiler.magic_translations_helpers = GetText
     when :fast_gettext
       require 'fast_gettext'
-      EngineMethods.magic_translations_helpers = FastGettext::Translation
+      Compiler.magic_translations_helpers = FastGettext::Translation
     else
       @enabled = false
       raise ArgumentError, "Backend #{backend.to_s} is not available in Haml::MagicTranslations"
     end
+    @original_parser = Haml::Options.defaults[:parser_class]
+    Haml::Options.defaults[:parser_class] = Parser
+    @original_compiler = Haml::Options.defaults[:compiler_class]
+    Haml::Options.defaults[:compiler_class] = Compiler
     @enabled = true
   end
 
   # Disable magic translations
   def self.disable
-    EngineMethods.magic_translations_helpers = nil
+    return unless @enabled
+
     @enabled = false
+    Haml::Options.defaults[:compiler_class] = @original_compiler
+    @original_compiler = nil
+    Haml::Options.defaults[:parser_class] = @original_parser
+    @original_parser = nil
+    Compiler.magic_translations_helpers = nil
   end
 
   module TemplateMethods # :nodoc:all
@@ -135,72 +200,6 @@ module Haml::MagicTranslations
       Haml::MagicTranslations.enable backend
     end
   end
-
-  module EngineMethods # :nodoc:all
-    class << self
-      attr_accessor :magic_translations_helpers
-    end
-
-    def magic_translations?
-      return self.options[:magic_translations] unless self.options[:magic_translations].nil?
-
-      Haml::MagicTranslations.enabled?
-    end
-
-    # Overriden function that parses Haml tags. Injects gettext call for all plain
-    # text lines.
-    def parse_tag(line)
-      tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
-        nuke_inner_whitespace, action, value, last_line = super(line)
-
-      if magic_translations? && !value.empty?
-        unless action && action == '=' || action == '!' && value[0] == ?= || action == '&' && value[0] == ?=
-          value, interpolation_arguments = Haml::MagicTranslations.prepare_i18n_interpolation(value)
-          value = "\#{_('#{value.gsub(/'/, "\\\\'")}') % #{interpolation_arguments}\}\n"
-        end
-      end
-      [tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
-         nuke_inner_whitespace, action, value, last_line]
-    end
-
-    # Magical translations will be also used for plain text.
-    def plain(text, escape_html = nil)
-      if magic_translations?
-        value, interpolation_arguments = Haml::MagicTranslations.prepare_i18n_interpolation(text, escape_html)
-        value = "_('#{value.gsub(/'/, "\\\\'")}') % #{interpolation_arguments}\n"
-        script(value, !:escape_html)
-      else
-        super
-      end
-    end
-
-    def compile_filter
-      super unless magic_translations?
-
-      case @node.value[:name]
-        when 'markdown', 'maruku'
-          @node.value[:text] = "\#{_(<<-'END_OF_TRANSLATABLE_MARKDOWN'.rstrip
-#{@node.value[:text].rstrip.gsub(/\n/, '\n')}
-END_OF_TRANSLATABLE_MARKDOWN
-)}"
-        when 'javascript'
-          @node.value[:text].gsub!(/_\(('(([^']|\\')+)'|"(([^"]|\\")+)")\)/) do |m|
-            to_parse = $1[1..-2].gsub(/"/, '\"')
-            parsed_string = JSON.parse("[\"#{to_parse}\"]")[0]
-            parsed_string.gsub!(/'/, "\\\\'")
-            "\#{_('#{parsed_string}').to_json}"
-          end
-      end
-      super
-    end
-
-    def compile_root
-      if magic_translations?
-        @precompiled << "extend #{EngineMethods.magic_translations_helpers};"
-      end
-      super
-    end
-  end
 end
 
 Haml::Engine.send(:include, Haml::MagicTranslations)

data/lib/haml/magic_translations/xgettext/haml_parser.rb

@@ -20,10 +20,10 @@ module Haml::MagicTranslations::XGetText # :nodoc:
     end
 
     def parse(file) # :nodoc:
-      Parser.new(file).parse
+      XGetTextParser.new(file).parse
     end
 
-    class Parser # :nodoc:all
+    class XGetTextParser # :nodoc:all
       attr_reader :file
       attr_reader :content
       def initialize(file)
@@ -37,107 +37,113 @@ module Haml::MagicTranslations::XGetText # :nodoc:
       end
 
       def parse
-        Haml::Engine.send(:include, XGetTextEngine)
-        engine = Haml::Engine.new(
+        # Engine#initialize parses and compiles
+        HamlEngineCompiler.filename = @file
+        Haml::Engine.new(
             content, :filename => @file,
-                     :xgettext => true,
-                     :magic_translations => false).targets
+                     :parser_class => HamlEngineParser,
+                     :compiler_class => HamlEngineCompiler)
+        targets = HamlEngineCompiler.targets
+        HamlEngineCompiler.reset_targets
+        targets
       end
     end
 
-    module XGetTextEngine # :nodoc:all
-      def add_target(text, lineno = @node.line)
-        @targets = {} if @targets.nil?
-        unless text.empty?
-          @targets[text] = [] unless @targets[text]
-          @targets[text].push("#{options[:filename]}:#{lineno}")
-        end
-      end
-
-      def targets
-        (@targets || {}).keys.sort.collect do |k|
-          [k] + @targets[k]
-        end
-      end
-
-      # We can't piggyback `compile_tag` because the following gets no
-      # distinction at all:
-      #
-      #     %p= "Hello"
-      #
-      # and:
-      #
-      #     %p #{"Hello"}
-      #
-      # So let's hook in the parser, just for this specific case.
-      def parse_tag(line)
-        return super unless self.options[:xgettext]
-
+    class HamlEngineParser < Haml::Parser
+      def tag(line)
         tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
-          nuke_inner_whitespace, action, value, last_line = super(line)
+          nuke_inner_whitespace, action, value, last_line = parse_tag(line)
         if action && (action == '=' || (action == '!' && value[0] == ?=) ||
                                        (action == '&' && value[0] == ?=))
-          # Search for explicitely translated strings
-          value.gsub(/_\('(([^']|\\')+)'\)/) do |m|
-            parsed_string = "#{$1}"
-            add_target(parsed_string, last_line)
-          end
+          parsed_tag = true
         else
-          interpolated = Haml::MagicTranslations.prepare_i18n_interpolation(value)
-          add_target(interpolated[0], last_line)
+          parsed_tag = false
         end
-        [tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
-            nuke_inner_whitespace, action, value, last_line]
+        node = super(line)
+        node[:value][:parsed_tag] = parsed_tag
+        node
       end
+    end
 
-      def compile_plain
-        return super unless self.options[:xgettext]
+    class HamlEngineCompiler < Haml::Compiler
+      class << self
+         attr_accessor :filename
+
+         def add_target(text, lineno)
+           @targets = {} if @targets.nil?
+           unless text.empty?
+             @targets[text] = [] unless @targets[text]
+             @targets[text].push("#{filename}:#{lineno}")
+           end
+         end
+
+         def reset_targets
+           @targets = {}
+         end
+
+         def targets
+           (@targets || {}).keys.sort.collect do |k|
+             [k] + @targets[k]
+           end
+         end
+      end
 
-        add_target(@node.value[:text])
+      def compile(node)
+        super(node)
+      end
+
+      def compile_plain
+        HamlEngineCompiler.add_target(@node.value[:text], @node.line)
       end
 
       def compile_doctype
-        return super unless self.options[:xgettext]
+        # do nothing
       end
 
       def compile_script
-        return super unless self.options[:xgettext]
-
         yield if block_given?
       end
 
       def compile_silent_script
-        return super unless self.options[:xgettext]
-
         yield if block_given?
       end
 
       def compile_tag
-        return super unless self.options[:xgettext]
-
+        if @node.value[:parsed_tag]
+          # Search for explicitely translated strings
+          @node.value[:value].gsub(/_\('(([^']|\\')+)'\)/) do |m|
+            parsed_string = "#{$1}"
+            HamlEngineCompiler.add_target(parsed_string, @node.line)
+          end
+        else
+          value = @node.value[:value]
+          if value
+            # strip quotes if needed
+            value = value[1..-2] if @node.value[:parse]
+            value, args = Haml::MagicTranslations.prepare_i18n_interpolation(value)
+            HamlEngineCompiler.add_target(value, @node.line)
+          end
+        end
         # handle explicit translations in attributes
         @node.value[:attributes_hashes].each do |hash_string|
           hash_string.gsub(/_\('(([^']|\\')+)'\)/) do |m|
-            add_target($1)
+            HamlEngineCompiler.add_target($1, @node.line)
           end
         end
-        # targets have been already handled in parse_tag
         yield if @node.value[:value].nil? && block_given?
       end
 
       def compile_filter
-        return super unless self.options[:xgettext]
-
         case @node.value[:name]
         when 'markdown', 'maruku'
-          add_target(@node.value[:text].rstrip)
+          HamlEngineCompiler.add_target(@node.value[:text].rstrip, @node.line)
         when 'javascript'
           lineno = 0
           @node.value[:text].split(/\r\n|\r|\n/).each do |line|
             lineno += 1
             line.gsub(/_\('(([^']|\\')+)'\)/) do |m|
               parsed_string = JSON.parse("[\"#{$1}\"]")[0]
-              add_target(parsed_string, @node.line + lineno)
+              HamlEngineCompiler.add_target(parsed_string, @node.line + lineno)
             end
           end
         end

data/spec/haml/magic_translations/xgettext/haml_parser_spec.rb

@@ -18,24 +18,24 @@ module Haml::MagicTranslations::XGetText
 
     describe '.parse' do
       it 'should properly instanciate a Parser' do
-        HamlParser::Parser.should_receive(:new).with('test.haml').
-            and_return(mock('Parser').as_null_object)
+        HamlParser::XGetTextParser.should_receive(:new).with('test.haml').
+            and_return(mock('XGetTextParser').as_null_object)
         HamlParser.parse('test.haml')
       end
       it 'should run the parser' do
-        parser = mock('Parser')
+        parser = mock('XGetTextParser')
         parser.should_receive(:parse)
-        HamlParser::Parser.stub!(:new).and_return(parser)
+        HamlParser::XGetTextParser.stub!(:new).and_return(parser)
         HamlParser.parse('test.haml')
       end
     end
 
-    describe HamlParser::Parser do
+    describe HamlParser::XGetTextParser do
       describe '#initialize' do
         context 'when given "test.haml"' do
           before(:each) do
             File.stub!(:open).and_return(StringIO.new('It works!'))
-            @parser = HamlParser::Parser.new('test.haml')
+            @parser = HamlParser::XGetTextParser.new('test.haml')
           end
           it 'should set file attribute' do
             @parser.file.should == 'test.haml'
@@ -45,14 +45,14 @@ module Haml::MagicTranslations::XGetText
           end
         end
         context 'when given a IO-like object' do
-          let (:parser) { HamlParser::Parser.new(StringIO.new('It works!')) }
+          let (:parser) { HamlParser::XGetTextParser.new(StringIO.new('It works!')) }
           it { parser.file.should == '(haml)' }
           it { parser.content.should == 'It works!' }
         end
       end
 
       describe '#parse' do
-        subject { HamlParser::Parser.new(StringIO.new(template)).parse }
+        subject { HamlParser::XGetTextParser.new(StringIO.new(template)).parse }
         context 'for an empty content' do
           let(:template) { '' }
           it 'should return no targets' do
@@ -197,7 +197,7 @@ module Haml::MagicTranslations::XGetText
         end
         context 'after extracting translations' do
           it 'should still allow Haml::Engine to build templates' do
-            HamlParser::Parser.new(StringIO.new('test')).parse
+            HamlParser::XGetTextParser.new(StringIO.new('test')).parse
             Haml::Engine.new('%p It works!').render.should == <<-'HTML'.strip_heredoc
               <p>It works!</p>
             HTML

data/spec/haml/magic_translations_spec.rb

@@ -24,19 +24,19 @@ module Haml
       context 'when using :i18n as backend' do
         before { Haml::MagicTranslations.enable :i18n }
         it { Haml::MagicTranslations.should be_enabled }
-        it { Haml::MagicTranslations::EngineMethods.
+        it { Haml::MagicTranslations::Compiler.
                  magic_translations_helpers.should == I18n::Gettext::Helpers }
       end
       context 'when using :gettext as backend' do
         before { Haml::MagicTranslations.enable :gettext }
         it { Haml::MagicTranslations.should be_enabled }
-        it { Haml::MagicTranslations::EngineMethods.
+        it { Haml::MagicTranslations::Compiler.
                magic_translations_helpers.should == GetText }
       end
       context 'when using :fast_gettext as backend' do
         before { Haml::MagicTranslations.enable :fast_gettext }
         it { Haml::MagicTranslations.should be_enabled }
-        it { Haml::MagicTranslations::EngineMethods.
+        it { Haml::MagicTranslations::Compiler.
                magic_translations_helpers.should == FastGettext::Translation }
       end
       context 'when giving another backend' do

data/spec/spec_helper.rb

@@ -7,14 +7,14 @@ require 'rspec'
 $:.unshift File.dirname(__FILE__)
 $:.unshift File.join(File.dirname(__FILE__), '../lib')
 
-require 'action_controller'
+require 'active_support'
 require 'action_view'
 
 require 'haml/magic_translations'
 require 'haml/template'
 
-Haml::Template.options[:ugly] = false
-Haml::Template.options[:format] = :xhtml
+Haml::Options.defaults[:ugly] = false
+Haml::Options.defaults[:format] = :xhtml
 
 def render(text, options = {}, &block)
   scope  = options.delete(:scope)  || Object.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml-magic-translations
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 4.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -19,7 +19,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +27,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: haml-contrib
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement