rubocop-i18n 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d3c4fbbfe759ead1c4d19be86d280092252ca70
-  data.tar.gz: e516b0a7acbbe8d554cf0fffea3faa243852eb70
+  metadata.gz: e2792a2344ae871fa62e564786c03d892bd5072d
+  data.tar.gz: 1354b5ac2e3a9606deb1b9c594edf8a23327db38
 SHA512:
-  metadata.gz: 7d1ab20e74da22d5ff3f9e57347f460615a2393cda816008a18216dec4f184ce7c7e53b787aaee34a5f60b3352fef868c990cd6a11b9ceafae5c4e5635eba02e
-  data.tar.gz: 01c62345a6f67c485d48d0a7e524b6073fc6fe93315303d48ed0f6f04f259377b0103790b8098b0465ac340816ea283520203824e93ec228f76cf10e65b23b08
+  metadata.gz: 76633906bc7a3ad0612fff96eab7a80eb21bf26f58b95d6a31c8e24ca2958df6c95f079000c5002785ad184711e207b22b2059383d1791665728a3a73330697e
+  data.tar.gz: 4f58a7770df70e74ea4d5150140ee35aaef1b31aacd65b776de7c6ceb6f638715756d71bf43dd5a4b870c724496e01fda0e3f95bdee02da3f7755e98935997bc

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+matrix:
+  fast_finish: true
+  include:
+    - rvm: 2.4.1
+notifications:
+  email: false

data/README.md

