i18nliner 0.2.4 → 0.3.0

data/lib/i18nliner/railtie.rb

@@ -1,22 +1,24 @@
-require 'i18nliner/extensions/controller'
-require 'i18nliner/extensions/view'
-require 'i18nliner/extensions/model'
+# frozen_string_literal: true
+
+require "i18nliner/extensions/controller"
+require "i18nliner/extensions/view"
+require "i18nliner/extensions/model"
 
 module I18nliner
   class Railtie < Rails::Railtie
-    initializer 'i18nliner' do
+    initializer "i18nliner" do
       ActiveSupport.on_load :action_controller do
-        ActionController::Base.send :include, I18nliner::Extensions::Controller
+        ActionController::Base.include I18nliner::Extensions::Controller
       end
 
       ActiveSupport.on_load :action_view do
-        require 'i18nliner/erubi'
+        require "i18nliner/erubi"
         ActionView::Template::Handlers::ERB.erb_implementation = I18nliner::Erubi
-        ActionView::Base.send :include, I18nliner::Extensions::View
+        ActionView::Base.include I18nliner::Extensions::View
       end
 
       ActiveSupport.on_load :active_record do
-        ActiveRecord::Base.send :include, I18nliner::Extensions::Model
+        ActiveRecord::Base.include I18nliner::Extensions::Model
       end
     end
 
@@ -25,5 +27,3 @@ module I18nliner
     end
   end
 end
-
-

data/lib/i18nliner/reserved_keys.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 keys = I18n::RESERVED_KEYS.dup
 keys << :i18nliner_scope << :i18nliner_inferred_key
 I18n.send(:remove_const, :RESERVED_KEYS)

data/lib/i18nliner/scope.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module I18nliner
   class Scope
-    attr_reader :scope
-    attr_reader :allow_relative
-    attr_reader :context
-    alias :allow_relative? :allow_relative
+    attr_reader :scope, :allow_relative, :context
+    alias_method :allow_relative?, :allow_relative
     attr_accessor :remove_whitespace
-    alias :remove_whitespace? :remove_whitespace
+    alias_method :remove_whitespace?, :remove_whitespace
 
     def initialize(scope = nil, options = {})
       @scope = scope ? "#{scope}." : scope
@@ -16,12 +16,10 @@ module I18nliner
 
     def normalize_key(key, inferred, i18n_scope)
       return key if key.nil?
-      if key.is_a?(Array)
-        return key.map { |k| normalize_key(k, inferred, i18n_scope) }
-      end
+      return key.map { |k| normalize_key(k, inferred, i18n_scope) } if key.is_a?(Array)
 
       key = key.to_s.dup
-      if allow_relative? && key.sub!(/\A\./, '')
+      if allow_relative? && key.delete_prefix!(".")
         scope + key
       else
         key

data/lib/i18nliner.rb

@@ -1,8 +1,10 @@
-require 'i18n'
-require 'i18nliner/base'
+# frozen_string_literal: true
 
-require 'i18nliner/extensions/core'
-I18n.send :extend, I18nliner::Extensions::Core
-require 'i18nliner/reserved_keys'
+require "i18n"
+require "i18nliner/base"
 
-require 'i18nliner/railtie' if defined?(Rails)
+require "i18nliner/extensions/core"
+I18n.extend I18nliner::Extensions::Core
+require "i18nliner/reserved_keys"
+
+require "i18nliner/railtie" if defined?(Rails)

data/lib/tasks/i18nliner.rake

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 namespace :i18nliner do
   desc "Verifies all translation calls"
-  task :check => :environment do
-    require 'i18nliner/commands/check'
+  task check: :environment do
+    require "i18nliner/commands/check"
 
-    options = {:only => ENV['ONLY']}
+    options = { only: ENV["ONLY"] }
     @command = I18nliner::Commands::Check.run(options)
     @command.success? or exit 1
   end
 
   desc "Generates a new [default_locale].yml file for all translations"
-  task :dump => :check do
-    require 'i18nliner/commands/dump'
+  task dump: :check do
+    require "i18nliner/commands/dump"
 
