device_detector 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89802f3d1a2276198bb17c6889848941b692e962
-  data.tar.gz: e4ee7d45dd2e0307a5e547f1f77e0e5f4f99e725
+  metadata.gz: 98cdaab8265efd95799dcb71e4588cef6c300528
+  data.tar.gz: f43a7ef253ca782d672d8856d1b1214c6b300cfb
 SHA512:
-  metadata.gz: 5c52585792a08a2bd4e9ee96439af347898113872f888119e60f0096239fec438d058c6782c89c4ed52e42cc1414d0776219b2b350730888b71ccf19e05cab65
-  data.tar.gz: 988d986ea34e7a9fa96efdf3414ea97eba1931d4b74e7db18b794dca732b2787907c8323f91f54d6102b7cb345367961881d812e6137690fd979ae208b3f3f52
+  metadata.gz: 579c755cd334bb9dbb4f23402de2f7982d7b62f1d6a852524834ddc28f09a099e849d8a7c3111e89dfbed39ece1eb2467a07cb333dc8b7f1b458cc209eda1bc1
+  data.tar.gz: 84c58c57130167b1eab5162aaf4aa000e62ec1f38fd3e550f802602f483e85c1a4ff969fe31d7bc30fff2cfc14e3c8243a90dfde32495257cb4bb0070bc509b5

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in device_detector.gemspec
 gemspec
+
+if RUBY_VERSION >= "2.0" && defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
+  gem 'byebug'
+end

data/Rakefile

@@ -1,6 +1,9 @@
 require 'rake'
 require 'rake/testtask'
 
+$:.unshift 'lib'
+require 'device_detector'
+
 Rake::TestTask.new do |t|
   t.pattern = 'spec/**/*_spec.rb'
   t.libs.push 'spec'
@@ -9,14 +12,12 @@ end
 task default: :test
 
 task :detectable_names do
-  require 'device_detector'
-  bot_names = DeviceDetector::Bot.new.send(:regexes).map { |r| r['name'] }.uniq
+  bot_names = DeviceDetector::Bot.new.send(:regexes).map { |r| r['name'] }.uniq.sort_by { |n| n.downcase }
   bot_names.delete('$1')
-  client_names = DeviceDetector::Client.new.send(:regexes).map { |r| r['name'] }.uniq
+  client_names = DeviceDetector::Client.new.send(:regexes).map { |r| r['name'] }.uniq.sort_by { |n| n.downcase }
   client_names.delete('$1')
-  device_filepaths = DeviceDetector::Device.new.send(:filepaths)
-  device_regexes = DeviceDetector::Device.load_regexes(device_filepaths)
-  device_names = device_regexes.flat_map { |dn| dn.keys }.sort.uniq
+  device_regexes = DeviceDetector::Device.new.send(:load_regexes)
+  device_names = device_regexes.flat_map { |dn| dn.keys }.uniq.sort_by { |n| n.downcase }
 
   today = Date.today.strftime
 
@@ -38,3 +39,8 @@ task :detectable_names do
   puts
 end
 
+desc 'update regex database from piwik project'
+task :update_regexes do
+  top = File.expand_path('..', __FILE__)
+  system "curl -s -L https://api.github.com/repos/piwik/device-detector/tarball/master | tar xzvf - --strip-components 1 --include */regexes/*.yml -C #{top}"
+end

data/device_detector.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'pry', '>= 0.10'
 end

data/lib/device_detector.rb

@@ -1,8 +1,5 @@
 require 'yaml'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 require 'device_detector/version'
 require 'device_detector/metadata_extractor'
 require 'device_detector/version_extractor'
@@ -44,7 +41,55 @@ class DeviceDetector
   end
 
   def device_type
-    device.type
+    t = device.type
+
+    if t.nil? && android_tablet_fragment?
+      t = 'tablet'
+    end
+
+    if t.nil? && android_mobile_fragment?
+      t = 'smartphone'
+    end
+
+    # 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
+    # merged and it is for smartphones and tablets
+    #
+    # 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'
+        t = 'smartphone'
+      elsif os.full_version >= '3' && os.full_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
+
+    # 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).
+    # 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.
+    if t.nil? && touch_enabled? &&
+       (os.short_name == 'WRT' || (os.short_name == 'WIN' && os.full_version && os.full_version >= '8'))
+      t = 'tablet'
+    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?
+      t = 'desktop'
+    end
+
+    t
   end
 
   def known?
