brand_logo 1.0.0 → 2.0.0

data/lib/brand_logo/strategies/manifest.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'json'
+
+module BrandLogo
+  module Strategies
+    class Manifest
+      extend T::Sig
+      include Base
+
+      sig { override.returns(Symbol) }
+      def stage
+        :remote
+      end
+
+      sig { override.params(context: Context).returns(T::Array[Icon]) }
+      def call(context)
+        page = context.page
+        return [] unless page
+
+        manifest_url = page.resolve(page.document.at_css('link[rel~="manifest"]')&.[]('href'))
+        response = manifest_url && context.get(manifest_url)
+        return [] unless response
+
+        icons = parse(response)
+        icons.filter_map { |entry| build(entry, response.url) }
+      end
+
+      private
+
+      sig { params(response: Http::Response).returns(T::Array[T.untyped]) }
+      def parse(response)
+        data = JSON.parse(response.body)
+        icons = data['icons'] if data.is_a?(::Hash)
+        icons.is_a?(::Array) ? icons : []
+      rescue JSON::ParserError => e
+        Logging.logger.warn("Manifest: invalid JSON at #{response.url}: #{e.message}")
+        []
+      end
+
+      sig { params(entry: T.untyped, manifest_url: String).returns(T.nilable(Icon)) }
+      def build(entry, manifest_url)
+        return nil unless entry.is_a?(::Hash)
+
+        url = UrlResolver.resolve(entry['src'], manifest_url) if entry['src'].is_a?(String)
+        return nil unless url
+
+        Icon.new(
+          url: url,
+          source: :manifest,
+          kind: kind(entry['purpose']),
+          format: ImageFormat.from_mime(entry['type']) || ImageFormat.from_url(url),
+          dimensions: Dimensions.parse(entry['sizes'])
+        )
+      end
+
+      sig { params(purpose: T.untyped).returns(Symbol) }
+      def kind(purpose)
+        purposes = purpose.to_s.downcase.split
+        if purposes.include?('monochrome') then :monochrome
+        elsif purposes.include?('maskable') && !purposes.include?('any') then :maskable
+        else :icon
+        end
+      end
+    end
+  end
+end

data/lib/brand_logo/strategies/meta_tag.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+# typed: strict
+
+module BrandLogo
+  module Strategies
+    class MetaTag
+      extend T::Sig
+      include Base
+
+      KINDS = T.let({
+        'og:image' => :social,
+        'og:image:secure_url' => :social,
+        'og:image:url' => :social,
+        'twitter:image' => :social,
+        'twitter:image:src' => :social,
+        'og:logo' => :logo,
+        'msapplication-tileimage' => :tile
+      }.freeze, T::Hash[String, Symbol])
+
+      SIDES = T.let({ 'og:image:width' => :width, 'og:image:height' => :height }.freeze, T::Hash[String, Symbol])
+
+      sig { override.returns(Symbol) }
+      def stage
+        :document
+      end
+
+      sig { override.params(context: Context).returns(T::Array[Icon]) }
+      def call(context)
+        page = context.page
+        page ? collect(page) : []
+      end
+
+      private
+
+      sig { params(page: Page).returns(T::Array[Icon]) }
+      def collect(page)
+        icons = T.let([], T::Array[Icon])
+        og_index = T.let(nil, T.nilable(Integer))
+        entries(page.document).each do |key, content|
+          if (side = SIDES[key])
+            icons[og_index] = with_side(T.must(icons[og_index]), side, content.to_i) if og_index
+          elsif (icon = build(page, key, content))
+            og_index = icons.size if key.start_with?('og:image')
+            icons << icon
+          end
+        end
+        icons
+      end
+
+      sig { params(document: Nokogiri::HTML5::Document).returns(T::Array[[String, String]]) }
+      def entries(document)
+        document.css('meta[content]').map do |meta|
+          [(meta['property'] || meta['name']).to_s.strip.downcase, meta['content'].to_s.strip]
+        end
+      end
+
+      sig { params(page: Page, key: String, content: String).returns(T.nilable(Icon)) }
+      def build(page, key, content)
+        kind = KINDS[key]
+        url = page.resolve(content) if kind
+        return nil unless kind && url
+
+        Icon.new(url: url, source: :meta_tag, kind: kind, format: ImageFormat.from_url(url))
+      end
+
+      sig { params(icon: Icon, side: Symbol, pixels: Integer).returns(Icon) }
+      def with_side(icon, side, pixels)
+        return icon unless pixels.positive?
+
+        current = icon.dimensions
+        dimensions = if side == :width
+                       Dimensions.new(width: pixels, height: current.height)
+                     else
+                       Dimensions.new(width: current.width, height: pixels)
+                     end
+        icon.with(dimensions: dimensions)
+      end
+    end
+  end
+end

