puttext 0.1.0

data/spec/fixtures/parser_base_shared_fixture.rb

@@ -0,0 +1,3 @@
+class TestClass
+  _('string')
+end

data/spec/shared/parser_base_shared.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'unindent'
+
+RSpec.shared_examples 'PutText::Parser::Base' do
+  describe '#strings_from_file' do
+    let(:fixture_file_path) do
+      File.join(
+        File.dirname(__FILE__),
+        '../fixtures/parser_base_shared_fixture.rb'
+      )
+    end
+
+    let(:fixture_file_contents) do
+      <<-RUBY.unindent
+        class TestClass
+          _('string')
+        end
+      RUBY
+    end
+
+    before do
+      allow(subject).to receive(:strings_from_source).and_return(['something'])
+    end
+
+    it 'passes file content to strings_from_source' do
+      subject.strings_from_file(fixture_file_path)
+
+      expect(subject).to have_received(:strings_from_source).with(
+        fixture_file_contents, filename: fixture_file_path
+      )
+    end
+
+    it 'returns the result from strings_from_source' do
+      expect(subject.strings_from_file(fixture_file_path)).to eq(['something'])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'puttext'
+
+# Load shared specs.
+Dir[File.join(File.dirname(__FILE__), 'shared/**/*.rb')].each { |f| require f }

data/spec/unit/extractor_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'unindent'
+
+describe PutText::Extractor do
+  describe '.file_supported?(path)' do
+    context 'passing a file with a supported extension' do
+      it 'returns true' do
+        expect(described_class.file_supported?('test/file.rb')).to be true
+      end
+    end
+
+    context 'passing a file with an unsupported extension' do
+      it 'returns false' do
+        expect(described_class.file_supported?('test/file.php')).to be false
+      end
+    end
+  end
+
+  describe '#extract_from_file' do
+    context 'passing a Ruby file' do
+      before do
+        allow_any_instance_of(PutText::Parser::Ruby).to(
+          receive(:strings_from_file).and_return(['stuff'])
+        )
+      end
+
+      it 'uses the Ruby parser to extract strings' do
+        expect_any_instance_of(PutText::Parser::Ruby).to(
+          receive(:strings_from_file).with('test/file.rb')
+        )
+
+        subject.extract_from_file('test/file.rb')
+      end
+
+      it 'returns the results of the #strings_from_file call' do
+        expect(subject.extract_from_file('test/file.rb')).to eq(['stuff'])
+      end
+    end
+
+    context 'passing a Slim file' do
+      before do
+        allow_any_instance_of(PutText::Parser::Slim).to(
+          receive(:strings_from_file).and_return(['stuff'])
+        )
+      end
+
+      it 'uses the Slim parser to extract strings' do
+        expect_any_instance_of(PutText::Parser::Slim).to(
+          receive(:strings_from_file).with('test/file.slim')
+        )
+
+        subject.extract_from_file('test/file.slim')
+      end
+
+      it 'returns the results of the #strings_from_file call' do
+        expect(subject.extract_from_file('test/file.slim')).to eq(['stuff'])
+      end
+    end
+
+    context 'passing an unsupported file' do
+      it 'throws a PutText::Extractor::UnsupportedFileError' do
+        expect { subject.extract_from_file('test/file.php') }.to raise_error(
+          PutText::Extractor::UnsupportedFileError
+        )
+      end
+    end
+  end
+
+  describe '#extract' do
+    let(:entry) { PutText::POEntry.new(msgid: 'test') }
+
+    context 'passing a folder as the path' do
+      let(:fixtures_path) do
+        File.join(File.dirname(__FILE__), '../fixtures/extractor_fixtures')
+      end
+
+      context 'files do not contain any strings' do
+        before do
+          allow(subject).to receive(:extract_from_file).and_return([])
+          subject.extract(fixtures_path)
+        end
+
+        it 'extracts strings from 4 files' do
+          expect(subject).to have_received(:extract_from_file).exactly(4).times
+        end
+
+        it 'extracts strings from file_1.rb' do
+          expect(subject).to have_received(:extract_from_file).with(
+            %r{extractor_fixtures/file_1\.rb$}
+          )
+        end
+
+        it 'extracts strings from file_2.rb' do
+          expect(subject).to have_received(:extract_from_file).with(
+            %r{extractor_fixtures/file_2\.rb$}
+          )
+        end
+
+        it 'extracts strings from subfolder/subfile_1.rb' do
+          expect(subject).to have_received(:extract_from_file).with(
+            %r{extractor_fixtures/subfolder/subfile_1\.rb$}
+          )
+        end
+
+        it 'extracts strings from subfolder/subfile_2.rb' do
+          expect(subject).to have_received(:extract_from_file).with(
+            %r{extractor_fixtures/subfolder/subfile_2\.rb$}
+          )
+        end
+      end
+
+      context 'files contain some strings' do
+        before do
+          allow(subject).to receive(:extract_from_file).and_return([entry])
+        end
+
+        it 'returns a POFile with entries extracted from the files' do
+          dup_entry = entry.dup
+
+          expect(subject.extract(fixtures_path)).to eq(
+            PutText::POFile.new([dup_entry, dup_entry, dup_entry, dup_entry])
+          )
+        end
+      end
+    end
+
+    context 'passing a folder as the path' do
+      let(:fixture_path) do
+        File.join(
+          File.dirname(__FILE__),
+          '../fixtures/extractor_fixtures/file_1.rb'
+        )
+      end
+
+      before do
+        allow(subject).to receive(:extract_from_file).and_return([entry])
+      end
+
+      it 'extracts strings from 1 file' do
+        subject.extract(fixture_path)
+        expect(subject).to have_received(:extract_from_file).once
+      end
+
+      it 'extracts contents from file_1.rb' do
+        subject.extract(fixture_path)
+        expect(subject).to have_received(:extract_from_file).with(
+          %r{extractor_fixtures/file_1\.rb$}
+        )
+      end
+
+      it 'returns a POFile with entries extracted from the file' do
+        expect(subject.extract(fixture_path)).to eq(
+          PutText::POFile.new([entry])
+        )
+      end
+    end
+
+    context 'passing a not existing path' do
+      it 'throws a PutText::Extractor::NoSuchFileError' do
+        expect { subject.extract('non/existing/path') }.to raise_error(
+          PutText::Extractor::NoSuchFileError
+        )
+      end
+    end
+  end
+end

