device_detector 1.0.0 → 1.1.3

data/lib/device_detector/parser.rb

@@ -1,7 +1,17 @@
+# frozen_string_literal: true
+
 class DeviceDetector
-  class Parser < Struct.new(:user_agent)
+  class Parser
+    ROOT = File.expand_path('../..', __dir__)
+
+    REGEX_CACHE = ::DeviceDetector::MemoryCache.new({})
+    private_constant :REGEX_CACHE
+
+    def initialize(user_agent)
+      @user_agent = user_agent
+    end
 
-    ROOT = File.expand_path('../../..', __FILE__)
+    attr_reader :user_agent
 
     def name
       from_cache(['name', self.class.name, user_agent]) do
@@ -32,51 +42,77 @@ class DeviceDetector
     end
 
     def filenames
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def filepaths
       filenames.map do |filename|
-        [ filename.to_sym, File.join(ROOT, 'regexes', filename) ]
+        [filename.to_sym, File.join(ROOT, 'regexes', filename)]
       end
     end
 
     def regexes_for(file_paths)
-      from_cache(['regexes', self.class]) do
+      REGEX_CACHE.get_or_set(file_paths) do
         load_regexes(file_paths).flat_map { |path, regex| parse_regexes(path, regex) }
       end
     end
 
     def load_regexes(file_paths)
-      file_paths.map { |path, full_path| [path, symbolize_keys!(YAML.load_file(full_path))] }
+      file_paths.map do |path, full_path|
+        object = YAML.load_file(full_path)
+        object = rewrite_device_object!(object) if device_yml_file?(full_path)
+        object = rewrite_vendor_object!(object) if vendor_yml_file?(full_path)
+
+        [path, symbolize_keys!(object)]
+      end
+    end
+
+    def device_yml_file?(file_path)
+      file_path.include?('/regexes/device/')
+    end
+
+    def vendor_yml_file?(file_path)
+      file_path.include?('/regexes/vendorfragments')
+    end
+
+    def rewrite_vendor_object!(object)
+      object.map { |key, values| values.map { |v| { 'regex_name' => key, 'regex' => v } } }.flatten
+    end
+
+    def rewrite_device_object!(object)
+      object.map { |key, value| [key, { 'regex_name' => key }.merge!(value)] }.to_h
     end
 
     def symbolize_keys!(object)
       case object
       when Array
-        object.map!{ |v| symbolize_keys!(v) }
+        object.map! { |v| symbolize_keys!(v) }
       when Hash
-        object.keys.each{ |k| object[k.to_sym] = symbolize_keys!(object.delete(k)) if k.is_a?(String) }
+        keys = object.keys
+        keys.each do |k|
+          object[k.to_sym] = symbolize_keys!(object.delete(k)) if k.is_a?(String)
+        end
       end
       object
     end
 
     def parse_regexes(path, raw_regexes)
       raw_regexes.map do |meta|
-        fail "invalid device spec: #{meta.inspect}" unless meta[:regex].is_a? String
+        raise "invalid device spec: #{meta.inspect}" unless meta[:regex].is_a? String
+
         meta[:regex] = build_regex(meta[:regex])
+        meta[:versions].each { |v| v[:regex] = build_regex(v[:regex]) } if meta.key?(:versions)
         meta[:path] = path
         meta
       end
     end
 
     def build_regex(src)
-      Regexp.new('(?:^|[^A-Z0-9\-_]|[^A-Z0-9\-]_|sprd-)(?:' + src + ')', Regexp::IGNORECASE)
+      Regexp.new("(?:^|[^A-Z0-9_-]|[^A-Z0-9-]_|sprd-|MZ-)(?:#{src})", Regexp::IGNORECASE)
     end
 
-    def from_cache(key)
-      DeviceDetector.cache.get_or_set(key) { yield }
+    def from_cache(key, &block)
+      DeviceDetector.cache.get_or_set(key, &block)
     end
-
   end
 end

data/lib/device_detector/vendor_fragment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'set'
+
+class DeviceDetector
+  class VendorFragment < Parser
+    def name
+      vendor_fragment_info
+    end
+
+    private
+
+    def vendor_fragment_info
+      from_cache(['vendor_fragment', self.class.name, user_agent]) do
+        return if regex_meta.nil? || regex_meta.empty?
+
+        regex_meta[:regex_name]
+      end
+    end
+
+    def filenames
+      ['vendorfragments.yml']
+    end
+  end
+end

data/lib/device_detector/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DeviceDetector
-  VERSION = '1.0.0'
+  VERSION = '1.1.3'
 end

data/lib/device_detector/version_extractor.rb

@@ -1,12 +1,39 @@
+# frozen_string_literal: true
+
 class DeviceDetector
   class VersionExtractor < MetadataExtractor
