svenfuchs-i18n-tools 0.0.4 → 0.0.5

data/lib/i18n/ripper2ruby/translate_call.rb

@@ -0,0 +1,66 @@
+module Ruby
+  class Node
+    def select_translate_calls(*args)
+      select(Ruby::Call, *args) { |node| node.is_translate_call? }.map { |call| call.to_translate_call }
+    end
+
+    def is_translate_call?
+      false
+    end
+  end
+
+  class Call
+    def to_translate_call
+      unless meta_class.include?(TranslateCall)
+        meta_class.send(:include, TranslateCall)
+        arguments.to_translate_args_list if arguments.respond_to?(:to_translate_args_list)
+      end
+      self
+    end
+
+    def is_translate_call?
+      identifier.try(:token) == 't' &&
+      is_translate_method_target?(target) &&
+      is_translate_key?(arguments.first.try(:arg))
+    end
+    
+    protected
+
+      def is_translate_method_target?(target)
+        target.nil? || target.try(:identifier).try(:token) == 'I18n'
+      end
+
+      def is_translate_key?(arg)
+        # TODO ... what to do with Arrays? what to do with DynaSymbols w/ embedded expressions?
+        arg && [Ruby::Symbol, Ruby::DynaSymbol, Ruby::String].include?(arg.class) && arg.try(:value)
+      end
+  end
+
+  module TranslateCall
+    def full_key(*args)
+      arguments.full_key(*args)
+    end
+
+    def key(*args)
+      arguments.key(*args)
+    end
+
+    def scope(*args)
+      arguments.scope(*args)
+    end
+
+    def key_matches?(*args)
+      arguments.key_matches?(*args)
+    end
+
+    def replace_key(search, replacement)
+      arguments.replace_key(search, replacement)
+    end
+
+    def to_s(options = {})
+      context = (options.has_key?(:context) ? self.context(options.update(:width => options[:context].to_i)) : '')
+      context = context.split("\n").map(&:strip).join("\n")
+      "#{key}: #{filename} [#{row}/#{column}]\n" + context
+    end
+  end
+end

data/lib/i18n/translation_properties.rb

@@ -0,0 +1,38 @@
+module I18n
+  module TranslationProperties
+    class << self
+      def property_names
+        @property_names ||= []
+      end
+
+      def define_property(name)
+        unless respond_to?(name)
+          attr_accessor(name)
+          property_names << name unless property_names.include?(name)
+        end
+      end
+    end
+
+    def properties
+      TranslationProperties.property_names.inject({}) do |properties, name|
+        properties[name] = self.send(name)
+        properties
+      end
+    end
+
+    def set_properties(properties)
+      properties.each { |name, value| set_property(name, value) }
+    end
+
+    def set_property(name, value)
+      TranslationProperties.define_property(name)
+      send(:"#{name}=", value)
+    end
+
+    def unset_properties
+      TranslationProperties.property_names.each do |name|
+        remove_instance_variable("@#{name}") rescue NameError
+      end
+    end
+  end
+end

data/test/all.rb

@@ -1 +1 @@
-Dir[File.dirname(__FILE__) + '/*_test.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/**/*_test.rb'].each { |file| require file }

data/test/core_ext/hash_iterate_nested.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'core_ext/hash/iterate_nested'
+
+class HashIterateNestedTest < Test::Unit::TestCase
+  def test_hash_each_nested
+    hash = { :foo => { :bar => { :baz => :baa, :bas => :bah }, :bor => { :boz => :boo, :bos => :boh } } }
+    result = { :keys => [], :values => []}
+    hash.each_nested do |keys, value|
+      result[:keys] << keys
+      result[:values] << value
+    end
+    assert_equal [[:foo, :bar, :baz], [:foo, :bar, :bas], [:foo, :bor, :boz], [:foo, :bor, :bos]], result[:keys]
+    assert_equal [:baa, :bah, :boo, :boh], result[:values]
+  end
+
+  def test_hash_select_nested
+    hash = { :foo => { :bar => { :baz => :baa, :bas => :bah }, :bor => { :boz => :boo, :bos => :boh } } }
+    
+    expected = hash
+    result = hash.select_nested { |keys, value| keys.include?(:foo) }
+    assert_equal expected, result
+
+    expected = { :foo => { :bar => { :baz => :baa, :bas => :bah } } }
+    result = hash.select_nested { |keys, value| keys.include?(:bar) }
+    assert_equal expected, result
+
+    expected = { :foo => { :bor => { :boz => :boo } } }
+    result = hash.select_nested { |keys, value| keys.include?(:boz) }
+    assert_equal expected, result
+  end
+end

