browserino 3.0.1 → 4.0.0

data/lib/browserino/definitions/matchers.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+Browserino.config.define do
+  # a set of global matchers that will use formatted properties found earlier
+  # they will also be applied to every matcher unless that matcher has it's own
+  # property set for the defined smart matcher
+  smart_match :version,        with: ':name/([\d\._]+)',   flags: [:i]
+  smart_match :engine_version, with: ':engine/([\d\._]+)', flags: [:i]
+
+  # a simple set of global matchers that will be merged
+  # with an identity the final client object is created
+  match do
+    locale           %r{(?<!nintendo)[;\s](\w{2}(?:\-\w{2})?)[;)]}i
+    architecture     %r{((?:(?:x|x86_|amd|wow|win)64)|i[36]86)}i
+    mobile           %r{(bolt|nokia|samsung(?!b)|mobi(?:le)?|i?p(?:[ao]d|hone)
+                        |android|bb\d+|blackberry|iemobile|fennec|bada|meego
+                        |tizen|vodafone|t\-mobile|opera\sm(?:ob|in)i)}xi
+    platform         %r{.*(xbox|wii|nintendo\sds|playstation|windows(?:\sphone)?
+                        |macintosh|mac\sos\sx|android|tizen|ip(?:[ao]d|hone)
+                        |blackberry|linux|ubuntu|x11|bsd|s(?:unos|olaris)
+                        |w(?:eb)?os)}xi
+    platform_version %r{(?:windows(?:\sphone(?:\sos)?)?|nt|mac\sos\sx|android
+                      |(?:cpu\s|ip(?:[ao]d|hone)\s)os|blackberry|bb
+                      |s(?:unos|olaris)/?|w(?:eb)?os/|tizen)\s?([\d\._]+)}xi
+  end
+
+  # automatically set type to :browser for each defined matcher
+  browsers do
+    # a single matcher that will create an Identity for a specific match
+    # identities are added in an array in order of definition - higher is better
+    # aliasses are prepended to the list instead of appended (e.g. like blocks)
+    # this ensures that aliasses will be matched before any regular matcher
+    match %r{maxthon}i do
+      # define properties by calling a method with the desired name and:
+      #  -- value   # => will create a static method that returns that value
+      #  -- /(pat)/ # => will create a method that scans the UA and
+      #                  saves the first capture group
+      #  -- { blk } # => will create a dynamic method that returns the result
+      #                  of the block, it will be executed within an
+      #                  instantiated Client object
+      name           :maxthon
+
+      version        %r{maxthon[/\s]([\d\.]+)}i
+      engine         %r{(webkit|presto|gecko|trident)}i
+      engine_version %r{(?:webkit|presto|gecko|trident)/([\d\.]+)}i
+    end
+
+    match %r{retawq}i do
+      name           :retawq
+      locale         %r{\[(\w{2}(?:\-\w{2})?)\]}i
+    end
+
+    match %r{lynx}i do
+      name           :lynx
+    end
+
+    match %r{ucbrowser}i do
+      name           :ucbrowser
+
+      version        %r{ucbrowser/?([\d\.]+)}i
+      engine         %r{(trident|gecko|webkit|presto)}i
+      engine_version %r{(?:trident|gecko|webkit|presto)/([\d\.]+)}i
+    end
+
+    match %r{edge}i do
+      name           :edge
+      engine         :edge
+      modern?        true
+    end
+
+    match %r{ope?ra?\smini}i do
+      name           :opera_mini
+
+      version        %r{ope?ra?\smini/([\d\.]+)}i
+      engine         %r{(presto|webkit)}i
+      engine_version %r{(?:presto|webkit)/([\d\.]+)}i
+    end
+
+    match %r{opera[^\w]}i do
+      name           :opera
+
+      version        %r{(?:opera[\s/]|version/)([\d\.]+)}i
+      engine         %r{(presto|webkit)}i
+      engine_version %r{(?:presto|webkit)/([\d\.]+)}i
+    end
+
+    match %r{msie|trident}i do
+      name           :ie
+      engine         :trident
+
+      version        %r{(?:(?:ms)?ie\s|rv:)([\d\.]+)}i
+      modern?        { version >= 10 }
+    end
+
+    match %r{chrome(?:ium)?}i do
+      name           :chrome
+
+      version        %r{chrome(?:ium)?/([\d\.]+)}i
+      engine         %r{(webkit|blink)}i
+      engine_version %r{(?:webkit|blink)/([\d\.]+)}i
+      modern?        { version >= 50 }
+    end
+
+    match %r{firefox}i do
+      name           :firefox
+
+      engine         %r{(gecko|servo)}i
+      engine_version %r{(?:rv:\s?|servo/)([\d\.]+)}i
+      modern?        { version >= 50 }
+    end
+
+    match %r{konqueror}i do
+      name           :konqueror
+    end
+
+    match %r{midori}i do
+      name           :midori
+      engine         :webkit
+    end
+
+    match %r{safari}i do
+      name           :safari
+      engine         :webkit
+
+      version        %r{(?:safari|version)/([\d\.]+)}i
+      modern?        { version >= 9 }
+    end
+  end
+
+  # automatically set type to :bot for each defined matcher
+  bots do
+    match %r{googlebot}i,                   name: :googlebot
+    match %r{yahoo\!\sslurp}i,              name: :yahoo_slurp
+    match %r{msnbot}i,                      name: :msnbot
+    match %r{bingbot}i,                     name: :bingbot
+    match %r{baiduspider}i,                 name: :baiduspider
+    match %r{yandexbot}i,                   name: :yandexbot
+    match %r{sosospider}i,                  name: :sosospider
+    match %r{exabot}i,                      name: :exabot
+    match %r{sogou\s?spider}i,              name: :sogou_spider
+    match %r{nutch}i,                       name: :nutch
+    match %r{scrapy}i,                      name: :scrapy
+    match %r{dataparksearch}i,              name: :dataparksearch
+    match %r{holmes}i,                      name: :holmes
+    match %r{(?:ask)\sjeeves}i,             name: :ask
+    match %r{duckduckgo}i,                  name: :duckduckgo
+    match %r{beslistbot}i,                  name: :beslistbot
+    match %r{twitterbot}i,                  name: :twitterbot
+    match %r{linkedinbot}i,                 name: :linkedin
+    match %r{instagram}i,                   name: :instagram
+    match %r{pinterest}i,                   name: :pinterest
+    match %r{tumblr}i,                      name: :tumblr
+    match %r{ia_archiver}i,                 name: :alexa
+    match %r{4anything}i,                   name: :four_anything
+    match %r{autoemailspider}i,             name: :auto_email_spider
+    match %r{boston[_ ]project}i,           name: :boston_project
+    match %r{atomz}i,                       name: :atomz
+    match %r{atomic_email_hunter}i,         name: :atomic_email_hunter
+    match %r{altavista}i,                   name: :altavista
+    match %r{alkaline}i,                    name: :alkalinebot
+    match %r{acoi}i,                        name: :acoi
+    match %r{acoon}i,                       name: :acoon
+    match %r{accoona}i,                     name: :accoona
+    match %r{face(?:bookexternalhit|bot)}i, name: :facebook
+    match %r{linkdexbot}i,                  name: :linkdexbot
+    match %r{aitcsrobot}i,                  name: :aitcsrobot
+    match %r{alexibot}i,                    name: :alexibot
+    match %r{aqua_products}i,               name: :aqua_products
+    match %r{arachnophilia}i,               name: :arachnophilia
+    match %r{aspider}i,                     name: :aspider
+    match %r{asterias}i,                    name: :asterias
+    match %r{auresys}i,                     name: :auresys
+    match %r{b2w}i,                         name: :b2w
+    match %r{backdoorbot}i,                 name: :backdoorbot
+    match %r{backrub}i,                     name: :backrub
+    match %r{big\sbrother}i,                name: :big_brother
+    match %r{bizbot}i,                      name: :bizbot
+    match %r{black\shole}i,                 name: :black_hole
+    match %r{blackwidow}i,                  name: :blackwidow
+    match %r{blexbot}i,                     name: :blexbot
+    match %r{bspider}i,                     name: :bspider
+    match %r{bullseye}i,                    name: :bullseye
+    match %r{emailcollector}i,              name: :emailcollector
+    match %r{emailsiphon}i,                 name: :emailsiphon
+    match %r{emailwolf}i,                   name: :emailwolf
+    match %r{ecatch}i,                      name: :ecatch
+    match %r{flaming\sattackbot}i,          name: :flaming_attackbot
+    match %r{getright}i,                    name: :getright
+    match %r{harvest}i,                     name: :harvest
+    match %r{huaweisymantecspider}i,        name: :huaweisymantecspider
+
+    match %r{mass\sdownloader}i, name: :mass_downloader,
+                                 version: %r{mass\sdownloader/([\d\.]+)}i
+    match %r{safetynet\srobot}i, name: :safetynet_robot,
+                                 version: %r{safetynet\srobot\s([\d\.]+)}i
+    match %r{internet\sninja}i,  name: :internet_ninja,
+                                 version: %r{internet\sninja\s([\d\.]+)}i
+    match %r{go\!zilla}i,        name: :gozilla,
+                                 version: %r{go\!zilla\s([\d\.]+)}i
+    match %r{larbin}i,           name: :larbin,
+                                 version: %r{larbin_([\d\.]+)}i
+    match %r{download\sdemon}i,  name: :download_demon,
+                                 version: %r{download\sdemon/([\d\.]+)}i
+  end
+
+  # automatically set type to :library for each defined matcher
+  validators do
+    match %r{cse\shtml\svalidator}i, name: :cse_html_validator
+    match %r{csscheck}i,             name: :csscheck
+    match %r{htmlparser}i,           name: :htmlparser
+    match %r{p3p\svalidator}i,       name: :p3p_validator
+    match %r{wdg_validator}i,        name: :wdg_validator
+    match %r{w3c_validator}i,        name: :w3c_validator
+
+    match %r{cynthia}i, name: :cynthia,
+                        version: %r{cynthia\s([\d\.]+)}i
+
+    match %r{w3c_css_validator}i,
+          name: :w3c_css_validator,
+          version: %r{w3c_css_validator_jfouffa/([\d\.]+)}i
+  end
+
+  # automatically set type to :library for each defined matcher
+  libraries do
+    match %r{php}i,    name: :php
+    match %r{python}i, name: :python, version: %r{-urllib/([\d\.]+)}i
+    match %r{perl}i,   name: :perl
+    match %r{java}i,   name: :java
+    match %r{pycurl}i, name: :pycurl
+    match %r{curl}i,   name: :curl
+  end
+
+  # inherit properties a standard set of properties by the name of a
+  # previously defined matcher, overwritten by properties added within matchers
+  # inherit properties from Identity where name == :chrome
+  like :chrome do
+    match %r{brave}i,         name: :brave,    version: %r{brave/([\d\.]+)}i
+    match %r{vivaldi}i,       name: :vivaldi,  version: %r{vivaldi/([\d\.]+)}i
+    match %r{colibri}i,       name: :colibri,  version: %r{colibri/([\d\.]+)}i
+    match %r{rockmelt}i,      name: :rockmelt, version: %r{rockmelt/([\d\.]+)}i
+    match %r{flock}i,         name: :flock,    version: %r{flock/([\d\.]+)}i
+
+    match %r{comodo_dragon}i, name: :comodo_dragon,
+                              version: %r{comodo_dragon/([\d\.]+)}i
+  end
+
+  # inherit properties from Identity where name == :safari
+  like :safari do
+    match %r{bolt}i,           name: :bolt, version: %r{bolt/([\d\.]+)}i
+
+    match %r{stainless}i,      name: :stainless,
+                               version: %r{stainless/([\d\.]+)}i
+    match %r{samsungbrowser}i, name: :samsungbrowser,
+                               version: %r{samsungbrowser/([\d\.]+)}i
+    match %r{omniweb}i,        name: :omniweb,
+                               version: %r{omniweb/v([\d\.]+)}i
+
+    match %r{webos|wosbrowser}i,
+          name: :webosbrowser,
+          version: %r{(?:version|w(?:eb)?osbrowser)/([\d\.]+)}i
+  end
+
+  # inherit properties from Identity where name == :firefox
+  like :firefox do
+    match %r{prism}i,     name: :prism,     version: %r{prism/([\d\.]+)}i
+    match %r{waterfox}i,  name: :waterfox,  version: %r{waterfox/([\d\.]+)}i
+    match %r{firebird}i,  name: :firebird,  version: %r{firebird/([\d\.]+)}i
+    match %r{netscape}i,  name: :netscape,  version: %r{netscape/([\d\.]+)}i
+    match %r{icecat}i,    name: :icecat,    version: %r{icecat/([\d\.]+)}i
+    match %r{iceweasel}i, name: :iceweasel, version: %r{iceweasel/([\d\.]+)}i
+    match %r{seamonkey}i, name: :seamonkey, version: %r{seamonkey/([\d\.]+)}i
+    match %r{superswan}i, name: :superswan, version: %r{superswan/([\d\.]+)}i
+    match %r{lunascape}i, name: :lunascape, version: %r{lunascape/([\d\.]+)}i
+    match %r{camino}i,    name: :camino,    version: %r{camino/([\d\.]+)}i,
+                          locale: %r{\s(\w{2}(?:\-\w{2})?),}i
+  end
+
+  # never thought a browser would want to be like IE...
+  like :ie do
+    # version does not have to be supplied because we simply want to use
+    # the version supplied by the MSIE token instead (there is no version on
+    # the avant browser or slimbrowser UA itself)
+    match %r{avant\sbrowser}i,    name: :avant_browser
+    match %r{slimbrowser}i,       name: :slimbrowser
+
+    match %r{sleipnir}i,          name: :sleipnir,
+                                  version: %r{sleipnir/([\d\.]+)}i
+    match %r{deepnet\sexplorer}i, name: :deepnet_explorer,
+                                  version: %r{deepnet\sexplorer ([\d\.]+)}i
+  end
+end