data/lib/brand_logo/url_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'uri'
+
+module BrandLogo
+  module UrlResolver
+    extend T::Sig
+
+    DATA_IMAGE = %r{\Adata:image/}i
+
+    sig { params(href: T.nilable(String), base: String).returns(T.nilable(String)) }
+    def self.resolve(href, base)
+      value = href.to_s.strip
+      return nil if value.empty?
+      return value if value.match?(DATA_IMAGE)
+
+      uri = join(base, value) || join(base, URI::DEFAULT_PARSER.escape(value))
+      uri.to_s if uri.is_a?(URI::HTTP) && uri.host
+    end
+
+    sig { params(base: String, value: String).returns(T.nilable(URI::Generic)) }
+    def self.join(base, value)
+      URI.join(base, value)
+    rescue URI::Error
+      nil
+    end
+    private_class_method :join
+  end
+end

data/lib/brand_logo/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module BrandLogo
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/brand_logo.rb

@@ -1,37 +1,39 @@
 # frozen_string_literal: true
 # typed: strict
 
-require 'sorbet-runtime'
+require_relative 'brand_logo/sorbet'
 
-# Foundation
 require_relative 'brand_logo/version'
 require_relative 'brand_logo/errors'
-require_relative 'brand_logo/config'
 require_relative 'brand_logo/logging'
-
-# Interfaces & implementations
-require_relative 'brand_logo/http_client'
-require_relative 'brand_logo/image_analyzer'
-require_relative 'brand_logo/html_parser'
-
-# Domain model
+require_relative 'brand_logo/concurrency'
+require_relative 'brand_logo/cache'
+require_relative 'brand_logo/dimensions'
+require_relative 'brand_logo/image_format'
 require_relative 'brand_logo/icon'
-
-# Strategies — base must be loaded before subclasses
-require_relative 'brand_logo/strategies/base_strategy'
-
-# Scraping utilities (loaded before strategies that use them)
-require_relative 'brand_logo/strategies/scraping/format_extractor'
-require_relative 'brand_logo/strategies/scraping/url_normalizer'
-require_relative 'brand_logo/strategies/scraping/dimensions_extractor'
-require_relative 'brand_logo/strategies/scraping/default_favicon_checker'
-require_relative 'brand_logo/strategies/scraping/icon_finder'
-
-# Concrete strategies
-require_relative 'brand_logo/strategies/scraping_strategy'
-require_relative 'brand_logo/strategies/duckduckgo_strategy'
-require_relative 'brand_logo/strategies/meta_tag_strategy'
-require_relative 'brand_logo/strategies/manifest_strategy'
-
-# Entry point
+require_relative 'brand_logo/config'
+require_relative 'brand_logo/deadline'
+require_relative 'brand_logo/domain'
+
+require_relative 'brand_logo/http/response'
+require_relative 'brand_logo/http/client'
+require_relative 'brand_logo/http/url_guard'
+require_relative 'brand_logo/http/real_client'
+
+require_relative 'brand_logo/url_resolver'
+require_relative 'brand_logo/image_probe'
+require_relative 'brand_logo/page'
+require_relative 'brand_logo/context'
+require_relative 'brand_logo/ranker'
+
+require_relative 'brand_logo/strategies/base'
+require_relative 'brand_logo/strategies/link_tag'
+require_relative 'brand_logo/strategies/json_ld'
+require_relative 'brand_logo/strategies/meta_tag'
+require_relative 'brand_logo/strategies/manifest'
+require_relative 'brand_logo/strategies/browserconfig'
+require_relative 'brand_logo/strategies/google'
+require_relative 'brand_logo/strategies/duckduckgo'
+
+require_relative 'brand_logo/lookup'
 require_relative 'brand_logo/fetcher'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brand_logo
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - AdVitam
@@ -30,6 +30,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -37,6 +40,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +64,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.18'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -65,23 +74,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.18'
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '2'
 description: 'Retrieves brand logos and icons from websites using a chain of strategies:
-  HTML favicon tags, Open Graph / Twitter meta images, PWA web app manifests, and
-  a DuckDuckGo fallback. Returns the best icon based on format and dimensions.'
+  HTML favicon tags, Open Graph / Twitter meta images, PWA web app manifests, JSON-LD
+  logos, browserconfig, then Google and DuckDuckGo fallbacks. Ranks every candidate
+  and returns the best one.'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -90,24 +89,37 @@ files:
 - LICENSE.txt
 - README.md
 - lib/brand_logo.rb
+- lib/brand_logo/cache.rb
+- lib/brand_logo/concurrency.rb
 - lib/brand_logo/config.rb
+- lib/brand_logo/context.rb
+- lib/brand_logo/deadline.rb
+- lib/brand_logo/dimensions.rb
+- lib/brand_logo/domain.rb
 - lib/brand_logo/errors.rb
 - lib/brand_logo/fetcher.rb
-- lib/brand_logo/html_parser.rb
-- lib/brand_logo/http_client.rb
+- lib/brand_logo/http/client.rb
+- lib/brand_logo/http/real_client.rb
+- lib/brand_logo/http/response.rb
+- lib/brand_logo/http/url_guard.rb
 - lib/brand_logo/icon.rb
-- lib/brand_logo/image_analyzer.rb
+- lib/brand_logo/image_format.rb
+- lib/brand_logo/image_probe.rb
 - lib/brand_logo/logging.rb
-- lib/brand_logo/strategies/base_strategy.rb
-- lib/brand_logo/strategies/duckduckgo_strategy.rb
-- lib/brand_logo/strategies/manifest_strategy.rb
-- lib/brand_logo/strategies/meta_tag_strategy.rb
-- lib/brand_logo/strategies/scraping/default_favicon_checker.rb
-- lib/brand_logo/strategies/scraping/dimensions_extractor.rb
-- lib/brand_logo/strategies/scraping/format_extractor.rb
-- lib/brand_logo/strategies/scraping/icon_finder.rb
-- lib/brand_logo/strategies/scraping/url_normalizer.rb
-- lib/brand_logo/strategies/scraping_strategy.rb
+- lib/brand_logo/lookup.rb
+- lib/brand_logo/page.rb
+- lib/brand_logo/ranker.rb
+- lib/brand_logo/sorbet.rb
+- lib/brand_logo/sorbet_shim.rb
+- lib/brand_logo/strategies/base.rb
+- lib/brand_logo/strategies/browserconfig.rb
+- lib/brand_logo/strategies/duckduckgo.rb
+- lib/brand_logo/strategies/google.rb
+- lib/brand_logo/strategies/json_ld.rb
+- lib/brand_logo/strategies/link_tag.rb
+- lib/brand_logo/strategies/manifest.rb
+- lib/brand_logo/strategies/meta_tag.rb
+- lib/brand_logo/url_resolver.rb
 - lib/brand_logo/version.rb
 homepage: https://github.com/AdVitam/brand_logo
 licenses:
@@ -132,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Fetch the best logo or icon for any website from its domain
 test_files: []