+    MAJOR_VERSION_2 = Gem::Version.new('2.0')
+    MAJOR_VERSION_3 = Gem::Version.new('3.0')
+    MAJOR_VERSION_4 = Gem::Version.new('4.0')
+    MAJOR_VERSION_8 = Gem::Version.new('8.0')
+
+    def call
+      simple_version = super&.chomp('.')
+
+      return simple_version unless simple_version&.empty?
+
+      os_version_by_regexes
+    end
 
     private
 
+    def os_version_by_regexes
+      version_matches = regex_meta[:versions]
+      return '' unless version_matches
+
+      version_matches.detect do |matcher|
+        user_agent.match(matcher[:regex]) do |match_data|
+          return matcher[:version].gsub(/\$(\d)/) do
+            match_data[Regexp.last_match(1).to_i].to_s
+          end.strip
+        end
+      end
+
+      ''
+    end
+
     def metadata_string
       String(regex_meta[:version])
     end
-
   end
 end
-

data/lib/device_detector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 require 'device_detector/version'
@@ -11,50 +13,113 @@ require 'device_detector/bot'
 require 'device_detector/client'
 require 'device_detector/device'
 require 'device_detector/os'
+require 'device_detector/browser'
+require 'device_detector/client_hint'
+require 'device_detector/vendor_fragment'
 
 class DeviceDetector
+  attr_reader :client_hint, :user_agent
+
+  def initialize(user_agent, headers = nil)
+    @client_hint = ClientHint.new(headers)
+    utf8_user_agent = encode_user_agent_if_needed(user_agent)
+    @user_agent = build_user_agent(utf8_user_agent)
+  end
+
+  # https://github.com/matomo-org/device-detector/blob/a2535ff3b63e4187f1d3440aed24ff43d74fb7f1/Parser/Device/AbstractDeviceParser.php#L2065-L2073
+  def build_user_agent(user_agent)
+    return user_agent if client_hint.model.nil?
+
+    regex = build_regex('Android 10[.\d]*; K(?: Build/|[;)])')
+    return user_agent unless user_agent =~ regex
+
+    version = client_hint.os_version || '10'
+
+    user_agent.gsub(/(Android 10[.\d]*; K)/, "Android #{version}; #{client_hint.model}")
+  end
 
-  attr_reader :user_agent
+  def encode_user_agent_if_needed(user_agent)
+    return if user_agent.nil?
+    return user_agent if user_agent.encoding.name == 'UTF-8'
 
-  def initialize(user_agent)
-    @user_agent = user_agent
+    user_agent.encode('utf-8', 'binary', undef: :replace)
   end
 
   def name
-    client.name
+    return client.name if mobile_fix?
+
+    client_hint.browser_name || client.name
   end
 
   def full_version
-    client.full_version
+    client_hint.full_version || client.full_version
+  end
+
+  def os_family
+    return 'GNU/Linux' if linux_fix?
+
+    client_hint.os_family || os.family || client_hint.platform
   end
 
   def os_name
-    os.name
+    return 'GNU/Linux' if linux_fix?
+
+    client_hint.os_name || os.name || client_hint.platform
   end
 
   def os_full_version
-    os.full_version
+    return if skip_os_version?
+    return os.full_version if pico_os_fix?
+    return fire_os_version if fire_os_fix?
+
+    client_hint.os_version || os.full_version
   end
 
   def device_name
-    device.name
+    return if fake_ua?
+
+    device.name || client_hint.model || fix_for_x_music
   end
 
   def device_brand
-    device.brand
+    return if fake_ua?
+
+    # Assume all devices running iOS / Mac OS are from Apple
+    brand = device.brand
+    brand = 'Apple' if brand.nil? && DeviceDetector::OS::APPLE_OS_NAMES.include?(os_name)
+
+    brand
   end
 
   def device_type
     t = device.type
 
-    if t.nil? && android_tablet_fragment? || opera_tablet?
-      t = 'tablet'
-    end
+    t = nil if fake_ua?
 
-    if t.nil? && android_mobile_fragment?
-      t = 'smartphone'
+    # Chrome on Android passes the device type based on the keyword 'Mobile'
+    # If it is present the device should be a smartphone, otherwise it's a tablet
+    # See https://developer.chrome.com/multidevice/user-agent#chrome_for_android_user_agent
+    # Note: We do not check for browser (family) here, as there might be mobile apps using Chrome,
+    # that won't have a detected browser, but can still be detected. So we check the useragent for
+    # Chrome instead.
+    if t.nil? && os_family == 'Android' && user_agent =~ build_regex('Chrome\/[\.0-9]*')
+      t = user_agent =~ build_regex('(?:Mobile|eliboM)') ? 'smartphone' : 'tablet'
     end
 
