inci_score 3.1.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a79fad4040ad0788ff5c79163b3ad4416a01d2c129e03f5a5af7d76cee14f76
-  data.tar.gz: de8dcf441618726801b223e635268b1a8d6785bd27596f42854284c948e7c19e
+  metadata.gz: 65b6b9212d839ed17a978457cc654b835e34e6a7d68dad7c61cbd3f54eaac8cf
+  data.tar.gz: ab6f3cebda2cbf8875aa203edc747864f0953559bbf8472f4f757e3a1b505b8b
 SHA512:
-  metadata.gz: d4f6fe4ebd15bc1a65f3249688aa28da08d23af9117ac48d5df299f9129cfdf721623c1c5e853986bb24f73b87c0eb3f68e690e3ff009eb90045ba8e8a375dac
-  data.tar.gz: 846d875bc0d60304640c68b31a7d5d2505a7ce572a0a52983518058d816844bfe7f47f60bea53b86c680c718b82653f888671f63ecbdbd12560d3b114b28bb2a
+  metadata.gz: b51ecb14b357c1926f34ee19d558b5aed024bbda9e5070149abe046f9ef713e40d03749d3ce3d78ee6c1fd48358e9530fb84bed301e7024de18af5466bab5865
+  data.tar.gz: 5974307d97068c706bcc483854fd27c6a12e8761d86f3328cfbb1e561cfb06432ddeefcd18aa9d15fee0f3ad8a90260de4919f5a99884119462d93982d361f86

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Commerce Layer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -11,9 +11,6 @@
   * [CLI](#cli)
 * [Benchmark](#benchmark)
   * [Levenshtein in C](#levenshtein-in-c)
-  * [Platform](#platform)
-  * [Wrk](#wrk)
-  * [Results](#results)
 
 ## Scope
 This gem computes the score of cosmetic components basing on the information provided by the [Biodizionario site](http://www.biodizionario.it/) by Fabrizio Zago.
@@ -70,8 +67,8 @@ In such case the score is computed anyway by considering only recognized compone
 Is still possible to query the object for its state:
 
 ```ruby
-inci = InciScore::Computer.new(src: 'ingredients:aqua,noent1,noent2').call
-inci.valid # false
+inci = InciScore::Computer.new(src: 'ingredients:aqua,noent1,noent2')
+inci.valid? # false
 inci.unrecognized # ["noent1", "noent2"]
 ```
 
@@ -82,32 +79,15 @@ You can collect INCI data by using the available CLI interface:
 inci_score --src="ingredients: aqua, dimethicone, pej-10, noent"
 
 TOTAL SCORE:
-        47.1803
+      	47.18
 VALID STATE:
-        true
-COMPONENTS (hazard - name): 
-        aqua
-        dimethicone
-        peg-10
+      	true
+PRECISION:
+      	75.0
+COMPONENTS:
+      	aqua\n	dimethicone\n	peg-10
 UNRECOGNIZED:
-        noent
-```
-
-#### HTTP server
-The CLI interface exposes a Web layer based on the [Puma](http://puma.io/) application server.  
-The HTTP server is started on the specified port by spawning as many workers as your current workstation supports:
-```shell
-inci_score --http=9292
-```
-Consider all other options are discarded when running HTTP server.
-
-##### Triggering a request
-The HTTP server responds with a JSON representation of the original *InciScore::Response* object.  
-You can pass the source string directly as a HTTP parameter (URI escaped):
-
-```shell
-curl http://127.0.0.1:9292?src=aqua,dimethicone
-=> {"components":{"aqua":0,"dimethicone":4},"unrecognized":[],"score":53.7629,"valid":true}
+      	noent
 ```
 
 #### Getting help
@@ -115,7 +95,6 @@ You can get CLI interface help by:
 ```shell
 Usage: inci_score --src="aqua, parfum, etc"
     -s, --src=SRC                    The INCI list: "aqua, parfum, etc"
-        --http=PORT                  Start HTTP server on the specified port
     -h, --help                       Prints this help
 ```
 
@@ -124,25 +103,10 @@ Usage: inci_score --src="aqua, parfum, etc"
 ### Levenshtein in C
 I noticed the APIs slows down dramatically when dealing with unrecognized components to fuzzy match on.  
 I profiled the code by using the [benchmark-ips](https://github.com/evanphx/benchmark-ips) gem, finding the bottleneck was the pure Ruby implementation of the Levenshtein distance algorithm.  
-After some pointless optimization, i replaced this routine with a C implementation: i opted for the straightforward [Ruby Inline](https://github.com/seattlerb/rubyinline) library to call the C code straight from Ruby.  
-
-### Platform
-I registered these benchmarks with a MacBook PRO 15 mid 2015 having these specs:
-* OSX Sierra
-* 2,2 GHz Intel Core i7 (4 cores)
-* 16 GB 1600 MHz DDR3
-* Ruby 2.4
-
-### Wrk
-As always i used [wrk](https://github.com/wg/wrk) as the loading tool.
-I measured the library three times, picking the best lap.  
+After some pointless optimization, i replaced this routine with a C implementation: i opted for the straightforward [Ruby Inline](https://github.com/seattlerb/rubyinline) library to call the C code straight from Ruby.
+
+Once downloaded source code, run the bench specs by:
+
 ```shell
-wrk -t 4 -c 100 -d 30s --timeout 2000 "http://0.0.0.0:9292/?src=<source>"
+bundle exec rake spec:bench
 ```
-
-### Results
-| Source                      | Throughput (req/s) |
-| --------------------------: | -----------------: |
-| aqua,parfum,zeolite         |          20296.75  |
-| agua,porfum,zeolithe        |           1098.45  |
-| agua/water,porfum/fragrance |           1599.47  |

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "inci_score"
-require "irb"
-require "irb/completion"
+require 'bundler/setup'
+require 'inci_score'
+require 'irb'
+require 'irb/completion'
+
 IRB.start

data/bin/inci_score

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-lib = File.expand_path("../../lib", __FILE__)
+lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require "inci_score"
+require 'inci_score'
 
 InciScore::CLI.new(args: ARGV.clone).call

data/lib/inci_score/cli.rb

@@ -1,38 +1,37 @@
-require "optparse"
-require "inci_score/computer"
-require "inci_score/server"
+# frozen_string_literal: true
+
+require 'optparse'
+require 'inci_score/computer'
 
 module InciScore
   class CLI
-    def initialize(args:, io: STDOUT, catalog: InciScore::Catalog.fetch)
+    attr_reader :args, :io, :catalog
+    attr_accessor :src
+
+    def initialize(args:, io: STDOUT, catalog: Config::CATALOG)
       @args = args
       @io = io
       @catalog = catalog
       @src = nil
-      @port = nil
     end
 
-    def call(server_klass: Server, computer_klass: Computer)
-      parser.parse!(@args)
-      return server_klass.new(port: @port, preload: true).run if @port
-      return @io.puts(%q{Specify inci list as: --src="aqua, parfum, etc"}) unless @src
-      @io.puts computer_klass.new(src: @src, catalog: @catalog).call
+    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)
+      io.puts computer.call
     end
 
     private def parser
       OptionParser.new do |opts|
-        opts.banner = %q{Usage: inci_score --src="aqua, parfum, etc"}
-
-        opts.on("-sSRC", "--src=SRC", %q{The INCI list: "aqua, parfum, etc"}) do |src|
-          @src = src
-        end
+        opts.banner = %q{Usage: inci_score --src='aqua, parfum, etc'}
 
-        opts.on("--http=PORT", "Start HTTP server on the specified port") do |port|
-          @port = port
+        opts.on('-sSRC', '--src=SRC', %q{The INCI list: 'aqua, parfum, etc'}) do |src|
+          self.src = src
         end
 
-        opts.on("-h", "--help", "Prints this help") do
-          @io.puts opts
+        opts.on('-h', '--help', 'Prints this help') do
+          io.puts opts
           exit
         end
       end

data/lib/inci_score/computer.rb

@@ -1,50 +1,50 @@
-require "inci_score/ingredient"
-require "inci_score/normalizer"
-require "inci_score/recognizer"
-require "inci_score/response"
-require "inci_score/scorer"
+# frozen_string_literal: true
 
 module InciScore
   class Computer
     TOLERANCE = 30.0
-    PERCENT = 100.0
+    DECIMALS = 2
 
-    def initialize(src:, 
-                   catalog: Catalog.fetch, 
-                   tolerance: TOLERANCE, 
-                   rules: Normalizer::DEFAULT_RULES)
+    attr_reader :src, :catalog, :rules, :ingredients, :components, :unrecognized
+
+    def initialize(src:, catalog: Config::CATALOG, rules: Normalizer::DEFAULT_RULES)
+      @unrecognized = []
       @src = src
       @catalog = catalog
-      @tolerance = Float(tolerance)
       @rules = rules
-      @unrecognized = []
+      @ingredients = Normalizer.new(src: src, rules: rules).call
+      @components = fetch_components
+      freeze
     end
 
     def call
-      @response ||= Response.new(components: components.map(&:name),
-                                 unrecognized: @unrecognized,
-                                 score: score,
-                                 valid: valid?)
+      Response.new(components: components.map(&:name),
+                   unrecognized: unrecognized,
+                   score: score,
+                   valid: valid?,
+                   precision: precision)
     end
 
-    private def score
-      Scorer.new(components.map(&:hazard)).call
+    def score
+      Scorer.new(components.map(&:hazard)).call.round(DECIMALS)
     end
 
-    private def ingredients
-      @ingredients ||= Normalizer.new(src: @src, rules: @rules).call
+    def precision
+      (100 - ((unrecognized.size / Float(ingredients.size)) * 100)).round(DECIMALS)
     end
 
-    private def components
-      @components ||= ingredients.map do |ingredient|
-        Recognizer.new(ingredient, @catalog).call.tap do |component|
-          @unrecognized << ingredient unless component
-        end
-      end.compact
+    def valid?
+      precision >= TOLERANCE
     end
 
-    private def valid?
-      @unrecognized.size / (ingredients.size / PERCENT) <= @tolerance
+    private
+
+    def fetch_components
+      ingredients.map do |ingredient|
+        Recognizer.new(ingredient, catalog).call.tap do |component|
+          unrecognized << ingredient unless component
+        end
+      end.compact
     end
   end
 end

data/lib/inci_score/config.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module InciScore
+  module Config
+    CATALOG = YAML::load_file(File::expand_path('../../../config/catalog.yml', __FILE__)).freeze
+    HAZARDS = YAML::load_file(File::expand_path('../../../config/hazards.yml', __FILE__)).freeze
+  end
+end

data/lib/inci_score/ingredient.rb

@@ -1,40 +1,39 @@
+# frozen_string_literal: true
+
 module InciScore
   class Ingredient
-    SLASH = "/"
-    SLASH_RULE = /(?<!ate)\//
-    PARENTHESIS = %w[( ) [ ]]
-    DETAILS_RULE = /(\(.+\)|\[.+\])/
+    SLASH = '/'
+    SLASH_RULE = /(?<!ate)\//.freeze
+    PARENTHESIS = %w[( ) [ ]].freeze
+    DETAILS_RULE = /(\(.+\)|\[.+\])/.freeze
+
+    attr_reader :raw, :tokens, :values
 
     def initialize(raw)
       @raw = raw.to_s
       @tokens = @raw.split(SLASH_RULE).map(&:strip)
+      @values ||= synonims.unshift(name).compact
+      freeze
     end
 
     def to_s
       values.join(SLASH)
     end
 
-    def values
-      @values ||= synonims.unshift(name).compact
-    end
-
-    private def name
-      return @tokens.first unless parenthesis?
-      @raw.sub(DETAILS_RULE, "").strip
-    end
+    private
 
-    private def synonims
-      @tokens[1, @tokens.size].to_a
+    def name
+      return tokens.first unless parenthesis?
+      raw.sub(DETAILS_RULE, '').strip
     end
 
-    private def details
-      return unless parenthesis?
-      @raw.match(DETAILS_RULE)[1].delete(PARENTHESIS.join("|"))
+    def synonims
+      tokens[1, tokens.size].to_a
     end
 
-    private def parenthesis?
+    def parenthesis?
       PARENTHESIS.each_slice(2).any? do |pair|
-        pair.all? { |p| @raw.index(p) }
+        pair.all? { |p| raw.index(p) }
       end
     end
   end

data/lib/inci_score/levenshtein.rb

@@ -1,24 +1,28 @@
-require "inline"
+# frozen_string_literal: true
+
+require 'inline'
 
 module InciScore
   class LevenshteinC
-    C_PROGRAM = File::expand_path("../../../ext/levenshtein.c", __FILE__)
+    C_PROGRAM = File::expand_path('../../../ext/levenshtein.c', __FILE__)
 
     inline(:C) do |builder|
-      builder.c File::read(C_PROGRAM) 
+      builder.c File::read(C_PROGRAM)
     end
   end
 
   class Levenshtein
+    attr_reader :s, :t
+
     def initialize(s, t)
-      @s = s.downcase.unpack("U*")
-      @t = t.downcase.unpack("U*")
+      @s = s.downcase.unpack('U*')
+      @t = t.downcase.unpack('U*')
     end
 
     def call
-      n, m = @s.length, @t.length
+      n, m = s.length, t.length
 
-      return 0 if @s == @t
+      return 0 if s == t
       return m if n.zero?
       return n if m.zero?
 
@@ -28,7 +32,7 @@ module InciScore
       n.times do |i|
         e = i + 1
         m.times do |j|
-          c = @s[i] == @t[j] ? 0 : 1
+          c = s[i] == t[j] ? 0 : 1
           ins = d[j + 1] + 1
           del = e + 1
           sub = d[j] + c
@@ -43,4 +47,3 @@ module InciScore
     end
   end
 end
-

data/lib/inci_score/normalizer.rb

@@ -1,20 +1,22 @@
-require "inci_score/normalizer_rules"
+# frozen_string_literal: true
+
+require 'inci_score/normalizer_rules'
 
 module InciScore
   class Normalizer
-    DEFAULT_RULES = [Rules::Replacer, Rules::Downcaser, Rules::Beheader, Rules::Separator, Rules::Tokenizer, Rules::Sanitizer, Rules::Uniquifier]
+    DEFAULT_RULES = [Rules::Replacer, Rules::Downcaser, Rules::Beheader, Rules::Separator, Rules::Tokenizer, Rules::Sanitizer, Rules::Uniquifier].freeze
 
-    attr_reader :src
+    attr_reader :src, :rules
 
     def initialize(src:, rules: DEFAULT_RULES)
       @src = src
       @rules = rules
+      freeze
     end
 
     def call
-      yield(@rules) if block_given?
-      @rules.reduce(@src) do |src, rule|
-        @src = rule.call(src)
+      rules.reduce(src) do |_src, rule|
+        _src = rule.call(_src)
       end
     end
   end

data/lib/inci_score/normalizer_rules.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 module InciScore
   class Normalizer
     module Rules
       SEPARATOR = ','
 
+      Downcaser = ->(src) { src.downcase }.freeze
+
+      Tokenizer = ->(src) { src.split(SEPARATOR).map(&:strip) }.freeze
+
+      Uniquifier = ->(src) { Array(src).uniq }.freeze
+
       module Replacer
         extend self
 
@@ -14,7 +22,7 @@ module InciScore
           ['~', '-'],
           ['|', 'l'],
           [' I ', '/']
-        ]
+        ].freeze
 
         def call(src)
           REPLACEMENTS.reduce(src) do |_src, replacement|
@@ -24,14 +32,6 @@ module InciScore
         end
       end
 
-      module Downcaser
-        extend self
-
-        def call(src)
-          src.downcase
-        end
-      end 
-
       module Beheader
         extend self
 
@@ -40,7 +40,8 @@ module InciScore
 
         def call(src)
           sep_index = src.index(TITLE_SEP)
-          return src if !sep_index || sep_index > MAX_INDEX
+          return src unless sep_index
+          return src if sep_index > MAX_INDEX
           src[sep_index+1, src.size]
         end
       end
@@ -48,27 +49,19 @@ module InciScore
       module Separator
         extend self
 
-        SEPARATORS = ["; ", ". ", " ' ", " - ", " : "]
+        SEPARATORS = ['; ', '. ', " ' ", ' - ', ' : '].freeze
 
         def call(src)
           SEPARATORS.reduce(src) do |_src, separator|
             _src = _src.gsub(separator, SEPARATOR)
           end
         end
-      end 
-
-      module Tokenizer
-        extend self
-
-        def call(src)
-          src.split(SEPARATOR).map(&:strip)
-        end
       end
 
       module Sanitizer
         extend self
 
-        INVALID_CHARS = /[^\/\[\]\(\)\w\s-]/
+        INVALID_CHARS = /[^\/\[\]\(\)\w\s-]/.freeze
 
         def call(src)
           Array(src).map do |token|
@@ -76,14 +69,6 @@ module InciScore
           end.reject(&:empty?)
         end
       end
-
-      module Uniquifier
-        extend self
-
-        def call(src)
-          Array(src).uniq
-        end
-      end
     end
   end
 end

data/lib/inci_score/recognizer.rb

@@ -1,38 +1,43 @@
+# frozen_string_literal: true
+
 require "inci_score/recognizer_rules"
 
 module InciScore
   class Recognizer
-    DEFAULT_RULES = [Rules::Key, Rules::Levenshtein, Rules::Digits, Rules::Tokens]
+    DEFAULT_RULES = [Rules::Key, Rules::Levenshtein, Rules::Digits, Rules::Hazard, Rules::Tokens].freeze
 
     Component = Struct.new(:name, :hazard)
 
-    attr_reader :applied
+    attr_reader :ingredient, :catalog, :rules, :applied
 
     def initialize(ingredient, catalog, rules = DEFAULT_RULES, wrapper = Ingredient)
       @ingredient = wrapper.new(ingredient)
       @catalog = catalog
       @rules = rules
       @applied = []
+      freeze
     end
 
     def call
-      return if @ingredient.to_s.empty?
+      return if ingredient.to_s.empty?
       component = find_component
       return unless component
-      Component.new(component, @catalog[component])
-    end 
+      Component.new(component, catalog[component])
+    end
+
+    private
 
-    private def find_component
-      @rules.reduce(nil) do |component, rule|
+    def find_component
+      rules.reduce(nil) do |component, rule|
         break(component) if component
         applied << rule
         apply(rule)
       end
     end
 
-    private def apply(rule)
-      @ingredient.values.map do |value|
-        rule.call(value, @catalog)
+    def apply(rule)
+      ingredient.values.map do |value|
+        rule.call(value, catalog)
       end.find(&:itself)
     end
   end

data/lib/inci_score/recognizer_rules.rb

@@ -1,4 +1,6 @@
-require "inci_score/refinements"
+# frozen_string_literal: true
+
+require 'inci_score/refinements'
 
 module InciScore
   using Refinements
@@ -6,13 +8,9 @@ module InciScore
     module Rules
       TOLERANCE = 3
 
-      module Key
-        extend self
+      Key = ->(src, catalog) { src if catalog.has_key?(src) }
 
-        def call(src, catalog)
-          src if catalog.has_key?(src)
-        end
-      end
+      Hazard = ->(src, _) { 'generic-hazard' if Config::HAZARDS.any? { |h| src.include?(h) } }
 
       module Levenshtein
         extend self
@@ -54,19 +52,21 @@ module InciScore
       module Tokens
         extend self
 
-        UNMATCHABLE = %w[extract oil sodium acid sulfate]
-      
+        UNMATCHABLE = %w[extract oil sodium acid sulfate].freeze
+
         def call(src, catalog)
           tokens(src).each do |token|
-            catalog.each do |component, _| 
+            catalog.each do |component, _|
               return component if component.include?(token)
             end
           end
           nil
         end
 
+        private
+
         def tokens(src)
-          (src.split(" ") - UNMATCHABLE).reject { |t| t.size < TOLERANCE }.sort! { |a, b| b.size <=> a.size }
+          (src.split(' ') - UNMATCHABLE).reject { |t| t.size < TOLERANCE }.sort! { |a, b| b.size <=> a.size }
         end
       end
     end

data/lib/inci_score/refinements.rb

@@ -1,4 +1,6 @@
-require "inci_score/levenshtein"
+# frozen_string_literal: true
+
+require 'inci_score/levenshtein'
 
 module InciScore
   module Refinements