price_scanner 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9402118514fcd9aff9b7e4ea1b56d53e95f92c8cb93b8d58d8769f8ee9e5608c
+  data.tar.gz: 35dd2b7a9d8c96e1d21214813bfe368ded2e1dce42cf0f45d1bdc52c6ce12345
+SHA512:
+  metadata.gz: d3911479ea0209ef0caf8584cfb3f09d21567be2322ee4950b560b121364e66b7038771da64d329d31bc6f664c0a0149dac662748e362e00159a3350bcd7654d
+  data.tar.gz: 48b172e116ce23cfc3607517bf21d179f0758e02ab4c51fb6043ff2fc64d54314548daa2d0030d8015a572979dc31bd0e4bf9749d4548423fa7636ec5742749f

data/.reek.yml

@@ -0,0 +1,6 @@
+---
+detectors:
+  TooManyConstants:
+    enabled: false
+  TooManyStatements:
+    max_statements: 7

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,53 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+
+require:
+  - rubocop-rspec
+  - rubocop-rake
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 140
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 30
+
+Metrics/ModuleLength:
+  Max: 150
+
+Metrics/AbcSize:
+  Max: 35
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Style/Documentation:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/ExpectActual:
+  Enabled: false

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Justyna Wojtczak
+
+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

@@ -0,0 +1,177 @@
+# PriceScanner
+
+Battle-tested multi-currency price extraction from text. Supports PLN, EUR, GBP, USD with Polish and English number formats.
+
+## Installation
+
+```ruby
+gem "price_scanner"
+```
+
+## Usage
+
+### Parse a single price
+
+```ruby
+PriceScanner.parse("1.299,00 zł")
+# => { amount: 1299.0, currency: "PLN", text: "1.299,00 zł" }
+
+PriceScanner.parse("£49.99")
+# => { amount: 49.99, currency: "GBP", text: "£49.99" }
+```
+
+### Extract all prices from text
+
+```ruby
+PriceScanner.scan("Was £49.99 Now £29.99")
+# => [{ amount: 49.99, currency: "GBP", text: "£49.99" },
+#     { amount: 29.99, currency: "GBP", text: "£29.99" }]
+```
+
+### Check if text contains a price
+
+```ruby
+PriceScanner.contains_price?("Only 99,00 zł")  # => true
+PriceScanner.contains_price?("No price here")   # => false
+```
+
+### GDPR consent detection (optional, requires nokogiri)
+
+```ruby
+require "nokogiri"
+
+doc = Nokogiri::HTML(html)
+node = doc.css(".cookie-banner").first
+PriceScanner::ConsentDetector.consent_node?(node)  # => true/false
+```
+
+### Advanced API
+
+For finer control, use `Detector` and `Parser` modules directly.
+
+#### Detect prices in text
+
+```ruby
+PriceScanner::Detector.contains_price?("see price: 49,00 zł")  # => true
+
+PriceScanner::Detector.extract_prices_from_text("Was 49,00 zł, now 29,00 zł")
+# => [{ text: "49,00 zł", value: 49.0, position: 4 },
+#     { text: "29,00 zł", value: 29.0, position: 18 }]
+
+PriceScanner::Detector::PRICE_PATTERN  # => Regexp matching prices
+```
+
+#### Parse and normalize prices
+
+```ruby
+PriceScanner::Parser.normalized_price("1.299,00 zł")  # => 1299.0
+PriceScanner::Parser.normalized_price("$49.99")        # => 49.99
+
+PriceScanner::Parser.extract_currency("49,00 zł")  # => "PLN"
+PriceScanner::Parser.extract_currency("€120")      # => "EUR"
+```
+
+#### Strip price mentions from text
+
+```ruby
+PriceScanner::Parser.strip_price_mentions("Buy for 49,00 zł or 59,00 zł", "49,00 zł", "59,00 zł")
+# => "Buy for or"
+```
+
+#### Build a regex for a specific price value
+
+```ruby
+PriceScanner::Parser.price_regex_from_value("1.299,00 zł")
+# => Regexp matching variations like "1 299,00 zł", "1299,00zł", etc.
+```
+
+## Supported currencies
+
+| Currency | Symbol | Code | Example input | Parsed |
+|----------|--------|------|---------------|--------|
+| PLN | `zł`, `zl` | `PLN` | `1.299,00 zł` | 1299.0 |
+| EUR | `€` | `EUR` | `€99,00` | 99.0 |
+| USD | `$` | `USD` | `$1,019.00` | 1019.0 |
+| GBP | `£` | `GBP` | `£49.99` | 49.99 |
+
+Currency symbols and codes are matched case-insensitively (`pln`, `PLN`, `Pln` all work).
+
+## Supported number formats
+
+| Format | Example | Parsed |
+|--------|---------|--------|
+| Dot thousands, comma decimal (Polish) | `1.299,00 zł` | 1299.0 |
+| Space thousands, comma decimal | `1 299,00 zł` | 1299.0 |
+| NBSP thousands, comma decimal | `1\u00a0299,00 zł` | 1299.0 |
+| Comma thousands, dot decimal (English) | `$1,299.00` | 1299.0 |
+| No thousands separator | `799,00 zł` | 799.0 |
+| Integer (no decimals) | `£150` | 150.0 |
+| Currency before amount | `zł 248,86` | 248.86 |
+
+## Smart filtering
+
+Prices that match the following patterns are automatically excluded from results:
+
+### Negative prices
+
+Prices preceded by `-` or `−` (U+2212) are treated as discount badges and filtered out.
+
+```ruby
+PriceScanner.scan("449,00 zł -100,00 zł 349,00 zł")
+# => [{ amount: 449.0, ... }, { amount: 349.0, ... }]
+# -100,00 zł is excluded
+```
+
+### Price ranges
+
+Two prices connected by an en-dash (`–`, `—`) or spaced hyphen (` - `) are recognized as a range and both are removed.
+
+```ruby
+PriceScanner.scan("Size S–XL, £3.29 – £92.71, buy now for £49.99")
+# => [{ amount: 49.99, currency: "GBP", text: "£49.99" }]
+# range £3.29 – £92.71 is excluded
+```
+
+### Savings amounts
+
+When 3+ prices are detected and one equals the difference between two others (within ±2% tolerance), the savings amount is removed.
+
+```ruby
+PriceScanner.scan("Was 449,00 zł, now 349,00 zł. You save 100,00 zł!")
+# => [{ amount: 449.0, ... }, { amount: 349.0, ... }]
+# 100,00 zł is excluded (449 - 349 = 100)
+```
+
+### Per-unit prices
+
+Prices followed by a unit indicator are filtered out.
+
+Supported units: `kg`, `g`, `mg`, `l`, `ml`, `szt`, `m`, `m²`, `m³`, `cm`, `mm`, `op`, `opak`, `pcs`, `pc`, `unit`, `each`, `ea`, `kaps`, `tabl`, `tab`
+
+Recognized prefixes: `/` (slash) and `za` (Polish "per").
+
+```ruby
+PriceScanner.scan("32,74 zł/kg — buy 500g for 16,37 zł")
+# => [{ amount: 16.37, currency: "PLN", text: "16,37 zł" }]
+# 32,74 zł/kg is excluded
+```
+
+### Deduplication
+
+If the same price value appears multiple times, only one occurrence is kept.
+
+## Features
+
+- **Zero dependencies** (nokogiri optional, only for consent detection)
+- Case-insensitive currency matching
+- Handles regular spaces, non-breaking spaces (NBSP), and mixed whitespace
+- Tracks position of each price in the source text
+- Ignores letter-preceded numbers to avoid false positives from product codes (e.g. `DKA2zł`)
+
+## Used by
+
+- [snipe.sale](https://snipe.sale) — price tracking service processing thousands of product pages daily
+
+## License
+
+MIT License. See [LICENSE](LICENSE).

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/price_scanner/consent_detector.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PriceScanner
+  # Detects GDPR/cookie consent banners in HTML nodes (requires nokogiri).
+  module ConsentDetector
+    CONSENT_TEXT_REGEX = /
+      \bcookie\b|\bcookies\b|\bconsent\b|\bgdpr\b|\bprivacy\b|\btracking\b|\bpreferences\b|\bpersonaliz|marketing\s+cookies|
+      do\s+not\s+sell|opt\s+out|opt\s+in|cookie\s+policy|privacy\s+policy|
+      \bciasteczk(?:a|i|ami|ach|om)?\b|\bprywatn|\bzgod(?:a|y|ę|zie)?\b|\brodo\b
+    /ix
+    CONSENT_ACTION_REGEX = /
+      \baccept\b|\bagree\b|\ballow\b|\bmanage\b|\bpreferences\b|\bdecline\b|\breject\b|\bok\b|\bokay\b|\bcontinue\b|save\s+preferences|
+      accept\s+all|allow\s+all|got\s+it|\brozumiem\b|\bzgadzam\b|\bakceptuj|\bzaakceptuj|\bodrzuc|\bodmow
+    /ix
+    CONSENT_ATTR_REGEX = /
+      cookie|consent|gdpr|privacy|cmp|onetrust|trustarc|cookielaw|cookiebot|osano|
+      quantcast|usercentrics|didomi|cookieyes|termly|iubenda|shopify-pc__banner
+    /ix
+
+    ANCESTOR_DEPTH = 3
+
+    module_function
+
+    def consent_node?(node)
+      return false unless node
+
+      nodes = [node] + node.ancestors.take(ANCESTOR_DEPTH)
+      hits = detect_hits(nodes)
+      text_hit = hits[:text]
+      attr_hit = hits[:attr]
+      return false unless text_hit || attr_hit
+
+      (text_hit && hits[:action]) || attr_hit
+    end
+
+    def detect_hits(nodes)
+      result = { text: false, attr: false, action: false }
+      nodes.each do |item|
+        result[:text] ||= item.text.to_s.match?(CONSENT_TEXT_REGEX)
+        result[:attr] ||= attribute_text(item).match?(CONSENT_ATTR_REGEX)
+        result[:action] ||= action_button?(item)
+      end
+      result
+    end
+
+    ATTR_KEYS = %w[id class role aria-label aria-modal].freeze
+    ACTION_SELECTOR = "button, [role='button'], input[type='button'], input[type='submit'], a"
+
+    def attribute_text(node)
+      ATTR_KEYS.filter_map { |key| node[key] }.join(" ")
+    end
+
+    def action_button?(node)
+      node.css(ACTION_SELECTOR).any? do |button|
+        collect_text(button).match?(CONSENT_ACTION_REGEX)
+      end
+    end
+
+    def collect_text(node)
+      [node.text, node["aria-label"], node["title"], node["value"]].compact.join(" ")
+    end
+
+    private_class_method :detect_hits, :attribute_text, :action_button?, :collect_text
+  end
+end

data/lib/price_scanner/detector.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module PriceScanner
+  # Extracts prices from text using regex patterns with smart filtering.
+  module Detector
+    PRICE_PATTERN = /
+      (?:zł|pln|€|\$|£)[\s\u00a0]*(?:\d{1,3}(?:[.\s\u00a0]\d{3})+|\d{1,4})(?:[.,]\d{1,2})?  |
+      (?<![a-zA-Z])(?:\d{1,3}(?:[.\s\u00a0]\d{3})+|\d{1,4})[.,]\d{2}[\s\u00a0]*(?:zł|pln|€|\$|£|eur|usd|gbp)(?!\d)  |
+      (?<![a-zA-Z])(?:\d{1,3}(?:[.\s\u00a0]\d{3})+|\d{1,4})[\s\u00a0]*(?:zł|pln|€|\$|£)(?!\d)
+    /ix
+
+    PER_UNIT_PATTERN = %r{(?:/\s*|za\s+)(?:kg|g|mg|l|ml|szt|m[²³23]?|cm|mm|op|opak|pcs|pc|unit|each|ea|kaps|tabl|tab)\b}i
+    PER_UNIT_ANCHOR = /\A#{PER_UNIT_PATTERN.source}/i
+
+    NEGATIVE_PREFIXES = ["-", "\u2212"].freeze
+
+    RANGE_SEPARATOR_PATTERN = /\s*[–—]\s*|\s+-\s+/
+
+    TEXT_AFTER_LOOKAHEAD = 200
+    MIN_PRICES_FOR_RANGE = 2
+    MIN_PRICES_FOR_SAVINGS = 3
+    SAVINGS_MIN_RATIO = 0.1
+    SAVINGS_MIN_DIFF = 0.01
+    SAVINGS_TOLERANCE_RATIO = 0.02
+    SAVINGS_TOLERANCE_MIN = 1.0
+
+    module_function
+
+    def extract_prices_from_text(text)
+      text_str = text.to_s
+      raw_prices = scan_raw_prices(text_str)
+      filtered = filter_range_prices(raw_prices, text_str)
+      unique = filtered.uniq { |price| price[:value] }
+      filter_savings_by_difference(unique)
+    end
+
+    def contains_price?(text)
+      text.to_s.match?(PRICE_PATTERN)
+    end
+
+    def scan_raw_prices(text_str)
+      results = []
+      last_end = 0
+
+      text_str.scan(PRICE_PATTERN) do |match_str|
+        result, last_end = find_price_at(text_str, match_str, last_end)
+        results << result if result
+      end
+
+      results
+    end
+
+    def find_price_at(text_str, match_str, search_from)
+      return [nil, search_from] if match_str.empty?
+
+      match_index = text_str.index(match_str, search_from)
+      return [nil, search_from] unless match_index
+
+      match_end = match_index + match_str.length
+      [build_price_result(text_str, match_str, match_index), match_end]
+    end
+
+    def build_price_result(text_str, match_str, match_index)
+      value = Parser.normalized_price(match_str)
+      return unless value
+
+      return if negative_price?(text_str, match_index)
+      return if per_unit_price?(text_str, match_index + match_str.length)
+
+      clean_text = match_str.gsub(Parser::COLLAPSE_WHITESPACE, " ").strip
+      { text: clean_text, value: value, position: match_index }
+    end
+
+    def negative_price?(text_str, match_index)
+      match_index.positive? && NEGATIVE_PREFIXES.include?(text_str[match_index - 1])
+    end
+
+    def per_unit_price?(text_str, match_end)
+      text_after = text_str[match_end, TEXT_AFTER_LOOKAHEAD].to_s.gsub(Parser::COLLAPSE_WHITESPACE, " ").lstrip
+      text_after.match?(PER_UNIT_ANCHOR)
+    end
+
+    def filter_range_prices(prices, text)
+      return prices if prices.size < MIN_PRICES_FOR_RANGE
+
+      range_indices = find_range_indices(prices, text)
+      prices.reject.with_index { |_, idx| range_indices.include?(idx) }
+    end
+
+    def find_range_indices(prices, text)
+      indices = Set.new
+      prices.each_cons(2).with_index do |(current, next_price), idx|
+        if range_between?(current, next_price, text)
+          indices << idx
+          indices << (idx + 1)
+        end
+      end
+      indices
+    end
+
+    def range_between?(current, next_price, text)
+      start_pos = current[:position] + current[:text].length
+      end_pos = next_price[:position]
+      return false if end_pos <= start_pos
+
+      text[start_pos...end_pos].match?(RANGE_SEPARATOR_PATTERN)
+    end
+
+    def filter_savings_by_difference(prices)
+      return prices if prices.size < MIN_PRICES_FOR_SAVINGS
+
+      values = prices.map { |entry| entry[:value] }
+      min_value = values.min
+
+      return prices unless savings_amount?(values, min_value)
+
+      prices.zip(values).filter_map { |price, val| price unless val == min_value }
+    end
+
+    def savings_amount?(values, min_value)
+      values.combination(2).any? do |first, second|
+        next false if first == min_value || second == min_value
+
+        matches_savings_pattern?((first - second).abs, min_value)
+      end
+    end
+
+    def matches_savings_pattern?(diff, min_value)
+      return false if diff < [min_value * SAVINGS_MIN_RATIO, SAVINGS_MIN_DIFF].max
+
+      tolerance = [min_value * SAVINGS_TOLERANCE_RATIO, SAVINGS_TOLERANCE_MIN].max
+      (min_value - diff).abs <= tolerance
+    end
+
+    private_class_method :scan_raw_prices, :find_price_at, :build_price_result,
+                         :negative_price?, :per_unit_price?,
+                         :filter_range_prices, :find_range_indices, :range_between?,
+                         :filter_savings_by_difference, :savings_amount?, :matches_savings_pattern?
+  end
+end

data/lib/price_scanner/parser.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module PriceScanner
+  # Normalizes price strings into floats and extracts currency codes.
+  module Parser
+    CURRENCY_MAP = {
+      "zł" => "PLN", "pln" => "PLN", "zl" => "PLN",
+      "€" => "EUR", "eur" => "EUR",
+      "$" => "USD", "usd" => "USD",
+      "£" => "GBP", "gbp" => "GBP"
+    }.freeze
+
+    CURRENCY_SYMBOLS = CURRENCY_MAP.keys.map { |key| Regexp.escape(key) }.freeze
+    CURRENCY_REGEX = /(#{CURRENCY_SYMBOLS.join("|")})/i
+    CURRENCY_SUFFIX = /(?:#{CURRENCY_SYMBOLS.join("|")})/i
+
+    MULTIPLE_SPACES = /\s{2,}/
+    COLLAPSE_WHITESPACE = /\s+/
+    NBSP = "\u00a0"
+    DECIMAL_PLACES = 2
+    THOUSANDS_GROUP = /.{1,3}/
+
+    module_function
+
+    def normalized_price(value)
+      text = value.to_s.tr(NBSP, " ").strip
+      return nil if text.empty?
+
+      clean = clean_price_text(text)
+      return nil unless clean
+
+      Float(clean)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def extract_currency(value)
+      text = value.to_s
+      return nil if text.empty?
+
+      match = text.match(CURRENCY_REGEX)
+      resolve_currency(match)
+    end
+
+    def strip_price_mentions(text, *prices)
+      cleaned = text.to_s.tr(NBSP, " ")
+      prices.compact.each do |price|
+        cleaned = strip_single_price(cleaned, price)
+      end
+      cleaned.gsub(MULTIPLE_SPACES, " ").strip
+    end
+
+    def price_regex_from_value(value)
+      integer, decimals = split_price_parts(value)
+      int_pattern = thousands_pattern(integer)
+      /#{int_pattern}[.,]#{decimals}\s?#{CURRENCY_SUFFIX.source}?/i
+    end
+
+    def split_price_parts(value)
+      format("%.#{DECIMAL_PLACES}f", value).split(".")
+    end
+
+    def thousands_groups(integer)
+      integer.reverse.scan(THOUSANDS_GROUP).map(&:reverse).reverse
+    end
+
+    def thousands_pattern(integer)
+      thousands_groups(integer).join("[\\s\\u00a0]?")
+    end
+
+    def clean_price_text(text)
+      digits = text.gsub(/[^\d.,\s]/, "")
+      return nil if digits.empty?
+
+      normalize_separators(digits).gsub(/\s/, "")
+    end
+
+    def resolve_currency(match)
+      return nil unless match
+
+      symbol = match[1]
+      CURRENCY_MAP.fetch(symbol.downcase, symbol.upcase)
+    end
+
+    def strip_single_price(cleaned, price)
+      normalized = price.to_s.tr(NBSP, " ").strip
+      return cleaned if normalized.empty?
+
+      result = cleaned.gsub(normalized, "").gsub(normalized.delete(" "), "")
+      price_value = normalized_price(price)
+      return result unless price_value
+
+      result.gsub(price_regex_from_value(price_value), "")
+    end
+
+    def normalize_separators(clean)
+      return clean unless clean.include?(",")
+
+      if clean.include?(".")
+        resolve_mixed_separators(clean)
+      else
+        resolve_comma_only(clean)
+      end
+    end
+
+    def resolve_mixed_separators(clean)
+      if clean.rindex(",") > clean.rindex(".")
+        clean.delete(".").tr(",", ".")
+      else
+        clean.delete(",")
+      end
+    end
+
+    def resolve_comma_only(clean)
+      parts = clean.split(",")
+      if parts.size == 2
+        clean.tr(",", ".")
+      else
+        "#{parts[0...-1].join}.#{parts.last}"
+      end
+    end
+
+    private_class_method :clean_price_text, :resolve_currency, :strip_single_price,
+                         :normalize_separators, :resolve_mixed_separators,
+                         :resolve_comma_only
+  end
+end

data/lib/price_scanner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PriceScanner
+  VERSION = "0.1.0"
+end

data/lib/price_scanner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+Dir.glob(File.join(__dir__, "price_scanner", "*.rb")).each { |f| require_relative f }
+
+# Multi-currency price extraction from text.
+module PriceScanner
+  module_function
+
+  def parse(text)
+    prices = Detector.extract_prices_from_text(text)
+    return nil if prices.empty?
+
+    build_result(prices.first)
+  end
+
+  def scan(text)
+    Detector.extract_prices_from_text(text).map { |price| build_result(price) }
+  end
+
+  def contains_price?(text)
+    Detector.contains_price?(text)
+  end
+
+  def build_result(price)
+    price_text = price[:text]
+    { amount: price[:value], currency: Parser.extract_currency(price_text), text: price_text }
+  end
+
+  private_class_method :build_result
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: price_scanner
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Justyna
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Battle-tested price parser supporting PLN, EUR, GBP, USD. Extracts prices
+  from text, handles Polish and English number formats, filters savings badges and
+  price ranges.
+email:
+- justine84@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".reek.yml"
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE
+- README.md
+- Rakefile
+- lib/price_scanner.rb
+- lib/price_scanner/consent_detector.rb
+- lib/price_scanner/detector.rb
+- lib/price_scanner/parser.rb
+- lib/price_scanner/version.rb
+homepage: https://github.com/justi/price_scanner
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/justi/price_scanner
+  source_code_uri: https://github.com/justi/price_scanner
+  changelog_uri: https://github.com/justi/price_scanner/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Multi-currency price extraction from text
+test_files: []