i18n-processes 0.1.0

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module Command
+    module OptionParsers
+      module Enum
+        class Parser
+          DEFAULT_ERROR = proc do |invalid, valid|
+            "#{invalid} is not one of: #{valid * ', '}."
+          end
+
+          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
+              fail CommandError, @error_message.call(value, @valid)
+            end
+          end
+        end
+
+        class ListParser
+          DEFAULT_ERROR = proc do |invalid, valid|
+            "#{invalid * ', '} is not in: #{valid * ', '}."
+          end
+
+          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
+              fail CommandError, @error_message.call(invalid, @valid)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  module Command
+    module OptionParsers
+      module Locale
+        module Validator
+          VALID_LOCALE_RE = /\A\w[\w\-\.]*\z/i
+
+          def validate!(locale)
+            if VALID_LOCALE_RE !~ locale
+              fail CommandError, "invalid locale: #{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
+              move_base_locale_to_front!(vals.map { |v| v == 'base' ? context.base_locale : v }, context.base_locale)
+            end.tap do |locales|
+              locales.each { |locale| validate! locale }
+            end
+          end
+
+          def move_base_locale_to_front!(locales, base_locale)
+            if (pos = locales.index(base_locale)) && pos.positive?
+              locales[pos], locales[0] = locales[0], locales[pos]
+            end
+            locales
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/dsl'
+
+module I18n::Processes
+  module Command
+    module Options
+      module Common
+        include Command::DSL
+
+        arg :nostdin,
+            '-S',
+            '--nostdin',
+            'Do not read from stdin'
+
+        arg :confirm,
+            '-y',
+            '--confirm',
+            desc: 'Confirm automatically'
+
+        arg :pattern,
+            '-p',
+            '--pattern PATTERN',
+            "Filter by key pattern (e.g. 'common.*')"
+
+        arg :value,
+            '-v',
+            '--value VALUE',
+            'Value. Interpolates: %{value}, %{human_key}, %{key}, %{default}, %{value_or_human_key}, %{value_or_default_or_human_key}'
+
+        def arg_or_pos!(key, opts)
+          opts[key] ||= opts[:arguments].try(:shift)
+        end
+
+        def pos_or_stdin!(opts)
+          opts[:arguments].try(:shift) || $stdin.read
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/option_parsers/enum'
+require 'i18n/processes/command/dsl'
+module I18n::Processes
+  module Command
+    module Options
+      module Data
+        include Command::DSL
+
+        DATA_FORMATS = %w[yaml json keys].freeze
+        OUT_FORMATS  = ['terminal-table', *DATA_FORMATS, 'inspect'].freeze
+
+        format_arg = proc do |type, values|
+          default = values.first
+          arg type,
+              '-f',
+              '--format FORMAT',
+              values,
+              { 'yml' => 'yaml' },
+              "#{type}: #{values * ', '}",
+              parser: OptionParsers::Enum::Parser.new(values,
+                                                      proc do |value, valid|
+                                                        "invalid format: #{value}. valid: #{valid * ', '}."
+                                                      end)
+        end
+
+        format_arg.call(:data_format, DATA_FORMATS)
+
+        format_arg.call(:out_format, OUT_FORMATS)
+
+        # @return [I18n::Processes::Data::Tree::Siblings]
+        def forest_pos_or_stdin!(opt, format = opt[:format])
+          parse_forest(pos_or_stdin!(opt), format)
+        end
+
+        # @return [Array<I18n::Processes::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) do |result, forest|
+            result.merge! forest
+          end
+        end
+
+        # @return [I18n::Processes::Data::Tree::Siblings]
+        def parse_forest(src, format)
+          fail CommandError, "pass locale forest" unless src
+          if format == 'keys'
+            ::I18n::Processes::Data::Tree::Siblings.from_key_names parse_keys(src)
+          else
+            ::I18n::Processes::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
+
+        def print_changed_keys(diff, version = :changed_keys)
+          terminal_report.send(version, diff)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/option_parsers/locale'
+require 'i18n/processes/command/dsl'
+module I18n::Processes
+  module Command
+    module Options
+      module Locales
+        include Command::DSL
+
+        arg :locales,
+            '-l',
+            '--locales en,es,ru',
+            Array,
+            'Locale(s) to process. Special: base',
+            parser:             OptionParsers::Locale::ListParser,
+            default:            'all',
+            consume_positional: true
+
+        arg :locale,
+            '-l',
+            '--locale en',
+            'i18n_processes.common.locale',
+            parser:  OptionParsers::Locale::Parser,
+            default: 'base'
+
+        arg :locale_to_translate_from,
+            '-f',
+            '--from en',
+            'Locale to translate from',
+            parser:  OptionParsers::Locale::Parser,
+            default: 'base'
+      end
+    end
+  end
+end

