fias 0.0.2 → 1.0.0

data/lib/fias/name/extract.rb

@@ -0,0 +1,85 @@
+module Fias
+  module Name
+    module Extract
+      class << self
+        def extract(name)
+          return if name.blank?
+          name = cleanup(name)
+
+          matches = find(name)
+          rates = assign_rates(name, matches)
+          winner = pick_winner(rates)
+          return [name] unless winner
+
+          extract_name(name, winner)
+        end
+
+        private
+
+        def cleanup(name)
+          name.split(' ').join(' ').strip
+        end
+
+        def find(name)
+          matches = Fias.config.index.keys.map do |query|
+            match = name.match(/(\s|^)(#{Regexp.escape(query)})(\.|\s|$)/ui)
+            match if match && match[2]
+          end
+          matches.compact
+        end
+
+        def assign_rates(name, matches)
+          matches.map { |match| rate_match(name, match) }
+        end
+
+        def rate_match(name, match)
+          short_name = match[2]
+
+          rate =
+            (ends_with_dot?(short_name) * REWARD[:dot]) +
+            (starts_with_small_letter?(short_name) * REWARD[:small_letter]) +
+            (border_proximity(name, match))
+
+          rate *= 100
+          rate += short_name.size
+
+          [rate, match]
+        end
+
+        def border_proximity(name, match)
+          head = name.size - match.begin(1) + REWARD[:head]
+          tail = match.end(2)
+          [head, tail].max
+        end
+
+        def ends_with_dot?(value)
+          value[-1] == '.' ? 1 : 0
+        end
+
+        def starts_with_small_letter?(value)
+          value[0] =~ SMALL_LETTER ? 1 : 0
+        end
+
+        def pick_winner(rates)
+          rates = rates.sort_by(&:first).reverse
+          rate, match = rates.first
+          return if (rates[1..-1] || []).any? { |(r, _)| rate == r }
+          match
+        end
+
+        def extract_name(name, winner)
+          short_name = winner[2]
+          toponym = cleanup(name.gsub(winner.regexp, ' '))
+          return [name] if toponym.strip.blank?
+          [cleanup(toponym), Canonical.canonical(short_name)].flatten
+        end
+
+        SMALL_LETTER = /[а-яё]/u
+
+        REWARD = {
+          dot: 3, small_letter: 2, head: 1
+        }
+      end
+    end
+  end
+end

data/lib/fias/name/house_number.rb

@@ -0,0 +1,71 @@
+module Fias
+  module Name
+    module HouseNumber
+      class << self
+        def extract(name)
+          return [name, nil] unless contains_number?(name)
+
+          name, number =
+            try_split_by_colon(name)   ||
+            try_housing(name)          ||
+            try_house_word(name)       ||
+            try_ends_with_number(name)
+
+          [name.strip, number.strip]
+        end
+
+        private
+
+        def contains_number?(name)
+          !(name =~ JUST_A_NUMBER) && !(name =~ LINE_OR_MICRODISTRICT) &&
+            (
+              name =~ COLON ||
+              name =~ ENDS_WITH_NUMBER ||
+              name =~ HOUSE_WORD ||
+              name =~ NUMBER_WITH_HOUSING
+            )
+        end
+
+        def try_split_by_colon(name)
+          name.split(/\s*,\s*/, 2) if name =~ COLON
+        end
+
+        def try_housing(name)
+          match = name.match(NUMBER_WITH_HOUSING)
+          [match.pre_match, "#{match} #{match.post_match}"] if match
+        end
+
+        def try_house_word(name)
+          match = name.match(HOUSE_WORD)
+          [match.pre_match, match.post_match] if match
+        end
+
+        def try_ends_with_number(name)
+          match = name.match(ENDS_WITH_NUMBER)
+          [match.pre_match, match[1]] if match
+        end
+
+        def or_words(words)
+          words
+            .sort_by(&:length)
+            .reverse
+            .map { |w| Regexp.escape(w) }
+            .join('|')
+        end
+      end
+
+      COLON                 = /\,/
+      JUST_A_NUMBER         = /^[\s\d]+$/
+      STOPWORDS             = /(микрорайон|линия|микр|мкрн|мкр|лин)/ui
+      LINE_OR_MICRODISTRICT = /#{STOPWORDS}\.?[\s\w+]?\d+$/ui
+      NUMBER                = /\d+\/?#{Fias::LETTERS}?\d*/ui
+      ENDS_WITH_NUMBER      = /(#{NUMBER})$/ui
+      HOUSE_WORDS           = %w(ом д дом вл кв)
+      HOUSE_WORD =
+        /(\s|\,|\.|^)(#{or_words(HOUSE_WORDS)})(\s|\,|\.|$)/ui
+      HOUSING_WORDS         = %w(корпус корп к)
+      NUMBER_WITH_HOUSING   =
+        /#{NUMBER}[\s\,\.]+(#{or_words(HOUSING_WORDS)})[\s\,\.]+#{NUMBER}/ui
+    end
+  end
+end

data/lib/fias/name/split.rb

@@ -0,0 +1,60 @@
+module Fias
+  module Name
+    module Split
+      class << self
+        def split(name)
+          words = sanitize(name).scan(Fias.word)
+          words = cleanup_brackets(words)
+          words = split_all_initials(words)
+          words = split_all_dotwords(words)
+
+          words
+            .reject(&:blank?)
+            .flatten
+            .uniq
+        end
+
+        private
+
+        def sanitize(name)
+          Unicode.downcase(name).gsub('ё', 'е').gsub(QUOTAS, '')
+        end
+
+        def cleanup_brackets(words)
+          words.map { |word, _| word.gsub(BRACKETS, '') }
+        end
+
+        def split_all_initials(words)
+          words
+            .map { |word, _| split_initials(word) || word }
+            .compact
+            .flatten
+        end
+
+        def split_initials(word)
+          m_matches = word.match(Fias::INITIALS)
+          return m_matches.values_at(1, 3) if m_matches
+
+          s_matches = word.match(Fias::SINGLE_INITIAL)
+          return s_matches.values_at(2, 3) if s_matches
+        end
+
+        def split_all_dotwords(words)
+          words
+            .map { |word, _| split_dotwords(word) || word }
+            .compact
+        end
+
+        def split_dotwords(word)
+          return unless word =~ DOTWORD
+          dotwords = word.gsub(DOTWORD, '\1 ')
+          dotwords.split(' ').uniq.delete_if(&:blank?)
+        end
+      end
+
+      DOTWORD           = /(#{LETTERS}{2,}\.)/ui
+      BRACKETS          = /(\(|\))/
+      QUOTAS            = /[\"\']/
+    end
+  end
+end

data/lib/fias/name/synonyms.rb

@@ -0,0 +1,93 @@
+module Fias
+  module Name
+    module Synonyms
+      class << self
+        def expand(name)
+          Split
+            .split(name)
+            .map { |token| Array.wrap(tokenize(name, token)) }
+        end
+
+        def tokens(name)
+          expand(name).flatten.uniq
+        end
+
+        def forms(name)
+          recombine(expand(name))
+        end
+
+        private
+
+        def tokenize(name, token)
+          synonyms(token)          ||
+            bracketed(name, token) ||
+            proper_names(token)    ||
+            initials(token)        ||
+            annivesary(token)      ||
+            numerals(token)        ||
+            token
+        end
+
+        def synonyms(token)
+          Fias.config.synonyms_index[token]
+        end
+
+        def bracketed(name, token)
+          match = name.match(IN_BRACKETS)
+          [token, OPTIONAL] if match && match[1].include?(token)
+        end
+
+        def proper_names(token)
+          [token, OPTIONAL] if Fias.config.proper_names.include?(token)
+        end
+
+        def initials(token)
+          return unless
+            (Fias::INITIALS =~ token) && (Fias::SINGLE_INITIAL =~ token)
+
+          [token, OPTIONAL]
+        end
+
+        def annivesary(token)
+          return unless token =~ Fias::ANNIVESARIES
+
+          ANNIVESARY_FORMS.map do |form|
+            token.gsub(Fias::ANNIVESARIES, form)
+          end
+        end
+
+        def numerals(token)
+          return unless (/^\d+/ =~ token) || (Fias::ANNIVESARIES =~ token)
+          numerals_for(token)
+        end
+
+        def numerals_for(numeral)
+          n = numeral.gsub(/[^\d]/, '')
+
+          suffixes =
+            NUMERAL_SUFFIXES.map do |suffix|
+              ["#{n}#{suffix}", "#{n}-#{suffix}"]
+            end
+
+          suffixes.flatten + [n]
+        end
+
+        def recombine(variants)
+          return variants if variants.empty?
+          head, *rest = variants
+
+          forms = head.product(*rest)
+          forms
+            .map { |variant| variant.reject(&:blank?).sort.join(' ') }
+            .flatten
+        end
+
+        IN_BRACKETS      = /\((.*)\)/
+        OPTIONAL         = ''
+        NUMERAL_SUFFIXES = %w(й я е ая ий ый ой ые ое го)
+        ANNIVESARY_FORMS =
+          ['\1-летия', '\1-лет', '\1 летия', '\1 лет', '\1-летие', '\1 летие']
+      end
+    end
+  end
+end

data/lib/fias/query.rb

@@ -0,0 +1,43 @@
+module Fias
+  module Query
+    def initialize(params)
+      @params = Params.new(params)
+      @finder = Finder.new(@params, method(:find))
+    end
+
+    attr_reader :params
+
+    def perform
+      assumption = @finder.assumption
+      estimate(assumption)
+    end
+
+    protected
+
+    def find(_tokens)
+      fail NotImplementedError
+    end
+
+    def estimate(assumption)
+      chains = estimate_chains(assumption)
+      reject_invalid_chains(chains)
+    end
+
+    def estimate_chains(assumption)
+      assumption
+        .map { |chain| [rate(chain), chain.first] }
+        .sort_by(&:first)
+        .reverse
+    end
+
+    def reject_invalid_chains(chains)
+      return chains if chains.empty?
+      highest_rate = chains.first.first
+      chains.keep_if { |c| c.first == highest_rate }
+    end
+
+    def rate(chain)
+      Estimate.new(@params, chain).estimate
+    end
+  end
+end

data/lib/fias/query/estimate.rb

@@ -0,0 +1,67 @@
+module Fias
+  module Query
+    class Estimate
+      def initialize(params, chain)
+        @params = params
+        @chain = chain
+      end
+
+      def estimate
+        for_subject +
+          for_found_parts +
+          for_type +
+          for_deepness +
+          for_name_proximity
+      end
+
+      private
+
+      def for_subject
+        expected_type = @params.sanitized.keys.first
+        expected_type == @chain.first[:key] ? RATES[:subject] : 0
+      end
+
+      def for_found_parts
+        @chain.size * RATES[:found_part]
+      end
+
+      def for_type
+        @params.sanitized.sum do |key, (_, *expected_status)|
+          received_status = chain_by_key[key].try(:[], :abbr)
+
+          status_found =
+            expected_status.present? &&
+            expected_status.include?(received_status)
+
+          status_found ? RATES[:type] : 0
+        end
+      end
+
+      def for_deepness
+        @chain.first[:ancestry].size * RATES[:deep]
+      end
+
+      def for_name_proximity
+        @params.synonyms.sum do |key, (expected, _)|
+          given = chain_by_key[key].try(:[], :tokens) || []
+          expected = expected.flatten.uniq
+
+          proximity = (given & expected).size
+          proximity * RATES[:name]
+        end
+      end
+
+      def chain_by_key
+        @chain_by_key ||= @chain.index_by { |item| item[:key] }
+      end
+
+      RATES = {
+        subject: 10000,   # It's most important to match street if street is requested
+        found_part: 1000, # Than, maximum parts number should coincide
+        type: 100,        # Than, status should coincide,
+        name: 5,          # Than, how close name matches are
+        deep: -1          # Than, how deep is matching chain situated
+      }
+    end
+  end
+end

data/lib/fias/query/finder.rb

@@ -0,0 +1,75 @@
+module Fias
+  module Query
+    class Finder
+      def initialize(params, find)
+        @params = params
+        @find = find
+      end
+
+      def assumption
+        find_endpoints
+        return [] if @endpoints.blank?
+        reject_inconsistent_chains
+      end
+
+      private
+
+      def find_endpoints
+        @endpoints = @params.split.keys.map do |key|
+          find_endpoint(key)
+        end
+        @endpoints = Hash[@endpoints]
+        inject_key_to_endpoints
+      end
+
+      def find_endpoint(key)
+        words = @params.split[key]
+        endpoints = find(words)
+        endpoints = reject_endpoints(endpoints, key)
+        [key, endpoints]
+      end
+
+      def find(words)
+        @find.call(words)
+      end
+
+      def reject_endpoints(endpoints, key)
+        forms = @params.forms[key]
+
+        endpoints.reject do |endpoint|
+          (forms & endpoint[:forms]).blank?
+        end
+      end
+
+      def inject_key_to_endpoints
+        @endpoints.each do |key, endpoints|
+          endpoints.each { |endpoint| endpoint[:key] = key }
+        end
+      end
+
+      def reject_inconsistent_chains
+        starting_endpoints = @endpoints.values.first
+        parents = endpoints_parents
+
+        chains = starting_endpoints.map do |endpoint|
+          overlaps = parents.keys & endpoint[:ancestry]
+
+          if parents.blank? || overlaps.present?
+            [endpoint] + endpoint[:ancestry].map { |id| parents[id] }.compact
+          end
+        end
+
+        chains.compact
+      end
+
+      def endpoints_parents
+        parents = @endpoints.values.slice(1..-1)
+        return [] if parents.nil?
+        parents
+          .flatten
+          .reverse
+          .index_by { |endpoint| endpoint[:id] }
+      end
+    end
+  end
+end