+    # Some UA contain the fragment 'Pad/APad', so we assume those devices as tablets
+    t = 'tablet' if t == 'smartphone' && user_agent =~ build_regex('Pad\/APad')
+
+    # Some UA contain the fragment 'Android; Tablet;' or 'Opera Tablet', so we assume those devices
+    # as tablets
+    t = 'tablet' if t.nil? && (android_tablet_fragment? || opera_tablet?)
+
+    # Some user agents simply contain the fragment 'Android; Mobile;', so we assume those devices
+    # as smartphones
+    t = 'smartphone' if t.nil? && android_mobile_fragment?
+
+    # Some UA contains the 'Android; Mobile VR;' fragment
+    t = 'wearable' if t.nil? && android_vr_fragment?
+
     # Android up to 3.0 was designed for smartphones only. But as 3.0,
     # which was tablet only, was published too late, there were a
     # bunch of tablets running with 2.x With 4.0 the two trees were
@@ -63,46 +128,64 @@ class DeviceDetector
     # So were are expecting that all devices running Android < 2 are
     # smartphones Devices running Android 3.X are tablets. Device type
     # of Android 2.X and 4.X+ are unknown
-    if t.nil? && os.short_name == 'AND' && os.full_version && !os.full_version.empty?
-      if os.full_version < '2'
+    if t.nil? && os_name == 'Android' && os.full_version && !os.full_version.empty?
+      full_version = Gem::Version.new(os.full_version)
+      if full_version < VersionExtractor::MAJOR_VERSION_2
         t = 'smartphone'
-      elsif os.full_version >= '3' && os.full_version < '4'
+      elsif full_version >= VersionExtractor::MAJOR_VERSION_3 && \
+            full_version < VersionExtractor::MAJOR_VERSION_4
         t = 'tablet'
       end
     end
 
     # All detected feature phones running android are more likely a smartphone
-    if t == 'feature phone' && os.family == 'Android'
-      t = 'smartphone'
-    end
+    t = 'smartphone' if t == 'feature phone' && os_family == 'Android'
+
+    # All unknown devices under running Java ME are more likely a features phones
+    t = 'feature phone' if t.nil? && os_name == 'Java ME'
 
     # According to http://msdn.microsoft.com/en-us/library/ie/hh920767(v=vs.85).aspx
-    # Internet Explorer 10 introduces the "Touch" UA string token. If this token is present at the end of the
-    # UA string, the computer has touch capability, and is running Windows 8 (or later).
+    # Internet Explorer 10 introduces the "Touch" UA string token. If this token is present at the
+    # end of the UA string, the computer has touch capability, and is running Windows 8 (or later).
     # This UA string will be transmitted on a touch-enabled system running Windows 8 (RT)
     #
-    # As most touch enabled devices are tablets and only a smaller part are desktops/notebooks we assume that
-    # all Windows 8 touch devices are tablets.
+    # As most touch enabled devices are tablets and only a smaller part are desktops/notebooks we
+    # assume that all Windows 8 touch devices are tablets.
     if t.nil? && touch_enabled? &&
-       (os.short_name == 'WRT' || (os.short_name == 'WIN' && os.full_version && os.full_version >= '8'))
+       (os_name == 'Windows RT' ||
+        (os_name == 'Windows' && os_full_version &&
+         Gem::Version.new(os_full_version) >= VersionExtractor::MAJOR_VERSION_8))
       t = 'tablet'
     end
 
-    if opera_tv_store?
-      t = 'tv'
-    end
+    # All devices running Opera TV Store are assumed to be a tv
+    t = 'tv' if opera_tv_store?
 
-    if t.nil? && ['Kylo', 'Espial TV Browser'].include?(client.name)
+    # All devices that contain Andr0id in string are assumed to be a tv
+    if user_agent =~ build_regex('Andr0id|(?:Android(?: UHD)?|Google) TV|\(lite\) TV|BRAVIA')
       t = 'tv'
     end
 
-    # set device type to desktop for all devices running a desktop os that were
-    # not detected as an other device type
-    if t.nil? && os.desktop? && !puffin_browser?
-      t = 'desktop'
-    end
+    # All devices running Tizen TV or SmartTV are assumed to be a tv
+    t = 'tv' if t.nil? && tizen_samsung_tv?
+
+    # Devices running those clients are assumed to be a TV
+    t = 'tv' if ['Kylo', 'Espial TV Browser', 'LUJO TV Browser', 'LogicUI TV Browser',
+                 'Open TV Browser', 'Seraphic Sraf', 'Opera Devices', 'Crow Browser',
+                 'Vewd Browser', 'TiviMate', 'Quick Search TV', 'QJY TV Browser',
+                 'TV Bro'].include?(name)
+
+    # All devices containing TV fragment are assumed to be a tv
+    t = 'tv' if t.nil? && user_agent =~ build_regex('\(TV;')
+
+    has_desktop = t != 'desktop' && desktop_string? && desktop_fragment?
+    t = 'desktop' if has_desktop
+
+    # set device type to desktop for all devices running a desktop os that were not detected as
+    # another device type
+    return t if t || !desktop?
 