@@ -104,4 +149,20 @@ class DeviceDetector
     @os ||= OS.new(user_agent)
   end
 
+  def android_tablet_fragment?
+    user_agent =~ build_regex('Android; Tablet;')
+  end
+
+  def android_mobile_fragment?
+    user_agent =~ build_regex('Android; Mobile;')
+  end
+
+  def touch_enabled?
+    user_agent =~ build_regex('Touch')
+  end
+
+  def build_regex(src)
+    Regexp.new('(?:^|[^A-Z0-9\_\-])(?:' + src + ')', Regexp::IGNORECASE)
+  end
+
 end

data/lib/device_detector/client.rb

@@ -9,12 +9,12 @@ class DeviceDetector
 
     def filenames
       [
-        'browsers.yml',
-        'feed_readers.yml',
-        'libraries.yml',
-        'mediaplayers.yml',
-        'mobile_apps.yml',
-        'pim.yml'
+        'client/feed_readers.yml',
+        'client/mobile_apps.yml',
+        'client/mediaplayers.yml',
+        'client/pim.yml',
+        'client/browsers.yml',
+        'client/libraries.yml',
       ]
     end
   end

data/lib/device_detector/device.rb

@@ -1,6 +1,21 @@
 class DeviceDetector
   class Device < Parser
 
+    # order is relevant for testing with fixtures
+    DEVICE_NAMES = [
+        'desktop',
+        'smartphone',
+        'tablet',
+        'feature phone',
+        'console',
+        'tv',
+        'car browser',
+        'smart display',
+        'camera',
+        'portable media player',
+        'phablet'
+    ]
+
     def known?
       regex_meta.any?
     end
@@ -10,50 +25,66 @@ class DeviceDetector
     end
 
     def type
-      regex_meta['device']
+      hbbtv? ? 'tv' : regex_meta[:device]
     end
 
     private
 
-    # The order of files is relevant.
-    # portable_media_players has to come before mobiles because of devices like the iPod
-    # which would otherwise be detected as iPhones
-    # televisions.yml works best at the end
+    # The order of files needs to be the same as the order of device
+    # parser classes used in the piwik project.
     def filenames
       [
-        'devices/cameras.yml',
-        'devices/car_browsers.yml',
-        'devices/consoles.yml',
-        'devices/portable_media_players.yml',
-        'devices/mobiles.yml',
-        'devices/televisions.yml',
+        'device/televisions.yml',
+        'device/consoles.yml',
+        'device/car_browsers.yml',
+        'device/cameras.yml',
+        'device/portable_media_player.yml',
+        'device/mobiles.yml',
       ]
     end
 
-    def parse_regexes(raw_regexes, device = nil)
-      raw_regexes.map { |base, nest|
+    def matching_regex
+      from_cache([self.class.name, user_agent]) do
+        regex_list = hbbtv? ? regexes_for_hbbtv : regexes_other
+        regex = regex_list.find { |r| user_agent =~ r[:regex] }
+        if regex && regex[:models]
+          model_regex = regex[:models].find { |m| user_agent =~ m[:regex]}
+          if model_regex
+            regex = regex.merge(:regex_model => model_regex[:regex], :model => model_regex[:model])
+            regex[:device] = model_regex[:device] if model_regex.key?(:device)
+            regex.delete(:models)
+          end
+        end
+        regex
+      end
+    end
+
+    def hbbtv?
+      @regex_hbbtv ||= build_regex('HbbTV/([1-9]{1}(\.[0-9]{1}){1,2})')
+      user_agent =~ @regex_hbbtv
+    end
 
-        if !nest.nil? && nest.key?('models')
-          default_device = nest['device']
-          parse_regexes(nest['models'], default_device)
-        else
-          regex =
-            case base
-            when Hash
-              base
-            when String
-              nest
-            else
-              fail "#{filenames.join(', ')} regexes are either malformed or format has changes."
-            end
+    def regexes_for_hbbtv
+      regexes.select { |r| r[:path] == :'device/televisions.yml' }
+    end
 
-          regex['device'] ||= device
-          regex['regex'] = Regexp.new(regex['regex'])
+    def regexes_other
+      regexes.select { |r| r[:path] != :'device/televisions.yml' }
+    end
 
-          regex
+    def parse_regexes(path, raw_regexes)
+      raw_regexes.map do |brand, meta|
+        fail "invalid device spec: #{meta.inspect}" unless meta[:regex].is_a? String
+        meta[:regex] = build_regex(meta[:regex])
+        if meta.key?(:models)
+          meta[:models].each do |model|
+            fail "invalid model spec: #{model.inspect}" unless model[:regex].is_a? String
+            model[:regex] = build_regex(model[:regex])
+          end
         end
-
-      }.flatten
+        meta[:path] = path
+        meta
+      end
     end
 
   end