data/lib/i18n/processes/command_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  # When this type of error is caught:
+  # 1. show error message of the backtrace
+  # 2. exit with non-zero exit code
+  class CommandError < StandardError
+    def initialize(error = nil, message) # rubocop:disable Style/OptionalArguments
+      super(message)
+      set_backtrace error.backtrace if error
+    end
+  end
+end

data/lib/i18n/processes/commands.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'i18n/processes/command/dsl'
+require 'i18n/processes/command/collection'
+require 'i18n/processes/command/commands/health'
+require 'i18n/processes/command/commands/missing'
+require 'i18n/processes/command/commands/usages'
+require 'i18n/processes/command/commands/eq_base'
+require 'i18n/processes/command/commands/data'
+require 'i18n/processes/command/commands/tree'
+require 'i18n/processes/command/commands/meta'
+require 'i18n/processes/command/commands/xlsx'
+require 'i18n/processes/command/commands/preprocessing'
+require 'i18n/processes/command/commander'
+
+module I18n::Processes
+  class Commands < Command::Commander
+    include Command::DSL
+    include Command::Commands::Health
+    include Command::Commands::Missing
+    include Command::Commands::Usages
+    include Command::Commands::EqBase
+    include Command::Commands::Data
+    include Command::Commands::Tree
+    include Command::Commands::Meta
+    include Command::Commands::XLSX
+    include Command::Commands::Preprocessing
+
+    require 'highline/import'
+  end
+end

data/lib/i18n/processes/configuration.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module I18n::Processes::Configuration # rubocop:disable Metrics/ModuleLength
+  DEFAULTS = {
+    base_locale:     'en',
+    internal_locale: 'en',
+    search:          ::I18n::Processes::UsedKeys::SEARCH_DEFAULTS,
+    data:            ::I18n::Processes::Data::DATA_DEFAULTS
+  }.freeze
+
+  # i18n-processes config (defaults + config/i18n-processes.yml)
+  # @return [Hash{String => String,Hash,Array}]
+  def config
+    @config || (self.config = {})
+  end
+
+  CONFIG_FILES = %w[
+    config/i18n-processes.yml config/i18n-processes.yml.erb
+    i18n-processes.yml i18n-processes.yml.erb
+  ].freeze
+
+  def file_config
+    file   = CONFIG_FILES.detect { |f| File.exist?(f) }
+    # rubocop:disable Security/Eval
+    config = file && YAML.load(eval(Erubi::Engine.new(File.read(file, encoding: 'UTF-8')).src))
+    # rubocop:enable Security/Eval
+    if config.present?
+      config.with_indifferent_access.tap do |c|
+        if c[:relative_roots]
+          warn_deprecated 'Please move relative_roots under search in config/i18n-processes.yml.'
+          c[:search][:relative_roots] = c.delete(:relative_roots)
+        end
+      end
+    else
+      {}.with_indifferent_access
+    end
+  end
+
+  def config=(conf)
+    @config = file_config.deep_merge(conf)
+    @config_sections = {}
+  end
+
+  # data config
+  #  @return [Hash<adapter: String, options: Hash>]
+  def data_config
+    @config_sections[:data] ||= begin
+      {
+        adapter: data.class.name,
+        config:  data.config
+      }
+    end
+  end
+
+  # translation config
+  # @return [Hash{String => String,Hash,Array}]
+  def translation_config
+    @config_sections[:translation] ||= begin
+      conf = (config[:translation] || {}).with_indifferent_access
+      conf[:api_key] ||= ENV['GOOGLE_TRANSLATE_API_KEY'] if ENV.key?('GOOGLE_TRANSLATE_API_KEY')
+      conf
+    end
+  end
+
+  # @return [Array<String>] all available locales, base_locale is always first
+  def locales
+    @config_sections[:locales] ||= data.locales
+  end
+
+  # @return [String] default i18n locale
+  def base_locale
+    @config_sections[:base_locale] ||= (config[:base_locale] || DEFAULTS[:base_locale]).to_s
+  end
+
+  def internal_locale
+    @config_sections[:internal_locale] ||= begin
+      internal_locale = (config[:internal_locale] || DEFAULTS[:internal_locale]).to_s
+      valid_locales = Dir[File.join(I18n::Processes.gem_path, 'config', 'locales', '*.yml')]
+                      .map { |f| File.basename(f, '.yml') }
+      unless valid_locales.first.include?(internal_locale)
+        log_warn "invalid internal_locale #{internal_locale.inspect}. "\
+                 "Available internal locales: #{valid_locales * ', '}."
+        internal_locale = DEFAULTS[:internal_locale].to_s
+      end
+      internal_locale
+    end
+  end
+
+  def ignore_config(type = nil)
+    key = type ? "ignore_#{type}" : 'ignore'
+    @config_sections[key] ||= config[key]
+  end
+
+  IGNORE_TYPES = [nil, :missing, :unused, :eq_base].freeze
+  # evaluated configuration (as the app sees it)
+  def config_sections
+    # init all sections
+    base_locale
+    internal_locale
+    locales
+    data_config
+    @config_sections[:search] ||= search_config
+    translation_config
+    IGNORE_TYPES.each do |ignore_type|
+      ignore_config ignore_type
+    end
+    @config_sections
+  end
+
+  def config_for_inspect
+    to_hash_from_indifferent(config_sections.reject { |_k, v| v.blank? }).tap do |sections|
+      sections.each_value do |section|
+        section.merge! section.delete('config') if section.is_a?(Hash) && section.key?('config')
+      end
+    end
+  end
+
+  private
+
+  def to_hash_from_indifferent(value)
+    case value
+    when Hash
+      value.stringify_keys.to_hash.tap do |h|
+        h.each { |k, v| h[k] = to_hash_from_indifferent(v) if v.is_a?(Hash) || v.is_a?(Array) }
+      end
+    when Array
+      value.map { |e| to_hash_from_indifferent e }
+    else
+      value
+    end
+  end
+end