data/lib/brand_logo/html_parser.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-require 'sorbet-runtime'
-require 'nokogiri'
-
-module BrandLogo
-  # Value Object wrapping a parsed HTML document.
-  # Exposes only the subset of the Nokogiri API that strategies need,
-  # preventing strategies from depending on Nokogiri directly.
-  class ParsedDocument
-    extend T::Sig
-
-    sig { params(doc: Nokogiri::HTML::Document).void }
-    def initialize(doc)
-      @doc = T.let(doc, Nokogiri::HTML::Document)
-    end
-
-    # Returns all elements matching the CSS selector.
-    sig { params(selector: String).returns(T::Array[T.untyped]) }
-    def css(selector)
-      @doc.css(selector).to_a
-    end
-
-    # Returns the first element matching the CSS selector, or nil.
-    sig { params(selector: String).returns(T.untyped) }
-    def at(selector)
-      @doc.at(selector)
-    end
-
-    # Returns the href of the <base> tag if present.
-    sig { returns(T.nilable(String)) }
-    def base_href
-      node = @doc.at('base')
-      return nil unless node
-
-      node['href']
-    end
-  end
-
-  # Interface for parsing raw HTML into a ParsedDocument.
-  # Strategies receive this via dependency injection.
-  module HtmlParser
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
-    sig { abstract.params(html: String).returns(ParsedDocument) }
-    def parse(html); end
-  end
-
-  # Concrete implementation using the Nokogiri gem.
-  class NokogiriParser
-    extend T::Sig
-    include HtmlParser
-
-    sig { override.params(html: String).returns(ParsedDocument) }
-    def parse(html)
-      ParsedDocument.new(Nokogiri::HTML(html))
-    end
-  end
-end

data/lib/brand_logo/http_client.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-require 'sorbet-runtime'
-require 'http'
-
-module BrandLogo
-  # Interface for HTTP operations used by strategies.
-  # Decouples strategies from the HTTP gem, enabling injection of test doubles.
-  module HttpClient
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
-    # Fetches the body of a URL. Returns nil on any failure (network, non-2xx, timeout).
-    sig { abstract.params(url: String).returns(T.nilable(String)) }
-    def get_body(url); end
-
-    # Returns true if a HEAD request to the URL succeeds (2xx). Returns false on any failure.
-    sig { abstract.params(url: String).returns(T::Boolean) }
-    def head_success?(url); end
-  end
-
-  # Concrete HTTP client using the `http` gem.
-  # Centralizes timeout and redirect configuration previously hardcoded
-  # across ScrapingStrategy, DuckduckgoStrategy, and UrlNormalizer.
-  class RealHttpClient
-    extend T::Sig
-    include HttpClient
-
-    sig { params(config: Config).void }
-    def initialize(config)
-      @timeout  = T.let(config.timeout, Integer)
-      @max_hops = T.let(config.max_hops, Integer)
-    end
-
-    sig { override.params(url: String).returns(T.nilable(String)) }
-    def get_body(url)
-      response = HTTP
-                 .timeout(connect: @timeout, read: @timeout, write: @timeout)
-                 .follow(max_hops: @max_hops)
-                 .get(url)
-      response.status.success? ? response.body.to_s : nil
-    rescue StandardError
-      nil
-    end
-
-    sig { override.params(url: String).returns(T::Boolean) }
-    def head_success?(url)
-      response = HTTP
-                 .timeout(connect: @timeout, read: @timeout, write: @timeout)
-                 .head(url)
-      response.status.success?
-    rescue StandardError
-      false
-    end
-  end
-end

