inci_score 4.1.5 → 4.3.0

data/lib/inci_score/cli.rb

@@ -4,20 +4,19 @@ require 'optparse'
 
 module InciScore
   class CLI
-    attr_reader :args, :io, :catalog
+    attr_reader :args, :io
     attr_accessor :src
 
-    def initialize(args:, io: STDOUT, catalog: Config::CATALOG)
+    def initialize(args:, io: STDOUT)
       @args = args
       @io = io
-      @catalog = catalog
       @src = nil
     end
 
     def call
       parser.parse!(args)
       return io.puts(%q{Specify inci list as: --src='aqua, parfum, etc'}) unless src
-      computer = Computer.new(src: src, catalog: catalog)
+      computer = Computer.new(src: src)
       io.puts computer.call
     end
 

data/lib/inci_score/computer.rb

@@ -5,12 +5,11 @@ module InciScore
     TOLERANCE = 30.0
     DECIMALS = 2
 
-    attr_reader :src, :catalog, :rules, :ingredients, :components, :unrecognized
+    attr_reader :src, :rules, :ingredients, :components, :unrecognized
 
-    def initialize(src:, catalog: Config::CATALOG, rules: Normalizer::DEFAULT_RULES)
+    def initialize(src:, rules: Normalizer::DEFAULT_RULES)
       @unrecognized = []
       @src = src
-      @catalog = catalog
       @rules = rules
       @ingredients = Normalizer.new(src: src, rules: rules).call
       @components = fetch_components
@@ -40,7 +39,7 @@ module InciScore
 
     def fetch_components
       ingredients.map do |ingredient|
-        Recognizer.new(ingredient, catalog).call.tap do |component|
+        Recognizer.new(ingredient).call.tap do |component|
           unrecognized << ingredient unless component
         end
       end.compact

data/lib/inci_score/config.rb

@@ -5,6 +5,7 @@ require 'yaml'
 module InciScore
   module Config
     CATALOG = YAML::load_file(File::expand_path('../../../config/catalog.yml', __FILE__)).freeze
+    CIR = File.readlines(File::expand_path('../../../config/cir', __FILE__)).freeze
     HAZARDS = YAML::load_file(File::expand_path('../../../config/hazards.yml', __FILE__)).freeze
   end
 end

data/lib/inci_score/ingredient.rb

@@ -5,14 +5,13 @@ module InciScore
     SLASH = '/'
     SLASH_RULE = /(?<!ate)\//.freeze
     PARENTHESIS = %w[( ) [ ]].freeze
-    DETAILS_RULE = /(\(.+\)|\[.+\])/.freeze
+    PARENTHESIS_RULE = /(\(.+\)|\[.+\])/.freeze
 
-    attr_reader :raw, :tokens, :values
+    attr_reader :raw, :values
 
     def initialize(raw)
       @raw = raw.to_s
-      @tokens = @raw.split(SLASH_RULE).map(&:strip)
-      @values ||= synonims.unshift(name).compact
+      @values = fetch_values
       freeze
     end
 
@@ -22,13 +21,15 @@ module InciScore
 
     private
 
-    def name
-      return tokens.first unless parenthesis?
-      raw.sub(DETAILS_RULE, '').strip
-    end
-
-    def synonims
-      tokens[1, tokens.size].to_a
+    def fetch_values
+      if parenthesis?
+        parenthesis = PARENTHESIS.join
+        parenthesis_values = raw.match(PARENTHESIS_RULE).captures.map { |c| c.delete(parenthesis) }
+        deparenthesized = raw.sub(PARENTHESIS_RULE, '').sub(/\s+/, ' ').strip
+        [deparenthesized].concat(parenthesis_values)
+      else
+        raw.split(SLASH_RULE).map(&:strip)
+      end
     end
 
     def parenthesis?

data/lib/inci_score/recognizer.rb

@@ -2,15 +2,14 @@
 
 module InciScore
   class Recognizer
-    DEFAULT_RULES = [Rules::Key, Rules::Levenshtein, Rules::Digits, Rules::Hazard, Rules::Tokens].freeze
+    DEFAULT_RULES = [Rules::Key, Rules::Levenshtein, Rules::Hazard, Rules::Prefix, Rules::Tokens].freeze
 
     Component = Struct.new(:name, :hazard)
 