data/lib/device_detector/memory_cache.rb

@@ -42,7 +42,7 @@ class DeviceDetector
     attr_reader :lock
 
     def purge_cache
-      key_size = data.keys.size
+      key_size = data.size
 
       if key_size >= max_keys
         # always remove about 1/3 of keys to reduce garbage collecting

data/lib/device_detector/metadata_extractor.rb

@@ -14,23 +14,14 @@ class DeviceDetector
 
     def extract_metadata
       user_agent.match(regex) do |match_data|
-        replace_metadata_string_with(match_data)
+        metadata_string.gsub(/\$(\d)/) {
+          match_data[$1.to_i].to_s
+        }.strip
       end
     end
 
-    def replace_metadata_string_with(match_data)
-      string = metadata_string
-
-      1.upto(9) do |index|
-        matched_data = String(match_data[index])
-        string = string.gsub(/\$#{index}/, matched_data)
-      end
-
-      string.strip
-    end
-
     def regex
-      @regex ||= regex_meta['regex']
+      @regex ||= regex_meta[:regex]
     end
 
   end

data/lib/device_detector/model_extractor.rb

@@ -1,10 +1,19 @@
 class DeviceDetector
   class ModelExtractor < MetadataExtractor
 
+    def call
+      s = super.to_s.gsub('_',' ').strip
+      s.empty? ? nil : s
+    end
+
     private
 
     def metadata_string
-      String(regex_meta['model'])
+      String(regex_meta[:model])
+    end
+
+    def regex
+      @regex ||= regex_meta[:regex_model] || regex_meta[:regex]
     end
 
   end

data/lib/device_detector/name_extractor.rb

@@ -12,7 +12,7 @@ class DeviceDetector
     private
 
     def metadata_string
-      regex_meta['name']
+      regex_meta[:name]
     end
 
   end

data/lib/device_detector/os.rb

@@ -1,16 +1,152 @@
+require 'set'
+
 class DeviceDetector
   class OS < Parser
 
+    def name
+      os_info[:name]
+    end
+
+    def short_name
+      os_info[:short]
+    end
+
+    def family
+      os_info[:family]
+    end
+
+    def desktop?
+      DESKTOP_OSS.include?(family)
+    end
+
     def full_version
-      raw_version = super
+      raw_version = super.to_s.split('_').join('.')
+      raw_version == '' ? nil : raw_version
+    end
+
+    private
 
-      # This solution won't scale, but for now it will do
-      if raw_version && name == 'Mac'
-        raw_version.split('_').join('.')
+    def os_info
+      from_cache(['os_info', self.class.name, user_agent]) do
+        os_name = NameExtractor.new(user_agent, regex_meta).call
+        if os_name && short = DOWNCASED_OPERATING_SYSTEMS[os_name.downcase]
+          os_name = OPERATING_SYSTEMS[short]
+        else
+          short = 'UNK'
+        end
+        { name: os_name, short: short, family: FAMILY_TO_OS[short] }
       end
     end
 
-    private
+    DESKTOP_OSS = Set.new(['AmigaOS', 'IBM', 'GNU/Linux', 'Mac', 'Unix', 'Windows', 'BeOS', 'Chrome OS'])
+
+    # OS short codes mapped to long names
+    OPERATING_SYSTEMS = {
+        'AIX' => 'AIX',
+        'AND' => 'Android',
+        'AMG' => 'AmigaOS',
+        'ATV' => 'Apple TV',
+        'ARL' => 'Arch Linux',
+        'BTR' => 'BackTrack',
+        'SBA' => 'Bada',
+        'BEO' => 'BeOS',
+        'BLB' => 'BlackBerry OS',
+        'QNX' => 'BlackBerry Tablet OS',
+        'BMP' => 'Brew',
+        'CES' => 'CentOS',
+        'COS' => 'Chrome OS',
+        'CYN' => 'CyanogenMod',
+        'DEB' => 'Debian',
+        'DFB' => 'DragonFly',
+        'FED' => 'Fedora',
+        'FOS' => 'Firefox OS',
+        'BSD' => 'FreeBSD',
+        'GNT' => 'Gentoo',
+        'GTV' => 'Google TV',
+        'HPX' => 'HP-UX',
+        'HAI' => 'Haiku OS',
+        'IRI' => 'IRIX',
+        'INF' => 'Inferno',
+        'KNO' => 'Knoppix',
+        'KBT' => 'Kubuntu',
+        'LIN' => 'GNU/Linux',
+        'LBT' => 'Lubuntu',
+        'VLN' => 'VectorLinux',
+        'MAC' => 'Mac',
+        'MDR' => 'Mandriva',
+        'SMG' => 'MeeGo',
+        'MCD' => 'MocorDroid',
+        'MIN' => 'Mint',
+        'MLD' => 'MildWild',
+        'MOR' => 'MorphOS',
+        'NBS' => 'NetBSD',
+        'WII' => 'Nintendo',
+        'NDS' => 'Nintendo Mobile',
+        'OS2' => 'OS/2',
+        'T64' => 'OSF1',
+        'OBS' => 'OpenBSD',
+        'PSP' => 'PlayStation Portable',
+        'PS3' => 'PlayStation',
+        'RHT' => 'Red Hat',
+        'ROS' => 'RISC OS',
+        'RZD' => 'RazoDroiD',
+        'SAB' => 'Sabayon',
+        'SSE' => 'SUSE',
+        'SAF' => 'Sailfish OS',
+        'SLW' => 'Slackware',
+        'SOS' => 'Solaris',
+        'SYL' => 'Syllable',
+        'SYM' => 'Symbian',
+        'SYS' => 'Symbian OS',
+        'S40' => 'Symbian OS Series 40',
+        'S60' => 'Symbian OS Series 60',
+        'SY3' => 'Symbian^3',
+        'TIZ' => 'Tizen',
+        'UBT' => 'Ubuntu',
+        'WTV' => 'WebTV',
+        'WIN' => 'Windows',
+        'WCE' => 'Windows CE',
+        'WMO' => 'Windows Mobile',
+        'WPH' => 'Windows Phone',
+        'WRT' => 'Windows RT',
+        'XBX' => 'Xbox',
+        'XBT' => 'Xubuntu',
+        'YNS' => 'YunOs',
+        'IOS' => 'iOS',
+        'POS' => 'palmOS',
+        'WOS' => 'webOS'
+       }
+
+    DOWNCASED_OPERATING_SYSTEMS = OPERATING_SYSTEMS.each_with_object({}){|(short,long),h| h[long.downcase] = short}
+
+    OS_FAMILIES = {
+        'Android'               => ['AND', 'CYN', 'RZD', 'MLD', 'MCD'],
+        'AmigaOS'               => ['AMG', 'MOR'],
+        'Apple TV'              => ['ATV'],
+        'BlackBerry'            => ['BLB', 'QNX'],
+        'Brew'                  => ['BMP'],
+        'BeOS'                  => ['BEO', 'HAI'],
+        'Chrome OS'             => ['COS'],
+        'Firefox OS'            => ['FOS'],
+        'Gaming Console'        => ['WII', 'PS3'],
+        'Google TV'             => ['GTV'],
+        'IBM'                   => ['OS2'],
+        'iOS'                   => ['IOS'],
+        'RISC OS'               => ['ROS'],
+        'GNU/Linux'             => ['LIN', 'ARL', 'DEB', 'KNO', 'MIN', 'UBT', 'KBT', 'XBT', 'LBT', 'FED', 'RHT', 'VLN', 'MDR', 'GNT', 'SAB', 'SLW', 'SSE', 'CES', 'BTR', 'YNS', 'SAF'],
+        'Mac'                   => ['MAC'],
+        'Mobile Gaming Console' => ['PSP', 'NDS', 'XBX'],
+        'Other Mobile'          => ['WOS', 'POS', 'SBA', 'TIZ', 'SMG'],
+        'Symbian'               => ['SYM', 'SYS', 'SY3', 'S60', 'S40'],
+        'Unix'                  => ['SOS', 'AIX', 'HPX', 'BSD', 'NBS', 'OBS', 'DFB', 'SYL', 'IRI', 'T64', 'INF'],
+        'WebTV'                 => ['WTV'],
+        'Windows'               => ['WIN'],
+        'Windows Mobile'        => ['WPH', 'WMO', 'WCE', 'WRT']
+    }
+
+    FAMILY_TO_OS = OS_FAMILIES.each_with_object({}) do |(family,oss),h|
+      oss.each{|os| h[os] = family}
+    end
 
     def filenames
       ['oss.yml']