i18nliner 0.2.4 → 0.3.0

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

@@ -1,7 +1,8 @@
-# encoding: UTF-8
-require 'i18nliner/base'
-require 'i18nliner/scope'
-require 'i18nliner/extractors/translate_call'
+# frozen_string_literal: true
+
+require "i18nliner/base"
+require "i18nliner/scope"
+require "i18nliner/extractors/translate_call"
 
 describe I18nliner::Extractors::TranslateCall do
   def call(scope, *args)
@@ -9,62 +10,62 @@ describe I18nliner::Extractors::TranslateCall do
   end
 
   let(:no_scope) { I18nliner::Scope.new(nil) }
-  let(:scope) { I18nliner::Scope.new("foo", :auto => true, :allow_relative => true) }
-  let(:erb_scope) { I18nliner::Scope.new(nil, :remove_whitespace => true) }
+  let(:scope) { I18nliner::Scope.new("foo", auto: true, allow_relative: true) }
+  let(:erb_scope) { I18nliner::Scope.new(nil, remove_whitespace: true) }
 
   describe "signature" do
     it "should reject extra arguments" do
-      expect {
+      expect do
         call(no_scope, :key, "value", {}, :wat)
-      }.to raise_error(I18nliner::InvalidSignatureError)
+      end.to raise_error(I18nliner::InvalidSignatureError)
     end
 
     it "should accept a valid key or default" do
-      expect {
+      expect do
         call(no_scope, "key", "value", {})
-      }.to_not raise_error
+      end.not_to raise_error
 
-      expect {
+      expect do
         call(no_scope, "key_or_value", {})
-      }.to_not raise_error
+      end.not_to raise_error
 
-      expect {
+      expect do
         call(no_scope, :key, {})
-      }.to_not raise_error
+      end.not_to raise_error
     end
 
     it "should require at least a key or default" do
-      expect {
+      expect do
         call(no_scope)
-      }.to raise_error(I18nliner::InvalidSignatureError)
+      end.to raise_error(I18nliner::InvalidSignatureError)
     end
 
     it "should require a literal default" do
-      expect {
+      expect do
         call(no_scope, :key, Object.new)
-      }.to raise_error(I18nliner::InvalidSignatureError)
+      end.to raise_error(I18nliner::InvalidSignatureError)
     end
 
     # for legacy calls, e.g. t :key, :default => "foo"
     it "should allow the default to be specified in the options hash" do
-      call = call(no_scope, :key, :default => "foo")
+      call = call(no_scope, :key, default: "foo")
       expect(call.default).to eq "foo"
     end
 
     it "should not extract symbol defaults" do
-      call = call(no_scope, :key, :default => :bar_key)
+      call = call(no_scope, :key, default: :bar_key)
       expect(call.default).to be_nil
     end
 
     it "should extract the first string default" do
-      call = call(no_scope, :key, :default => [:foo_key, :bar_key, "baz"])
+      call = call(no_scope, :key, default: [:foo_key, :bar_key, "baz"])
       expect(call.default).to eq "baz"
     end
 
     it "should ensure options is a hash, if provided" do
-      expect {
+      expect do
         call(no_scope, :key, "value", Object.new)
-      }.to raise_error(I18nliner::InvalidSignatureError)
+      end.to raise_error(I18nliner::InvalidSignatureError)
     end
   end
 
@@ -72,28 +73,30 @@ describe I18nliner::Extractors::TranslateCall do
     it "should generate literal keys" do
       I18nliner.inferred_key_format :literal do
         expect(call(no_scope, "zomg key").translations).to eq(
-          [["zomg key", "zomg key"]])
+          [["zomg key", "zomg key"]]
+        )
       end
     end
 
     it "should generate underscored keys" do
       I18nliner.inferred_key_format :underscored do
         expect(call(no_scope, "zOmg key!!").translations).to eq(
-          [["zomg_key", "zOmg key!!"]])
+          [["zomg_key", "zOmg key!!"]]
+        )
       end
     end
 
     it "should transliterate underscored keys according to the default locale" do
       orig_locale = I18n.default_locale