data/lib/browserino/identity.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Browserino
+  class Identity
+    attr_reader :pattern, :properties
+
+    SETTINGS = { name: nil, type: :unknown }.freeze
+
+    def initialize(pattern = //, opts = {}, **additional, &block)
+      opts        = pattern if pattern.is_a?(Hash) && opts.empty?
+      @properties = SETTINGS.merge(opts.merge(additional))
+      @pattern    = pattern
+
+      instance_eval(&block) if block
+    end
+
+    def matches?(user_agent)
+      pattern =~ user_agent if pattern.is_a? Regexp
+    end
+
+    def ===(other)
+      return false if properties[:name].nil?
+
+      case other
+      when Regexp   then other =~ properties[:name]
+      when String   then other.to_sym == properties[:name]
+      when Symbol   then other == properties[:name]
+      when Identity then other.properties[:name] == properties[:name]
+      else false
+      end
+    end
+
+    def to_str
+      properties[:name].to_s
+    end
+
+    def =~(other)
+      self === other
+    end
+
+    def ==(other)
+      self === other
+    end
+
+    def method_missing(sym, *args, &block)
+      return @properties[sym] = block      if block
+      return @properties[sym] = args.shift if args.any?
+
+      @properties[sym]
+    end
+
+    def respond_to_missing?(_, *__, &___)
+      true
+    end
+  end
+end

data/lib/browserino/integrate/action_controller.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'action_controller/railtie'
 
 module Browserino
   class ActionController
     module Base
-      def agent
-        @agent ||= Browserino.parse(request.headers['User-Agent'])
+      def client
+        @client ||= Browserino.parse request.headers['User-Agent']
       end
     end
   end

data/lib/browserino/integrate/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 require_relative 'action_controller'
 

data/lib/browserino/methods.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+module Browserino
+  def self.analyze(user_agent, identity = nil)
+    props = [*config.global_identities, identity].compact.map(&:properties)
+                                                 .reduce(&:merge)
+    like  = props.delete :like if props.key? :like
+    props = collect(props, user_agent)
+    props = normalize props
+    props = with_smart_matchers props
+    left  = props.select { |_, val| val.is_a? Regexp }
+    props = props.merge normalize(collect(left, user_agent)) if left.any?
+    props = with_labels props
+
+    if like
+      repl = user_agent =~ %r{#{like}}i && '' || like.to_s
+      like = parse user_agent.gsub identity.pattern, repl
+    end
+
+    Client.new props, like
+  end
+
+  def self.config
+    @config ||= Config.new({ before_parse: [],
+                             global_identities: [],
+                             properties: [],
+                             types: [:unknown],
+                             names: [],
+                             smart_matchers: {},
+                             identities: [],
+                             labels: Hash.new { |h, k| h[k] = [] },
+                             filters: Hash.new { |h, k| h[k] = [] },
+                             aliasses: Hash.new { |h, k| h[k] = [] } })
+  end
+
+  def self.label_for(target_name, version = nil)
+    return unless config.labels.key?(target_name) && version
+    version = Version.new version unless version.is_a? Version
+    return unless version > 0
+    config.labels[target_name].each do |candidate|
+      min = Version.new candidate[:range].min
+      max = Version.new candidate[:range].max
+
+      return candidate[:name] if version >= min && version <= max
+    end
+    nil
+  end
+
+  def self.with_labels(properties)
+    [:name, :engine, :platform].each do |prop|
+      lbl_prop = (prop == :name) && :label || "#{prop}_label".to_sym
+      ver_prop = (prop == :name) && :version || "#{prop}_version".to_sym
+      properties[lbl_prop] ||= label_for properties[prop], properties[ver_prop]
+    end
+
+    properties
+  end
+
+  def self.with_smart_matchers(properties)
+    config.smart_matchers.each_with_object properties do |(prop, detector), props|
+      props[prop] ||= parse_detector detector, properties
+    end
+  end
+
+  def self.parse_detector(detect, properties)
+    pat = properties.each_with_object(detect[:with].dup) do |(key, val), str|
+      replacement = val.to_s.strip
+      str.gsub! ":#{key}", replacement unless replacement.empty?
+    end
+
+    Regexp.new pat, get_flags(*detect[:flags].to_a)
+  end
+
+  def self.collect(properties, ua)
+    properties.each_with_object({}) do |(prop, value), res|
+      res[prop] = case value
+                  when Regexp then value.match(ua).to_a[1]
+                  else value
+                  end
+    end
+  end
+
+  def self.normalize(properties)
+    properties.each_with_object({}) do |(prop, value), store|
+      store[prop] = convert value, format: prop
+    end
+  end
+
+  def self.convert(val, **opts)
+    filters = config.filters[:global] + config.filters[opts[:format]]
+    filters.compact.each do |fmt|
+      val = fmt.call val
+    end
+
+    val
+  end
+
+  def self.get_flags(*flags)
+    val = 0
+
+    flags.each do |flag|
+      case flag.to_sym
+      when :m then val |= Regexp::MULTILINE
+      when :i then val |= Regexp::IGNORECASE
+      when :x then val |= Regexp::EXTENDED
+      end
+    end
+
+    val
+  end
+end

data/lib/browserino/options.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Browserino
+  class Options
+    def initialize(options = {})
+      @options = options
+    end
+
+    def method_missing(sym, *args, &block)
+      return @options[opt(sym)] == args.first if args.any?
+      @options[opt(sym)]
+    end
+
+    def respond_to_missing?(sym, *args, &block)
+      option? sym
+    end
+
+    def merge(other)
+      @options.merge! other
+      self
+    end
+
+    def to_hash
+      @options
+    end
+
+    def to_a
+      @options.to_a
+    end
+
+    def to_s
+      @options.to_s
+    end
+
+    private
+
+    def opt(sym)
+      sym.to_s.tr('?', '').to_sym
+    end
+
+    def option?(sym)
+      @options.keys.include? opt(sym)
+    end
+  end
+end

data/lib/browserino/version.rb

@@ -1,3 +1,74 @@
+# frozen_string_literal: true
 module Browserino
-  VERSION = '3.0.1'.freeze
+  VERSION = '4.0.0'.freeze
+
+  def self.version
+    @verion ||= Version.new VERSION.dup
+  end
+
+  # This class makes versions easily comparable using logical operators
+  # it makes it convenient to check versions in a natural way
+  class Version < Array
+    attr_reader :major, :minor, :patch
+
+    def initialize(val, *rest)
+      super parse_params(val, *rest)
+      @major = fetch 0, 0
+      @minor = fetch 1, 0
+      @patch = fetch 2, 0
+    end
+
+    def full
+      to_s
+    end
+
+    def to_s
+      @str ||= join '.'
+    end
+
+    def <(other)
+      compare :<, other
+    end
+
+    def <=(other)
+      compare :<=, other
+    end
+
+    def >(other)
+      compare :>, other
+    end
+
+    def >=(other)
+      compare :>=, other
+    end
+
+    def ==(other)
+      compare :==, other
+    end
+
+    def !=(other)
+      compare :!=, other
+    end
+
+    private
+
+    def parse_params(val, *rest)
+      case val
+      when Float   then val.to_s.split '.'
+      when Integer then [val, *rest]
+      when String  then val.tr('_', '.').split '.'
+      when Array   then val
+      when Hash    then [val[:major], val[:minor], val[:patch]]
+      when Symbol  then []
+      else val.to_a
+      end.map(&:to_i)
+    end
+
+    def compare(op, other)
+      other   = Version.new other unless other.is_a? Version
+      subsize = [size, other.size].min
+
+      (self[0...subsize] <=> other[0...subsize]).send op, 0
+    end
+  end
 end

data/lib/browserino.rb

@@ -1,67 +1,25 @@
-require_relative 'browserino/core/mapping'
-require_relative 'browserino/core/patterns'
-require_relative 'browserino/core/supported'
-require_relative 'browserino/core/questions'
-require_relative 'browserino/core/helpers'
-require_relative 'browserino/core/lies'
-require_relative 'browserino/core/alias'
-
+# frozen_string_literal: true
 require_relative 'browserino/integrate/rails' if defined?(::Rails)
 
-require_relative 'browserino/unknown'
-require_relative 'browserino/agent'
-
+require_relative 'browserino/options'
+require_relative 'browserino/config'
+require_relative 'browserino/methods'
+require_relative 'browserino/client'
 require_relative 'browserino/version'
-require_relative 'browserino/browser'
-require_relative 'browserino/engine'
-require_relative 'browserino/operating_system'
-require_relative 'browserino/console'
-
-module Browserino
-  module_function
-
-  def parse(ua)
-    name = Browser.name(ua)
-    info = fetch_info(strip_lies(ua), name)
-    tmp = info[:name].to_s.tr('_', ' ')
-    info[:name] = tmp.strip == '' ? nil : tmp
-
-    Agent.new check_for_aliases(info), ua
-  end
+require_relative 'browserino/identity'
 
-  def fetch_info(ua, name)
-    { name: name,
-      browser_version: Browser.version(ua, name),
-      engine_name: Engine.name(ua),
-      engine_version: Engine.version(ua),
-      system_name: OperatingSystem.name(ua),
-      system_version: OperatingSystem.version(ua),
-      system_architecture: OperatingSystem.architecture(ua),
-      console_name: Console.name(ua),
-      locale: OperatingSystem.locale(ua) }
-  end
-
-  def strip_lies(ua)
-    Core::LIES.inject(ua) do |s, arr|
-      s = s.gsub(arr[0], '') if arr[1] == true || s =~ arr[1]
-      s
-    end
-  end
+require_relative 'browserino/definitions/matchers'
+require_relative 'browserino/definitions/aliasses'
+require_relative 'browserino/definitions/filters'
+require_relative 'browserino/definitions/labels'
 
-  def check_for_aliases(h)
-    Core::ALIAS.each do |k, v|
-      h[k] = v.select { |n, re| n if h[k] =~ re }.keys.first || h[k]
+module Browserino
+  def self.parse(ua)
+    config.before_parse.each { |b| ua = b.call ua } if config.before_parse.any?
+    config.identities.each do |identity|
+      return analyze ua, identity if identity.matches? ua
     end
-    h
-  end
 
-  def extract_match(match, sym)
-    if match && match.names.include?(sym.to_s)
-      m = match[sym].to_s.downcase.strip
-      m = yield(m) if block_given?
-      m
-    else
-      UNKNOWN
-    end
+    analyze ua
   end
 end