-    t
+    'desktop'
   end
 
   def known?
@@ -118,7 +201,6 @@ class DeviceDetector
   end
 
   class << self
-
     class Configuration
       attr_accessor :max_cache_keys
 
@@ -137,11 +219,10 @@ class DeviceDetector
       @cache ||= MemoryCache.new(config.to_hash)
     end
 
-    def configure(&block)
+    def configure
       @config = Configuration.new
       yield(config)
     end
-
   end
 
   private
@@ -162,12 +243,63 @@ class DeviceDetector
     @os ||= OS.new(user_agent)
   end
 
+  # https://github.com/matomo-org/device-detector/blob/67ae11199a5129b42fa8b985d372ea834104fe3a/DeviceDetector.php#L931-L938
+  def fake_ua?
+    device.brand == 'Apple' && !DeviceDetector::OS::APPLE_OS_NAMES.include?(os_name)
+  end
+
+  # https://github.com/matomo-org/device-detector/blob/be1c9ef486c247dc4886668da5ed0b1c49d90ba8/Parser/Client/Browser.php#L772
+  # Fix mobile browser names e.g. Chrome => Chrome Mobile
+  def mobile_fix?
+    client.name == "#{client_hint.browser_name} Mobile"
+  end
+
+  def linux_fix?
+    client_hint.platform == 'Linux' &&
+      %w[iOS Android].include?(os.name) &&
+      %w[?0 0].include?(client_hint.mobile)
+  end
+
+  # Related to issue mentionned in device.rb#1562
+  def fix_for_x_music
+    user_agent&.include?('X-music Ⅲ') ? 'X-Music III' : nil
+  end
+
+  def pico_os_fix?
+    client_hint.os_name == 'Pico OS'
+  end
+
+  # https://github.com/matomo-org/device-detector/blob/323629cb679c8572a9745cba9c3803fee13f3cf6/Parser/OperatingSystem.php#L398-L403
+  def fire_os_fix?
+    !client_hint.platform.nil? && os.name == 'Fire OS'
+  end
+
+  def fire_os_version
+    DeviceDetector::OS
+      .mapped_os_version(client_hint.os_version, DeviceDetector::OS::FIRE_OS_VERSION_MAPPING)
+  end
+
+  # https://github.com/matomo-org/device-detector/blob/323629cb679c8572a9745cba9c3803fee13f3cf6/Parser/OperatingSystem.php#L378-L383
+  def skip_os_version?
+    !client_hint.os_family.nil? &&
+      client_hint.os_version.nil? &&
+      client_hint.os_family != os.family
+  end
+
   def android_tablet_fragment?
-    user_agent =~ build_regex('Android; Tablet;')
+    user_agent =~ build_regex('Android( [\.0-9]+)?; Tablet;|Tablet(?! PC)|.*\-tablet$')
   end
 
   def android_mobile_fragment?
-    user_agent =~ build_regex('Android; Mobile;')
+    user_agent =~ build_regex('Android( [\.0-9]+)?; Mobile;|.*\-mobile$')
+  end
+
+  def android_vr_fragment?
+    user_agent =~ build_regex('Android( [\.0-9]+)?; Mobile VR;| VR ')
+  end
+
+  def desktop_fragment?
+    user_agent =~ build_regex('Desktop(?: (x(?:32|64)|WOW64))?;')
   end
 
   def touch_enabled?
@@ -175,20 +307,36 @@ class DeviceDetector
   end
 
   def opera_tv_store?
-    user_agent =~ build_regex('Opera TV Store')
+    user_agent =~ build_regex('Opera TV Store|OMI/')
   end
 
   def opera_tablet?
     user_agent =~ build_regex('Opera Tablet')
   end
 
+  def tizen_samsung_tv?
+    user_agent =~ build_regex('SmartTV|Tizen.+ TV .+$')
+  end
+
+  def uses_mobile_browser?
+    client.browser? && client.mobile_only_browser?
+  end
+
   # This is a workaround until we support detecting mobile only browsers
-  def puffin_browser?
-    client.name == 'Puffin'
+  def desktop_string?
+    user_agent =~ /Desktop/
+  end
+
+  def desktop?
+    return false if os_name.nil? || os_name == '' || os_name == 'UNK'
+
+    # Check for browsers available for mobile devices only
+    return false if uses_mobile_browser?
+
+    DeviceDetector::OS::DESKTOP_OSS.include?(os_family)
   end
 
   def build_regex(src)
     Regexp.new('(?:^|[^A-Z0-9\_\-])(?:' + src + ')', Regexp::IGNORECASE)
   end
-
 end