browserino 4.0.0 → 4.1.0

data/lib/browserino/{identity.rb → matcher.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module Browserino
-  class Identity
+  class Matcher
     attr_reader :pattern, :properties
 
     SETTINGS = { name: nil, type: :unknown }.freeze
@@ -14,7 +15,11 @@ module Browserino
     end
 
     def matches?(user_agent)
-      pattern =~ user_agent if pattern.is_a? Regexp
+      pattern =~ user_agent
+    end
+
+    def =~(other)
+      pattern =~ other
     end
 
     def ===(other)
@@ -24,7 +29,7 @@ module Browserino
       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]
+      when Matcher then other.properties[:name] == properties[:name]
       else false
       end
     end
@@ -33,17 +38,13 @@ module Browserino
       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?
+      return @properties[sym] = block      if block
 
       @properties[sym]
     end

data/lib/browserino/methods.rb

@@ -1,35 +1,39 @@
 # 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
+  def self.analyze(ua, matcher = nil)
+    @defaults ||= config.global_matchers.map(&:properties).reduce(&:merge)
+
+    props    = @defaults.merge(matcher && matcher.properties || {})
+    like     = props.delete :like
+    props    = collect props, ua
+    props    = collect_with_smart_watchers props, ua
+    props    = with_labels props
+    like     = Client.new props.merge(like_attrs(props, like, ua)) if like
 
     Client.new props, like
   end
 
+  def self.like_attrs(props, like, user_agent)
+    lattrs = config.matchers.select { |m| m == like }.first.properties
+    fattrs = { name: like }
+    fattrs[:version] = lattrs[:version] if lattrs[:version].is_a? Regexp
+    fattrs[:version] ||= smart_matchers(fattrs)[:version]
+
+    props.dup.merge collect(fattrs, user_agent)
+  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] = [] } })
+    @config ||= Config.new(before_parse: [],
+                           global_matchers: [],
+                           properties: [],
+                           types: [:unknown],
+                           names: [],
+                           smart_matchers: {},
+                           matchers: [],
+                           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)
@@ -37,16 +41,13 @@ module Browserino
     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
+      return candidate[:name] if version.between? candidate[:range]
     end
     nil
   end
 
   def self.with_labels(properties)
-    [:name, :engine, :platform].each do |prop|
+    %i[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]
@@ -55,9 +56,14 @@ module Browserino
     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
+  def self.collect_with_smart_watchers(properties, user_agent)
+    properties.merge collect(smart_matchers(properties), user_agent)
+  end
+
+  def self.smart_matchers(properties)
+    config.smart_matchers.each_with_object({}) do |(prop, detector), props|
+      next if properties.key? prop
+      props[prop] = parse_detector detector, properties
     end
   end
 
@@ -71,23 +77,14 @@ module Browserino
   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
+    properties.each_with_object({}) do |(n, v), r|
+      r[n] = convert (v.is_a?(Regexp) ? v.match(ua).to_a[1] : v), format: n
     end
   end
 
   def self.convert(val, **opts)
     filters = config.filters[:global] + config.filters[opts[:format]]
-    filters.compact.each do |fmt|
+    filters.each do |fmt|
       val = fmt.call val
     end
 

data/lib/browserino/options.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
+
 module Browserino
   class Options
     def initialize(options = {})
       @options = options
     end
 
-    def method_missing(sym, *args, &block)
+    def method_missing(sym, *args, &___)
       return @options[opt(sym)] == args.first if args.any?
       @options[opt(sym)]
     end
 
-    def respond_to_missing?(sym, *args, &block)
+    def respond_to_missing?(sym, *_, &___)
       option? sym
     end
 

data/lib/browserino/version.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Browserino
-  VERSION = '4.0.0'.freeze
+  VERSION = '4.1.0'.freeze
 
   def self.version
-    @verion ||= Version.new VERSION.dup
+    @version ||= Version.new VERSION.dup
   end
 
   # This class makes versions easily comparable using logical operators
@@ -50,11 +51,19 @@ module Browserino
       compare :!=, other
     end
 
+    def between?(min, max = nil)
+      if min.is_a? Range
+        max = min.max
+        min = min.min
+      end
+
+      (self >= Version.new(min)) && (self <= Version.new(max))
+    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

data/lib/browserino.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'browserino/integrate/rails' if defined?(::Rails)
 
 require_relative 'browserino/options'
@@ -6,7 +7,7 @@ require_relative 'browserino/config'
 require_relative 'browserino/methods'
 require_relative 'browserino/client'
 require_relative 'browserino/version'
-require_relative 'browserino/identity'
+require_relative 'browserino/matcher'
 
 require_relative 'browserino/definitions/matchers'
 require_relative 'browserino/definitions/aliasses'
@@ -16,10 +17,9 @@ require_relative 'browserino/definitions/labels'
 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
+    config.matchers.each do |matcher|
+      return analyze ua, matcher if matcher.matches? ua
     end
-
     analyze ua
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: browserino
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Sidney Liebrand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-23 00:00:00.000000000 Z
+date: 2017-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -109,9 +123,9 @@ files:
 - lib/browserino/definitions/filters.rb
 - lib/browserino/definitions/labels.rb
 - lib/browserino/definitions/matchers.rb
-- lib/browserino/identity.rb
 - lib/browserino/integrate/action_controller.rb
 - lib/browserino/integrate/rails.rb
+- lib/browserino/matcher.rb
 - lib/browserino/methods.rb
 - lib/browserino/options.rb
 - lib/browserino/version.rb