-      I18n.available_locales = [:en, :de]
-      I18n.backend.store_translations(:de, :i18n => {
-        :transliterate => {
-          :rule => {
-            "ü" => "ue",
-            "ö" => "oe"
-          }
-        }
-      })
+      I18n.available_locales = %i[en de]
+      I18n.backend.store_translations(:de, i18n: {
+                                        transliterate: {
+                                          rule: {
+                                            "ü" => "ue",
+                                            "ö" => "oe"
+                                          }
+                                        }
+                                      })
 
       I18nliner.inferred_key_format :underscored do
         I18n.default_locale = :en
@@ -107,15 +110,16 @@ describe I18nliner::Extractors::TranslateCall do
     it "should generate underscored + crc32 keys" do
       I18nliner.inferred_key_format :underscored_crc32 do
         expect(call(no_scope, "zOmg key!!").translations).to eq(
-          [["zomg_key_90a85b0b", "zOmg key!!"]])
+          [["zomg_key_90a85b0b", "zOmg key!!"]]
+        )
       end
     end
   end
 
   describe "normalization" do
     it "should make keys absolute if scoped" do
-      expect(call(scope, '.key', "value").translations[0][0]).to match /\Afoo\.key/
-      expect(call(scope, ['.key1', '.key2'], "value").translations.map(&:first)).to eq ['foo.key1', 'foo.key2']
+      expect(call(scope, ".key", "value").translations[0][0]).to match(/\Afoo\.key/)
+      expect(call(scope, [".key1", ".key2"], "value").translations.map(&:first)).to eq ["foo.key1", "foo.key2"]
     end
 
     it "should strip leading whitespace from defaults" do
@@ -130,81 +134,85 @@ describe I18nliner::Extractors::TranslateCall do
   describe "pluralization" do
     describe "keys" do
       it "should be inferred from a word" do
-        translations = call(no_scope, "person", {:count => Object.new}).translations
+        translations = call(no_scope, "person", { count: Object.new }).translations
         expect(translations.map(&:first).sort).to eq ["count_people_489946e7.one", "count_people_489946e7.other"]
       end
 
       it "should be inferred from a hash" do
-        translations = call(no_scope, {:one => "just you", :other => "lotsa peeps"}, {:count => Object.new}).translations
+        translations = call(no_scope,
+                            { one: "just you", other: "lotsa peeps" },
+                            { count: Object.new }).translations
         expect(translations.map(&:first).sort).to eq ["lotsa_peeps_41499c40.one", "lotsa_peeps_41499c40.other"]
       end
     end
 
     describe "defaults" do
       it "should be inferred" do
-        translations = call(no_scope, "person", {:count => Object.new}).translations
+        translations = call(no_scope, "person", { count: Object.new }).translations
         expect(translations.map(&:last).sort).to eq ["%{count} people", "1 person"]
       end
 
       it "should not be inferred if given multiple words" do
-        translations = call(no_scope, "happy person", {:count => Object.new}).translations
+        translations = call(no_scope, "happy person", { count: Object.new }).translations
         expect(translations.map(&:last)).to eq ["happy person"]
       end
     end
 
     it "should accept valid hashes" do
-      expect(call(no_scope, {:one => "asdf", :other => "qwerty"}, :count => 1).translations.sort).to eq(
-        [["qwerty_98185351.one", "asdf"], ["qwerty_98185351.other", "qwerty"]])
-      expect(call(no_scope, :some_stuff, {:one => "asdf", :other => "qwerty"}, :count => 1).translations.sort).to eq(
-        [["some_stuff.one", "asdf"], ["some_stuff.other", "qwerty"]])
+      expect(call(no_scope, { one: "asdf", other: "qwerty" }, count: 1).translations.sort).to eq(
+        [["qwerty_98185351.one", "asdf"], ["qwerty_98185351.other", "qwerty"]]
+      )
+      expect(call(no_scope, :some_stuff, { one: "asdf", other: "qwerty" }, count: 1).translations.sort).to eq(
+        [["some_stuff.one", "asdf"], ["some_stuff.other", "qwerty"]]
+      )
     end
 
     it "should reject invalid keys" do