-    attr_reader :ingredient, :catalog, :rules, :applied
+    attr_reader :ingredient, :rules, :applied
 
-    def initialize(ingredient, catalog, rules = DEFAULT_RULES, wrapper = Ingredient)
-      @ingredient = wrapper.new(ingredient)
-      @catalog = catalog
+    def initialize(ingredient, rules = DEFAULT_RULES)
+      @ingredient = Ingredient.new(ingredient)
       @rules = rules
       @applied = []
       freeze
@@ -20,7 +19,7 @@ module InciScore
       return if ingredient.to_s.empty?
       component = find_component
       return unless component
-      Component.new(component, catalog[component])
+      Component.new(component, Config::CATALOG[component])
     end
 
     private
@@ -35,7 +34,7 @@ module InciScore
 
     def apply(rule)
       ingredient.values.map do |value|
-        rule.call(value, catalog)
+        rule.call(value)
       end.find(&:itself)
     end
   end

data/lib/inci_score/recognizer_rules.rb

@@ -7,9 +7,9 @@ module InciScore
     module Rules
       TOLERANCE = 3
 
-      Key = ->(src, catalog) { src if catalog.has_key?(src) }
+      Key = ->(src) { src if Config::CATALOG.has_key?(src) }
 
-      Hazard = ->(src, _) { 'generic-hazard' if Config::HAZARDS.any? { |h| src.include?(h) } }
+      Hazard = ->(src) { 'generic-hazard' if Config::HAZARDS.any? { |h| src.include?(h) } }
 
       module Levenshtein
         extend self
@@ -20,12 +20,12 @@ module InciScore
           end
         end
 
-        def call(src, catalog)
+        def call(src)
           return if src.empty?
           size = src.size
           farthest = Result.new(nil, size)
           initial = src[0]
-          result = catalog.reduce(farthest) do |nearest, (component, _)|
+          result = Config::CATALOG.reduce(farthest) do |nearest, (component, _)|
             next nearest unless component.start_with?(initial)
             next nearest if component.size > (size + TOLERANCE)
             d = src.distance(component)
@@ -36,15 +36,15 @@ module InciScore
         end
       end
 
-      module Digits
+      module Prefix
         extend self
 
         MIN_MEANINGFUL = 7
 
-        def call(src, catalog)
+        def call(src)
           return if src.size < TOLERANCE
           digits = src[0, MIN_MEANINGFUL]
-          catalog.detect { |component, _| component.start_with?(digits) }.to_a.first
+          Config::CATALOG.detect { |component, _| component.start_with?(digits) }.to_a.first
         end
       end
 
@@ -53,9 +53,10 @@ module InciScore
 
         UNMATCHABLE = %w[extract oil sodium acid sulfate].freeze
 
-        def call(src, catalog)
+        def call(src)
+          return if src.size <= TOLERANCE
           tokens(src).each do |token|
-            catalog.each do |component, _|
+            Config::CATALOG.each do |component, _|
               return component if component.include?(token)
             end
           end
@@ -65,7 +66,8 @@ module InciScore
         private
 
         def tokens(src)
-          (src.split(' ') - UNMATCHABLE).reject { |t| t.size < TOLERANCE }.sort! { |a, b| b.size <=> a.size }
+          words = src.split(' ').map { |w| w.split('-') }.flatten
+          (words - UNMATCHABLE).reject { |t| t.size < TOLERANCE }.sort! { |a, b| b.size <=> a.size }
         end
       end
     end

data/lib/inci_score/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module InciScore
-  VERSION = '4.1.5'
+  VERSION = '4.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inci_score
 version: !ruby/object:Gem::Version
-  version: 4.1.5
+  version: 4.3.0
 platform: ruby
 authors:
 - costajob
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-04 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -106,6 +106,7 @@ files:
 - README.md
 - bin/inci_score
 - config/catalog.yml
+- config/cir
 - config/hazards.yml
 - ext/levenshtein.c
 - lib/inci_score.rb