data/spec/unit/parser/ruby_spec.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'unindent'
+
+describe PutText::Parser::Ruby do
+  it_behaves_like 'PutText::Parser::Base'
+
+  describe '#strings_from_source' do
+    context 'passing Ruby code with gettext usages' do
+      let(:ruby_code) do
+        <<-RUBY.unindent
+          class RandomClass
+            def array_of_text
+              [
+                gettext('gettext'),
+                _('underscore'),
+                ngettext('1 ngettext', '%d ngettexts', 5),
+                n_('1 underscore', '%d underscores', 5),
+                sgettext('context|sgettext'),
+                s_('context---s underscore', '---'),
+                nsgettext('context|1 nsgettext', '%d nsgettexts', 5),
+                ns_('context---1 ns underscore', '%d ns underscores', 5, '---'),
+                pgettext('context', 'pgettext'),
+                p_('context', 'p underscore'),
+                npgettext('context', '1 npgettext', '%d npgettexts', 5),
+                np_('context', '1 np underscore', '%d np underscores', 5)
+              ]
+            end
+
+            def method_with_underscore_param(_)
+              'something'
+            end
+
+            before_event -> (_) { 'do_important_stuff' }
+          end
+        RUBY
+      end
+
+      before do
+        allow(PutText::POEntry).to receive(:new)
+        subject.strings_from_source(
+          ruby_code, filename: 'test.rb', first_line: 8
+        )
+      end
+
+      it 'extracts the correct number of strings' do
+        expect(PutText::POEntry).to have_received(:new).exactly(12).times
+      end
+
+      it 'correctly extracts string from gettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'gettext',
+          references: ['test.rb:11']
+        )
+      end
+
+      it 'correctly extracts string from _ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'underscore',
+          references: ['test.rb:12']
+        )
+      end
+
+      it 'correctly extracts string from ngettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: '1 ngettext',
+          msgid_plural: '%d ngettexts',
+          references: ['test.rb:13']
+        )
+      end
+
+      it 'correctly extracts string from n_ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: '1 underscore',
+          msgid_plural: '%d underscores',
+          references: ['test.rb:14']
+        )
+      end
+
+      it 'correctly extracts string from sgettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'context|sgettext',
+          references: ['test.rb:15']
+        )
+      end
+
+      it 'correctly extracts string from s_ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'context---s underscore',
+          separator: '---',
+          references: ['test.rb:16']
+        )
+      end
+
+      it 'correctly extracts string from nsgettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'context|1 nsgettext',
+          msgid_plural: '%d nsgettexts',
+          references: ['test.rb:17']
+        )
+      end
+
+      it 'correctly extracts string from ns_ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgid: 'context---1 ns underscore',
+          msgid_plural: '%d ns underscores',
+          separator: '---',
+          references: ['test.rb:18']
+        )
+      end
+
+      it 'correctly extracts string from pgettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgctxt: 'context',
+          msgid: 'pgettext',
+          references: ['test.rb:19']
+        )
+      end
+
+      it 'correctly extracts string from p_ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgctxt: 'context',
+          msgid: 'p underscore',
+          references: ['test.rb:20']
+        )
+      end
+
+      it 'correctly extracts string from npgettext calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgctxt: 'context',
+          msgid: '1 npgettext',
+          msgid_plural: '%d npgettexts',
+          references: ['test.rb:21']
+        )
+      end
+
+      it 'correctly extracts string from np_ calls' do
+        expect(PutText::POEntry).to have_received(:new).with(
+          msgctxt: 'context',
+          msgid: '1 np underscore',
+          msgid_plural: '%d np underscores',
+          references: ['test.rb:22']
+        )
+      end
+    end
+
+    context 'passing an empty string' do
+      it 'returns an empty array' do
+        expect(subject.strings_from_source('')).to eq([])
+      end
+    end
+
+    context 'passing Ruby code that uses text interpolations' do
+      let(:ruby_code) do
+        <<-RUBY.unindent
+          class RandomClass
+            def interpolations
+              'stuff'
+            end
+
+            def do_something
+              _("something with \#{interpolations}")
+            end
+          end
+        RUBY
+      end
+
+      it 'throws a PutText::Parser::ParseError error' do
+        expect { subject.strings_from_source(ruby_code) }.to raise_error(
+          PutText::Parser::ParseError
+        )
+      end
+    end
+  end
+end