-      expect {
-        call(no_scope, {:one => "asdf", :twenty => "qwerty"}, :count => 1)
-      }.to raise_error(I18nliner::InvalidPluralizationKeyError)
+      expect do
+        call(no_scope, { one: "asdf", twenty: "qwerty" }, count: 1)
+      end.to raise_error(I18nliner::InvalidPluralizationKeyError)
     end
 
     it "should require essential keys" do
-      expect {
-        call(no_scope, {:one => "asdf"}, :count => 1)
-      }.to raise_error(I18nliner::MissingPluralizationKeyError)
+      expect do
+        call(no_scope, { one: "asdf" }, count: 1)
+      end.to raise_error(I18nliner::MissingPluralizationKeyError)
     end
 
     it "should reject invalid count defaults" do
-      expect {
-        call(no_scope, {:one => "asdf", :other => Object.new}, :count => 1)
-      }.to raise_error(I18nliner::InvalidPluralizationDefaultError)
+      expect do
+        call(no_scope, { one: "asdf", other: Object.new }, count: 1)
+      end.to raise_error(I18nliner::InvalidPluralizationDefaultError)
     end
 
     it "should complain if no :count is provided" do
-      expect {
-        call(no_scope, {:one => "asdf", :other => "qwerty"})
-      }.to raise_error(I18nliner::MissingCountValueError)
+      expect do
+        call(no_scope, { one: "asdf", other: "qwerty" })
+      end.to raise_error(I18nliner::MissingCountValueError)
     end
   end
 
   describe "validation" do
     it "should require all interpolation values" do
       I18nliner.infer_interpolation_values false do
-        expect {
+        expect do
           call(no_scope, "asdf %{bob}")
-        }.to raise_error(I18nliner::MissingInterpolationValueError)
+        end.to raise_error(I18nliner::MissingInterpolationValueError)
       end
     end
 
     it "should require all interpolation values in count defaults" do
       I18nliner.infer_interpolation_values false do
-        expect {
-          call(no_scope, {:one => "asdf %{bob}", :other => "querty"})
-        }.to raise_error(I18nliner::MissingInterpolationValueError)
+        expect do
+          call(no_scope, { one: "asdf %{bob}", other: "querty" })
+        end.to raise_error(I18nliner::MissingInterpolationValueError)
       end
     end
 
     it "should ensure option keys are symbols or strings" do
-      expect {
-        call(no_scope, "hello", {Object.new => "okay"})
-      }.to raise_error(I18nliner::InvalidOptionKeyError)
+      expect do
+        call(no_scope, "hello", { Object.new => "okay" })
+      end.to raise_error(I18nliner::InvalidOptionKeyError)
     end
   end
 end

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

@@ -1,38 +1,39 @@
-require 'i18nliner/errors'
-require 'i18nliner/extractors/translation_hash'
+# frozen_string_literal: true
 
-describe I18nliner::Extractors::TranslationHash do
+require "i18nliner/errors"
+require "i18nliner/extractors/translation_hash"
 
+describe I18nliner::Extractors::TranslationHash do
   describe "#[]=" do
     let(:hash) { I18nliner::Extractors::TranslationHash.new }
 
     it "should accept identical key/values" do
-      expect {
+      expect do
         hash["foo"] = "Foo"
         hash["foo"] = "Foo"
-      }.to_not raise_error
-      expect(hash).to eq({"foo" => "Foo"})
+      end.not_to raise_error
+      expect(hash).to eq({ "foo" => "Foo" })
     end
 
     it "should reject mismatched values" do
-      expect {
+      expect do
         hash["foo"] = "Foo"
         hash["foo"] = "Bar"
-      }.to raise_error(I18nliner::KeyInUseError)
+      end.to raise_error(I18nliner::KeyInUseError)
     end
 
     it "should not let you use a key as a scope" do
-      expect {
+      expect do
         hash["foo"] = "Foo"
         hash["foo.bar"] = "Bar"
-      }.to raise_error(I18nliner::KeyAsScopeError)
+      end.to raise_error(I18nliner::KeyAsScopeError)
     end
 
     it "should not let you use a scope as a key" do
