i18n_flow 0.1.0

data/lib/i18n_flow/validator/errors.rb

@@ -0,0 +1,99 @@
+module I18nFlow::Validator
+  class Error
+    attr_reader :key
+    attr_reader :file
+    attr_reader :line
+
+    def initialize(key)
+      @key = key
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      data == other.data
+    end
+
+    def data
+      [key]
+    end
+
+    def single?
+      !!@single
+    end
+
+    def set_location(node)
+      @file = node.file_path
+      @line = node.start_line
+      self
+    end
+  end
+
+  class InvalidTypeError < Error
+    def initialize(key, single: false)
+      super(key)
+      @single = single
+    end
+  end
+
+  class MissingKeyError < Error
+    def initialize(key, single: false)
+      super(key)
+      @single = single
+    end
+  end
+
+  class ExtraKeyError < Error
+    def initialize(key, single: false)
+      super(key)
+      @single = single
+    end
+  end
+
+  class InvalidTodoError < Error
+  end
+
+  class TodoContentError < Error
+    attr_reader :expect
+    attr_reader :actual
+
+    def initialize(key, expect:, actual:)
+      super(key)
+      @expect = expect
+      @actual = actual
+    end
+
+    def data
+      super + [expect, actual]
+    end
+  end
+
+  class InvalidLocaleError < Error
+    attr_reader :expect
+    attr_reader :actual
+
+    def initialize(key, expect:, actual:)
+      super(key)
+      @expect = expect
+      @actual = actual
+    end
+
+    def data
+      super + [expect, actual]
+    end
+  end
+
+  class AsymmetricArgsError < Error
+    attr_reader :expect
+    attr_reader :actual
+
+    def initialize(key, expect:, actual:)
+      super(key)
+      @expect = expect
+      @actual = actual
+    end
+
+    def data
+      super + [expect, actual]
+    end
+  end
+end

data/lib/i18n_flow/validator/file_scope.rb

@@ -0,0 +1,58 @@
+require_relative 'errors'
+require_relative '../util'
+
+module I18nFlow::Validator
+  class FileScope
+    attr_reader :ast
+    attr_reader :filepath
+
+    def initialize(ast, filepath:)
+      @ast = ast
+      @filepath = filepath
+    end
+
+    def filepath_scopes
+      @filepath_scopes ||= I18nFlow::Util.filepath_to_scope(filepath)
+    end
+
+    def validate!
+      @errors = nil
+      validate_scope(ast, scopes: filepath_scopes)
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+  private
+
+    def validate_scope(tree, scopes:)
+      scopes.each_with_index do |scope, i|
+        node = tree[scope]
+
+        if node.nil?
+          full_key = scopes[0..i].join('.')
+          errors << MissingKeyError.new(full_key, single: true).set_location(tree)
+          break
+        end
+
+        if tree.mapping? && tree.size > 1
+          parent_scopes = scopes[0...i]
+          (tree.keys - [scope]).each do |key|
+            full_key = [*parent_scopes, key].join('.')
+            errors << ExtraKeyError.new(full_key, single: true).set_location(node)
+          end
+          break
+        end
+
+        if node.scalar?
+          full_key = scopes[0..i].join('.')
+          errors << InvalidTypeError.new(full_key, single: true).set_location(node)
+          break
+        end
+
+        tree = node
+      end
+    end
+  end
+end

data/lib/i18n_flow/validator/multiplexer.rb