data/spec/unit/parser/slim_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'unindent'
+
+describe PutText::Parser::Slim do
+  it_behaves_like 'PutText::Parser::Base'
+
+  describe '#strings_from_source' do
+    let(:slim_template) do
+      <<-SLIM.unindent
+        html attr=code(_('attr')) attr_2="\#{_('attr interpolation')}"
+          = multiline_ruby\\
+            n_('1 multiline ruby', '%d multiline rubies', 8)
+
+        - if condition
+          div *{'hash_attr'=>p_('ctx','splat hash attr')}
+
+        coffee:
+          _('should be ignored')
+
+        = method_call do
+          html
+            | inside
+            | with interpolations \#{_('text interpolation')}
+          # and_also_ruby
+          == _('unescaped string')
+      SLIM
+    end
+
+    before do
+      allow(PutText::POEntry).to receive(:new)
+      subject.strings_from_source(
+        slim_template, filename: 'test.slim', first_line: 8
+      )
+    end
+
+    it 'extracts the correct number of strings' do
+      expect(PutText::POEntry).to have_received(:new).exactly(6).times
+    end
+
+    it 'correctly extracts string from dynamic attribute value' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgid: 'attr',
+        references: ['test.slim:8']
+      )
+    end
+
+    it 'correctly extracts string from interpolated attribute value' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgid: 'attr interpolation',
+        references: ['test.slim:8']
+      )
+    end
+
+    it 'correctly extracts string from embedded Ruby code' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgid: '1 multiline ruby',
+        msgid_plural: '%d multiline rubies',
+        references: ['test.slim:10']
+      )
+    end
+
+    it 'correctly extracts string from splat attributes' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgctxt: 'ctx',
+        msgid: 'splat hash attr',
+        references: ['test.slim:13']
+      )
+    end
+
+    it 'correctly extracts string from text interpolation' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgid: 'text interpolation',
+        references: ['test.slim:21']
+      )
+    end
+
+    it 'correctly extracts string from unescaped Ruby output code' do
+      expect(PutText::POEntry).to have_received(:new).with(
+        msgid: 'unescaped string',
+        references: ['test.slim:23']
+      )
+    end
+  end
+end