petrovich 0.2.1 → 1.0.0

data/lib/petrovich/case/rule.rb

@@ -0,0 +1,63 @@
+module Petrovich
+  module Case
+    # A case rule from the set of rules
+    class Rule
+      attr_reader :gender, :modifiers, :tests, :tags, :as, :an_exception
+
+      def initialize(opts)
+        @gender       = opts[:gender].to_sym.downcase
+        @as           = opts[:as]
+        @an_exception = opts[:section] == :exceptions
+        @modifiers    = opts[:modifiers]
+        @tests        = opts[:tests]
+        @tags         = []
+
+        assert_name_part!(@as)
+      end
+
+      def match?(name, match_gender, match_as)
+        assert_name_part!(match_as)
+
+        return false unless match_as == as
+
+        match_gender = match_gender.to_sym.downcase
+
+        return false if gender == :male && match_gender == :female
+        return false if gender == :female && match_gender != :female
+
+        tests.detect { |test| test.match?(name) }
+      end
+
+      # Is this exceptional rule?
+      def an_exception?
+        an_exception == true
+      end
+
+      def get_modifier(name_case)
+        case name_case.to_sym
+        when :nominative
+          nil
+        when :genitive
+          modifiers[0]
+        when :dative
+          modifiers[1]
+        when :accusative
+          modifiers[2]
+        when :instrumental
+          modifiers[3]
+        when :prepositional
+          modifiers[4]
+        else
+          fail UnknownCaseError, "Unknown grammatic case: #{name_case}".freeze
+        end
+      end
+
+      private
+
+      def assert_name_part!(name_part)
+        return if [:lastname, :firstname, :middlename].include?(name_part)
+        fail ArgumentError, "Unknown 'as' option #{name_part}".freeze
+      end
+    end
+  end
+end

data/lib/petrovich/case/rule/modifier.rb

@@ -0,0 +1,19 @@
+module Petrovich
+  module Case
+    class Rule
+      # A modifier for the test rule
+      class Modifier
+        attr_reader :suffix, :offset
+
+        def initialize(suffix, offset = 0)
+          @suffix = suffix.to_s
+          @offset = offset
+        end
+
+        def inspect
+          [suffix, offset].inspect
+        end
+      end
+    end
+  end
+end

data/lib/petrovich/case/rule/test.rb

@@ -0,0 +1,23 @@
+module Petrovich
+  module Case
+    class Rule
+      # A test for the case rule
+      class Test
+        attr_reader :suffix
+
+        def initialize(suffix)
+          @suffix = Unicode.downcase(suffix)
+        end
+
+        def match?(name)
+          name = Unicode.downcase(name)
+          suffix == name.slice([name.size - suffix.size, 0].max..-1)
+        end
+
+        def inspect
+          suffix.inspect
+        end
+      end
+    end
+  end
+end

data/lib/petrovich/gender.rb

@@ -0,0 +1,39 @@
+module Petrovich
+  # Methods of determining gender by the name
+  module Gender
+    def self.detect(name)
+      # Accept hash and convert it to ostruct object
+      name     = Petrovich.normalize_name(name)
+      rule_set = Petrovich.rule_set
+      genders  = {}
+
+      Petrovich.assert_name!(name)
+
+      [:lastname, :firstname, :middlename].each do |name_part|
+        next unless name.respond_to?(name_part) && name.send(name_part)
+
+        rules = rule_set.find_all_gender_rules(name.send(name_part), name_part)
+
+        rules.each do |rule|
+          genders[name_part] = rule.nil? ? :androgynous : rule.gender
+        end
+      end
+
+      # Return gender if middlename is specified and gender is determined.
+      return genders[:middlename] if genders[:middlename] && genders[:middlename] != :androgynous
+
+      if genders.values.uniq.size > 1
+        if genders[:firstname] != :androgynous && genders[:lastname] == :androgynous
+          return genders[:firstname]
+        end
+
+        if genders[:lastname] != :androgynous && genders[:firstname] == :androgynous
+          return genders[:lastname]
+        end
+      end
+
+      # Otherwise, it returns what recognized
+      return genders.values.uniq.first if genders.values.uniq.size == 1
+    end
+  end
+end

