browserx 1.0.0

data/lib/browser/base.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Browser
+  class Base
+    include DetectVersion
+
+    attr_reader :ua
+
+    def initialize(ua, accept_language: nil)
+      validate_size(:user_agent, ua.to_s)
+
+      @ua = ua
+      @accept_language_raw = accept_language.to_s
+    end
+
+    # Return a meta info about this browser.
+    def meta
+      Meta.get(self)
+    end
+
+    # Return an array with all preferred languages that this browser accepts.
+    def accept_language
+      @accept_language ||= begin
+        validate_size(:accept_language, @accept_language_raw)
+        AcceptLanguage.parse(@accept_language_raw)
+      end
+    end
+
+    alias_method :to_a, :meta
+
+    # Return meta representation as string.
+    def to_s
+      meta.to_a.join(" ")
+    end
+
+    def version
+      full_version.split(".").first
+    end
+
+    # Return the platform.
+    def platform
+      @platform ||= Platform.new(ua)
+    end
+
+    # Return the bot info.
+    def bot
+      @bot ||= Bot.new(ua)
+    end
+
+    # Detect if current user agent is from a bot.
+    def bot?
+      bot.bot?
+    end
+
+    # Return the device info.
+    def device
+      @device ||= Device.new(ua, platform:)
+    end
+
+    # Detect if browser is Microsoft Internet Explorer.
+    def ie?(expected_version = nil)
+      instance_of?(InternetExplorer) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Microsoft Edge.
+    def edge?(expected_version = nil)
+      instance_of?(Edge) && detect_version?(full_version, expected_version)
+    end
+
+    def compatibility_view?
+      false
+    end
+
+    def msie_full_version
+      "0.0"
+    end
+
+    def msie_version
+      "0"
+    end
+
+    # Detect if browser is Instagram.
+    def instagram?(expected_version = nil)
+      instance_of?(Instagram) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Snapchat.
+    def snapchat?(expected_version = nil)
+      instance_of?(Snapchat) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser if Facebook.
+    def facebook?(expected_version = nil)
+      instance_of?(Facebook) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Otter.
+    def otter?(expected_version = nil)
+      instance_of?(Otter) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is WebKit-based.
+    def webkit?(expected_version = nil)
+      ua.match?(/AppleWebKit/i) &&
+        (!edge? || chromium_based?) &&
+        detect_version?(webkit_full_version, expected_version)
+    end
+
+    # Detect if browser is QuickTime
+    def quicktime?(expected_version = nil)
+      ua.match?(/QuickTime/i) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Apple CoreMedia.
+    def core_media?(expected_version = nil)
+      ua.include?("CoreMedia") && detect_version?(full_version,
+        expected_version)
+    end
+
+    # Detect if browser is PhantomJS
+    def phantom_js?(expected_version = nil)
+      instance_of?(PhantomJS) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Safari.
+    def safari?(expected_version = nil)
+      instance_of?(Safari) && detect_version?(full_version, expected_version)
+    end
+
+    def safari_webapp_mode?
+      (device.ipad? || device.iphone?) && ua.include?("AppleWebKit")
+    end
+
+    # Detect if browser is Firefox.
+    def firefox?(expected_version = nil)
+      instance_of?(Firefox) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Chrome.
+    def chrome?(expected_version = nil)
+      instance_of?(Chrome) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Opera.
+    def opera?(expected_version = nil)
+      instance_of?(Opera) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Sputnik.
+    def sputnik?(expected_version = nil)
+      instance_of?(Sputnik) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Yandex.
+    def yandex?(expected_version = nil)
+      instance_of?(Yandex) && detect_version?(full_version, expected_version)
+    end
+    alias_method :yandex_browser?, :yandex?
+
+    # Detect if browser is UCBrowser.
+    def uc_browser?(expected_version = nil)
+      instance_of?(UCBrowser) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Nokia S40 Ovi Browser.
+    def nokia?(expected_version = nil)
+      instance_of?(Nokia) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is MicroMessenger.
+    def micro_messenger?(expected_version = nil)
+      instance_of?(MicroMessenger) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    alias_method :wechat?, :micro_messenger?
+
+    def weibo?(expected_version = nil)
+      instance_of?(Weibo) && detect_version?(full_version, expected_version)
+    end
+
+    def alipay?(expected_version = nil)
+      instance_of?(Alipay) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Opera Mini.
+    def opera_mini?(expected_version = nil)
+      ua.include?("Opera Mini") && detect_version?(full_version,
+        expected_version)
+    end
+
+    # Detect if browser is DuckDuckGo.
+    def duck_duck_go?(expected_version = nil)
+      ua.include?("DuckDuckGo") && detect_version?(full_version,
+        expected_version)
+    end
+
+    # Detect if browser is Samsung.
+    def samsung_browser?(expected_version = nil)
+      ua.include?("SamsungBrowser") && detect_version?(full_version,
+        expected_version)
+    end
+
+    # Detect if browser is Huawei.
+    def huawei_browser?(expected_version = nil)
+      instance_of?(HuaweiBrowser) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Xiaomi Miui.
+    def miui_browser?(expected_version = nil)
+      instance_of?(MiuiBrowser) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Maxthon.
+    def maxthon?(expected_version = nil)
+      instance_of?(Maxthon) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is QQ.
+    def qq?(expected_version = nil)
+      instance_of?(QQ) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Sougou.
+    def sougou_browser?(expected_version = nil)
+      instance_of?(SougouBrowser) &&
+        detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Google Search App
+    def google_search_app?(expected_version = nil)
+      ua.include?("GSA") && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if browser is Chromium-based.
+    def chromium_based?
+      false
+    end
+
+    def webkit_full_version
+      ua[%r{AppleWebKit/([\d.]+)}, 1] || "0.0"
+    end
+
+    def known?
+      !unknown?
+    end
+
+    def unknown?
+      id == :unknown_browser
+    end
+
+    # Detect if browser is a proxy browser.
+    def proxy?
+      nokia? || uc_browser? || opera_mini?
+    end
+
+    # Detect if the browser is Electron.
+    def electron?(expected_version = nil)
+      instance_of?(Electron) && detect_version?(full_version, expected_version)
+    end
+
+    # Detect if the browser is Epiphany.
+    def epiphany?(expected_version = nil)
+      instance_of?(Epiphany) && detect_version?(full_version, expected_version)
+    end
+
+    private def validate_size(subject, input)
+      actual_bytesize = input.bytesize
+      size_limit =
+        if subject == :user_agent
+          Browser.user_agent_size_limit
+        else
+          Browser.accept_language_size_limit
+        end
+
+      return if actual_bytesize < size_limit
+
+      raise Error,
+        "#{subject} cannot be larger than #{size_limit} bytes; " \
+        "actual size is #{actual_bytesize} bytes"
+    end
+  end
+end

