i18n_flow 0.1.0

data/lib/i18n_flow/configuration.rb

@@ -0,0 +1,205 @@
+require 'yaml'
+require 'pathname'
+require_relative 'util'
+
+class I18nFlow::Configuration
+  module Validation
+    def self.included(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def _validators
+        @_validators ||= []
+      end
+
+      def validate(attr, message, &block)
+        _validators << [attr, message, block]
+      end
+    end
+
+    module InstanceMethods
+      def validate!
+        self.class._validators.each do |attr, message, block|
+          next if instance_eval(&block)
+          raise ValueError.new(attr, message)
+        end
+      end
+    end
+  end
+
+  class NoConfigurationFileFoundError < ::IOError
+    def message
+      'no configuration file found'
+    end
+  end
+
+  class ValueError < ::StandardError
+    def initialize(attr, message)
+      @attr    = attr
+      @message = message
+    end
+
+    def message
+      '%s: %s' % [@attr, @message]
+    end
+  end
+end
+
+class I18nFlow::Configuration
+  include Validation
+
+  CONFIG_FILES = [
+    'i18n_flow.yml',
+    'i18n_flow.yaml',
+  ].freeze
+
+  LINTERS = %i[
+    file_scope
+    symmetry
+  ].freeze
+
+  attr_reader(*%i[
+    base_path
+    glob_patterns
+    valid_locales
+    locale_pairs
+    linters
+    split_max_level
+    split_line_threshold
+  ])
+
+  validate :base_path, 'need to be an absolute path' do
+    !!base_path&.absolute?
+  end
+
+  validate :glob_patterns, 'should be an array' do
+    !glob_patterns.nil?
+  end
+
+  validate :glob_patterns, 'should contain at least one pattern' do
+    glob_patterns.any?
+  end
+
+  validate :valid_locales, 'should be an array' do
+    !valid_locales.nil?
+  end
+
+  validate :valid_locales, 'should contain at least one pattern' do
+    valid_locales.any?
+  end
+
+  validate :locale_pairs, 'should be an array' do
+    !locale_pairs.nil?
+  end
+
+  validate :linters, "should be an array" do
+    !linters.nil?
+  end
+
+  validate :linters, "should contain any of [#{LINTERS.join(', ')}]" do
+    (linters - LINTERS).empty?
+  end
+
+  validate :split_max_level, 'must be set' do
+    !split_max_level.nil?
+  end
+
+  validate :split_line_threshold, 'must be set' do
+    !split_line_threshold.nil?
+  end
+
+  def initialize
+    update(validate: false) do |c|
+      c.base_path            = File.expand_path('.')
+      c.glob_patterns        = ['*.en.yml']
+      c.valid_locales        = %w[en]
+      c.locale_pairs         = []
+      c.linters              = LINTERS
+      c.split_max_level      = 3
+      c.split_line_threshold = 50
+    end
+  end
+
+  def base_path=(path)
+    @base_path = path&.tap do |v|
+      break Pathname.new(v)
+    end
+  end
+
+  def glob_patterns=(patterns)
+    @glob_patterns = patterns&.tap do |v|
+      break unless v.is_a?(Array)
+      break v.map(&:to_s)
+    end
+  end
+
+  def locale_pairs=(pairs)
+    @locale_pairs = pairs&.tap do |v|
+      break unless v.is_a?(Array)
+      break unless v.all? { |e| e.size == 2 }
+      break v.map { |e| e.map(&:to_s) }
+    end
+  end
+
+  def valid_locales=(locales)
+    @valid_locales = locales&.tap do |v|
+      break unless v.is_a?(Array)
+      break v.map(&:to_s)
+    end
+  end
+
+  def linters=(linters)
+    @linters = linters&.tap do |v|
+      break unless v.is_a?(Array)
+      break v.map(&:to_sym)
+    end
+  end
+
+  def split_max_level=(level)
+    @split_max_level = level&.tap do |v|
+      break unless v.is_a?(Integer)
+    end
+  end
+
+  def split_line_threshold=(threshold)
+    @split_line_threshold = threshold&.tap do |v|
+      break unless v.is_a?(Integer)
+    end
+  end
+
+  def update(validate: true)
+    yield self if block_given?
+    validate! if validate
+  end
+
+  def auto_configure!
+    load_from_file!
+    update
+  end
+
+private
+
+  def load_from_file!
+    config_file = I18nFlow::Util.find_file_upward(*CONFIG_FILES)
+
+    unless config_file
+      raise NoConfigurationFileFoundError
+    end
+
+    yaml = YAML.load_file(config_file)
+    yaml_dir = File.dirname(config_file)
+
+    _base_path = yaml.delete('base_path')
+    self.base_path = _base_path ? File.absolute_path(_base_path, yaml_dir) : yaml_dir
+
+    yaml.each do |k, v|
+      if respond_to?("#{k}=")
+        send("#{k}=", v)
+      else
+        raise KeyError.new('invalid option: %s' % [k])
+      end
+    end
+  end
+end

data/lib/i18n_flow/parser.rb

@@ -0,0 +1,34 @@
+require 'psych'
+require_relative 'yaml_ast_proxy'
+
+class I18nFlow::Parser
+  attr_reader :buffer
+  attr_reader :file_path
+
+  def initialize(buffer, file_path: nil)
+    @buffer = buffer
+    @file_path = file_path
+  end
+
+  def parse!
+    parser.parse(buffer)
+  end
+
+  def root
+    builder.root
+  end
+
+  def root_proxy
+    @root_proxy ||= I18nFlow::YamlAstProxy.create(root, file_path: file_path)
+  end
+
+private
+
+  def builder
+    @builder ||= Psych::TreeBuilder.new
+  end
+
+  def parser
+    @parser ||= Psych::Parser.new(builder)
+  end
+end

data/lib/i18n_flow/repository.rb

@@ -0,0 +1,39 @@
+require 'pathname'
+require_relative 'parser'
+require_relative 'util'
+
+class I18nFlow::Repository
+  def initialize(
+    base_path:,
+    glob_patterns:
+  )
+    @base_path     = Pathname.new(base_path)
+    @glob_patterns = glob_patterns.to_a
+  end
+
+  def file_paths
+    @file_paths ||= @glob_patterns
+      .flat_map { |pattern| Dir.glob(@base_path.join(pattern)) }
+  end
+
+  def asts_by_path
+    @asts ||= file_paths
+      .map { |path|
+        rel_path = Pathname.new(path).relative_path_from(@base_path).to_s
+        parser = I18nFlow::Parser.new(File.read(path), file_path: rel_path)
+        parser.parse!
+        [rel_path, parser.root_proxy]
+      }
+      .to_h
+  end
+
+  def asts_by_scope
+    @asts_by_scope ||= Hash.new { |h, k| h[k] = {} }
+      .tap { |h|
+        asts_by_path.each { |path, tree|
+          locale, *scopes = I18nFlow::Util.filepath_to_scope(path)
+          h[scopes.join('.')][locale] = tree
+        }
+      }
+  end
+end

data/lib/i18n_flow/search.rb

@@ -0,0 +1,176 @@
+class I18nFlow::Search
+  class Item
+    attr_reader :locale
+    attr_reader :file
+    attr_reader :line
+    attr_reader :column
+    attr_reader :value
+    attr_reader :score
+
+    def initialize(
+      locale:,
+      file:,
+      line:,
+      column:,
+      value:,
+      score:
+    )
+      @locale = locale
+      @file   = file
+      @line   = line
+      @column = column
+      @value  = value
+      @score  = score
+    end
+  end
+end
+
+
+class I18nFlow::Search
+  attr_reader :repository
+  attr_reader :pattern
+
+  SCORE_KEY_CS_MATCH     = 10
+  SCORE_KEY_CI_MATCH     = 9
+  SCORE_CONTENT_CS_MATCH = 8
+  SCORE_CONTENT_CI_MATCH = 6
+
+  def initialize(
+    repository:,
+    pattern:,
+    include_all: false
+  )
+    @repository  = repository
+    @pattern     = pattern
+    @include_all = include_all
+  end
+
+  def search!
+    repository.asts_by_scope.each do |scope, locale_trees|
+      asts = locale_trees
+        .map { |locale, tree| tree[locale] }
+        .compact
+
+      search_on(asts)
+    end
+  end
+
+  def results
+    @results ||= indexed_results
+      .sort_by { |k, rs| -rs.map(&:score).max }
+      .to_h
+  end
+
+  def include_all?
+    !!@include_all
+  end
+
+  def indexed_results
+    @indexed_results ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  def pattern_downcase
+    @pattern_downcase ||= pattern.downcase
+  end
+
+private
+
+  def search_on(asts)
+    if include_all?
+      score = asts.map { |a| score_for(a) }.max
+      if score > 0
+        asts.each do |ast|
+          add_result(ast, score: score)
+        end
+      end
+    else
+      asts.each do |ast|
+        score = score_for(ast)
+        next unless score > 0
+        add_result(ast, score: score)
+      end
+    end
+
+    recursive_asts = asts.reject { |a| a.scalar? || a.alias? }
+    keys = recursive_asts.flat_map(&:keys).uniq
+
+    keys.each do |k|
+      search_on(recursive_asts.map { |a| a[k] }.compact)
+    end
+  end
+
+  def add_result(node, score:)
+    locale, *scopes = node.scopes
+    key = scopes.join('.')
+
+    indexed_results[key] << Item.new(
+      locale: locale,
+      file:   node.file_path,
+      line:   node.start_line,
+      column: node.start_column,
+      value:  node.value,
+      score:  score,
+    )
+  end
+
+  def score_for(node)
+    key = node.scopes[1..-1].join('.')
+
+    key_match_score(key).tap do |score|
+      return score if score > 0
+    end
+
+    if node.scalar?
+      return content_match_score(node.value)
+    end
+
+    0
+  end
+
+  def key_match_score(key)
+    if key == pattern
+      return SCORE_KEY_CS_MATCH
+    end
+    if key.downcase == pattern_downcase
+      return SCORE_KEY_CI_MATCH
+    end
+
+    0
+  end
+
+  def content_match_score(str)
+    if str.include?(pattern)
+      return SCORE_CONTENT_CS_MATCH * lcs_score(str, pattern)
+    end
+
+    str = str.downcase
+
+    if str.include?(pattern_downcase)
+      return SCORE_CONTENT_CI_MATCH * lcs_score(str, pattern_downcase)
+    end
+
+    0
+  end
+
+  def lcs_score(a, b)
+    a_size = a.size
+    b_size = b.size
+
+    m = Array.new(a_size) { 0 }
+
+    result = 0
+
+    b_size.times do |i|
+      result = d = 0
+
+      a_size.times do |j|
+        t = (b[i] == a[j]) ? d + 1 : d
+        d = m[j]
+
+        m[j] = result = [d, t, result].max
+      end
+    end
+
+    result * 2.0 / (a_size + b_size)
+  end
+end

data/lib/i18n_flow/splitter/merger.rb

@@ -0,0 +1,60 @@
+module I18nFlow::Splitter
+  class Merger
+    attr_reader :chunks
+
+    def initialize(chunks)
+      @chunks = chunks
+    end
+
+    def root
+      @root ||= I18nFlow::YamlAstProxy.new_root
+    end
+
+    def perform_merge!
+      chunks.each do |chunk|
+        append_chunk(chunk)
+      end
+    end
+
+    def to_yaml
+      root.parent.to_yaml
+    end
+
+  private
+
+    def append_chunk(chunk)
+      parent = root
+
+      chunk.scopes[0..(chunk.scalar? ? -2 : -1)]
+        .each
+        .with_index do |scope, i|
+          next_scope = chunk.scopes[i + 1]
+          is_seq = next_scope ? next_scope&.is_a?(Integer) : chunk.sequence?
+
+          node = parent[scope]
+
+          if node && (!is_seq && !node.mapping? || is_seq && !node.sequence?)
+            # TODO: should raise?
+            return
+          end
+
+          unless node
+            parent[scope] = if is_seq
+              Psych::Nodes::Sequence.new
+            else
+              Psych::Nodes::Mapping.new
+            end
+            node = parent[scope]
+          end
+
+          parent = node
+        end
+
+      if chunk.scalar?
+        parent[chunk.scopes[-1]] = chunk.node
+      else
+        parent.merge!(chunk)
+      end
+    end
+  end
+end

data/lib/i18n_flow/splitter/strategy.rb

@@ -0,0 +1,66 @@
+module I18nFlow::Splitter
+  class Strategy
+    DEFAULT_MAX_LEVEL      = 3
+    DEFAULT_LINE_THRESHOLD = 50
+
+    def initialize(
+      ast,
+      max_level:      DEFAULT_MAX_LEVEL,
+      line_threshold: DEFAULT_LINE_THRESHOLD
+    )
+      @ast            = ast
+      @max_level      = max_level
+      @line_threshold = line_threshold
+    end
+
+    def split!
+      @chunks = nil
+      traverse(@ast, level: 0)
+    end
+
+    def chunks
+      @chunks ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+  private
+
+    def traverse(node, level:)
+      return if node.scalar?
+
+      if level > 0 && node.mapping?
+        others, mappings = node.values.partition(&:scalar?)
+
+        others.each do |n|
+          add_chunk(n, delta_level: -2)
+        end
+
+        if mappings.sum(&:num_lines) < @line_threshold
+          mappings.each do |n|
+            add_chunk(n, delta_level: -2)
+          end
+          return
+        end
+
+        if level >= @max_level
+          add_chunk(node)
+          return
+        end
+      end
+
+      if node.sequence?
+        add_chunk(node, delta_level: -2)
+        return
+      end
+
+      node.each do |_, v|
+        traverse(v, level: level + 1)
+      end
+    end
+
+    def add_chunk(node, delta_level: 0)
+      level = [node.scopes.size + delta_level, 1].max
+      file_scopes = node.scopes[0...level]
+      chunks[file_scopes] << node
+    end
+  end
+end

data/lib/i18n_flow/splitter.rb

@@ -0,0 +1,5 @@
+module I18nFlow::Splitter
+end
+
+require_relative 'splitter/strategy'
+require_relative 'splitter/merger'

data/lib/i18n_flow/util.rb

@@ -0,0 +1,57 @@
+module I18nFlow::Util
+  extend self
+
+  def extract_args(text)
+    text.to_s
+      .gsub(/%%/, '')
+      .scan(/%\{([^\}]+)\}/)
+      .flatten
+      .sort
+  end
+
+  def filepath_to_scope(filepath)
+    *scopes, filename = filepath.split('/')
+    *basename, locale, _ = filename.split('.')
+
+    ([locale] + scopes + basename).compact.reject(&:empty?)
+  end
+
+  def scope_to_filepath(scopes)
+    locale, *components = scopes
+    [components.join('/'), locale, 'yml'].compact.reject(&:empty?).join('.')
+  end
+
+  def find_file_upward(*file_names)
+    pwd  = Dir.pwd
+    base = Hash.new { |h, k| h[k] = pwd }
+    file = {}
+
+    while base.values.all? { |b| '.' != b && '/' != b }
+      file_names.each do |name|
+        file[name] = File.join(base[name], name)
+        base[name] = File.dirname(base[name])
+
+        return file[name] if File.exists?(file[name])
+      end
+    end
+
+    nil
+  end
+
+  def parse_options(args)
+    options = {}
+
+    args.reject! do |arg|
+      case arg
+      when /^-([a-z0-9])$/i, /^--([a-z0-9][a-z0-9-]*)$/i
+        options[$1] = true
+      when /^--([a-z0-9][a-z0-9-]*)=(.+)$/i
+        options[$1] = $2
+      else
+        break
+      end
+    end
+
+    options
+  end
+end