browserino 3.0.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c6f36b794e0bff81d17dbf38d47cbed631945a6
-  data.tar.gz: 98d2b7537b25b4a93de0a7f277ca0d92eae46d5d
+  metadata.gz: 1bdd2af440a3b1476900a3cdd36d2905660053c6
+  data.tar.gz: 0c7a2151e6ec79341ba5dda81eceddef2e8128ed
 SHA512:
-  metadata.gz: c4b0dac61fd41e1dbf75d57592cc6f12aeadfb80212be8c84012fb12bff41e44a9f0cfa97407fad98fe72ca9c41ceefc134cb379986e13a0dbf3eec9daf70b30
-  data.tar.gz: 6c785f94a902086de7f5479ee59f4f468fd60dc2fa79cb6ef9bfd1c366441f38688d1fe62628982b87728d92c25735f48f6fcee74d4a54ae9adbd9b3289a2650
+  metadata.gz: fb4d367fb7cfd3bd9cf637998de4a41549e18f20aaa0f14e007cb28883aff70b66e4beb75f757d99fe299b61a77db0c4322b90da74691e30677c524428a1c3eb
+  data.tar.gz: c13adf9ce004e08c5504b07367c5f362446ca06dbc6abe372872f703cca9694e8b3dd6f8fd7900970dea265a917e5d37ca9e951aef94176f241afaa4eba3f82c

data/.rubocop.yml

@@ -7,3 +7,13 @@ AllCops:
 
 Documentation:
   Enabled: false
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15

data/.travis.yml

@@ -1,10 +1,9 @@
 language: ruby
-cache: bundler
 rvm:
-  - 2.3.1
-  - 2.3.0
-  - 2.2.1
-  - 2.1.0
   - 2.0.0
-before_install: gem install bundler -v 1.10.5
-script: 'bundle exec rspec spec'
+  - 2.1.0
+  - 2.2.0
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler
+script: bundle exec rspec spec

data/bin/browserino

@@ -1,60 +1,28 @@
 #!/usr/bin/env ruby
-
 require 'bundler/setup'
+require 'pry'
 require_relative '../lib/browserino'
 
-aliasses = [:fb, :ddg, :ff, :internet_explorer, :win, :osx, :bb]
+props = Browserino.parse(ARGV[0].dup).properties
 
-case ARGV[0]
-when 'parse', '-p'
-  if ARGV[1]
-    puts Browserino.parse(ARGV[1]).to_console_s
-  else
-    puts '  Usage: browserino parse [ua]'
-    puts '    * ua: the user agent string you want to parse'
-  end
-when 'list', '-l'
-  ARGV[1] ||= 'info'
-  type = (ARGV[1].to_s.gsub(/[\s\-]/, '_')).to_sym
-  if type == :info
-    puts '  Usage: browserino list [subject]'
-    puts '    * subject: the type you want to display'
-    puts '      * all                      - list everything that is supported'
-    puts '      * bots                     - list supported bots'
-    puts '      * browsers                 - list supported browsers'
-    puts '      * social-media             - list supported social media'
-    puts '      * search-engines           - list supported search engines'
-    puts '      * consoles                 - list supported consoles'
-    puts '      * libraries                - list supported libraries'
-    puts '      * operating-systems        - list supported operating systems'
-  else
-    res = {}
-    res[:bots] = Browserino::Core::SUPPORTED[:bots] - aliasses if type == :all || type == :bots
-    res[:browsers] = Browserino::Core::SUPPORTED[:browsers] - aliasses if type == :all || type == :browsers
-    res[:consoles] = Browserino::Core::SUPPORTED[:consoles] - aliasses if type == :all || type == :consoles
-    res[:libraries] = Browserino::Core::SUPPORTED[:libraries] - aliasses if type == :all || type == :libraries
-    res[:social_media] = Browserino::Core::SUPPORTED[:social_media]  - aliasses if type == :all || type == :social_media
-    res[:search_engines] = Browserino::Core::SUPPORTED[:search_engines] - aliasses if type == :all || type == :search_engines
-    res[:operating_systems] = Browserino::Core::SUPPORTED[:operating_systems] - aliasses if type == :all || type == :operating_systems
+parsed = props.each_with_object({}) do |(prop, val), store|
+  store[prop] = val.to_s
+end
 