@@ -31,12 +31,142 @@ GetText/DecorateFunctionMessage:
   Enabled: true
 ```
 
+## Cops
+
+### GetText/DecorateFunctionMessage
+
+This cop looks for any raise or fail functions and checks that the user visible message is using gettext decoration with the _() function.
+This cop makes sure the message is decorated, as well as checking that the formatting of the message is compliant according to the follow rules.
+This cop supports autocorrecting of [Simple decoration of a message](#Simple-decoration-of-a-message). See the rubocop documentation on how to run autocorrect.
+
+#### Simple decoration of a message
+
+Simple message strings should be decorated with the _() function
+
+##### Error message thrown
+
+```
+'raise' function, message string should be decorated
+```
+
+##### Bad
+
+``` ruby
+raise("Warning")
+```
+
+##### Good
+
+``` ruby
+raise(_("Warning"))
+```
+
+#### Multi-line message
+
+The message should not span multiple lines, it causes issues during the translation process.
+
+##### Error message thrown
+
+```
+'raise' function, message should not be a multi-line string
+```
+
+##### Bad
+
+``` ruby
+raise("this is a multi" \
+"line message")
+```
+
+##### Good
+
+``` ruby
+raise(_("this is a multi line message"))
+```
+
+#### Concatenated message
+
+The message should not concatenate multiple strings, it causes issues during translation and with the gettext.
+
+##### Error message thrown
+
+```
+'raise' function, message should not be a concatenated string
+```
+
+##### Bad
+
+``` ruby
+raise("this is a concatenated" + "message")
+```
+
+##### Good
+
+``` ruby
+raise(_("this is a concatenated message"))
+```
+
+#### Interpolated message
+
+The message should be formated in this particular style. Otherwise it causes issues during translation and with the gettext gem.
+
+##### Error message thrown
+
+```
+'raise' function, message should use correctly formatted interpolation
+```
+
+##### Bad
+
+``` ruby
+raise("this is an interpolated message IE #{variable}")
+```
+
+##### Good
+
+``` ruby
+raise(_("this is an interpolated message IE %{value0}") % {value0: var,})
+```
+
+#### No decoration and no string detected
+
+The raise or fail function does not contain any decoration, or a simple string
+
+##### Error message thrown
+
+```
+'raise' function, message should be decorated
+```
+
+##### Bad
+
+``` ruby
+raise(someOtherFuntioncall(foo, "bar"))
+```
+
+##### Good
+
+In this raise or fail function, the message does not contain any decoration at all and the message is not a simple string. It may make sense to convert the message to a simple string. eg [Simple decoration of a message](#Simple-decoration-of-a-message). 
+Or ignore this raise or fail function following this [How to ignore rules in code](#How-to-ignore-rules-in-code) section.
+
+## How to ignore rules in code
+
+It may be necessary to ignore a cop for a particular piece of code. We follow standard rubocop idioms.
+``` ruby
+raise("We don't want this translated")  # rubocop:disable GetText/DecorateFunctionMessage 
+```
+
+## Known Issues
+
+Rubocop currently does not detect Heredoc style messages in functions correctly, which in turn prevents this plugin from detecting them correctly.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that allows you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which creates a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/highb/rubocop-i18n. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+

data/lib/rubocop/cop/i18n/gettext/decorate_function_message.rb

@@ -3,92 +3,152 @@ module RuboCop
     module I18n
       module GetText
         class DecorateFunctionMessage < Cop
+          SUPPORTED_METHODS = ['raise', 'fail']
+          SUPPORTED_DECORATORS = ['_', 'n_', 'N_']
 
           def on_send(node)
             method_name = node.loc.selector.source
-            return if !/raise|fail/.match(method_name)
-            if method_name == "raise"
-              receiver_node, method_name, *arg_nodes = *node
-              if !arg_nodes.empty? && arg_nodes[0].type == :const && arg_nodes[1]
-                how_bad_is_it(node, method_name, arg_nodes[1])
-              end
-            elsif method_name == "fail"
-              receiver_node, method_name, *arg_nodes = *node
-              if !arg_nodes.empty?
-                how_bad_is_it(node, method_name, arg_nodes[0])
+            return if !supported_method_name?(method_name)
+            _, method_name, *arg_nodes = *node
+            if !arg_nodes.empty? && !already_decorated?(node) && (contains_string?(arg_nodes) || string_constant?(arg_nodes))
+              if string_constant?(arg_nodes)
+                message_section = arg_nodes[1]
+              else
+                message_section = arg_nodes[0]
               end
+
+              detect_and_report(node, message_section, method_name)
             end
           end
 
           private
 
-          def how_bad_is_it(node, method_name, message)
-            if message.str_type?
-              add_offense(message, :expression, "'#{method_name}' should have a decorator around the message")
-            elsif multiline_offense?(message)
-              add_offense(message, :expression, "'#{method_name}' should not use a multi-line string")
-            elsif concatination_offense?(message)
-              add_offense(message, :expression, "'#{method_name}' should not use a concatenated string")
-            elsif interpolation_offense?(message)
-              add_offense(message, :expression, "'#{method_name}' interpolation is a sin")
+          def supported_method_name?(method_name)
+            SUPPORTED_METHODS.include?(method_name)
+          end
+
+          def already_decorated?(node, parent = nil)
+            parent ||= node
+
+            if node.respond_to?(:loc) && node.loc.respond_to?(:selector)
+              return true if SUPPORTED_DECORATORS.include?(node.loc.selector.source)
             end
+
+            return false unless node.respond_to?(:children)
+
+            node.children.any? { |child| already_decorated?(child, parent) }
           end
 
-          def multiline_offense?(message)
-            found_multiline = false
-            found_strings = false
-            message.children.each { |child|
-              if child == :/
-                found_multiline = true
-              elsif ( (!child.nil? && child.class != Symbol) && ( child.str_type? || child.dstr_type? ) )
-                found_strings = true
-              end
-            }
-            found_multiline && found_strings
+          def string_constant?(nodes)
+            nodes[0].type == :const && nodes[1]
           end
 
-          def concatination_offense?(message)
-            found_concat = false
-            found_strings = false
-              message.children.each { |child|
-                if child == :+
-                  found_concat = true
-                elsif ( (!child.nil? && child.class != Symbol) && ( child.str_type? || child.dstr_type? ) )
-                  found_strings = true
-                end
-              }
-            found_concat && found_strings
+          def contains_string?(nodes)
+            nodes[0].inspect.include?(":str") || nodes[0].inspect.include?(":dstr")
           end
 
-          def interpolation_offense?(message)
-            found_funct = false
-            message.children.each { |child|
-              if !child.nil? && child.class != Symbol
-                if child.begin_type? || child.send_type?
-                  found_funct = true
-                elsif child.dstr_type?
-                  found_funct = true if child.inspect.include?(":send") || child.inspect.include?(":begin")
-                end
-              end
-            }
-            found_funct
+          def detect_and_report(node, message_section, method_name)
+            errors = how_bad_is_it(message_section)
+            return if errors.empty?
+            error_message = "'#{method_name}' function, "
+            errors.each do |error|
+              error_message << 'message string should be decorated. ' if error == :simple
+              error_message << 'message should not be a concatenated string. ' if error == :concatenation
+              error_message << 'message should not be a multi-line string. ' if error == :multiline
+              error_message << 'message should use correctly formatted interpolation. ' if error == :interpolation
+              error_message << 'message should be decorated. ' if error == :no_decoration
+            end
+            add_offense(message_section, :expression, error_message)
+          end
+
+          def how_bad_is_it(message_section)
+            errors = []
+
+            errors.push :simple if message_section.str_type?
+            errors.push :multiline if message_section.multiline?
+            errors.push :concatenation if concatenation_offense?(message_section)
+            errors.push :interpolation if interpolation_offense?(message_section)
+            errors.push :no_decoration if !already_decorated?(message_section)
+
+            # only display no_decoration, if that is the only problem.
+            if errors.size > 1 && errors.include?(:no_decoration)
+              errors.delete(:no_decoration)
+            end
+            errors
+          end
+
+          def concatenation_offense?(node, parent = nil)
+            parent ||= node
+
+            if node.respond_to?(:loc) && node.loc.respond_to?(:selector)
+              return true if node.loc.selector.source == '+'
+            end
+
+            return false unless node.respond_to?(:children)
+
+            node.children.any? { |child| concatenation_offense?(child, parent) }
+          end
+
+          def interpolation_offense?(node, parent = nil)
+            parent ||= node
+
+            return true if node.class == RuboCop::AST::Node  && node.dstr_type?
+
+            return false unless node.respond_to?(:children)
+
+            node.children.any? { |child| interpolation_offense?(child, parent) }
           end
 
           def autocorrect(node)
             if node.str_type?
               single_string_correct(node)
-            else
-              multiline_string_correct(node)
+            elsif interpolation_offense?(node)
+#              interpolation_correct(node)
             end
           end
 
           def single_string_correct(node)
-            ->(corrector) { corrector.insert_before(node.source_range , "_(")
+            ->(corrector) {
+              corrector.insert_before(node.source_range , "_(")
             corrector.insert_after(node.source_range , ")") }
           end
 
-          def multiline_string_correct(node)
+          def interpolation_correct(node)
+            interpolated_values_string = ""
+            count = 0
+            ->(corrector) {
+              node.children.each do |child|
+                # dstrs are split into "str" segments and other segments.
+                # The "other" segments are the interpolated values.
+                if child.type == :begin
+                  value = child.children[0]
+                  hash_key = "value"
+                  if value.type == :lvar
+                    # Use the variable's name as the format key
+                    hash_key = value.loc.name.source
+                  else
+                    # These are placeholders that will manually need to be given
+                    # a descriptive name
+                    hash_key << "#{count}"
+                    count += 1
+                  end
+                  if interpolated_values_string.empty?
+                    interpolated_values_string << "{ "
+                  end
+                  interpolated_values_string << "#{hash_key}: #{value.loc.expression.source}, "
+
+                  # Replace interpolation with format string
+                  corrector.replace(child.loc.expression, "%{#{hash_key}}")
+                end
+              end
+              if !interpolated_values_string.empty?
+                interpolated_values_string << "}"
+              end
+              corrector.insert_before(node.source_range, '_(')
+              corrector.insert_after(node.source_range, ") % #{interpolated_values_string}")
+            }
           end
+
         end
       end
     end

data/lib/rubocop/rspec/cop_helper.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+# This module provides methods that make it easier to test Cops.
+module CopHelper
+  extend RSpec::SharedContext
+
+  let(:ruby_version) { 2.2 }
+  let(:enabled_rails) { false }
+  let(:rails_version) { false }
+
+  def inspect_source_file(source)
+    Tempfile.open('tmp') { |f| inspect_source(source, f) }
+  end
+
+  def inspect_gemfile(source)
+    inspect_source(source, 'Gemfile')
+  end
+
+  def inspect_source(source, file = nil)
+    if source.is_a?(Array) && source.size == 1
+      raise "Don't use an array for a single line of code: #{source}"
+    end
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    processed_source = parse_source(source, file)
+    raise 'Error parsing example code' unless processed_source.valid_syntax?
+    _investigate(cop, processed_source)
+  end
+
+  def parse_source(source, file = nil)
+    source = source.join($RS) if source.is_a?(Array)
+
+    if file && file.respond_to?(:write)
+      file.write(source)
+      file.rewind
+      file = file.path
+    end
+
+    RuboCop::ProcessedSource.new(source, ruby_version, file)
+  end
+
+  def autocorrect_source_file(source)
+    Tempfile.open('tmp') { |f| autocorrect_source(source, f) }
+  end
+
+  def autocorrect_source(source, file = nil)
+    cop.instance_variable_get(:@options)[:auto_correct] = true
+    processed_source = parse_source(source, file)
+    _investigate(cop, processed_source)
+
+    corrector =
+      RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector.rewrite
+  end
+
+  def autocorrect_source_with_loop(source, file = nil)
+    loop do
+      cop.instance_variable_set(:@corrections, [])
+      new_source = autocorrect_source(source, file)
+      return new_source if new_source == source
+      source = new_source
+    end
+  end
+
+  def _investigate(cop, processed_source)
+    forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
+      next unless cop.join_force?(klass)
+      instances << klass.new([cop])
+    end
+
+    commissioner =
+      RuboCop::Cop::Commissioner.new([cop], forces, raise_error: true)
+    commissioner.investigate(processed_source)
+    commissioner
+  end
+end
+
+module RuboCop
+  module Cop
+    # Monkey-patch Cop for tests to provide easy access to messages and
+    # highlights.
+    class Cop
+      def messages
+        offenses.sort.map(&:message)
+      end
+
+      def highlights
+        offenses.sort.map { |o| o.location.source }
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CopHelper
+end

data/rubocop-i18n.gemspec

@@ -4,13 +4,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "rubocop-i18n"
-  spec.version       = '0.0.1'
-  spec.authors       = ["Brandon High"]
-  spec.email         = ["brandon.high@puppet.com"]
+  spec.version       = '1.0.0'
+  spec.authors       = ["Brandon High", "TP Honey", "Helen Campbell"]
+  spec.email         = ["brandon.high@puppet.com", "tp@puppet.com", "helen@puppet.com"]
 
   spec.summary       = %q{RuboCop rules for i18n}
   spec.description   = %q{RuboCop rules for detecting and autocorrecting undecorated strings for i18n}
-  spec.homepage      = "https://github.com/highb/rubocop-i18n"
+  spec.homepage      = "https://github.com/puppetlabs/rubocop-i18n"
   spec.license       = 'Apache-2'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rb-readline"
   spec.add_development_dependency "pry"
   spec.add_runtime_dependency "rubocop", "~> 0.49"
 end

metadata

@@ -1,14 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-i18n
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Brandon High
+- TP Honey
+- Helen Campbell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-11 00:00:00.000000000 Z
+date: 2017-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +54,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rb-readline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -84,14 +100,16 @@ description: RuboCop rules for detecting and autocorrecting undecorated strings
   i18n
 email:
 - brandon.high@puppet.com
+- tp@puppet.com
+- helen@puppet.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -102,8 +120,9 @@ files:
 - lib/rubocop/cop/i18n/gettext.rb
 - lib/rubocop/cop/i18n/gettext/decorate_function_message.rb
 - lib/rubocop/cop/i18n/gettext/decorate_string.rb
+- lib/rubocop/rspec/cop_helper.rb
 - rubocop-i18n.gemspec
-homepage: https://github.com/highb/rubocop-i18n
+homepage: https://github.com/puppetlabs/rubocop-i18n
 licenses:
 - Apache-2
 metadata: {}

data/Gemfile.lock

@@ -1,60 +0,0 @@
-PATH
-  remote: .
-  specs:
-    rubocop-i18n (0.0.1)
-      rubocop (~> 0.49)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.3.0)
-    coderay (1.1.1)
-    diff-lcs (1.3)
-    method_source (0.8.2)
-    parallel (1.12.0)
-    parser (2.4.0.0)
-      ast (~> 2.2)
-    powerpack (0.1.1)
-    pry (0.10.4)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rainbow (2.2.2)
-      rake
-    rake (10.5.0)
-    rspec (3.6.0)
-      rspec-core (~> 3.6.0)
-      rspec-expectations (~> 3.6.0)
-      rspec-mocks (~> 3.6.0)
-    rspec-core (3.6.0)
-      rspec-support (~> 3.6.0)
-    rspec-expectations (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-mocks (3.6.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-support (3.6.0)
-    rubocop (0.49.1)
-      parallel (~> 1.10)
-      parser (>= 2.3.3.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 1.99.1, < 3.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.8.1)
-    slop (3.6.0)
-    unicode-display_width (1.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.14)
-  pry
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  rubocop-i18n!
-
-BUNDLED WITH
-   1.14.6