data/test/fixtures/all.rb.src

@@ -0,0 +1,106 @@
+# occurences of \n will be replaced with actual newlines
+
+# numbers
+1
+1.1
+
+# symbols
+:a
+:"a"
+:"a \n b \n c"
+:'a'
+:'a \n b \n c'
+
+
+# strings
+
+"a"
+'a'
+%(a)
+%( a \n   b \n   c )
+%|a|
+%.a.
+
+
+# arrays
+
+[:a,:b,:c]
+[:a,:b, :c]
+[:a, :b,:c]
+[:a, :b, :c]
+[:a, :b, :c ]
+[ :a, :b, :c]
+[ :a, :b, :c ]
+
+[ \n :a, \n :b, \n :c \n ]
+
+%w(a b c)
+%w(a b c )
+%w( a b c)
+%w( a b c )
+
+# hashes
+
+{:a=>:a}
+{:a=>:a }
+{ :a=>:a}
+{:a => :a}
+{ :a=>:a }
+{:a=> :a }
+{ :a =>:a}
+{ :a => :a }
+
+{ \n :a => \n :a \n }
+
+# constants
+
+I18n
+
+# assignments
+
+a=b
+a,b=c
+a, b=c
+a, b=c,d
+a, b=c, d
+a, b=*c
+
+a = b
+a,b = c
+a, b = c
+a, b = c,d
+a, b = c, d
+a, b = *c
+
+a, \n b = \n c, \n d
+
+# calls
+
+t
+t()
+t(:a)
+t :a
+t  :a
+
+I18n.t
+I18n.t()
+I18n.t(:a)
+
+t(:a,:b)
+t(:a, :b)
+t(:a ,:b)
+t(:a, :b )
+t(:a ,:b )
+t( :a, :b)
+t( :a ,:b)
+t( :a, :b )
+t( :a ,:b )
+
+t(:a, :b,&c)
+t(:a, :b, &c)
+
+t(:a, :b, :c => :c, &c)
+t(:a, :b, { :c => :c }, &c)
+
+t( \n:a, \n :b, \n :c => \n :c, \n &d)
+

data/test/fixtures/config.yml

@@ -0,0 +1,3 @@
+indices:
+	default:
+		pattern: foo

data/test/fixtures/locale/de.yml

@@ -0,0 +1,4 @@
+de:
+  foo:
+    baz: Bas
+    bar: Bah

data/test/fixtures/locale/en.yml

@@ -0,0 +1,4 @@
+en:
+  foo:
+    bar: Bar
+    baz: Baz

data/test/fixtures/source_1.rb

@@ -2,13 +2,14 @@ class Foo
   def foo
     t(:bar)
     t(:"baaar")
-    t(:'baar')
+    t(:baar, :scope => [:baz, :fooo], :default => 'bla')
     t(:'foo.bar')
     t("bar")
     t('bar_1')
     1 + 1
     t(1)
     t(1.1)
+    t(1 + 1)
   end
   foo(:outside_)
 end

data/test/fixtures/translate/double_key.rb