-    out = res.each_with_object([]) do |(type, supported_names), arr|
-      arr << "  \e[1;32;49m#{type.to_s.tr('_', ' ')}:\e[0m"
-      supported_names.each { |name| arr << "    \e[1;95;49m- #{name}\e[0m" }
-    end
-    puts out
-  end
-when 'console', '-c'
-  require 'pry'
-  puts "Starting Browserino #{Browserino::VERSION} on Ruby #{RUBY_VERSION}"
-  Pry.start
+max_key_len = parsed.keys.map(&:size).max
+max_val_len = parsed.values.map(&:size).max
+spacing     = 2
+spacer      = ' ' * spacing
 
-else
-  puts '  Usage: browserino [command] [args]'
-  puts "\n"
-  puts '    Calling browserino with anything other than these options will show this help'
-  puts '    Entering a [command] without [args] will show help for that command if it requires [args]'
-  puts "\n"
-  puts '    * parse     or -p              - parse a user agent'
-  puts '    * list      or -l              - list supported entities'
-  puts '    * console   or -c              - enter a console'
+out = parsed.map do |pair|
+  key = [spacer, pair[0], spacer].join.ljust(max_key_len + (spacing * 2))
+  val = [spacer, pair[1], spacer].join.ljust(max_val_len + (spacing * 2))
+  tmp = [key, val].join '|'
+  "|#{tmp}|\n"
 end
+
+row = '+' * (out.map(&:size).max - 1) + "\n"
+
+out[0]  = "#{row}#{out[0]}"
+out[-1] = "#{out[-1]}#{row}"
+puts out.join("#{row}")

data/bin/console

@@ -1,15 +1,12 @@
 #!/usr/bin/env ruby
 
 require 'bundler/setup'
-require 'browserino'
 require 'pry'
+require 'browserino'
 
-ua = 'Mozilla/5.0 (hp-tablet; Linux; hpwOS/3.0.2; U; de-DE) AppleWebKit/534.6 (KHTML, like Gecko) wOSBrowser/234.40.1 Safari/534.6 TouchPad/1.0'
-@agent = Browserino.parse(ua)
-
-puts "> @agent variable available parsed with: '#{ua}'\n\n"
-puts "> You can create a fresh object by using\n"
-puts "> Browserino.parse([string] ua)\n\n"
-puts "> ua - The user agent you'd actually want to parse as a string"
+@client = Browserino.parse ARGV[0].dup || 'Mozilla/5.0 (Macintosh; Intel Mac\
+                                           OS X 10_11_2) AppleWebKit/601.3.9\
+                                           (KHTML, l ike Gecko) Version/9.0.\
+                                           2 Safari/601.3.9'
 
 Pry.start

data/browserino.gemspec

@@ -8,7 +8,6 @@ Gem::Specification.new do |spec|
   spec.version       = Browserino::VERSION
   spec.authors       = ["Sidney Liebrand"]
   spec.email         = ["sidneyliebrand@gmail.com"]
-
   spec.summary       = %q{A browser identification gem with command line and Rails (>= 3.2.0) integration}
   spec.homepage      = "https://sidofc.github.io/projects/browserino/"
   spec.license       = "MIT"
@@ -18,12 +17,9 @@ Gem::Specification.new do |spec|
   spec.executables   = ['browserino']
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "json"
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "term-ansicolor"
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "tins"
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "pry"
 end