-    options = {:translations => @command.translations, :file => ENV['YML_FILE']}
+    options = { translations: @command.translations, file: ENV["YML_FILE"] }
     @command = I18nliner::Commands::Dump.run(options)
     @command.success? or exit 1
   end
 end
-

data/spec/fixtures/app/models/invalid.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class User < ActiveRecord::Base
   def welcome_message
     t "welcome, #{name}"

data/spec/fixtures/app/models/valid.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Group < ActiveRecord::Base
   def welcome_message
     t "welcome, %{name}"

data/spec/{commands → i18nliner/commands}/check_spec.rb

@@ -1,8 +1,9 @@
-require 'i18nliner/commands/check'
+# frozen_string_literal: true
+
+require "i18nliner/commands/check"
 
 describe I18nliner::Commands::Check do
   describe ".run" do
-
     around do |example|
       I18nliner.base_path "spec/fixtures" do
         example.run
@@ -11,13 +12,11 @@ describe I18nliner::Commands::Check do
 
     it "should find errors" do
       allow(I18nliner).to receive(:manual_translations).and_return({})
-      checker = I18nliner::Commands::Check.new({:silent => true})
+      checker = I18nliner::Commands::Check.new({ silent: true })
       checker.check_files
       expect(checker.translations.values).to eq ["welcome, %{name}", "Hello World", "*This* is a test, %{user}"]
       expect(checker.errors.size).to eq 2
-      checker.errors.each do |error|
-        expect(error).to match /\Ainvalid signature/
-      end
+      expect(checker.errors).to all(match(/\Ainvalid signature/))
     end
   end
 end

data/spec/{commands → i18nliner/commands}/dump_spec.rb

@@ -1,11 +1,11 @@
-# encoding: UTF-8
-require 'i18nliner/commands/dump'
-require 'i18nliner/extractors/translation_hash'
-require 'tmpdir'
+# frozen_string_literal: true
+
+require "i18nliner/commands/dump"
+require "i18nliner/extractors/translation_hash"
+require "tmpdir"
 
 describe I18nliner::Commands::Dump do
   describe ".run" do
-
     around do |example|
       Dir.mktmpdir do |dir|
         I18nliner.base_path dir do
@@ -15,15 +15,14 @@ describe I18nliner::Commands::Dump do
     end
 
     it "should dump translations in utf8" do
-      translations = I18nliner::Extractors::TranslationHash.new('i18n' => "Iñtërnâtiônàlizætiøn")
-      dumper = I18nliner::Commands::Dump.new({:silent => true, :translations => translations})
+      translations = I18nliner::Extractors::TranslationHash.new("i18n" => "Iñtërnâtiônàlizætiøn")
+      dumper = I18nliner::Commands::Dump.new({ silent: true, translations: })
       dumper.run
-      expect(File.read(dumper.yml_file).gsub(/\s+$/, '')).to eq <<-YML.strip_heredoc.strip
+      expect(File.read(dumper.yml_file).gsub(/\s+$/, "")).to eq <<~YAML.strip
         ---
         #{I18n.default_locale}:
           i18n: Iñtërnâtiônàlizætiøn
-      YML
+      YAML
     end
   end
 end
-

data/spec/{extensions → i18nliner/extensions}/controller_spec.rb

@@ -1,6 +1,7 @@
-# encoding: UTF-8
-require 'i18nliner/extensions/controller'
-require 'i18nliner/call_helpers'
+# frozen_string_literal: true
+
+require "i18nliner/extensions/controller"
+require "i18nliner/call_helpers"
 
 describe I18nliner::Extensions::Controller do
   let(:i18n) do
@@ -19,21 +20,21 @@ describe I18nliner::Extensions::Controller do
     end
   end
 
-
   describe "#translate" do
     it "should inferpolate" do
       allow(i18n).to receive(:foo).and_return("FOO")
       allow(I18nliner::CallHelpers).to receive(:infer_key).and_return(:key)
 
-      expect(I18n).to receive(:translate).with(:key, :default => "hello %{foo}", :foo => "FOO", :i18nliner_scope => i18n.i18nliner_scope)
+      expect(I18n).to receive(:translate).with(:key,
+                                               default: "hello %{foo}",
+                                               foo: "FOO",
+                                               i18nliner_scope: i18n.i18nliner_scope)
       i18n.translate("hello %{foo}")
     end
 
     it "should pass along its scope to I18n.t" do