@@ -0,0 +1,58 @@
+require_relative 'file_scope'
+require_relative 'symmetry'
+require_relative '../parser'
+
+module I18nFlow::Validator
+  class Multiplexer
+    attr_reader :repository
+    attr_reader :valid_locales
+    attr_reader :locale_pairs
+    attr_reader :linters
+
+    def initialize(
+      repository:,
+      valid_locales:,
+      locale_pairs:,
+      linters: %i[file_scope symmetry]
+    )
+      @repository    = repository
+      @valid_locales = valid_locales
+      @locale_pairs  = locale_pairs
+      @linters       = linters
+    end
+
+    def validate!
+      @errors = nil
+
+      if linters.include?(:file_scope)
+        repository.asts_by_path.each do |path, tree|
+          validator = FileScope.new(tree, filepath: path)
+          validator.validate!
+          validator.errors.each do |err|
+            errors[err.file][err.key] = err
+          end
+        end
+      end
+
+      if linters.include?(:symmetry)
+        repository.asts_by_scope.each do |scope, locale_trees|
+          locale_pairs.each do |(master, slave)|
+            master_tree = locale_trees[master]
+            slave_tree = locale_trees[slave]
+            next unless master_tree && slave_tree
+
+            validator = Symmetry.new(master_tree[master], slave_tree[slave])
+            validator.validate!
+            validator.errors.each do |err|
+              errors[err.file][err.key] = err
+            end
+          end
+        end
+      end
+    end
+
+    def errors
+      @errors ||= Hash.new { |h, k| h[k] = {} }
+    end
+  end
+end

data/lib/i18n_flow/validator/symmetry.rb

@@ -0,0 +1,154 @@
+require_relative 'errors'
+require_relative '../util'
+
+module I18nFlow::Validator
+  class Symmetry
+    attr_reader :ast_1
+    attr_reader :ast_2
+
+    def initialize(ast_1, ast_2)
+      @ast_1 = ast_1
+      @ast_2 = ast_2
+    end
+
+    def validate!
+      @errors = nil
+      validate_content(ast_1, ast_2)
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+  private
+
+    def validate_content(t1, t2)
+      keys = t1.keys | t2.keys
+
+      keys.each do |k|
+        validate_node(t1, t2, k)
+      end
+    end
+
+    def validate_node(t1, t2, key)
+      n1 = t1[key]
+      n2 = t2[key]
+
+      check_only_tag(n1, n2)&.tap do |err|
+        errors << err if err
+        return
+      end
+
+      check_asymmetric_key(n1, n2, t2)&.tap do |err|
+        errors << err if err
+        return
+      end
+
+      check_type(n1, n2)&.tap do |err|
+        errors << err
+        return
+      end
+
+      check_todo_tag(n1, n2)&.tap do |err|
+        errors << err
+        return
+      end
+
+      if n1.scalar? || n1.alias?
+        check_args(n1, n2)&.tap do |err|
+          errors << err
+        end
+      else
+        validate_content(n1, n2)
+      end
+    end
+
+    def check_only_tag(n1, n2)
+      return unless n1&.marked_as_only? || n2&.marked_as_only?
+
+      if n1 && !n1.valid_locale?
+        return InvalidLocaleError.new(n1.full_key,
+          expect: n1.valid_locales,
+          actual: n1.locale,
+        ).set_location(n1)
+      end
+
+      if n2 && !n2.valid_locale?
+        return InvalidLocaleError.new(n2.full_key,
+          expect: n2.valid_locales,
+          actual: n2.locale,
+        ).set_location(n2)
+      end
+
+      if n1 && !n2 && n1.marked_as_only?
+        return false
+      end
+
+      if !n1 && n2 && n2.marked_as_only?
+        return false
+      end
+
+      if n1 && n2 && n1.valid_locales.any? && !n1.valid_locales.include?(n2.locale)
+        return InvalidLocaleError.new(n2.full_key,
+          expect: n1.valid_locales,
+          actual: n2.locale,
+        ).set_location(n2)
+      end
+
+      if n1 && n2 && n2.valid_locales.any? && !n2.valid_locales.include?(n1.locale)
+        return InvalidLocaleError.new(n1.full_key,
+          expect: n2.valid_locales,
+          actual: n1.locale,
+        ).set_location(n1)
+      end
+
+      false
+    end
+
+    def check_type(n1, n2)
+      return unless n1 && n2
+      return if n1.scalar? == n2.scalar?
+
+      InvalidTypeError.new(n2.full_key).set_location(n2)
+    end
+
+    def check_asymmetric_key(n1, n2, t2)
+      return false if n1&.ignored_violation == :key || n2&.ignored_violation == :key
+      return if n1 && n2
+
+      if n1
+        full_key = [t2.locale, *n1.scopes.drop(1)].join('.')
+        MissingKeyError.new(full_key).set_location(t2)
+      else
+        ExtraKeyError.new(n2.full_key).set_location(n2)
+      end
+    end
+
+    def check_todo_tag(n1, n2)
+      return unless n2.marked_as_todo?
+
+      if !n2.scalar?
+        InvalidTodoError.new(n2.full_key).set_location(n2)
+      elsif n2.value != n1.value
+        TodoContentError.new(n2.full_key,
+          expect: n1.value,
+          actual: n2.value,
+        ).set_location(n2)
+      end
+    end
+
+    def check_args(n1, n2)
+      return if n1.ignored_violation == :args || n2.ignored_violation == :args
+
+      args_1 = I18nFlow::Util.extract_args(n1.value).uniq
+      args_2 = I18nFlow::Util.extract_args(n2.value).uniq
+
+      return if args_1 == args_2
+
+      AsymmetricArgsError.new(n2.full_key,
+        expect: args_1,
+        actual: args_2,
+      ).set_location(n2)
+    end
+  end
+end