-      expect {
+      expect do
         hash["foo.bar"] = "Bar"
         hash["foo"] = "Foo"
-      }.to raise_error(I18nliner::KeyAsScopeError)
+      end.to raise_error(I18nliner::KeyAsScopeError)
     end
   end
 end

data/spec/{reserved_keys_spec.rb → i18nliner/i18n_spec.rb}

@@ -1,4 +1,6 @@
-require 'i18nliner/reserved_keys'
+# frozen_string_literal: true
+
+require "i18nliner/reserved_keys"
 
 describe I18n do
   it "adds new reserved keys" do

data/spec/{pre_processors → i18nliner/pre_processors}/erb_pre_processor_spec.rb

@@ -1,15 +1,16 @@
-# encoding: UTF-8
-require 'i18nliner/pre_processors/erb_pre_processor'
-require 'i18nliner/errors'
-require 'active_support/core_ext/string/strip.rb'
+# frozen_string_literal: true
+
+require "i18nliner/pre_processors/erb_pre_processor"
+require "i18nliner/errors"
+require "active_support/core_ext/string/strip"
 
 describe I18nliner::PreProcessors::ErbPreProcessor do
   before do
-    allow_any_instance_of(I18nliner::PreProcessors::ErbPreProcessor::TBlock).to receive(:infer_key).and_return(:key)
+    allow_any_instance_of(I18nliner::PreProcessors::ErbPreProcessor::TBlock).to receive(:infer_key).and_return(:key) # rubocop:disable RSpec/AnyInstance
   end
 
   describe ".process" do
-    def process(string, remove_blank_lines = true)
+    def process(string, remove_blank_lines: true)
       result = I18nliner::PreProcessors::ErbPreProcessor.process(string)
       result.gsub!(/\n+%>/, " %>") if remove_blank_lines
       result
@@ -17,12 +18,14 @@ describe I18nliner::PreProcessors::ErbPreProcessor do
 
     it "should transform t block expressions" do
       expect(process("<%= t do %>hello world!<% end %>")).to eq(
-        '<%= t :key, "hello world!", :i18nliner_inferred_key => (true) %>')
+        '<%= t :key, "hello world!", :i18nliner_inferred_key => (true) %>'
+      )
     end
 
     it "should remove extraneous whitespace from the default" do
       expect(process("<%= t do %> ohai!  lulz\t <% end %>")).to eq(
-        '<%= t :key, "ohai! lulz", :i18nliner_inferred_key => (true) %>')
+        '<%= t :key, "ohai! lulz", :i18nliner_inferred_key => (true) %>'
+      )
     end
 
     # so that line numbers are close-ish when you get an error in a
@@ -30,165 +33,165 @@ describe I18nliner::PreProcessors::ErbPreProcessor do
     # match up perfectly, but it will at least point to the start of the
     # t-block
     it "should preserve all newlines in the generated erb" do
-      expect(process(<<-SOURCE.strip_heredoc, false)).
+      expect(process(<<~ERB.strip_heredoc, remove_blank_lines: false)).
         <%= t do
         %>
           ohai!
           <%= test %>
           lulz
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED.strip_heredoc
-        <%= t :key, "ohai! %{test} lulz", :test => (test), :i18nliner_inferred_key => (true)
+      ERB
+        to eq <<~ERB.strip_heredoc
+          <%= t :key, "ohai! %{test} lulz", :test => (test), :i18nliner_inferred_key => (true)
 
 
 
 
-        %>
-        EXPECTED
+          %>
+        ERB
     end
 
     it "should not translate other block expressions" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= form_for do %>
           <%= t do %>Your Name<% end %>
           <input>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= form_for do %>
-          <%= t :key, "Your Name", :i18nliner_inferred_key => (true) %>
-          <input>
-        <% end %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= form_for do %>
+            <%= t :key, "Your Name", :i18nliner_inferred_key => (true) %>
+            <input>
+          <% end %>
+        ERB
     end
 
     it "should reject malformed erb" do
-      expect { process("<%= t do %>") }.
-        to raise_error(I18nliner::MalformedErbError)
+      expect { process("<%= t do %>") }
+        .to raise_error(I18nliner::MalformedErbError)
     end
 
     it "should disallow nesting non-t block expressions in a t block expression" do