@@ -0,0 +1,32 @@
+I18n.t(:"bar.baz",:scope=>:foo)
+I18n.t(:"bar.baz", :scope=>:foo)
+I18n.t(:"bar.baz",:scope =>:foo)
+I18n.t(:"bar.baz",:scope=> :foo)
+I18n.t(:"bar.baz",:scope=>:foo )
+I18n.t(:"bar.baz", :scope =>:foo)
+I18n.t(:"bar.baz", :scope=> :foo)
+I18n.t(:"bar.baz", :scope=>:foo )
+I18n.t(:"bar.baz", :scope =>:foo)
+I18n.t(:"bar.baz", :scope => :foo)
+I18n.t(:"bar.baz", :scope =>:foo )
+I18n.t(:"bar.baz", :scope => :foo )
+t(:"bar.baz",:scope=>:foo)
+t(:"bar.baz", :scope=>:foo)
+t(:"bar.baz",:scope =>:foo)
+t(:"bar.baz",:scope=> :foo)
+t(:"bar.baz",:scope=>:foo )
+t(:"bar.baz", :scope =>:foo)
+t(:"bar.baz", :scope=> :foo)
+t(:"bar.baz", :scope=>:foo )
+t(:"bar.baz", :scope =>:foo)
+t(:"bar.baz", :scope => :foo)
+t(:"bar.baz", :scope =>:foo )
+t(:"bar.baz", :scope => :foo )
+t :"bar.baz",:scope=>:foo
+t :"bar.baz", :scope=>:foo
+t :"bar.baz",:scope =>:foo
+t :"bar.baz",:scope=> :foo
+t :"bar.baz", :scope =>:foo
+t :"bar.baz", :scope=> :foo
+t :"bar.baz", :scope =>:foo
+t :"bar.baz", :scope => :foo

data/test/fixtures/translate/double_scope.rb

@@ -0,0 +1,32 @@
+I18n.t(:baz,:scope=>[:foo, :bar])
+I18n.t(:baz, :scope=>[:foo, :bar])
+I18n.t(:baz,:scope =>[:foo, :bar])
+I18n.t(:baz,:scope=> [:foo, :bar])
+I18n.t(:baz,:scope=>[:foo, :bar] )
+I18n.t(:baz, :scope =>[:foo, :bar])
+I18n.t(:baz, :scope=> [:foo, :bar])
+I18n.t(:baz, :scope=>[:foo, :bar] )
+I18n.t(:baz, :scope =>[:foo, :bar])
+I18n.t(:baz, :scope => [:foo, :bar])
+I18n.t(:baz, :scope =>[:foo, :bar] )
+I18n.t(:baz, :scope => [:foo, :bar] )
+t(:baz,:scope=>[:foo, :bar])
+t(:baz, :scope=>[:foo, :bar])
+t(:baz,:scope =>[:foo, :bar])
+t(:baz,:scope=> [:foo, :bar])
+t(:baz,:scope=>[:foo, :bar] )
+t(:baz, :scope =>[:foo, :bar])
+t(:baz, :scope=> [:foo, :bar])
+t(:baz, :scope=>[:foo, :bar] )
+t(:baz, :scope =>[:foo, :bar])
+t(:baz, :scope => [:foo, :bar])
+t(:baz, :scope =>[:foo, :bar] )
+t(:baz, :scope => [:foo, :bar] )
+t :baz,:scope=>[:foo, :bar]
+t :baz, :scope=>[:foo, :bar]
+t :baz,:scope =>[:foo, :bar]
+t :baz,:scope=> [:foo, :bar]
+t :baz, :scope =>[:foo, :bar]
+t :baz, :scope=> [:foo, :bar]
+t :baz, :scope =>[:foo, :bar]
+t :baz, :scope => [:foo, :bar]

data/test/fixtures/translate/single_key.rb

@@ -0,0 +1,10 @@
+I18n.t('foo')
+I18n.t('foo', :a)
+I18n.t('foo', :a => :a)
+t(:foo)
+t(:foo, :a)
+t(:foo, :a => :a)
+t :foo
+t :foo, :a
+t :foo, :a => :a
+

data/test/fixtures/translate/single_scope.rb

@@ -0,0 +1,32 @@
+I18n.t(:bar,:scope=>:foo)
+I18n.t(:bar, :scope=>:foo)
+I18n.t(:bar,:scope =>:foo)
+I18n.t(:bar,:scope=> :foo)
+I18n.t(:bar,:scope=>:foo )
+I18n.t(:bar, :scope =>:foo)
+I18n.t(:bar, :scope=> :foo)
+I18n.t(:bar, :scope=>:foo )
+I18n.t(:bar, :scope =>:foo)
+I18n.t(:bar, :scope => :foo)
+I18n.t(:bar, :scope =>:foo )
+I18n.t(:bar, :scope => :foo )
+t(:bar,:scope=>:foo)
+t(:bar, :scope=>:foo)
+t(:bar,:scope =>:foo)
+t(:bar,:scope=> :foo)
+t(:bar,:scope=>:foo )
+t(:bar, :scope =>:foo)
+t(:bar, :scope=> :foo)
+t(:bar, :scope=>:foo )
+t(:bar, :scope =>:foo)
+t(:bar, :scope => :foo)
+t(:bar, :scope =>:foo )
+t(:bar, :scope => :foo )
+t :bar,:scope=>:foo
+t :bar, :scope=>:foo
+t :bar,:scope =>:foo
+t :bar,:scope=> :foo
+t :bar, :scope =>:foo
+t :bar, :scope=> :foo
+t :bar, :scope =>:foo
+t :bar, :scope => :foo