data/lib/browser/blackberry.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Browser
+  class BlackBerry < Base
+    def id
+      :blackberry
+    end
+
+    def name
+      "BlackBerry"
+    end
+
+    def full_version
+      ua[%r{BlackBerry[\da-z]+/([\d.]+)}, 1] ||
+        ua[%r{Version/([\d.]+)}, 1] ||
+        "0.0"
+    end
+
+    def match?
+      ua.match?(/BlackBerry|BB10/)
+    end
+  end
+end

data/lib/browser/bot/empty_user_agent_matcher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Browser
+  class Bot
+    class EmptyUserAgentMatcher
+      def self.call(ua, _browser)
+        ua == ""
+      end
+    end
+  end
+end

data/lib/browser/bot/keyword_matcher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Browser
+  class Bot
+    class KeywordMatcher
+      def self.call(ua, _browser)
+        ua.match?(/crawl|fetch|search|monitoring|spider|bot/)
+      end
+    end
+  end
+end

data/lib/browser/bot/known_bots_matcher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Browser
+  class Bot
+    class KnownBotsMatcher
+      def self.call(ua, _browser)
+        ua.match?(Browser::Bot.keywords_pattern(Browser::Bot.bots))
+      end
+    end
+  end
+end

data/lib/browser/bot.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Browser
+  class Bot
+    GENERIC_NAME = "Generic Bot"
+
+    def self.matchers
+      @matchers ||= default_matchers
+    end
+
+    def self.default_matchers
+      DEFAULT_MATCHERS.dup
+    end
+
+    def self.load_yaml(path)
+      YAML.load_file(Browser.root.join(path))
+    end
+
+    def self.bots
+      @bots ||= load_yaml("bots.yml")
+    end
+
+    def self.bot_exceptions
+      @bot_exceptions ||= load_yaml("bot_exceptions.yml")
+    end
+
+    def self.search_engines
+      @search_engines ||= load_yaml("search_engines.yml")
+    end
+
+    # One regexp per keyword list (an Array, or a Hash keyed by keyword),
+    # rebuilt when the list grows or is replaced.
+    def self.keywords_pattern(keywords)
+      @keywords_pattern_by_list ||= {}.compare_by_identity
+      size, pattern = @keywords_pattern_by_list[keywords]
+      return pattern if size == keywords.size
+
+      words = (keywords.is_a?(Hash) ? keywords.keys : keywords).map(&:to_s)
+      pattern = Regexp.new(trie_source(words))
+      @keywords_pattern_by_list[keywords] = [keywords.size, pattern]
+      pattern
+    end
+
+    # A Regexp.union of hundreds of words tries each of them at every
+    # position; nested by common prefix, the regexp follows a single branch
+    # per character.
+    def self.trie_source(words)
+      trie = {}
+      words.each do |word|
+        leaf = word.each_char.reduce(trie) { |node, char| node[char] ||= {} }
+        leaf[:end] = true
+      end
+      trie_node_source(trie) || "(?!)"
+    end
+
+    def self.trie_node_source(node)
+      # A shorter keyword matches wherever a longer one would.
+      return "" if node.key?(:end)
+
+      branches = node.map do |char, child|
+        Regexp.escape(char) + trie_node_source(child)
+      end
+      (branches.size == 1) ? branches.first : "(?:#{branches.join("|")})"
+    end
+    private_class_method :trie_source, :trie_node_source
+
+    def self.why?(ua)
+      ua = ua.downcase.strip
+      browser = Browser.new(ua)
+      matchers.find { |matcher| matcher.call(ua, browser) }
+    end
+
+    attr_reader :ua
+
+    def initialize(ua)
+      @ua = ua.downcase.strip
+    end
+
+    def bot?
+      !bot_exception? && detect_bot?
+    end
+
+    def why?
+      self.class.matchers.find { |matcher| matcher.call(ua, self) }
+    end
+
+    def search_engine?
+      ua.match?(self.class.keywords_pattern(self.class.search_engines))
+    end
+
+    def name
+      return unless bot?
+
+      self.class.bots.find { |key, _| ua.include?(key) }&.last || GENERIC_NAME
+    end
+
+    private def bot_exception?
+      ua.match?(self.class.keywords_pattern(self.class.bot_exceptions))
+    end
+
+    private def detect_bot?
+      self.class.matchers.any? do |matcher|
+        matcher.call(ua, default_matchers.include?(matcher) ? nil : browser)
+      end
+    end
+
+    # The built-in matchers ignore the browser: building it would detect the
+    # user agent twice.
+    private def default_matchers
+      DEFAULT_MATCHERS
+    end
+
+    private def browser
+      @browser ||= Browser.new(ua)
+    end
+
+    private :ua
+  end
+end