-      expect { process("<%= t { %><%= s { %>nope<% } %><% } %>") }.
-        to raise_error(I18nliner::TBlockNestingError)
-      expect { process("<%= t { %><%= s(:some, :args) { |args, here, too| %>nope<% } %><% } %>") }.
-        to raise_error(I18nliner::TBlockNestingError)
+      expect { process("<%= t { %><%= s { %>nope<% } %><% } %>") }
+        .to raise_error(I18nliner::TBlockNestingError)
+      expect { process("<%= t { %><%= s(:some, :args) { |args, here, too| %>nope<% } %><% } %>") }
+        .to raise_error(I18nliner::TBlockNestingError)
     end
 
     it "should disallow statements in a t block expression" do
-      expect { process("<%= t { %>I am <% if happy %>happy<% else %>sad<% end %><% } %>") }.
-        to raise_error(I18nliner::TBlockNestingError)
+      expect { process("<%= t { %>I am <% if happy %>happy<% else %>sad<% end %><% } %>") }
+        .to raise_error(I18nliner::TBlockNestingError)
     end
 
     it "should create wrappers for markup" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           <b>bold</b>, or even <a href="#"><i><img>combos</i></a> get wrapper'd
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "*bold*, or even **combos** get wrapper'd", :i18nliner_inferred_key => (true), :wrappers => ["<b>\\\\1</b>", "<a href=\\\"#\\\"><i><img>\\\\1</i></a>"] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "*bold*, or even **combos** get wrapper'd", :i18nliner_inferred_key => (true), :wrappers => ["<b>\\\\1</b>", "<a href=\\"#\\"><i><img>\\\\1</i></a>"] %>
+        ERB
     end
 
     it "should not create wrappers for markup with multiple text nodes" do
-      expect { puts process("<%= t do %>this is <b><i>too</i> complicated</b><% end %>") }.
-        to raise_error(I18nliner::UnwrappableContentError)
+      expect { process("<%= t do %>this is <b><i>too</i> complicated</b><% end %>") }
+        .to raise_error(I18nliner::UnwrappableContentError)
     end
 
     it "should create wrappers for link_to calls with string content" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           You should <%= link_to("create a profile", "/profile") %>.
           idk why <%= link_to "this " + "link", "/zomg" %> has concatention
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "You should *create a profile*. idk why **this link** has concatention", :i18nliner_inferred_key => (true), :wrappers => [link_to("\\\\1", "/profile"), link_to("\\\\1", "/zomg")] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "You should *create a profile*. idk why **this link** has concatention", :i18nliner_inferred_key => (true), :wrappers => [link_to("\\\\1", "/profile"), link_to("\\\\1", "/zomg")] %>
+        ERB
     end
 
     it "should create wrappers for link_to calls with other content" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           Your account rep is <%= link_to(@user.name, "/user/\#{@user.id}") %>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "Your account rep is *%{user_name}*", :user_name => (@user.name), :i18nliner_inferred_key => (true), :wrappers => [link_to("\\\\1", "/user/\#{@user.id}")] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "Your account rep is *%{user_name}*", :user_name => (@user.name), :i18nliner_inferred_key => (true), :wrappers => [link_to("\\\\1", "/user/\#{@user.id}")] %>
+        ERB
     end
 
     it "should reuse identical wrappers" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           the wrappers for
           <%= link_to "these", url %> <%= link_to "links", url %> are the same,
           as are the ones for
           <b>these</b> <b>tags</b>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "the wrappers for **these** **links** are the same, as are the ones for *these* *tags*", :i18nliner_inferred_key => (true), :wrappers => ["<b>\\\\1</b>", link_to("\\\\1", url)] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "the wrappers for **these** **links** are the same, as are the ones for *these* *tags*", :i18nliner_inferred_key => (true), :wrappers => ["<b>\\\\1</b>", link_to("\\\\1", url)] %>
+        ERB
     end
 
     it "should generate placeholders for inline expressions" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           Hello, <%= name %>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "Hello, %{name}", :name => (name), :i18nliner_inferred_key => (true) %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "Hello, %{name}", :name => (name), :i18nliner_inferred_key => (true) %>
+        ERB
     end
 
     it "should generate placeholders for inline expressions in wrappers" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           Go to <a href="/asdf" title="<%= name %>">your account</a>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "Go to *your account*", :i18nliner_inferred_key => (true), :wrappers => ["<a href=\\"/asdf\\" title=\\"\#{name}\\">\\\\1</a>"] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "Go to *your account*", :i18nliner_inferred_key => (true), :wrappers => ["<a href=\\"/asdf\\" title=\\"\#{name}\\">\\\\1</a>"] %>
+        ERB
     end
 
     # this is really the same as the one above, but it's good to have a
     # spec for this in case the underlying implementation changes
     # dramatically
     it "should transform nested t block expressions in wrappers" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           Go to <a href="/asdf" title="<%= t do %>manage account stuffs, <%= name %><% end %>">your account</a>
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "Go to *your account*", :i18nliner_inferred_key => (true), :wrappers => ["<a href=\\"/asdf\\" title=\\"\#{t :key, \"manage account stuffs, %{name}\", :name => (name), :i18nliner_inferred_key => (true)}\\">\\\\1</a>"] %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "Go to *your account*", :i18nliner_inferred_key => (true), :wrappers => ["<a href=\\"/asdf\\" title=\\"\#{t :key, "manage account stuffs, %{name}", :name => (name), :i18nliner_inferred_key => (true)}\\">\\\\1</a>"] %>
+        ERB
     end
 
     it "should generate placeholders for empty markup" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           Create <input name="count"> groups
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "Create %{input_name_count} groups", :input_name_count => ("<input name=\\"count\\">".html_safe), :i18nliner_inferred_key => (true) %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "Create %{input_name_count} groups", :input_name_count => ("<input name=\\"count\\">".html_safe), :i18nliner_inferred_key => (true) %>
+        ERB
     end
 
     it "should unescape entities" do
-      expect(process(<<-SOURCE)).
+      expect(process(<<~ERB)).
         <%= t do %>
           &copy; <%= year %> ACME Corp. All Rights Reserved. Our lawyers &gt; your lawyers
         <% end %>
-        SOURCE
-      to eq <<-EXPECTED
-        <%= t :key, "© %{year} ACME Corp. All Rights Reserved. Our lawyers > your lawyers", :year => (year), :i18nliner_inferred_key => (true) %>
-        EXPECTED
+      ERB
+        to eq <<~ERB
+          <%= t :key, "© %{year} ACME Corp. All Rights Reserved. Our lawyers > your lawyers", :year => (year), :i18nliner_inferred_key => (true) %>
+        ERB
     end
   end
 end

data/spec/i18nliner/processors/erb_processor_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "i18nliner/processors/erb_processor"
+require "i18nliner/extractors/translation_hash"
+require "i18nliner/scope"
+
+describe I18nliner::Processors::ErbProcessor do
+  let(:translations) { I18nliner::Extractors::TranslationHash.new }
+  let(:processor) { I18nliner::Processors::ErbProcessor.new(translations) }
+
+  describe "#scope_for" do
+    context "with an erb template" do
+      subject(:scope) { processor.scope_for("app/views/foos/show.html.erb") }
+
+      specify { expect(scope).to be_allow_relative }
+      specify { expect(scope).to be_remove_whitespace }
+      specify { expect(scope.scope).to eq "foos.show." }
+    end
+
+    context "with anything else" do
+      subject(:scope) { processor.scope_for("foo.erb") }
+
+      specify { expect(scope).to be I18nliner::Scope.root }
+    end
+  end
+
+  describe "#check_contents" do
+    it "should extract valid translation calls" do
+      processor.check_contents(<<~ERB)
+        <%= t "Inline!" %>
+        <%= t do %>
+          Zomg a block
+          <a href="/nesting"
+             title="<%= t do %>what is this?<% end %>"
+             >with nesting</a>!!!
+        <% end %>
+      ERB
+      expect(translations.values.sort).to eq [
+        "Inline!",
+        "Zomg a block *with nesting*!!!",
+        "what is this?"
+      ]
+    end
+  end
+end