data/lib/i18n_flow/validator.rb

@@ -0,0 +1,4 @@
+module I18nFlow::Validator
+end
+
+require_relative 'validator/multiplexer'

data/lib/i18n_flow/version.rb

@@ -0,0 +1,7 @@
+module I18nFlow
+  MAJOR    = 0
+  MINOR    = 1
+  REVISION = 0
+
+  VERSION = [MAJOR, MINOR, REVISION].join('.')
+end

data/lib/i18n_flow/yaml_ast_proxy/mapping.rb

@@ -0,0 +1,72 @@
+require 'psych'
+require_relative 'node'
+
+module I18nFlow::YamlAstProxy
+  class Mapping < Node
+    extend Forwardable
+
+    def_delegators :indexed_object, :==, :keys, :size
+
+    def each
+      indexed_object.each do |k, _|
+        yield k, cache[k]
+      end
+    end
+
+    def values
+      indexed_object.map { |k, _| cache[k] }
+    end
+
+    def set(key, value)
+      super.tap do
+        cache.delete(key)
+        synchronize!
+      end
+    end
+    alias []= set
+
+    def batch
+      @locked = true
+      yield
+    ensure
+      @locked = false
+      synchronize!
+    end
+
+    def merge!(other)
+      return unless other&.is_a?(Mapping)
+
+      batch do
+        other.batch do
+          other.each do |k, rhs|
+            if (lhs = self[k])
+              lhs.merge!(rhs)
+            else
+              self[k] = rhs.node
+            end
+          end
+        end
+      end
+    end
+
+  private
+
+    def cache
+      @cache ||= Hash.new { |h, k| h[k] = wrap(indexed_object[k], key: k) }
+    end
+
+    def indexed_object
+      @indexed_object ||= node.children
+        .each_slice(2)
+        .map { |k, v| [k.value, v] }
+        .to_h
+    end
+
+    def synchronize!
+      return if @locked
+
+      children = indexed_object.flat_map { |k, v| [Psych::Nodes::Scalar.new(k), v] }
+      node.children.replace(children)
+    end
+  end
+end

data/lib/i18n_flow/yaml_ast_proxy/node.rb