data/lib/browserino/client.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+module Browserino
+  class Client
+    attr_reader :property_names
+
+    def initialize(props = {}, like = nil)
+      @property_names = props.is_a?(Hash) && props.keys || []
+      @like           = like if like
+      # properties are added as methods that will each be defined in a specific
+      # order below. First, seperate static value methods from procs,
+      # procs will be able to call methods in this instances' context
+      # therefore we need to define static methods before procs
+
+      # for each static property:
+      # -- define a method that returns it's property value
+      # -- define a question method that returns it's property value or
+      #    checks version against supplied value if truthy
+      define_simple_methods! props
+
+      # for each proc property:
+      # -- define a method that returns it's instance evalled block value
+      # -- define a question method that returns it's instance evalled block
+      #    value or checks version against supplied value if truthy
+      define_proc_methods! props
+
+      # for each of #name, #engine and #platform, use their results as
+      # methods names, this will create a method #firefox? for the output
+      # of a #name # => :firefox for example.
+      define_name_result_methods!
+
+      # finally, add labels and their aliasses into the mix
+      # none of these methods should override an existing method
+      # therefore we check it's existence using defined?
+      define_label_methods!
+    end
+
+    def properties
+      @properties ||= @property_names.each_with_object({}) do |prop, result|
+        result[prop] = send prop
+      end
+    end
+
+    def like
+      @like ||= self
+    end
+
+    def like?(sym = nil, opts = {})
+      opts  = sym if sym.is_a? Hash
+      must  = []
+      must << like.is?(sym) if sym
+      must << like.version?(opts[:version]) if opts[:version]
+
+      must.any? && must.all?
+    end
+
+    def x64?
+      @x64_cache ||= architecture == :x64
+    end
+
+    def x32?
+      @x32_cache ||= architecture == :x32
+    end
+
+    # check the type of a Client
+    def type?(sym)
+      return type == sym if sym.is_a? Symbol
+      type == sym.to_sym
+    end
+
+    # the catch all method, anything it can ask as question will respond
+    # otherwise nil is returned, this is also true when supplying a version
+    def is?(sym, opts = {})
+      return send "#{sym}?", opts[:version] if opts[:version]
+      send "#{sym}?"
+    end
+
+    def ===(other)
+      return false unless name
+
+      case other
+      when Regexp then other =~ name
+      when String then other.to_sym == name
+      when Symbol, Browserino::Client then other == name
+      else false
+      end
+    end
+
+    def ==(other)
+      self === other
+    end
+
+    def =~(other)
+      self === other
+    end
+
+    def to_str
+      to_s
+    end
+
+    def to_json(*args)
+      @json_cache ||= properties.map do |prop, val|
+        final = val.is_a?(Version) && val.full || val
+        [prop, final]
+      end.to_h.to_json(*args)
+    end
+
+    def to_s
+      @str_cache ||= [:name, :engine, :platform].map do |prop|
+        name = send prop
+        ver  = version if prop == :name
+        ver  = send "#{prop}_version" if ver.nil?
+
+        [[name], [name, (ver.major if ver > '0.0.0')].compact.join.to_sym]
+      end.flatten.uniq.join(' ').gsub(/\s{2,}/, ' ').strip
+    end
+
+    def to_hash
+      properties
+    end
+
+    def to_h
+      properties
+    end
+
+    def to_a
+      properties.to_a
+    end
+
+    # scary, I know, but a falsy value is all we need to return if some
+    # property isn't known or true as any property can be defined on the Client
+    def method_missing(_, *__, &___)
+      nil
+    end
+
+    # always respond to missing, read method_missing comment
+    def respond_to_missing?(_, *__, &___)
+      true
+    end
+
+    private
+
+    def define_simple_methods!(props)
+      props.reject { |val| val.respond_to? :call }.each do |name, value|
+        define_singleton_method(name) { value }
+        define_singleton_method("#{name}?") do |val = nil, **opts|
+          values = [value, *Browserino.config.aliasses[value]]
+          return values.include? val if val && !opts[:version]
+          if val && opts[:version]
+            ver_res = send(name == :name ? :version : "#{name}_version")
+            return (ver_res == opts[:version]) && values.include?(val)
+          end
+          return value > 0 if value.is_a? Version
+          value && true
+        end
+      end
+    end
+
+    def define_proc_methods!(props)
+      props.select { |_, val| val.respond_to? :call }.each do |name, value|
+        result = instance_eval(&value)
+        define_singleton_method(name) { result }
+      end
+    end
+
+    def define_name_result_methods!
+      [:name, :engine, :platform].each do |prop|
+        result  = send prop
+        ver_res = version if prop == :name
+        ver_res = send("#{prop}_version") if ver_res.nil?
+
+        # for each of the props:
+        # -- define a question method using the value of prop
+        #    (ex: name # => firefox # => "firefox?")
+        #    -- when supplied with a value, check it against {prop_res}_version
+        #    -- when called without argument, return result
+        define_singleton_method("#{result}?") do |value = nil|
+          return ver_res == value if value
+          result && true
+        end
+
+        # for each of the aliasses found:
+        # -- define a question method using the current alias
+        #    -- when supplied with a value, check it against {prop_res}_version
+        #    -- when called without argument, return result
+        Browserino.config.aliasses[result].each do |alt|
+          define_singleton_method("#{alt}?") do |value = nil|
+            return ver_res == value if value
+            result && true
+          end
+        end
+      end
+    end
+
+    def define_label_methods!
+      property_names.select { |name| name =~ /label/i }.each do |prop|
+        next unless (result = send(prop))
+
+        ver_type = prop.to_s.gsub /_?label/, ''
+        ver_res  = version if ver_type.empty?
+        ver_res  = send("#{ver_type}_version") unless prop == :label
+
+        define_singleton_method("#{result}?") do |value = nil|
+          return ver_res == value if value
+          result && true
+        end
+
+        Browserino.config.aliasses[result].each do |alt|
+          define_singleton_method("#{alt}?") do |value = nil|
+            return ver_res == value if value
+            result && true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/browserino/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module Browserino
+  class Config < Options
+    def define(&block)
+      instance_eval(&block)
+      return unless identities.any? && identities.all?
+
+      identities.each do |identity|
+        properties << identity.properties.keys
+        types      << identity.type
+        names      << identity.name
+      end
+
+      properties.flatten!.uniq!
+      types.uniq!
+      names.uniq!
+    end
+
+    def label(name, **opts)
+      return false unless opts[:for]
+      opts[:name] ||= name
+      labels[opts[:for]] << opts
+    end
+
+    def filter(*props, &block)
+      props << :global unless props.any?
+      props.each { |prop| filters[prop] << block }
+    end
+
+    def smart_match(prop, **options)
+      smart_matchers[prop] = options if options[:with]
+    end
+
+    def match(rgxp = nil, **opts, &block)
+      rgxp, opts = [nil, rgxp] if rgxp.is_a? Hash
+      opts = @tmp_defaults.merge opts if @tmp_defaults.is_a? Hash
+
+      if rgxp && opts[:like]
+        identities.unshift with_alias(rgxp, opts, &block)
+      elsif rgxp
+        identities << Identity.new(rgxp, opts, &block)
+      else
+        global_identities.unshift Identity.new(&block)
+      end
+    end
+
+    def alias_for(name, *names)
+      aliasses[name] += names
+    end
+
+    def before_parse(&block)
+      @options[:before_parse] << block if block
+      @options[:before_parse]
+    end
+
+    def preset(props, &block)
+      @tmp_defaults = props
+      instance_eval(&block)
+      @tmp_defaults = nil
+    end
+
+    def like(tmp, &block)
+      preset like: tmp.to_sym, &block
+    end
+
+    def validators(&block)
+      preset type: :validator, &block
+    end
+
+    def browsers(&block)
+      preset type: :browser, &block
+    end
+
+    def bots(&block)
+      preset type: :bot, &block
+    end
+
+    def libraries(&block)
+      preset type: :library, &block
+    end
+
+    def with_alias(pattern, **opts, &block)
+      id = identities.select { |id| id == opts[:like] }.first
+
+      raise "No alias found for: #{opts[:like] || 'nil'}" unless id
+
+      Identity.new pattern, id.properties.merge(opts), &block
+    end
+  end
+end