data/lib/i18n/processes/console_context.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module I18n::Processes
+  class ConsoleContext < BaseProcess
+    def to_s
+      @to_s ||= "i18n-processes-#{I18n::Processes::VERSION}"
+    end
+
+    def banner
+      puts Messages.banner
+    end
+
+    def guide
+      puts Messages.guide
+    end
+
+    class << self
+      def start
+        require 'irb'
+        IRB.setup nil
+        ctx = IRB::Irb.new.context
+        IRB.conf[:MAIN_CONTEXT] = ctx
+        $stderr.puts Messages.banner
+        require 'irb/ext/multi-irb'
+        IRB.irb nil, new
+      end
+    end
+
+    module Messages
+      module_function
+
+      def banner
+        Rainbow("i18n-processes v#{I18n::Processes::VERSION} IRB").bright + "\nType #{Rainbow('guide').green} to learn more"
+      end
+
+      def guide
+        Rainbow('i18n-processes IRB Quick Start guide').green.bright + "\n" + <<-TEXT
+#{Rainbow('Data as trees').yellow}
+  tree(locale)
+  used_tree(key_filter: nil, strict: nil)
+  unused_tree(locale: base_locale, strict: nil)
+  build_tree('es' => {'hello' => 'Hola'})
+
+#{Rainbow('Traversal').yellow}
+  tree = missing_diff_tree('es')
+  tree.nodes { |node| }
+  tree.nodes.to_a
+  tree.leaves { |node| }
+  tree.each { |root_node| }
+  # also levels, depth_first, and breadth_first
+
+#{Rainbow('Select nodes').yellow}
+  tree.select_nodes { |node| } # new tree with only selected nodes
+
+#{Rainbow('Match by full key').yellow}
+  tree.select_keys { |key, leaf| } # new tree with only selected keys
+  tree.grep_keys(/hello/)          # grep, using ===
+  tree.keys { |key, leaf| }        # enumerate over [full_key, leaf_node]
+  # Pass {root: true} to include root node in full_key (usually locale)
+
+#{Rainbow('Nodes').yellow}
+  node = node(key, locale)
+  node.key      # only the part after the last dot
+  node.full_key # full key. Includes root key, pass {root: false} to override.
+  # also: value, value_or_children_hash, data, walk_to_root, walk_from_root
+  Tree::Node.new(key: 'en')
+
+#{Rainbow('Keys').yellow}
+  t(key, locale)
+  key_value?(key, locale)
+  depluralize_key(key, locale) # convert 'hat.one' to 'hat'
+        TEXT
+      end
+    end
+  end
+end

data/lib/i18n/processes/data/adapter/json_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module I18n::Processes
+  module Data
+    module Adapter
+      module JsonAdapter
+        class << self
+          # @return [Hash] locale tree
+          def parse(str, opts)
+            JSON.parse(str, parse_opts(opts))
+          end
+
+          # @return [String]
+          def dump(tree, opts)
+            JSON.generate(tree, parse_opts(opts))
+          end
+
+          private
+
+          def parse_opts(opts)
+            opts.try(:symbolize_keys) || {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/processes/data/adapter/yaml_adapter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'yaml'
+module I18n::Processes
+  module Data
+    module Adapter
+      module YamlAdapter
+        class << self
+          # @return [Hash] locale tree
+          def parse(str, options)
+            if YAML.method(:load).arity.abs == 2
+              YAML.load(str, options || {})
+            else
+              # older jruby and rbx 2.2.7 do not accept options
+              YAML.load(str)
+            end
+          end
+
+          # @return [String]
+          def dump(tree, options)
+            tree.to_yaml(options || {})
+          end
+        end
+      end
+    end
+  end
+end