data/lib/browser/browser.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+require_relative "version"
+require_relative "detect_version"
+require_relative "accept_language"
+require_relative "base"
+require_relative "safari"
+require_relative "chrome"
+require_relative "internet_explorer"
+require_relative "firefox"
+require_relative "edge"
+require_relative "opera"
+require_relative "blackberry"
+require_relative "unknown"
+require_relative "phantom_js"
+require_relative "uc_browser"
+require_relative "nokia"
+require_relative "micro_messenger"
+require_relative "weibo"
+require_relative "qq"
+require_relative "alipay"
+require_relative "electron"
+require_relative "facebook"
+require_relative "otter"
+require_relative "instagram"
+require_relative "yandex"
+require_relative "sputnik"
+require_relative "snapchat"
+require_relative "duck_duck_go"
+require_relative "samsung_browser"
+require_relative "huawei_browser"
+require_relative "miui_browser"
+require_relative "maxthon"
+require_relative "sougou_browser"
+require_relative "google_search_app"
+require_relative "epiphany"
+
+require_relative "bot"
+require_relative "bot/empty_user_agent_matcher"
+require_relative "bot/keyword_matcher"
+require_relative "bot/known_bots_matcher"
+
+require_relative "middleware"
+require_relative "platform"
+require_relative "device"
+require_relative "meta"
+
+module Browser
+  EMPTY_STRING = ""
+
+  Bot::DEFAULT_MATCHERS =
+    [Bot::EmptyUserAgentMatcher, Bot::KnownBotsMatcher, Bot::KeywordMatcher]
+      .freeze
+
+  Error = Class.new(StandardError)
+
+  def self.root
+    @root ||= Pathname.new(File.expand_path("../..", __dir__))
+  end
+
+  class << self
+    attr_accessor :user_agent_size_limit, :accept_language_size_limit
+  end
+
+  self.user_agent_size_limit = 2048
+  self.accept_language_size_limit = 2048
+
+  # Hold the list of browser matchers.
+  # Order is important.
+  def self.matchers
+    @matchers ||= [
+      Nokia,
+      UCBrowser,
+      PhantomJS,
+      BlackBerry,
+      Opera,
+      Edge,
+      InternetExplorer,
+      Firefox,
+      Otter,
+      Epiphany,
+      Facebook,
+      Instagram,
+      Snapchat,
+      Weibo,
+      MicroMessenger, # must be placed before QQ
+      QQ,
+      Alipay,
+      Electron,
+      Yandex,
+      Sputnik,
+      DuckDuckGo,
+      SamsungBrowser,
+      HuaweiBrowser,
+      MiuiBrowser,
+      Maxthon,
+      SougouBrowser,
+      GoogleSearchApp,
+
+      # Must be last
+      Chrome,
+      Safari,
+      Unknown
+    ]
+  end
+
+  def self.new(user_agent, **)
+    matchers.each do |matcher_class|
+      matcher = matcher_class.new(user_agent || EMPTY_STRING, **)
+      return matcher if matcher.match?
+    end
+  end
+end