data/lib/browserino/definitions/aliasses.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+Browserino.config.define do
+  # aliasses will be defined after a Client has been initialized
+  # only the aliasses matching the Client will be defined
+  alias_for :firefox,    :ff
+  alias_for :windows,    :win
+  alias_for :macintosh,  :mac, :osx, :macos
+  alias_for :blackberry, :bb
+  alias_for :ie,         :internet_explorer
+  alias_for :facebook,   :fb
+  alias_for :duckduckgo, :ddg
+end

data/lib/browserino/definitions/filters.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+Browserino.config.define do
+  # executes before parsing the user agent, 's' in this case is the actual
+  # user agent string in full glory. Do manipulations as you wish, I'm
+  # using it to successfully strip lies from the user agent and to sometimes
+  # simplify a word e.g. 'AppleWebKit' => 'webkit'
+
+  # the returned result will be used as the user agent to parse so make
+  # sure to return the final ua at the end
+  before_parse do |ua|
+    ua = ua.gsub(%r{applewebkit}i, 'webkit').gsub %r{(Mozilla/[\d\.]+)}i, ''
+    ua = ua.gsub(%r{chrome|safari}i, '').gsub('OPR', 'opera') if ua =~ %r{OPR}
+    ua = ua.gsub %r{9\.80}, '' if ua =~ %r{opera}i
+    ua = ua.gsub %r{webkit/}i, '' if ua =~ %r{presto}i
+    ua = ua.gsub %r{(?:ms)?ie}i, '' if ua =~ %r{rv:}i
+    ua = ua.gsub %r{android|linux}i, '' if ua =~ %r{tizen}i
+    ua = ua.gsub %r{linux}i, '' if ua =~ %r{android|s(unos|olaris)|w(eb)?os}i
+    ua = ua.gsub %r{x11}i, '' if ua =~ %r{bsd|s(unos|olaris)}i
+    ua = ua.gsub %r{windows\snt}i, '' if ua =~ %r{windows\sphone}i
+    ua = ua.gsub %r{rv:}i, '' if ua =~ %r{servo}i
+    ua = ua.gsub %r{mac\sos\sx}i, '' if ua =~ %r{ip(?:[ao]d|hone)}i
+    ua = ua.gsub %r{msie}i, '' if ua =~ %r{huaweisymantecspider}i
+    ua
+  end
+
+  # after an identity is found, it's values are filtered in two stages
+  # first, filters will parse all statically defined values (e.g.) no regexp
+  # or block within matchers, after that, smart matcher patterns will be
+  # conditionally added and parsed with the previously collected values and
+  # then also filtered
+
+  # this is a global filter, multiple can be defined and they will all run
+  # before any named filters
+  filter do |value|
+    case value
+    when TrueClass, FalseClass, NilClass, Proc then value
+    when %r{\A[\d_\.]+\z}i then value.to_s.strip.tr('_', '.')
+    else value.to_s.downcase.strip.gsub(%r{[\s-]+}i, '_').to_sym
+    end
+  end
+
+  # this is a named filter, it defines the same filter for 3 properties
+  # multiple name filters for the same property can be created, they will be
+  # executed in order of addition
+  filter :version, :engine_version, :platform_version do |value|
+    Browserino::Version.new value
+  end
+
+  filter :platform do |value|
+    value = :ios       if value =~ %r{ip(?:[ao]d|hone)}i
+    value = :webos     if value =~ %r{w(?:eb)?os}i
+    value = :linux     if value =~ %r{ubuntu|x11}i
+    value = :solaris   if value =~ %r{s(?:unos|olaris)}i
+    value = :macintosh if value =~ %r{mac_os_x}i
+    value
+  end
+
+  filter :architecture do |value|
+    value = :x64 if value && value =~ %r{(?:x86_|amd|wow)?64|i686}i
+    value = :x32 if value && value != :x64
+    value
+  end
+
+  filter :mobile do |value|
+    !value.to_s.strip.empty?
+  end
+end