@@ -0,0 +1,128 @@
+require_relative 'node_meta_data'
+require 'forwardable'
+
+module I18nFlow::YamlAstProxy
+  class Node
+    extend Forwardable
+    include NodeMetaData
+
+    TAG_IGNORE = /^!ignore:(args|key)$/
+    TAG_TODO   = /^!todo(?::([,a-zA-Z_-]+))?$/
+    TAG_ONLY   = /^!only(?::([,a-zA-Z_-]+))?$/
+
+    attr_reader :node
+    attr_reader :parent
+    attr_reader :scopes
+    attr_reader :file_path
+    attr_reader :ignored_violation
+
+    def_delegators :indexed_object, :each
+
+    def initialize(
+      node,
+      parent:    nil,
+      scopes:    [],
+      file_path: nil
+    )
+      @node      = node
+      @parent    = parent
+      @scopes    = scopes
+      @file_path = file_path
+
+      parse_tag!(node.tag)
+    end
+
+    def get(key)
+      wrap(indexed_object[key], key: key)
+    end
+    alias [] get
+
+    def set(key, value)
+      indexed_object[key] = value
+    end
+    alias []= set
+
+    def value
+      node.value if node.respond_to?(:value)
+    end
+
+    def merge!(other)
+      return unless other&.is_a?(Node)
+
+      if scalar? && other.scalar?
+        node.value = other.value
+        return
+      end
+
+      if !scalar? && !other.scalar?
+        batch do
+          other.batch do
+            other.each do |k, rhs|
+              if (lhs = self[k])
+                lhs.merge!(rhs)
+              else
+                self[k] = rhs.node
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def batch
+      yield
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      identity_data == other.identity_data
+    end
+
+    def to_yaml
+      parent.to_yaml(nil, line_width: -1)
+    end
+
+    def keys
+      return [] if scalar? || alias?
+      indexed_object.keys
+    end
+
+  private
+
+    def identity_data
+      (scalar? || alias?) ? value : indexed_object
+    end
+
+    def indexed_object
+      @indexed_object ||= I18nFlow::YamlAstProxy.create(node,
+        parent:    parent,
+        scopes:    scopes,
+        file_path: file_path,
+      )
+    end
+
+    def wrap(value, key:)
+      I18nFlow::YamlAstProxy.create(value,
+        parent:    node,
+        scopes:    [*scopes, key],
+        file_path: file_path,
+      )
+    end
+
+    def parse_tag!(tag)
+      return unless tag
+
+      case tag
+      when TAG_TODO
+        @tag = :todo
+        @todo_locales = $1.to_s.split(',').freeze
+      when TAG_ONLY
+        @tag = :only
+        @valid_locales = $1.to_s.split(',').freeze
+      when TAG_IGNORE
+        @tag = :ignore
+        @ignored_violation = $1.freeze.to_sym
+      end
+    end
+  end
+end

data/lib/i18n_flow/yaml_ast_proxy/node_meta_data.rb

@@ -0,0 +1,86 @@
+module I18nFlow::YamlAstProxy
+  module NodeMetaData
+    def num_lines
+      return 1 unless end_line
+      end_line - start_line + 1
+    end
+
+    def key
+      scopes.last
+    end
+
+    def locale
+      scopes.first
+    end
+
+    def full_key
+      scopes.join('.')
+    end
+
+    def start_line
+      node.start_line + line_correction
+    end
+
+    def end_line
+      node.end_line + line_correction
+    end
+
+    def start_column
+      node.start_column
+    end
+
+    def end_column
+      node.end_column
+    end
+
+    def anchor
+      node.anchor
+    end
+
+    def sequence?
+      is_a?(Sequence)
+    end
+
+    def mapping?
+      is_a?(Mapping)
+    end
+
+    def scalar?
+      node.is_a?(Psych::Nodes::Scalar)
+    end
+
+    def alias?
+      node.is_a?(Psych::Nodes::Alias)
+    end
+
+    def has_anchor?
+      !!anchor
+    end
+
+    def marked_as_todo?
+      @tag == :todo
+    end
+
+    def marked_as_only?
+      @tag == :only
+    end
+
+    def todo_locales
+      @todo_locales ||= []
+    end
+
+    def valid_locales
+      @valid_locales ||= []
+    end
+
+    def valid_locale?
+      valid_locales.empty? || valid_locales.include?(locale)
+    end
+
+  private
+
+    def line_correction
+      node.is_a?(Psych::Nodes::Scalar) ? 1 : 0
+    end
+  end
+end

data/lib/i18n_flow/yaml_ast_proxy/sequence.rb

@@ -0,0 +1,29 @@
+require_relative 'node'
+
+module I18nFlow::YamlAstProxy
+  class Sequence < Node
+    def_delegators :indexed_object, :==, :<<, :size
+
+    def each
+      indexed_object.each.with_index do |o, i|
+        yield i, wrap(o, key: i)
+      end
+    end
+
+    def merge!(other)
+      return unless other&.is_a?(Sequence)
+
+      indexed_object.concat(other.send(:indexed_object))
+    end
+
+    def keys
+      (0...size).to_a
+    end
+
+  private
+
+    def indexed_object
+      node.children
+    end
+  end
+end