i18n-tasks 0.7.13 → 0.8.0

data/lib/i18n/tasks/command/option_parsers/enum.rb

@@ -0,0 +1,53 @@
+module I18n::Tasks
+  module Command
+    module OptionParsers
+      module Enum
+        class Parser
+          DEFAULT_ERROR = proc { |invalid, valid|
+            I18n.t('i18n_tasks.cmd.enum_opt.invalid', invalid: invalid, valid: valid * ', ')
+          }
+
+          def initialize(valid, error_message = DEFAULT_ERROR)
+            @valid         = valid.map(&:to_s)
+            @error_message = error_message
+          end
+
+          def call(value, *)
+            return @valid.first unless value.present?
+            if @valid.include?(value)
+              value
+            else
+              raise CommandError.new @error_message.call(value, @valid)
+            end
+          end
+        end
+
+        class ListParser
+          DEFAULT_ERROR = proc { |invalid, valid|
+            I18n.t('i18n_tasks.cmd.enum_list_opt.invalid', invalid: invalid * ', ', valid: valid * ', ')
+          }
+
+          def initialize(valid, error_message = DEFAULT_ERROR)
+            @valid         = valid.map(&:to_s)
+            @error_message = error_message
+          end
+
+          def call(values, *)
+            values = Array(values)
+            return @valid if values == %w(all)
+            invalid = values - @valid
+            if invalid.empty?
+              if values.empty?
+                @valid
+              else
+                values
+              end
+            else
+              raise CommandError.new @error_message.call(invalid, @valid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/option_parsers/locale.rb

@@ -0,0 +1,48 @@
+module I18n::Tasks
+  module Command
+    module OptionParsers
+      module Locale
+        module Validator
+          VALID_LOCALE_RE = /\A\w[\w\-\.]*\z/i
+
+          def validate!(locale)
+            if VALID_LOCALE_RE !~ locale
+              raise CommandError.new(I18n.t('i18n_tasks.cmd.errors.invalid_locale', invalid: locale))
+            end
+            locale
+          end
+        end
+
+        module Parser
+          module_function
+          extend Validator
+
+          # @param [#base_locale, #locales] context
+          def call(val, context)
+            if val.blank? || val == 'base'
+              context.base_locale
+            else
+              validate! val
+            end
+          end
+        end
+
+        module ListParser
+          module_function
+          extend Validator
+
+          # @param [#base_locale,#locales] context
+          def call(vals, context)
+            if vals == %w(all) || vals.blank?
+              context.locales
+            else
+              vals.map { |v| v == 'base' ? context.base_locale : v }
+            end.tap do |locales|
+              locales.each { |locale| validate! locale }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/options/common.rb

@@ -1,46 +1,36 @@
-require 'i18n/tasks/command/options/enum_opt'
-require 'i18n/tasks/command/options/list_opt'
 
 module I18n::Tasks
   module Command
     module Options
       module Common
         include Command::DSL
-        include Options::EnumOpt
-        include Options::ListOpt
 
-        VALID_LOCALE_RE = /\A\w[\w\-\.]*\z/i
+        arg :nostdin,
+            '-S',
+            '--nostdin',
+            t('i18n_tasks.cmd.args.desc.nostdin')
 
-        cmd_opt :nostdin, {
-            short: :S,
-            long:  :nostdin,
-            desc:  t('i18n_tasks.cmd.args.desc.nostdin'),
-            conf:  {default: false}
-        }
+        arg :confirm,
+            '-y',
+            '--confirm',
+            desc: t('i18n_tasks.cmd.args.desc.confirm')
 
-        cmd_opt :confirm, {
-            short: :y,
-            long:  :confirm,
-            desc:  t('i18n_tasks.cmd.args.desc.confirm'),
-            conf:  {default: false}
-        }
+        arg :pattern,
+            '-p',
+            '--pattern PATTERN',
+            t('i18n_tasks.cmd.args.desc.key_pattern')
 
-        cmd_opt :pattern, {
-            short: :p,
-            long:  :pattern=,
-            desc:  t('i18n_tasks.cmd.args.desc.key_pattern'),
-            conf:  {argument: true, optional: false}
-        }
+        arg :value,
+            '-v',
+            '--value VALUE',
+            t('i18n_tasks.cmd.args.desc.value')
 
-        cmd_opt :value, {
-            short: :v,
-            long:  :value=,
-            desc:  t('i18n_tasks.cmd.args.desc.value'),
-            conf:  {argument: true, optional: false}
-        }
+        def arg_or_pos!(key, opts)
+          opts[key] ||= opts[:arguments].try(:shift)
+        end
 
-        def opt_or_arg!(key, opt)
-          opt[key] ||= opt[:arguments].try(:shift)
+        def pos_or_stdin!(opts)
+          opts[:arguments].try(:shift) || $stdin.read
         end
       end
     end

data/lib/i18n/tasks/command/options/data.rb

@@ -0,0 +1,91 @@
+require 'i18n/tasks/command/option_parsers/enum'
+
+module I18n::Tasks
+  module Command
+    module Options
+      module Data
+        include Command::DSL
+
+        DATA_FORMATS = %w(yaml json keys)
+        OUT_FORMATS  = ['terminal-table', *DATA_FORMATS, 'inspect']
+
+        format_arg = proc { |type, values|
+          default = values.first
+          arg type,
+              '-f',
+              '--format FORMAT',
+              values,
+              {'yml' => 'yaml'},
+              t("i18n_tasks.cmd.args.desc.#{type}", valid_text: values * ', ', default_text: default),
+              parser: OptionParsers::Enum::Parser.new(values,
+                                                     proc { |value, valid|
+                                                       I18n.t('i18n_tasks.cmd.errors.invalid_format',
+                                                              invalid: value, valid: valid * ', ') })
+        }
+
+        # i18n-tasks-use t('i18n_tasks.cmd.args.desc.data_format')
+        format_arg.call(:data_format, DATA_FORMATS)
+
+        # i18n-tasks-use t('i18n_tasks.cmd.args.desc.out_format')
+        format_arg.call(:out_format, OUT_FORMATS)
+
+        def forest_pos_or_stdin!(opt, format = opt[:format])
+          parse_forest(pos_or_stdin!(opt), format)
+        end
+
+        # @return [Array<I18n::Tasks::Data::Tree::Siblings>] trees read from stdin and positional arguments
+        def forests_stdin_and_pos!(opt, num = false, format = opt[:format])
+          args = opt[:arguments] || []
+          if opt[:nostdin]
+            sources = []
+          else
+            sources = [$stdin.read]
+            num     -= 1 if num
+          end
+          if num
+            num.times { sources << args.shift }
+          else
+            sources += args
+            args.clear
+          end
+          sources.map { |src| parse_forest(src, format) }
+        end
+
+        def merge_forests_stdin_and_pos!(opt)
+          forests_stdin_and_pos!(opt).inject(i18n.empty_forest) { |result, forest|
+            result.merge! forest
+          }
+        end
+
+        def parse_forest(src, format)
+          if !src
+            raise CommandError.new(I18n.t('i18n_tasks.cmd.errors.pass_forest'))
+          end
+          if format == 'keys'
+            ::I18n::Tasks::Data::Tree::Siblings.from_key_names parse_keys(src)
+          else
+            ::I18n::Tasks::Data::Tree::Siblings.from_nested_hash i18n.data.adapter_parse(src, format)
+          end
+        end
+
+        def parse_keys(src)
+          Array(src).compact.flat_map { |v| v.strip.split(/\s*[,\s\n]\s*/) }.map(&:presence).compact
+        end
+
+        def print_forest(forest, opts, version = :show_tree)
+          format = opts[:format].to_s
+          case format
+            when 'terminal-table'
+              terminal_report.send(version, forest)
+            when 'inspect'
+              puts forest.inspect
+            when 'keys'
+              puts forest.key_names(root: true)
+            when *DATA_FORMATS
+              puts i18n.data.adapter_dump forest.to_hash(true), format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/tasks/command/options/locales.rb

@@ -1,53 +1,33 @@
+require 'i18n/tasks/command/option_parsers/locale'
+
 module I18n::Tasks
   module Command
     module Options
       module Locales
         include Command::DSL
 
-        cmd_opt :locales, {
-            short: :l,
-            long:  :locales=,
-            desc:  t('i18n_tasks.cmd.args.desc.locales_filter'),
-            conf:  {as: Array, delimiter: /\s*[+:,]\s*/, default: 'all', argument: true, optional: false},
-            parse: :parse_locales
-        }
-
-        cmd_opt :locale, {
-            short: :l,
-            long:  :locale=,
-            desc:  t('i18n_tasks.cmd.args.desc.locale'),
-            conf:  {default: 'base', argument: true, optional: false},
-            parse: :parse_locale
-        }
-
-        cmd_opt :locale_to_translate_from, cmd_opt(:locale).merge(
-            short: :f,
-            long: :from=,
-            desc: t('i18n_tasks.cmd.args.desc.locale_to_translate_from'))
-
-        def parse_locales(opt, key = :locales)
-          argv    = Array(opt[:arguments]) + Array(opt[key])
-          locales = if argv == ['all'] || argv == 'all' || argv.blank?
-                      i18n.locales
-                    else
-                      explode_list_opt(argv).map { |v| v == 'base' ? base_locale : v }
-                    end
-          locales.each { |locale| validate_locale!(locale) }
-          log_verbose "locales for the command are #{locales.inspect}"
-          opt[key] = locales
-        end
+        arg :locales,
+            '-l',
+            '--locales en,es,ru',
+            Array,
+            t('i18n_tasks.cmd.args.desc.locales_filter'),
+            parser:             OptionParsers::Locale::ListParser,
+            default:            'all',
+            consume_positional: true
 
-        def parse_locale(opt, key = :locale)
-          val      = opt[key]
-          opt[key] = base_locale if val.blank? || val == 'base'
-          opt[key]
-        end
+        arg :locale,
+            '-l',
+            '--locale en',
+            t('i18n_tasks.cmd.args.desc.locale'),
+            parser:  OptionParsers::Locale::Parser,
+            default: 'base'
 
-        def validate_locale!(locale)
-          if Common::VALID_LOCALE_RE !~ locale
-            raise CommandError.new(I18n.t('i18n_tasks.cmd.errors.invalid_locale', invalid: locale))
-          end
-        end
+        arg :locale_to_translate_from,
+            '-f',
+            '--from en',
+            t('i18n_tasks.cmd.args.desc.locale_to_translate_from'),
+            parser:  OptionParsers::Locale::Parser,
+            default: 'base'
       end
     end
   end

data/lib/i18n/tasks/data/file_system_base.rb

@@ -25,9 +25,9 @@ module I18n::Tasks
         locales = config[:locales].presence
         @locales = LocaleList.normalize_locale_list(locales || available_locales, base_locale, true)
         if locales.present?
-          log_verbose "data locales: #{@locales}"
+          log_verbose "locales read from config #{@locales * ', '}"
         else
-          log_verbose "data locales (inferred): #{@locales}"
+          log_verbose "locales inferred from data: #{@locales * ', '}"
         end
       end
 

data/lib/i18n/tasks/data/tree/node.rb

@@ -4,6 +4,9 @@ require 'i18n/tasks/data/tree/traversal'
 require 'i18n/tasks/data/tree/siblings'
 module I18n::Tasks::Data::Tree
   class Node
+    include Enumerable
+    include Traversal
+
     attr_accessor :value
     attr_reader :key, :children, :parent
 
@@ -42,9 +45,6 @@ module I18n::Tasks::Data::Tree
       self
     end
 
-    include Enumerable
-    include Traversal
-
     def value_or_children_hash
       leaf? ? value : children.try(:to_hash)
     end

data/lib/i18n/tasks/data/tree/nodes.rb

@@ -4,6 +4,9 @@ require 'i18n/tasks/data/tree/traversal'
 module I18n::Tasks::Data::Tree
   # A list of nodes
   class Nodes
+    include Enumerable
+    include Traversal
+
     attr_reader :list
 
     def initialize(opts = {})
@@ -11,8 +14,6 @@ module I18n::Tasks::Data::Tree
     end
 
     delegate :each, :present?, :empty?, :blank?, :size, :to_a, to: :@list
-    include Enumerable
-    include Traversal
 
     def to_nodes
       self

data/lib/i18n/tasks/data/tree/siblings.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 
-require 'i18n/tasks/data/tree/traversal'
 require 'i18n/tasks/data/tree/nodes'
 module I18n::Tasks::Data::Tree
   # Siblings represents a subtree sharing a common parent

data/lib/i18n/tasks/logging.rb

@@ -3,24 +3,28 @@ module I18n::Tasks::Logging
   extend self
 
   def warn_deprecated(message)
-    log_stderr Term::ANSIColor.yellow Term::ANSIColor.bold "i18n-tasks: [DEPRECATED] #{message}"
+    log_stderr Term::ANSIColor.yellow Term::ANSIColor.bold "#{program_name}: [DEPRECATED] #{message}"
   end
 
   def log_verbose(message)
-    if ENV['VERBOSE']
-      log_stderr Term::ANSIColor.green "i18n-tasks: #{message}"
+    if ::I18n::Tasks.verbose?
+      log_stderr Term::ANSIColor.bright_blue(message)
     end
   end
 
   def log_warn(message)
-    log_stderr Term::ANSIColor.yellow "i18n-tasks: [WARN] #{message}"
+    log_stderr Term::ANSIColor.yellow "#{program_name}: [WARN] #{message}"
   end
 
   def log_error(message)
-    log_stderr Term::ANSIColor.red Term::ANSIColor.bold "i18n-tasks: #{message}"
+    log_stderr Term::ANSIColor.red Term::ANSIColor.bold "#{program_name}: #{message}"
   end
 
   def log_stderr(*args)
     $stderr.puts(*args)
   end
+
+  def program_name
+    @program_name ||= File.basename($PROGRAM_NAME)
+  end
 end

data/lib/i18n/tasks/scanners/base_scanner.rb

@@ -10,17 +10,15 @@ module I18n::Tasks::Scanners
 
     attr_reader :config, :key_filter, :ignore_lines_res
 
+    ALWAYS_EXCLUDE = %w(*.jpg *.png *.gif *.svg *.ico *.eot *.ttf *.woff *.woff2 *.pdf
+                        *.css *.sass *.scss *.less *.yml *.json)
+
     def initialize(config = {})
       @config = config.dup.with_indifferent_access.tap do |conf|
-        conf[:relative_roots] = %w(app/views) if conf[:relative_roots].blank?
+        conf[:relative_roots] = %w(app/views app/controllers app/helpers app/presenters) if conf[:relative_roots].blank?
         conf[:paths]   = %w(app/) if conf[:paths].blank?
         conf[:include] = Array(conf[:include]) if conf[:include].present?
-        if conf.key?(:exclude)
-          conf[:exclude] = Array(conf[:exclude])
-        else
-          # exclude common binary extensions by default (images and fonts)
-          conf[:exclude] = %w(*.jpg *.png *.gif *.svg *.ico *.eot *.ttf *.woff *.woff2 *.pdf)
-        end
+        conf[:exclude] = Array(conf[:exclude]) + ALWAYS_EXCLUDE
         # Regexps for lines to ignore per extension
         if conf[:ignore_lines] && !conf[:ignore_lines].is_a?(Hash)
           warn_deprecated "search.ignore_lines must be a Hash, found #{conf[:ignore_lines].class.name}"
@@ -28,6 +26,7 @@ module I18n::Tasks::Scanners
         end
         conf[:ignore_lines] ||= {
             'rb'     => %q(^\s*#(?!\si18n-tasks-use)),
+            'opal'   => %q(^\s*#(?!\si18n-tasks-use)),
             'haml'   => %q(^\s*-\s*#(?!\si18n-tasks-use)),
             'slim'   => %q(^\s*(?:-#|/)(?!\si18n-tasks-use)),
             'coffee' => %q(^\s*#(?!\si18n-tasks-use)),