data/lib/browser/chrome.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Browser
+  class Chrome < Base
+    def id
+      :chrome
+    end
+
+    def name
+      "Chrome"
+    end
+
+    def full_version
+      # Each regex on its own line to enforce precedence.
+      ua[%r{Chrome/([\d.]+)}, 1] ||
+        ua[%r{CriOS/([\d.]+)}, 1] ||
+        ua[%r{Safari/([\d.]+)}, 1] ||
+        ua[%r{AppleWebKit/([\d.]+)}, 1] ||
+        "0.0"
+    end
+
+    def chromium_based?
+      true
+    end
+
+    def match?
+      ua.match?(/Chrome|CriOS/) &&
+        !ua.match?(/PhantomJS|FxiOS|ArchiveBot/) &&
+        !opera? &&
+        !edge? &&
+        !duck_duck_go? &&
+        !yandex? &&
+        !sputnik? &&
+        !samsung_browser? &&
+        !huawei_browser? &&
+        !miui_browser? &&
+        !maxthon? &&
+        !qq? &&
+        !sougou_browser? &&
+        !google_search_app?
+    end
+  end
+end

data/lib/browser/detect_version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Browser
+  module DetectVersion
+    private def detect_version?(actual_version, expected_version)
+      return true unless expected_version
+      return false unless actual_version
+
+      expected_version = parse_version(expected_version)
+      actual_version = parse_version(actual_version)
+
+      Gem::Requirement.create(expected_version)
+        .satisfied_by?(Gem::Version.create(actual_version))
+    rescue ArgumentError
+      false
+    end
+
+    private def parse_version(version)
+      version.is_a?(Numeric) ? version.to_s : version
+    end
+  end
+end

data/lib/browser/device/android.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Browser
+  class Device
+    class Android < Base
+      def id
+        :unknown
+      end
+
+      def name
+        ua[/\(Linux.*?; Android.*?; ([-_a-z0-9 ]+) Build[^)]+\)/i, 1] ||
+          "Unknown"
+      end
+
+      def match?
+        ua.include?("Android")
+      end
+    end
+  end
+end

data/lib/browser/device/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Browser
+  class Device
+    class Base
+      attr_reader :ua
+
+      def initialize(ua)
+        @ua = ua
+      end
+    end
+  end
+end

data/lib/browser/device/blackberry_playbook.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Browser
+  class Device
+    class BlackBerryPlaybook < Base
+      def id
+        :playbook
+      end
+
+      def name
+        "BlackBerry Playbook"
+      end
+
+      def match?
+        ua.match?(/PlayBook.*?RIM Tablet/)
+      end
+    end
+  end
+end