data/test/i18n/backend/simple_storage_test.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'i18n'
+require 'i18n/backend/simple_storage'
+
+class I18nSimpleStorageTest < Test::Unit::TestCase
+  def setup
+    @filenames = {
+      :de => File.dirname(__FILE__) + '/../../fixtures/locale/de.yml',
+      :en => File.dirname(__FILE__) + '/../../fixtures/locale/en.yml',
+      :pr => File.dirname(__FILE__) + '/../../fixtures/locale/pr.yml'
+    }
+    I18n.load_path += @filenames.values_at(:de, :en)
+    @backend = I18n.backend = I18n::Backend::SimpleStorage.new
+  end
+
+  def teardown
+    File.delete(@filenames[:pr]) rescue nil
+  end
+
+  define_method :"test: sets filename property on translations" do
+    assert_equal @filenames[:de], I18n.t(:'foo.bar', :locale => :de).filename
+    assert_equal @filenames[:de], I18n.t(:'foo.baz', :locale => :de).filename
+    assert_equal @filenames[:en], I18n.t(:'foo.bar', :locale => :en).filename
+    assert_equal @filenames[:en], I18n.t(:'foo.baz', :locale => :en).filename
+  end
+
+  define_method :"test each_translation" do
+    locales, keys, values = [], [], []
+    I18n.backend.send(:each_translation) do |locale, key, value|
+      locales << locale
+      keys << key
+      values << value
+    end
+    assert_equal [:de, :en], locales.uniq
+    assert_equal [[:foo, :bar], [:foo, :baz]], keys.uniq.sort
+    assert_equal %w(Bah Bar Bas Baz), values.sort
+  end
+
+  define_method :"test select_translations" do
+    translations = @backend.send(:select_translations) { |keys, translation| translation.filename =~ /de.yml/ }
+    expected = { :de => { :foo => { :bar => "Bah", :baz => "Bas" } } }
+    assert_equal expected, translations
+  end
+
+  define_method :"test by_filename" do
+    translations = @backend.send(:by_filename, @filenames[:de])
+    expected = { :de => { :foo => { :bar => "Bah", :baz => "Bas" } } }
+    assert_equal expected, translations
+  end
+
+  define_method :"test save_translations" do
+    filename = @filenames[:pr]
+    data = @backend.send(:by_filename, @filenames[:de])[:de].deep_clone
+
+    @backend.send(:set_translation_properties, data, :filename => filename)
+    @backend.store_translations(:pr, data)
+    @backend.save_translations(filename)
+
+    expected = I18n.backend.send(:deep_stringify_keys, :pr => data)
+    assert_equal(expected, YAML.load_file(filename))
+    assert_equal(['bar', 'baz'], YAML.load_file(filename)['pr']['foo'].keys)
+    assert_equal "--- \npr: \n  foo: \n    bar: Bah\n    baz: Bas\n", File.read(filename)
+  end
+
+  define_method :"test remove_translation" do
+    assert_equal({ :bar => "Bar", :baz => "Baz" }, I18n.t(:foo))
+
+    @backend.remove_translation([:foo, :bar])
+    assert_equal({ :baz => "Baz" }, I18n.t(:foo))
+
+    @backend.remove_translation([:foo])
+    assert_equal "translation missing: en, foo", I18n.t(:foo)
+    assert_equal "translation missing: de, foo", I18n.t(:foo, :locale => :de)
+  end
+
+  define_method :"test store_translation does not overwrite existing keys" do
+    assert_equal({ :bar => "Bar", :baz => "Baz" }, I18n.t(:foo))
+    assert_raises(I18n::KeyExists) { @backend.store_translations(:en, :foo => 'Foo') }
+    assert_equal({ :bar => "Bar", :baz => "Baz" }, I18n.t(:foo))
+  end
+end