data/lib/petrovich/gender/rule.rb

@@ -0,0 +1,22 @@
+module Petrovich
+  module Gender
+    # A gender rule from the set of rules
+    class Rule
+      attr_reader :gender, :as, :suffix
+
+      # TODO: check options (see Case::Rule)
+      def initialize(opts)
+        @gender = opts[:gender]
+        @as = opts[:as]
+        @suffix = opts[:suffix]
+      end
+
+      def match?(name, match_as)
+        return false unless match_as == as
+
+        name = Unicode.downcase(name)
+        @suffix == name.slice([name.size - @suffix.size, 0].max..-1)
+      end
+    end
+  end
+end

data/lib/petrovich/inflected.rb

@@ -0,0 +1,18 @@
+module Petrovich
+  # Keeps inflected @name
+  class Inflected
+    extend Forwardable
+
+    def_delegator :@name, :lastname, :lastname
+    def_delegator :@name, :firstname, :firstname
+    def_delegator :@name, :middlename, :middlename
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      [lastname, firstname, middlename].compact.join(' ')
+    end
+  end
+end

data/lib/petrovich/inflector.rb

@@ -0,0 +1,42 @@
+module Petrovich
+  class Inflector
+    def initialize(name, gender, name_case)
+      Petrovich.assert_name!(name)
+
+      @name = Petrovich.normalize_name(name)
+      @gender = gender
+      @name_case = name_case
+    end
+
+    def inflect_lastname(rules)
+      inflect(@name.lastname, rules)
+    end
+
+    def inflect_firstname(rules)
+      inflect(@name.firstname, rules)
+    end
+
+    def inflect_middlename(rules)
+      inflect(@name.middlename, rules)
+    end
+
+    private
+
+    def inflect(name, rules)
+      return name if rules.size == 0
+
+      parts = name.split('-')
+      parts.map! do |part|
+        rule = rules.shift
+
+        if rule && (modifier = rule.get_modifier(@name_case))
+          part.slice(0, part.size - modifier.offset) + modifier.suffix
+        else
+          part
+        end
+      end
+
+      parts.join('-')
+    end
+  end
+end

data/lib/petrovich/name.rb

@@ -0,0 +1,75 @@
+module Petrovich
+  class Name
+    extend Forwardable
+
+    def_delegator :@name, :lastname, :lastname
+    def_delegator :@name, :firstname, :firstname
+    def_delegator :@name, :middlename, :middlename
+
+    def initialize(opts)
+      @rule_set = Petrovich.rule_set
+      @gender = opts[:gender]
+      @name = Petrovich.normalize_name(
+        lastname: opts[:lastname],
+        firstname: opts[:firstname],
+        middlename: opts[:middlename]
+      )
+    end
+
+    def gender
+      if !@gender.nil? && [:male, :female, :androgynous].include?(@gender.to_sym)
+        @gender.to_sym
+      else
+        Gender.detect(@name)
+      end
+    end
+
+    def male?
+      Gender.detect(@name) == :male
+    end
+
+    def female?
+      Gender.detect(@name) == :female
+    end
+
+    def androgynous?
+      Gender.detect(@name) == :androgynous
+    end
+
+    def to(name_case)
+      Petrovich.assert_case!(name_case)
+      Inflected.new(inflect(@name.dup, gender, name_case))
+    end
+
+    def to_s
+      [lastname, firstname, middlename].join(' ')
+    end
+
+    Petrovich::CASES.each do |name_case|
+      define_method name_case do
+        to(name_case)
+      end
+    end
+
+    private
+
+    def inflect(name, gender, name_case)
+      inflector = Inflector.new(name, gender, name_case)
+      find = proc { |x| @rule_set.find_all_case_rules(name.send(x), gender, x) }
+
+      if !name.lastname.nil? && (rules = find.call(:lastname))
+        name.lastname = inflector.inflect_lastname(rules)
+      end
+
+      if !name.firstname.nil? && (rules = find.call(:firstname))
+        name.firstname = inflector.inflect_firstname(rules)
+      end
+
+      if !name.middlename.nil? && (rules = find.call(:middlename))
+        name.middlename = inflector.inflect_middlename(rules)
+      end
+
+      name
+    end
+  end
+end