data/lib/brand_logo/image_analyzer.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-require 'sorbet-runtime'
-require 'fastimage'
-
-module BrandLogo
-  # Interface for extracting image dimensions from a URL.
-  # Implementations are injected into strategies, enabling testing without network calls.
-  module ImageAnalyzer
-    extend T::Sig
-    extend T::Helpers
-
-    interface!
-
-    sig { abstract.params(url: String).returns(T::Hash[Symbol, T.nilable(Integer)]) }
-    def dimensions(url); end
-  end
-
-  # Concrete implementation using the FastImage gem.
-  # Avoids downloading the full image by parsing only the header bytes.
-  class FastimageAnalyzer
-    extend T::Sig
-    include ImageAnalyzer
-
-    sig { override.params(url: String).returns(T::Hash[Symbol, T.nilable(Integer)]) }
-    def dimensions(url)
-      result = FastImage.size(url)
-      return { width: nil, height: nil } unless result
-
-      { width: result[0], height: result[1] }
-    rescue StandardError
-      { width: nil, height: nil }
-    end
-  end
-end

data/lib/brand_logo/strategies/base_strategy.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-# typed: strict
-
-require 'sorbet-runtime'
-
-module BrandLogo
-  module Strategies
-    # Abstract base class implementing the Template Method pattern.
-    #
-    # Subclasses implement `fetch_all` (the customization point).
-    # `fetch` is the common algorithm: fetch_all → filter valid → select best.
-    # This eliminates duplicated selection/validation logic across strategies.
-    class BaseStrategy
-      extend T::Sig
-      extend T::Helpers
-
-      abstract!
-
-      UNKNOWN_DIMENSION_SCORE = T.let(-1, Integer)
-
-      sig { params(config: Config).void }
-      def initialize(config:)
-        @config = T.let(config, Config)
-      end
-
-      # Returns ALL icons found for the domain (unfiltered).
-      # Subclasses must implement this method.
-      sig { abstract.params(domain: String).returns(T::Array[Icon]) }
-      def fetch_all(domain); end
-
-      # Returns the best valid icon for the domain, or nil if none found.
-      # Delegates to fetch_all, filters by validity, then selects the best.
-      sig { params(domain: String).returns(T.nilable(Icon)) }
-      def fetch(domain)
-        valid_icons = fetch_all(domain).select { |icon| valid_icon?(icon) }
-        select_best_icon(valid_icons)
-      end
-
-      protected
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def valid_icon?(icon)
-        valid_dimensions?(icon) && valid_format?(icon)
-      end
-
-      private
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def valid_dimensions?(icon)
-        return true if svg_icon?(icon)
-        return true if missing_dimensions?(icon)
-
-        meets_minimum_dimensions?(icon) && within_maximum_dimensions?(icon)
-      end
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def valid_format?(icon)
-        return true if icon.format != 'svg'
-
-        @config.allow_svg
-      end
-
-      sig { params(icons: T::Array[Icon]).returns(T.nilable(Icon)) }
-      def select_best_icon(icons)
-        return nil if icons.empty?
-
-        if @config.allow_svg
-          svg_icon = icons.find { |icon| icon.format == 'svg' }
-          return svg_icon if svg_icon
-        end
-
-        icons.max_by { |icon| icon_score(icon) }
-      end
-
-      sig { params(icon: Icon).returns(Integer) }
-      def icon_score(icon)
-        width  = icon.dimensions[:width]
-        height = icon.dimensions[:height]
-        return UNKNOWN_DIMENSION_SCORE if width.nil? || height.nil?
-
-        width * height
-      end
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def svg_icon?(icon)
-        @config.allow_svg && icon.format == 'svg'
-      end
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def missing_dimensions?(icon)
-        icon.dimensions[:width].nil? || icon.dimensions[:height].nil?
-      end
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def meets_minimum_dimensions?(icon)
-        min = @config.min_dimensions
-        width  = icon.dimensions[:width]
-        height = icon.dimensions[:height]
-        return false if width.nil? || height.nil?
-
-        width >= min[:width] && height >= min[:height]
-      end
-
-      sig { params(icon: Icon).returns(T::Boolean) }
-      def within_maximum_dimensions?(icon)
-        max = @config.max_dimensions
-        return true if max.nil?
-
-        width  = icon.dimensions[:width]
-        height = icon.dimensions[:height]
-        return true if width.nil? || height.nil?
-
-        width <= max[:width] && height <= max[:height]
-      end
-    end
-  end
-end