-      expect(I18n).to receive(:translate).with(:key, :default => "foo", :i18nliner_scope => i18n.i18nliner_scope)
+      expect(I18n).to receive(:translate).with(:key, default: "foo", i18nliner_scope: i18n.i18nliner_scope)
       i18n.translate(:key, "foo")
     end
   end
 end
-
-

data/spec/{extensions → i18nliner/extensions}/core_spec.rb

@@ -1,19 +1,21 @@
-require 'i18n'
-require 'i18nliner/extensions/core'
+# frozen_string_literal: true
+
+require "i18n"
+require "i18nliner/extensions/core"
 
 describe I18nliner::Extensions::Core do
   let(:i18n) do
     Module.new do
       extend(Module.new do
         def translate(key, **options)
-          if RUBY_VERSION >= '3.0'
+          if RUBY_VERSION >= "3.0"
             simple_translate(key, **options)
           else
             simple_translate(key, options)
           end
         end
 
-        def simple_translate(key, **options)
+        def simple_translate(_key, **options)
           string = options.delete(:default)
           interpolate_hash(string, options)
         end
@@ -28,66 +30,71 @@ describe I18nliner::Extensions::Core do
 
   describe ".translate" do
     it "should should normalize the arguments passed into the original translate" do
-      expect(i18n).to receive(:simple_translate).with("hello_name_84ff273f", :default => "Hello %{name}", :name => "bob")
-      i18n.translate("Hello %{name}", :name => "bob")
+      expect(i18n).to receive(:simple_translate).with("hello_name_84ff273f",
+                                                      default: "Hello %{name}",
+                                                      name: "bob")
+      i18n.translate("Hello %{name}", name: "bob")
     end
 
     it "should not mutate the arguments passed in" do
-      expect(i18n).to receive(:simple_translate).with("my.key", :default => "ohai whitespace ")
-      key = "my.key".freeze
-      default = " ohai whitespace ".freeze
-      expect {
+      expect(i18n).to receive(:simple_translate).with("my.key", default: "ohai whitespace ")
+      key = "my.key"
+      default = " ohai whitespace "
+      expect do
         i18n.translate(key, default)
-      }.to_not raise_error
+      end.not_to raise_error
     end
 
     it "should infer pluralization hashes" do
-      expect(i18n).to receive(:simple_translate).with("count_lights_58339e29", :default => {:one => "1 light", :other => "%{count} lights"}, count: 1)
-      i18n.translate("light", :count => 1)
+      expect(i18n).to receive(:simple_translate).with("count_lights_58339e29",
+                                                      default: { one: "1 light", other: "%{count} lights" },
+                                                      count: 1)
+      i18n.translate("light", count: 1)
     end
 
     it "should not stringify nil keys" do
-      expect(i18n).to receive(:simple_translate).with(nil, {:default => [:foo, :bar]})
-      i18n.translate(nil, {:default => [:foo, :bar]})
+      expect(i18n).to receive(:simple_translate).with(nil, { default: %i[foo bar] })
+      i18n.translate(nil, { default: %i[foo bar] })
     end
 
     it "should stringify array keys, but not the array itself" do
-      if RUBY_VERSION >= '3.0'
-        expect(i18n).to receive(:simple_translate).with(["bar", "baz"])
+      if RUBY_VERSION >= "3.0"
+        expect(i18n).to receive(:simple_translate).with(%w[bar baz])
       else
-        expect(i18n).to receive(:simple_translate).with(["bar", "baz"], {})
+        expect(i18n).to receive(:simple_translate).with(%w[bar baz], {})
       end
-      i18n.translate([:bar, :baz])
+      i18n.translate(%i[bar baz])
     end
 
     context "with wrappers" do
       it "should apply a single wrapper" do
-        result = i18n.translate("Hello *bob*.", :wrapper => '<b>\1</b>')
+        result = i18n.translate("Hello *bob*.", wrapper: '<b>\1</b>')
         expect(result).to eq "Hello <b>bob</b>."
       end
 
       it "should be html-safe" do
-        result = i18n.translate("Hello *bob*.", :wrapper => '<b>\1</b>')
+        result = i18n.translate("Hello *bob*.", wrapper: '<b>\1</b>')
         expect(result).to be_html_safe
       end
 
       it "should apply multiple wrappers" do
-        result = i18n.translate("Hello *bob*. Click **here**", :wrappers => ['<b>\1</b>', '<a href="/">\1</a>'])
+        result = i18n.translate("Hello *bob*. Click **here**", wrappers: ['<b>\1</b>', '<a href="/">\1</a>'])
         expect(result).to eq "Hello <b>bob</b>. Click <a href=\"/\">here</a>"
       end
 
       it "should apply multiple wrappers with arbitrary delimiters" do
-        result = i18n.translate("Hello !!!bob!!!. Click ???here???", :wrappers => {'!!!' => '<b>\1</b>', '???' => '<a href="/">\1</a>'})
+        result = i18n.translate("Hello !!!bob!!!. Click ???here???",
+                                wrappers: { "!!!" => '<b>\1</b>', "???" => '<a href="/">\1</a>' })
         expect(result).to eq "Hello <b>bob</b>. Click <a href=\"/\">here</a>"
       end
 
       it "should html-escape the default when applying wrappers" do
-        expect(i18n.translate("*bacon* > narwhals", :wrappers => ['<b>\1</b>'])).
-          to eq "<b>bacon</b> &gt; narwhals"
+        expect(i18n.translate("*bacon* > narwhals", wrappers: ['<b>\1</b>']))
+          .to eq "<b>bacon</b> &gt; narwhals"
       end
 
       it "should allow escaping asterisks and backslashes" do
-        result = i18n.translate("Hello \\\\*b\\*b*.", :wrapper => '<b>\1</b>')
+        result = i18n.translate("Hello \\\\*b\\*b*.", wrapper: '<b>\1</b>')
         expect(result).to eq 'Hello \<b>b*b</b>.'
       end
     end
@@ -95,37 +102,41 @@ describe I18nliner::Extensions::Core do
 
   describe ".translate!" do
     it "should behave like translate" do
-      expect(i18n).to receive(:simple_translate).with("hello_name_84ff273f", :default => "Hello %{name}", :name => "bob")
-      i18n.translate!("Hello %{name}", :name => "bob")
+      expect(i18n).to receive(:simple_translate).with("hello_name_84ff273f",
+                                                      default: "Hello %{name}",
+                                                      name: "bob")
+      i18n.translate!("Hello %{name}", name: "bob")
     end
   end
 
   describe ".interpolate_hash" do
     it "should not mark the result as html-safe if none of the components are html-safe" do
-      result = i18n.interpolate_hash("hello %{name}", :name => "<script>")
+      result = i18n.interpolate_hash("hello %{name}", name: "<script>")
       expect(result).to eq "hello <script>"
       expect(result).not_to be_html_safe
     end
 
     it "should html-escape values if the string is html-safe" do
-      result = i18n.interpolate_hash("some markup: %{markup}".html_safe, :markup => "<html>")
+      result = i18n.interpolate_hash("some markup: %{markup}".html_safe, markup: "<html>")
       expect(result).to eq "some markup: &lt;html&gt;"
       expect(result).to be_html_safe
     end
 
     it "should html-escape the string and other values if any value is html-safe strings" do
       markup = "<input>"
-      result = i18n.interpolate_hash("type %{input} & you get this: %{output}", :input => markup, :output => markup.html_safe)
+      result = i18n.interpolate_hash("type %{input} & you get this: %{output}",
+                                     input: markup,
+                                     output: markup.html_safe)
       expect(result).to eq "type &lt;input&gt; &amp; you get this: <input>"
       expect(result).to be_html_safe
     end
 
     it "should not html-escape the string if the html-safe values are not strings" do
-      markup = "<input>"
-      result = i18n.interpolate_hash("my favorite number is %{number} & my favorite color is %{color}", :number => 1, :color => "red")
+      result = i18n.interpolate_hash("my favorite number is %{number} & my favorite color is %{color}",
+                                     number: 1,
+                                     color: "red")
       expect(result).to eq "my favorite number is 1 & my favorite color is red"
       expect(result).not_to be_html_safe
     end
   end
 end
-

data/spec/i18nliner/extensions/inferpolation_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "i18nliner/extensions/inferpolation"
+
+describe I18nliner::Extensions::Inferpolation do
+  let(:foo) do
+    bar = double(baz: "lol")
+    foo = double(bar:, bar2: "foo")
+    foo.instance_variable_set(:@bar, foo.bar)
+    foo.instance_variable_set(:@bar2, "foo")
+    foo.extend I18nliner::Extensions::Inferpolation
+    foo
+  end
+
+  it "should inferpolate valid instance methods and chains" do
+    options = { default: "hello %{bar.baz} %{bar2}" }
+    expect(foo.inferpolate(options)).to eq({
+                                             default: "hello %{bar_baz} %{bar2}",
+                                             bar_baz: foo.bar.baz,
+                                             bar2: foo.bar2
+                                           })
+  end
+
+  it "should inferpolate valid instance variables and chains" do
+    options = { default: "hello %{@bar.baz} %{@bar2}" }
+    expect(foo.inferpolate(options)).to eq({
+                                             default: "hello %{bar_baz} %{bar2}",
+                                             bar_baz: foo.bar.baz,
+                                             bar2: foo.bar2
+                                           })
+  end
+
+  it "should not inferpolate invalid instance methods and chains" do
+    options = { default: "hello %{lol} %{bar.baz.lol}" }
+    expect(foo.inferpolate(options)).to eq options
+  end
+
+  it "should not inferpolate invalid instance variables and chains" do
+    options = { default: "hello %{@lol} %{@bar.baz.lol}" }
+    expect(foo.inferpolate(options)).to eq options
+  end
+
+  it "should work with pluralization hashes" do
+    options = { default: { one: "%{bar2} has 1 item", other: "%{bar2} has %{count} items" } }
+    expect(foo.inferpolate(options)).to eq({
+                                             default: { one: "%{bar2} has 1 item",
+                                                        other: "%{bar2} has %{count} items" },
+                                             bar2: foo.bar2
+                                           })
+  end
+end

data/spec/i18nliner/extensions/model_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "i18nliner/extensions/model"
+require "i18nliner/call_helpers"
+
+describe I18nliner::Extensions::Model do
+  let(:i18n) do
+    Module.new do
+      extend I18nliner::Extensions::Model
+    end
+  end
+
+  describe "#translate" do
+    it "should inferpolate" do
+      allow(i18n).to receive(:foo).and_return("FOO")
+      allow(I18nliner::CallHelpers).to receive(:infer_key).and_return(:key)
+
+      expect(I18n).to receive(:translate).with(:key,
+                                               default: "hello %{foo}",
+                                               foo: "FOO",
+                                               i18nliner_scope: i18n.i18nliner_scope,
+                                               i18nliner_inferred_key: true)
+      i18n.translate("hello %{foo}")
+    end
+
+    it "should pass along its scope to I18n.t" do
+      expect(I18n).to receive(:translate).with(:key, default: "foo", i18nliner_scope: i18n.i18nliner_scope)
+      i18n.translate(:key, "foo")
+    end
+  end
+end

data/spec/{extensions → i18nliner/extensions}/view_spec.rb

@@ -1,6 +1,7 @@
-# encoding: UTF-8
-require 'i18nliner/extensions/view'
-require 'i18nliner/call_helpers'
+# frozen_string_literal: true
+
+require "i18nliner/extensions/view"
+require "i18nliner/call_helpers"
 
 describe I18nliner::Extensions::View do
   let(:i18n) do
@@ -15,34 +16,35 @@ describe I18nliner::Extensions::View do
     end
   end
 
-
   describe "#translate" do
     it "should inferpolate" do
       allow(i18n).to receive(:foo).and_return("FOO")
       allow(I18nliner::CallHelpers).to receive(:infer_key).and_return(:key)
 
-      expect(I18n).to receive(:translate).with(:key, :default => "hello %{foo}", :foo => "FOO", :i18nliner_scope => i18n.i18nliner_scope)
+      expect(I18n).to receive(:translate).with(:key,
+                                               default: "hello %{foo}",
+                                               foo: "FOO",
+                                               i18nliner_scope: i18n.i18nliner_scope)
       i18n.translate("hello %{foo}")
     end
 
     it "should raise an error when given a block" do
-      expect {
-        i18n.translate(:foo) {
+      expect do
+        i18n.translate(:foo) do
           uhoh there was a bug with erb extraction or im doing it wrong
-        }
-      }.to raise_error I18nliner::InvalidBlockUsageError
+        end
+      end.to raise_error I18nliner::InvalidBlockUsageError
     end
 
     it "should raise an error when given an incorrect number of arguments" do
-      expect {
+      expect do
         i18n.translate
-      }.to raise_error /wrong number of arguments/
+      end.to raise_error(/wrong number of arguments/)
     end
 
     it "should pass along its scope to I18n.t" do
-      expect(I18n).to receive(:translate).with(:key, :default => "foo", :i18nliner_scope => i18n.i18nliner_scope)
+      expect(I18n).to receive(:translate).with(:key, default: "foo", i18nliner_scope: i18n.i18nliner_scope)
       i18n.translate(:key, "foo")
     end
   end
 end
-

data/spec/{extractors → i18nliner/extractors}/ruby_extractor_spec.rb

@@ -1,22 +1,24 @@
-require 'ruby_parser'
-require 'i18nliner/errors'
-require 'i18nliner/scope'
-require 'i18nliner/extractors/ruby_extractor'
+# frozen_string_literal: true
+
+require "prism"
+require "i18nliner/errors"
+require "i18nliner/scope"
+require "i18nliner/extractors/ruby_extractor"
 
 describe I18nliner::Extractors::RubyExtractor do
   def extract(source, scope = I18nliner::Scope.new(nil))
-    sexps = RubyParser.new.parse(source)
+    sexps = Prism::Translation::RubyParser.new.parse(source)
     extractor = I18nliner::Extractors::RubyExtractor.new(sexps, scope)
     translations = []
     extractor.each_translation { |translation| translations << translation }
-    Hash[translations]
+    translations.to_h
   end
 
   def assert_error(*args)
     error = args.pop
-    expect {
+    expect do
       extract(*args)
-    }.to raise_error(error)
+    end.to raise_error(error)
   end
 
   describe "#each_translation" do
@@ -34,19 +36,26 @@ describe I18nliner::Extractors::RubyExtractor do
 
     it "should extract valid t calls" do
       expect(extract("t 'Foo'")).to eq(
-        {"foo_f44ad75d" => "Foo"})
+        { "foo_f44ad75d" => "Foo" }
+      )
       expect(extract("t :bar, 'Baz'")).to eq(
-        {"bar" => "Baz"})
+        { "bar" => "Baz" }
+      )
       expect(extract("t 'lol', 'wut'")).to eq(
-        {"lol" => "wut"})
+        { "lol" => "wut" }
+      )
       expect(extract("translate 'one', {:one => '1', :other => '2'}, :count => 1")).to eq(
-        {"one.one" => "1", "one.other" => "2"})
+        { "one.one" => "1", "one.other" => "2" }
+      )
       expect(extract("t({:one => 'just one', :other => 'zomg lots'}, :count => 1)")).to eq(
-        {"zomg_lots_a54248c9.one" => "just one", "zomg_lots_a54248c9.other" => "zomg lots"})
+        { "zomg_lots_a54248c9.one" => "just one", "zomg_lots_a54248c9.other" => "zomg lots" }
+      )
       expect(extract("t 'foo2', <<-STR\nFoo\nSTR")).to eq(
-        {'foo2' => "Foo"})
+        { "foo2" => "Foo" }
+      )
       expect(extract("t 'foo', 'F' + 'o' + 'o'")).to eq(
-        {'foo' => "Foo"})
+        { "foo" => "Foo" }
+      )
     end
 
     it "should handle omitted values in hashes" do