data/lib/petrovich/rule_set.rb

@@ -0,0 +1,118 @@
+require 'yaml'
+
+module Petrovich
+  # A set of loaded rules from YAML file
+  class RuleSet
+    def initialize
+      clear!
+    end
+
+    def add_case_rule(rule)
+      unless rule.is_a?(Case::Rule)
+        fail ArgumentError, 'Expecting rule of type Petrovich::Case::Rule'.freeze
+      end
+
+      @case_rules << rule
+    end
+
+    def add_gender_rule(rule)
+      unless rule.is_a?(Gender::Rule)
+        fail ArgumentError, 'Expecting rule of type Petrovich::Gender::Rule'.freeze
+      end
+
+      @gender_rules << rule
+    end
+
+    def find_all_case_rules(name, gender, as)
+      name.split('-').map { |part| find_case_rule(part, gender, as) }
+    end
+
+    def find_all_gender_rules(name, as)
+      name.split('-').map { |part| find_gender_rule(part, as) }
+    end
+
+    def clear!
+      @case_rules = []
+      @gender_rules = []
+    end
+
+    def load!
+      return false if @case_rules.size > 0
+
+      rules = YAML.load_file(
+        File.expand_path('../../../rules/rules.yml', __FILE__)
+      )
+
+      load_case_rules!(rules)
+      load_gender_rules!(rules)
+    end
+
+    private
+
+    # Load rules for names
+    def load_case_rules!(rules)
+      [:lastname, :firstname, :middlename].each do |name_part|
+        [:exceptions, :suffixes].each do |section|
+          entries = rules[name_part.to_s][section.to_s]
+          next if entries.nil?
+
+          entries.each do |entry|
+            load_case_entry(name_part, section, entry)
+          end
+        end
+      end
+    end
+
+    # Load rules for genders
+    def load_gender_rules!(rules)
+      [:lastname, :firstname, :middlename].each do |name_part|
+        # First, add androgynous rules. Order is matters.
+        [:androgynous, :male, :female].each do |section|
+          entries = rules['gender'][name_part.to_s][section.to_s]
+          next if entries.nil?
+
+          entries.each do |entry|
+            load_gender_entry(name_part, section, entry)
+          end
+        end
+      end
+    end
+
+    def find_case_rule(name, gender, as)
+      @case_rules.find { |rule| rule.match?(name, gender, as) }
+    end
+
+    def find_gender_rule(name, as)
+      @gender_rules.find { |rule| rule.match?(name, as) }
+    end
+
+    def load_case_entry(as, section, entry)
+      modifiers = entry['mods'].map do |mod|
+        suffix = mod.scan(/[^.-]+/).first
+        offset = mod.count('-')
+        Petrovich::Case::Rule::Modifier.new(suffix, offset)
+      end
+
+      tests = entry['test'].map do |suffix|
+        Petrovich::Case::Rule::Test.new(suffix)
+      end
+
+      add_case_rule Petrovich::Case::Rule.new(
+        gender: entry['gender'],
+        as: as,
+        section: section,
+        modifiers: modifiers,
+        tests: tests,
+        tags: entry['tags']
+      )
+    end
+
+    def load_gender_entry(as, section, entry)
+      add_gender_rule Gender::Rule.new(
+        as: as,
+        gender: section,
+        suffix: entry
+      )
+    end
+  end
+end

data/lib/petrovich/unicode.rb

@@ -1,4 +1,5 @@
-class Petrovich
+module Petrovich
+  # Custom downcase and upcase methods for russian language.
   module Unicode
     RU_UPPER = [
       "\u0410", "\u0411", "\u0412", "\u0413", "\u0414", "\u0415", "\u0416", "\u0417",
@@ -16,11 +17,11 @@ class Petrovich
       "\u0451" # Ё
     ].join
 
-    def downcase(entry)
+    def self.downcase(entry)
       entry.to_s.tr(RU_UPPER, RU_LOWER)
     end
 
-    def upcase(entry)
+    def self.upcase(entry)
       entry.to_s.tr(RU_LOWER, RU_UPPER)
     end
   end