data/lib/browserino/definitions/labels.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+Browserino.config.define do
+  # labels will be defined before a client has been initialized
+  # they will not be filtered before being injected into the Client
+
+  # labels will be matched against values of #name, #engine and #platform and
+  # will create #label, #engine_label and #platform_label properties
+  # respectively. These enjoy all the features that regular defined properties
+  # in for instance methods enjoy, such as automatic question methods like
+  # client.platform_label? :mavericks
+  label :android,            for: :android,   range: '1'..'1.4.9'
+  label :cupcake,            for: :android,   range: '1.5'..'1.9.9'
+  label :eclair,             for: :android,   range: '2'..'2.1'
+  label :froyo,              for: :android,   range: '2.2'..'2.2.3'
+  label :gingerbread,        for: :android,   range: '2.2.4'..'2.3.7'
+  label :honeycomb,          for: :android,   range: '3'..'3.2.6'
+  label :ice_cream_sandwich, for: :android,   range: '4'..'4.0.4'
+  label :jelly_bean,         for: :android,   range: '4.1'..'4.3.1'
+  label :kitkat,             for: :android,   range: '4.4'..'4.4.4'
+  label :lollipop,           for: :android,   range: '5'..'5.1.1'
+  label :marshmallow,        for: :android,   range: '6'..'6.1.1'
+  label :nougat,             for: :android,   range: '7'..'7.1.1'
+
+  label :cheetah,            for: :macintosh, range: '10.0'..'10.0.9'
+  label :puma,               for: :macintosh, range: '10.1'..'10.1.9'
+  label :jaguar,             for: :macintosh, range: '10.2'..'10.2.9'
+  label :panther,            for: :macintosh, range: '10.3'..'10.3.9'
+  label :tiger,              for: :macintosh, range: '10.4'..'10.4.9'
+  label :leopard,            for: :macintosh, range: '10.5'..'10.5.9'
+  label :snow_leopard,       for: :macintosh, range: '10.6'..'10.6.9'
+  label :lion,               for: :macintosh, range: '10.7'..'10.7.9'
+  label :mountain_lion,      for: :macintosh, range: '10.8'..'10.8.9'
+  label :mavericks,          for: :macintosh, range: '10.9'..'10.9.9'
+  label :yosemite,           for: :macintosh, range: '10.10'..'10.10.9'
+  label :el_capitan,         for: :macintosh, range: '10.11'..'10.11.9'
+  label :sierra,             for: :macintosh, range: '10.12'..'10.12.9'
+
+  label :windows_dos,        for: :windows,   range: '3.1'..'4.0'
+  label :windows_2000,       for: :windows,   range: '5.0'..'5.0.9'
+  label :windows_xp,         for: :windows,   range: '5.1'..'5.2.9'
+  label :windows_vista,      for: :windows,   range: '6.0'..'6.0.9'
+  label :windows_7,          for: :windows,   range: '6.1'..'6.1.9'
+  label :windows_8,          for: :windows,   range: '6.2'..'6.3'
+  label :windows_10,         for: :windows,   range: '10.0'..'10.0.9'
+end