i18n_linter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 546355f63e25c1190ee40b9754f0c4da3c975eae482294e7e6cdf5d05ac6adf8
+  data.tar.gz: 5c67c90c7145f8cad0be840c4f612532f01a724a2152b702d15479e741e1425c
+SHA512:
+  metadata.gz: 22ed44d204dbfa491c700496ee972863baac3cd6c5aacc6f30f6d2276e052adb4fdb68717e763a3cd82f3fd3c786d582562644e3e0a33447ce7a5ea891209a88
+  data.tar.gz: 9c926cc219f5e2ffe66104c74db113abcd2b8f017a3e1bf1f5e1abe9ee4f369efaeeced79a5724c2265bd1a901a60e9dcd0dd6484490515a34041c563338b7dd

data/README.md

@@ -0,0 +1,95 @@
+# I18nLinter
+
+[![CircleCI](https://circleci.com/gh/rootstrap/i18n_linter/tree/master.svg?style=svg&circle-token=15c1ee79b304665b14e47e04dc7577c715de293c)](https://circleci.com/gh/rootstrap/i18n_linter/tree/master)
+[![Maintainability](https://api.codeclimate.com/v1/badges/50f3ec30e8147c3df712/maintainability)](https://codeclimate.com/repos/5c6b0bbdd561465d35008579/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/50f3ec30e8147c3df712/test_coverage)](https://codeclimate.com/repos/5c6b0bbdd561465d35008579/test_coverage)
+
+Internationalization linter for your Ruby on Rails projects.
+
+## Installation
+All you have to do is run the following command:
+```bash
+$ gem install i18n_linter
+```
+If you want to install using `bundler`, add this to the `Gemfile` under the `development` group:
+```ruby
+gem 'i18n_linter', require: false
+```
+
+## Usage
+Just type `i18n_linter` in a Ruby on Rails project's folder and watch the strings that could be internationalized. Note: only strings in ruby files will be reported.
+```
+$ cd my/ruby_on_rails/project
+$ i18n_linter [options]
+```
+
+## Options
+The available options are:
+```
+-f PATTERN, --files=PATTERN     Pattern to find files, default: -f '**/*.rb'
+-o FILE, --out=FILE,            Write output to a file instead of STDOUT
+```
+
+For example:
+
+```
+$ i18n_linter -f users_controller.rb
+```
+```
+$ i18n_linter -f app/controllers/**/*.rb -o i18n_linter_output.txt
+```
+
+## Configuration
+The behavior of I18nLinter can be controlled via the `.i18n_linter.yml` configuration file.
+It's possible to enable or disable Rules and exclude files from the validations as follows:
+```ruby
+Linter:
+  Include:
+    - '**/*.rb'
+  Exclude:
+    - 'spec/**/*'
+Rules:
+  Uppercase:
+    Enabled: true
+  MiddleSpace:
+    Enabled: false
+```
+
+## Example
+Imagine a source file sample.rb containing:
+```ruby
+class UserController < ApplicationController
+  rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+  def show
+    @user = User.find(params[:id])
+  end
+
+  private
+
+  def render_not_found
+    render json: { error: "Couldn't find the record" }, status: :not_found
+  end
+end
+```
+I18nLinter will return the following warnings in this file:
+```
+$ i18n_linter -f sample.rb
+
+sample.rb:11:26
+10:    def render_not_found
+11:      render json: { error: "Couldn't find the record" }, status: :not_found
+12:    end
+----------------
+```
+
+## Contributing
+Bug reports (please use Issues) and pull requests are welcome on GitHub at https://github.com/rootstrap/i18n_linter. 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.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Credits
+**I18nLinter** is maintained by [Rootstrap](http://www.rootstrap.com) with the help of our [contributors](https://github.com/rootstrap/i18n_linter/contributors).
+
+[<img src="https://s3-us-west-1.amazonaws.com/rootstrap.com/img/rs.png" width="100"/>](http://www.rootstrap.com)

data/config/default.yml

@@ -0,0 +1,36 @@
+Linter:
+  Include:
+    - '**/*.rb'
+  Exclude:
+    - 'config/**/*'
+    - 'spec/**/*'
+    - 'db/**/*'
+Rules:
+  ClassName:
+    Enabled: true
+  Constant:
+    Enabled: true
+  EnvironmentVariable:
+    Enabled: true
+  HttpHeaders:
+    Enabled: true
+  Logger:
+    Enabled: true
+  MiddleSpace:
+    Enabled: true
+  MimeType:
+    Enabled: true
+  Puts:
+    Enabled: true
+  Query:
+    Enabled: true
+  RegExp:
+    Enabled: true
+  Scope:
+    Enabled: true
+  Strftime:
+    Enabled: true
+  Underscore:
+    Enabled: true
+  Words:
+    Enabled: true

data/exe/i18n_linter

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'i18n_linter'
+require 'i18n_linter/version'
+require 'i18n_linter/runner'
+require 'i18n_linter/options'
+require 'i18n_linter/config'
+require 'optparse'
+
+Version = I18nLinter::VERSION
+
+config = I18nLinter::Config.new
+options = I18nLinter::Options.new(config)
+
+opt = OptionParser.new
+opt.banner = 'Usage: i18n_linter'
+opt.on('-f PATTERN', '--files=PATTERN', "Pattern to find files, default: -f '**/*.rb'") do |pattern|
+  options.files = [pattern]
+end
+opt.on('-o FILE', '--out=FILE', 'Write output to a file instead of STDOUT') do |file|
+  options.out_file = file
+end
+
+opt.parse!
+
+runner = I18nLinter::Runner.new(options, config)
+ret = runner.run
+exit(ret)

data/lib/i18n_linter/config.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module I18nLinter
+  class Config
+    DOTFILE = '.i18n_linter.yml'
+    I18N_LINTER_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+    DEFAULT_FILE = File.join(I18N_LINTER_HOME, 'config', 'default.yml')
+
+    def initialize
+      path = File.exist?(DOTFILE) ? DOTFILE : DEFAULT_FILE
+      @hash = load_yaml_configuration(path)
+      add_missing_rules(@hash['Rules'])
+    end
+
+    def patterns_to_include
+      linter_patterns['Include'] || []
+    end
+
+    def patterns_to_exclude
+      linter_patterns['Exclude'] || []
+    end
+
+    def enabled_positive_rules
+      all_rules.keys.select { |rule| positive_rule?(rule) && enabled_rule?(rule) }
+    end
+
+    def enabled_negative_rules
+      all_rules.keys.select { |rule| negative_rule?(rule) && enabled_rule?(rule) }
+    end
+
+    private
+
+    def [](key)
+      @hash[key]
+    end
+
+    def linter_patterns
+      @linter_patterns ||= self['Linter'] || {}
+    end
+
+    def all_rules
+      @all_rules ||= self['Rules'] || {}
+    end
+
+    def enabled_rule?(rule)
+      all_rules[rule]['Enabled']
+    end
+
+    def positive_rule?(rule)
+      Rules::POSITIVE_RULES.include?(rule)
+    end
+
+    def negative_rule?(rule)
+      Rules::NEGATIVE_RULES.include?(rule)
+    end
+
+    def load_yaml_configuration(path)
+      yaml_code = File.read(path)
+      hash = YAML.safe_load(yaml_code, [Regexp, Symbol], [], false, path) || {}
+
+      raise(TypeError, "Malformed configuration in #{path}") unless hash.is_a?(Hash)
+
+      hash
+    end
+
+    def add_missing_rules(loaded_rules)
+      missing = (Rules::POSITIVE_RULES + Rules::NEGATIVE_RULES) - loaded_rules.keys
+      missing.each do |rule|
+        loaded_rules.store(rule, 'Enabled' => true)
+      end
+    end
+  end
+end

data/lib/i18n_linter/constants.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class Constants
+    HTTP_HEADERS = %w[
+      Accept
+      Accept-Charset
+      Accept-Encoding
+      Accept-Language
+      Accept-Ranges
+      Access-Control-Allow-Credentials
+      Access-Control-Allow-Headers
+      Access-Control-Allow-Methods
+      Access-Control-Allow-Origin
+      Access-Control-Expose-Headers
+      Access-Control-Max-Age
+      Access-Control-Request-Headers
+      Access-Control-Request-Method
+      Age
+      Allow
+      Alt-Svc
+      Authorization
+      Cache-Control
+      Clear-Site-Data
+      Connection
+      Content-Disposition
+      Content-Encoding
+      Content-Language
+      Content-Length
+      Content-Location
+      Content-Range
+      Content-Security-Policy
+      Content-Security-Policy-Report-Only
+      Content-Type
+      Cookie
+      Cookie2
+      DNT
+      Date
+      ETag
+      Early-Data
+      Expect
+      Expect-CT
+      Expires
+      Feature-Policy
+      Forwarded
+      From
+      Host
+      If-Match
+      If-Modified-Since
+      If-None-Match
+      If-Range
+      If-Unmodified-Since
+      Index
+      Keep-Alive
+      Large-Allocation
+      Last-Modified
+      Location
+      Origin
+      Pragma
+      Proxy-Authenticate
+      Proxy-Authorization
+      Public-Key-Pins
+      Public-Key-Pins-Report-Only
+      Range
+      Referer
+      Referrer-Policy
+      Retry-After
+      Sec-WebSocket-Accept
+      Server
+      Server-Timing
+      Set-Cookie
+      Set-Cookie2
+      SourceMap
+      Strict-Transport-Security
+      TE
+      Timing-Allow-Origin
+      Tk
+      Trailer
+      Transfer-Encoding
+      Upgrade-Insecure-Requests
+      User-Agent
+      Vary
+      Via
+      WWW-Authenticate
+      Warning
+      X-Content-Type-Options
+      X-DNS-Prefetch-Control
+      X-Forwarded-For
+      X-Forwarded-Host
+      X-Forwarded-Proto
+      X-Frame-Options
+      X-XSS-Protection
+    ].freeze
+
+    QUERY_METHODS = %w[
+      annotate find find_by create_with distinct eager_load extending extract_associated from group
+      having includes joins left_outer_joins limit lock none offset optimizer_hints order
+      preload readonly references reorder reselect reverse_order select where
+    ].freeze
+  end
+end

data/lib/i18n_linter/helpers/digger.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class Digger
+    def initialize(type)
+      @type = type
+    end
+
+    def find(targets, tree)
+      return false unless tree.is_a? Array
+      return true if target_found?(targets, tree)
+
+      tree.each do |item|
+        return true if find(targets, item)
+      end
+      false
+    end
+
+    def target_found?(targets, tree)
+      matches_type?(tree[0]) && matches_target?(tree[1], targets)
+    end
+
+    def matches_type?(item)
+      item == @type
+    end
+
+    def matches_target?(item, targets)
+      targets.include?(item)
+    end
+  end
+end

data/lib/i18n_linter/linter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'i18n_linter'
+require 'colorize'
+
+module I18nLinter
+  class Linter
+    def initialize(options, config)
+      @options = options
+      @config = config
+      @strings = []
+    end
+
+    def lint(filename:, file:)
+      parsed_file = tokenize_file(filename, file)
+      find_strings(filename, parsed_file)
+      compile(filename)
+    end
+
+    def show_errors(results)
+      puts
+      results.each do |result|
+        file = File.readlines(result.filename)
+        line = result.line
+        print_block(result, file, line)
+      end
+      puts
+    end
+
+    private
+
+    def tokenize_file(filename, file)
+      Ripper.sexp(file, filename)
+    end
+
+    def get_token(file, index)
+      file[index]
+    end
+
+    def get_string_array(file, current_index)
+      rest_of_file(file, current_index).take_while { |token|
+        !%i[on_tstring_end on_label_end].include?(token.type)
+      }.map(&:content)
+    end
+
+    def rest_of_file(file, current_index)
+      file.last(file.length - current_index)
+    end
+
+    def find_strings(filename, tokens)
+      return unless array?(tokens)
+
+      if array?(tokens[0])
+        tokens.each { |child| find_strings(filename, child) }
+      else
+        check_rules(filename, tokens)
+      end
+    end
+
+    def check_rules(filename, tokens)
+      if string_element?(tokens)
+        string = tokens[1]
+        @strings << StringLine.new(tokens[2], string) if Rules.check_string_rules(@config, string)
+      else
+        test_rules(filename, tokens)
+      end
+    end
+
+    def array?(elem)
+      elem.class == Array
+    end
+
+    def string_element?(elem)
+      elem[0] == :@tstring_content
+    end
+
+    def compile(filename)
+      result_set = ResultSet.new
+      @strings.each do |string_line|
+        result_set.add_result(Result.new(filename, string_line, string_line.string))
+      end
+      @strings = []
+      result_set
+    end
+
+    def test_rules(filename, tokens)
+      return if tokens.empty? || Rules.check_negative_rules(@config, tokens)
+
+      check_rest_of_tokens(filename, tokens)
+    end
+
+    def check_rest_of_tokens(filename, tokens)
+      tokens[1..-1].each { |child| find_strings(filename, child) }
+    end
+
+    def print_block(result, file, line)
+      line_number = line.line_number
+      column_number = line.column_number
+
+      previous_line = file[line_number - 2] if line_number > 2
+      current_line = file[line_number - 1]
+      next_line = file[line_number] if line_number < file.length
+
+      output = "#{result.filename}:#{line_number}:#{column_number}\n".colorize(:green)
+      output += "#{line_number - 1}:  #{previous_line}" if previous_line
+      output += "#{line_number}:  #{current_line}".colorize(:yellow)
+      output += "#{line_number + 1}:  #{next_line}" if next_line
+
+      puts output
+    end
+  end
+end

data/lib/i18n_linter/options.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class Options
+    attr_writer :files
+    attr_accessor :out_file
+
+    def initialize(config)
+      @config = config
+    end
+
+    def files
+      return Dir[*@files].uniq.sort if @files
+
+      supported_files.sort
+    end
+
+    private
+
+    def supported_files
+      (Dir.glob(@config.patterns_to_include, 0) - Dir.glob(@config.patterns_to_exclude, 0)).uniq
+    end
+  end
+end

data/lib/i18n_linter/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class Result
+    attr_reader :filename
+    attr_reader :line
+    attr_reader :string
+
+    def initialize(filename, line, string)
+      @filename = filename
+      @line = line
+      @string = string
+    end
+  end
+end

data/lib/i18n_linter/result_set.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class ResultSet
+    include Enumerable
+
+    def initialize
+      @results = []
+    end
+
+    def add_result(result)
+      @results << result
+    end
+
+    def each
+      @results.each do |result|
+        yield result
+      end
+    end
+
+    def success?
+      count.zero?
+    end
+  end
+end

data/lib/i18n_linter/rules/class_name.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class ClassName
+      CLASS_NAME_LABEL = 'class_name:'
+
+      def check(tokens)
+        tokens[0] == :assoc_new &&
+          I18nLinter::Digger.new(:@label).find([CLASS_NAME_LABEL], tokens[1])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/constant.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Constant
+      def check(tokens)
+        tokens[0] == :assign && constant_assign(tokens)
+      end
+
+      private
+
+      def constant_assign(tokens)
+        assign_tokens = tokens[1]
+        assign_tokens[0] == :var_field && assign_tokens[1][0] == :@const
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/environment_variable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class EnvironmentVariable
+      ENV_CONST = 'ENV'
+
+      def check(tokens)
+        reference_or_method(tokens) && I18nLinter::Digger.new(:@const).find([ENV_CONST], tokens[1])
+      end
+
+      private
+
+      def reference_or_method(tokens)
+        %i[aref method_add_arg].include?(tokens[0])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/http_headers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class HttpHeaders
+      def check(tokens)
+        tokens[0] == :assoc_new && literal_or_symbol(tokens)
+      end
+
+      private
+
+      def literal_or_symbol(tokens)
+        literal_symbol_tokens = tokens[1]
+        (literal(literal_symbol_tokens) || symbol(literal_symbol_tokens)) &&
+          string_content(literal_symbol_tokens)
+      end
+
+      def literal(tokens)
+        tokens[0] == :string_literal
+      end
+
+      def symbol(tokens)
+        tokens[0] == :dyna_symbol
+      end
+
+      def string_content(tokens)
+        content_tokens = tokens[1]
+        content_tokens[0] == :string_content && header_string(content_tokens)
+      end
+
+      def header_string(tokens)
+        header_tokens = tokens[1]
+        header_tokens[0] == :@tstring_content && http_header(header_tokens)
+      end
+
+      def http_header(tokens)
+        string = tokens[1].downcase
+        I18nLinter::Constants::HTTP_HEADERS.map(&:downcase).any? do |header|
+          string.include?(header)
+        end
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/logger.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Logger
+      LOGGER_IDENT = 'logger'
+
+      def check(tokens)
+        command_or_method(tokens) && I18nLinter::Digger.new(:@ident).find([LOGGER_IDENT], tokens[1])
+      end
+
+      private
+
+      def command_or_method(tokens)
+        %i[command_call method_add_block method_add_arg].include?(tokens[0])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/middle_space.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class MiddleSpace
+      def check(string)
+        /.\s+./ =~ string
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/mime_type.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'mime/types'
+
+module I18nLinter
+  module Rules
+    class MimeType
+      def check(tokens)
+        tokens[0] == :string_content && mime_type?(tokens)
+      end
+
+      private
+
+      def mime_type?(tokens)
+        string_tokens = tokens[1]
+        return false unless string_tokens
+
+        string_tokens[0] == :@tstring_content && check_mime_types(string_tokens)
+      end
+
+      def check_mime_types(tokens)
+        string = tokens[1]
+        MIME::Types.any? { |mime| string.include?(mime) }
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/puts.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Puts
+      PUTS_IDENT = 'puts'
+
+      def check(tokens)
+        command_or_method(tokens) && I18nLinter::Digger.new(:@ident).find([PUTS_IDENT], tokens[1])
+      end
+
+      private
+
+      def command_or_method(tokens)
+        %i[command method_add_arg].include?(tokens[0])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/query.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Query
+      def check(tokens)
+        tokens[0] == :method_add_arg &&
+          I18nLinter::Digger.new(:@ident).find(I18nLinter::Constants::QUERY_METHODS, tokens[1])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/reg_exp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class RegExp
+      def check(tokens)
+        tokens[0] == :regexp_literal
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/scope.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Scope
+      SCOPE_IDENT = 'scope'
+
+      def check(tokens)
+        tokens[0] == :command && I18nLinter::Digger.new(:@ident).find([SCOPE_IDENT], tokens[1])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/strftime.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Strftime
+      STRFTIME_IDENT = 'strftime'
+
+      def check(tokens)
+        tokens[0] == :method_add_arg &&
+          I18nLinter::Digger.new(:@ident).find([STRFTIME_IDENT], tokens[1])
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/underscore.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Underscore
+      def check(tokens)
+        tokens[0] == :string_content && underscore?(tokens)
+      end
+
+      private
+
+      def underscore?(tokens)
+        string_tokens = tokens[1]
+        return false unless string_tokens
+
+        string_tokens[0] == :@tstring_content && /\_/ =~ string_tokens[1]
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules/words.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    class Words
+      def check(string)
+        /^[A-Z].*[a-z]/ =~ string.strip
+      end
+    end
+  end
+end

data/lib/i18n_linter/rules.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  module Rules
+    POSITIVE_RULES = %w[MiddleSpace Words].freeze
+    # Rules that filter the strings found
+    NEGATIVE_RULES = %w[
+      ClassName Constant EnvironmentVariable HttpHeaders
+      Logger MimeType Puts Query RegExp Scope Strftime Underscore
+    ].freeze
+
+    class << self
+      def check_rule(rule, string_or_tokens)
+        Kernel.const_get("I18nLinter::Rules::#{rule}").new.check(string_or_tokens)
+      end
+
+      def check_positive_rules(config, string)
+        config.enabled_positive_rules.any? { |rule| Rules.check_rule(rule, string) }
+      end
+
+      def check_negative_rules(config, tokens)
+        config.enabled_negative_rules.any? { |rule| Rules.check_rule(rule, tokens) }
+      end
+
+      def check_string_rules(config, string)
+        check_positive_rules(config, string)
+      end
+    end
+  end
+end

data/lib/i18n_linter/runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'i18n_linter/linter'
+require 'i18n_linter/options'
+require 'i18n_linter/config'
+
+module I18nLinter
+  class Runner
+    def initialize(options, config)
+      @options = options
+      @linter = I18nLinter.linter.new(options, config)
+    end
+
+    def run
+      $stdout = StringIO.new
+
+      result = @options.files.map { |file|
+        lint_result = lint(file)
+        if lint_result.success?
+          true
+        else
+          @linter.show_errors(lint_result)
+          false
+        end
+      }.all?
+
+      handle_results
+
+      $stdout = STDOUT
+
+      result
+    end
+
+    private
+
+    def handle_results
+      output_file = @options.out_file
+      output = $stdout.string
+
+      if output_file
+        File.open(output_file, 'w') do |file|
+          file.write output
+        end
+      else
+        STDOUT.puts output
+      end
+    end
+
+    def lint(filename)
+      file = File.read(filename)
+      @linter.lint(filename: filename, file: file)
+    end
+  end
+end

data/lib/i18n_linter/string_line.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class StringLine
+    attr_reader :line_number
+    attr_reader :column_number
+    attr_reader :string
+
+    def initialize(coords, string)
+      @line_number = coords[0]
+      @column_number = coords[1]
+      @string = string
+    end
+  end
+end

data/lib/i18n_linter/token.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  class Token
+    attr_reader :coords
+    attr_reader :type
+    attr_reader :content
+
+    def initialize(token)
+      @coords = token[0]
+      @type = token[1]
+      @content = token[2]
+    end
+  end
+end

data/lib/i18n_linter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module I18nLinter
+  VERSION = '0.1.0'
+end

data/lib/i18n_linter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'i18n_linter/linter'
+
+require 'i18n_linter/rules'
+require 'i18n_linter/rules/middle_space'
+require 'i18n_linter/rules/words'
+require 'i18n_linter/rules/environment_variable'
+require 'i18n_linter/rules/class_name'
+require 'i18n_linter/rules/constant'
+require 'i18n_linter/rules/logger'
+require 'i18n_linter/rules/puts'
+require 'i18n_linter/rules/scope'
+require 'i18n_linter/rules/strftime'
+require 'i18n_linter/rules/http_headers'
+require 'i18n_linter/rules/underscore'
+require 'i18n_linter/rules/reg_exp'
+require 'i18n_linter/rules/query'
+require 'i18n_linter/rules/mime_type'
+
+require 'i18n_linter/helpers/digger'
+require 'i18n_linter/options'
+require 'i18n_linter/constants'
+require 'i18n_linter/result'
+require 'i18n_linter/token'
+require 'i18n_linter/result_set'
+require 'i18n_linter/string_line'
+
+require 'ripper'
+
+module I18nLinter
+  class << self
+    def linter
+      ::I18nLinter::Linter
+    end
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: i18n_linter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Franco Pariani
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+description: i18n linter plugin
+email: franco@rootstrap.com
+executables:
+- i18n_linter
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- config/default.yml
+- exe/i18n_linter
+- lib/i18n_linter.rb
+- lib/i18n_linter/config.rb
+- lib/i18n_linter/constants.rb
+- lib/i18n_linter/helpers/digger.rb
+- lib/i18n_linter/linter.rb
+- lib/i18n_linter/options.rb
+- lib/i18n_linter/result.rb
+- lib/i18n_linter/result_set.rb
+- lib/i18n_linter/rules.rb
+- lib/i18n_linter/rules/class_name.rb
+- lib/i18n_linter/rules/constant.rb
+- lib/i18n_linter/rules/environment_variable.rb
+- lib/i18n_linter/rules/http_headers.rb
+- lib/i18n_linter/rules/logger.rb
+- lib/i18n_linter/rules/middle_space.rb
+- lib/i18n_linter/rules/mime_type.rb
+- lib/i18n_linter/rules/puts.rb
+- lib/i18n_linter/rules/query.rb
+- lib/i18n_linter/rules/reg_exp.rb
+- lib/i18n_linter/rules/scope.rb
+- lib/i18n_linter/rules/strftime.rb
+- lib/i18n_linter/rules/underscore.rb
+- lib/i18n_linter/rules/words.rb
+- lib/i18n_linter/runner.rb
+- lib/i18n_linter/string_line.rb
+- lib/i18n_linter/token.rb
+- lib/i18n_linter/version.rb
+homepage: http://rubygems.org/gems/i18n_linter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: i18n linter plugin
+test_files: []