brauser 3.3.2 → 4.0.0

data/lib/brauser/browseable/attributes.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the brauser gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Brauser
-  # The interface of brauser browsers.
-  module Browseable
-    # Methods to handle attributes.
-    module Attributes
-      # Gets a human-readable browser name.
-      #
-      # @return [String] A human-readable browser name.
-      def readable_name
-        parse_agent(@agent) unless @name
-        ::Brauser::Browser.browsers.fetch(@name).label
-      rescue KeyError
-        "Unknown Browser"
-      end
-
-      # Gets a human-readable platform name.
-      #
-      # @return [String] A readable platform name.
-      def platform_name
-        parse_agent(@agent) unless @platform
-        ::Brauser::Browser.platforms[@platform].try(:label) || "Unknown Platform"
-      end
-
-      # Returns an array of information about the browser. Information are strings which are suitable to use as CSS classes.
-      #
-      # For version, it will be included a class for every token of the version. For example, version `7.0.1.2` will return this:
-      #
-      # ```ruby
-      # ["version-7", "version-7_0", "version-7_0_1", "version-7_0_1_2"]
-      # ```
-      #
-      # If you provide a block (with accepts name, version and platform as arguments), it will be used for translating the name.
-      #
-      # @param join [String|NilClass] If non falsy, the separator to use to join information. If falsy, informations will be returned as array.
-      # @param name [Boolean] If non falsy, the string to prepend to the name. If falsy, the name information will not be included.
-      # @param version [String|NilClass] If non falsy, the string to prepend to the version. If falsy, the version information will not be included.
-      # @param platform [String|NilClass] If non falsy, the string to prepend to the platform. If falsy, the platform information will not be included.
-      # @param block [Proc] A block to translate browser name.
-      # @return [String|Array] CSS ready information of the current browser.
-      def classes(join = " ", name = "", version = "version-", platform = "platform-", &block)
-        platform = "platform-" if platform.is_a?(TrueClass)
-        rv = [stringify_name(name, &block), stringify_version(version), !platform ? nil : (platform + @platform.to_s)].compact.flatten
-        join ? rv.join(join) : rv
-      end
-      alias_method :meta, :classes
-      alias_method :to_s, :classes
-
-      private
-
-      # Stringifies a browser name(s).
-      #
-      # @param name [Boolean] If non falsy, the string to prepend to the name. If falsy, the name information will not be included.
-      # @param block [Proc] A block to translate browser name.
-      # @return [String|Array|nil] The browser name(s) or `nil`, if it was set to be skipped.
-      def stringify_name(name, &block)
-        if name
-          name, block = prepare_name_stringification(name, block)
-          names = block.call(@name, @version, @platform).ensure_array { |n| "#{name}#{n}" }
-          names.length > 1 ? names : names.first
-        else
-          nil
-        end
-      end
-
-      # Prepare a name stringification
-      #
-      # @param name [Boolean] If non falsy, the string to prepend to the name. If falsy, the name information will not be included.
-      # @param block [Proc] A block to translate browser name.
-      # @return [Array] A name and a translator ready to use.
-      def prepare_name_stringification(name, block)
-        parse_agent(@agent) unless @name
-        [(name.is_a?(TrueClass) ? "" : name), block || proc { |n, *| n == :msie_compatibility ? [:msie_compatibility, :msie] : n }]
-      end
-
-      # Stringifies a browser version.
-      #
-      # @param version [String|NilClass] If non falsy, the string to prepend to the version. If falsy, the version information will not be included.
-      # @return [Array] The version strings or `nil`, if it was set to be skipped.
-      def stringify_version(version)
-        version = "version-" if version.is_a?(TrueClass)
-        tokens = @version.split(".")
-
-        !version ? nil : tokens.reduce([version + tokens.shift]) {|prev, current|
-          prev + [prev.last + "_" + current]
-        }.flatten
-      end
-    end
-  end
-end

data/lib/brauser/browseable/general.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the brauser gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Brauser
-  # The interface of brauser browsers.
-  module Browseable
-    # General methods.
-    module General
-      extend ActiveSupport::Concern
-
-      # Class methods.
-      module ClassMethods
-        # Returns the list of browser that can be recognized.
-        #
-        # The keys are the browser name, the values are arrays of the name matcher, the version match and the label.
-        #
-        # @return [Hash] The list of browser that can be recognized.
-        def browsers
-          @definitions[:browsers]
-        end
-
-        # Returns the list of platforms that can be recognized.
-        #
-        # The keys are the platform name, values are arrays of the matcher and the label.
-        #
-        # @return [Hash] The list of platform that can be recognized.
-        def platforms
-          @definitions[:platforms]
-        end
-
-        # Returns the list of languages that can be recognized.
-        #
-        # The keys are the languages code, the values the labels.
-        #
-        # @return [Hash] The list of languages that can be recognized.
-        def languages
-          @definitions[:languages]
-        end
-
-        # Compares two versions.
-        #
-        # @param v1 [String] The first versions to compare.
-        # @param operator [Symbol] The operator to use for comparison, can be one of `[:lt, :lte, :eq, :gte, :gt]`.
-        # @param v2 [Symbol] The second version to compare.
-        # @return [Boolean] true if comparison is valid, `false` otherwise.
-        def compare_versions(v1 = "", operator = :eq, v2 = "")
-          valid_results = {lt: [-1], lte: [-1, 0], eq: [0], gte: [0, 1], gt: [1]}.fetch(operator, [])
-
-          if valid_results.present? && v1.ensure_string.present?
-            p1, p2 = find_relevant_tokens(v1, v2)
-            p1, p2 = normalize_tokens(p1, p2)
-            valid_results.include?(p1 <=> p2)
-          else
-            false
-          end
-        end
-
-        private
-
-        # Find relevant tokens (that is, the first two which are not equals) in a string for comparison.
-        #
-        # @param v1 [String] The first versions to compare.
-        # @param v2 [String] The second version to compare.
-        # @return [Array] The tokens to compare.
-        def find_relevant_tokens(v1, v2)
-          v1 = v1.ensure_string.strip.split(".")
-          v2 = v2.ensure_string.strip.split(".")
-
-          p1 = nil
-          p2 = nil
-          [v1.length, v2.length].max.times do |i|
-            p1 = v1[i]
-            p2 = v2[i]
-            break if !p1 && !p2 || p1 != p2
-          end
-
-          [p1 || "0", p2 || "0"]
-        end
-
-        # Normalizes token for comparison.
-        #
-        # @param p1 [String] The first token to normalize.
-        # @param p2 [String] The second token to normalize.
-        # @return [Array] The tokens to compare.
-        def normalize_tokens(p1, p2)
-          if !p1.is_integer?
-            ll = p1.length
-            p1 = p2 + p1
-            p2 += ("z" * ll)
-          else
-            ll = [p1.length, p2.length].max
-            p1 = p1.rjust(ll, "0")
-            p2 = p2.rjust(ll, "0")
-          end
-
-          [p1, p2]
-        end
-      end
-    end
-  end
-end

data/lib/brauser/browseable/parsing.rb

@@ -1,127 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the brauser gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Brauser
-  # The interface of brauser browsers.
-  module Browseable
-    # Methods to parse the user agent.
-    module Parsing
-      # Parses the User-Agent header.
-      # @param agent [String] The User-Agent header.
-      # @return [Boolean] `true` if the browser was detected, `false` otherwise.
-      def parse_agent(agent = nil)
-        agent = agent.ensure_string
-
-        @name, _ = match_name_and_version(agent)
-        @version = adjust_version(@version)
-        @platform = match_platform(agent)
-
-        (@name != :unknown) ? true : false
-      end
-
-      # Parses the Accept-Language header.
-      #
-      # @param accept_language [String] The Accept-Language header.
-      # @return [Array] The list of accepted languages.
-      def parse_accept_language(accept_language = nil)
-        accept_language.ensure_string.gsub(/;q=[\d.]+/, "").split(",").map { |l| l.downcase.strip }.select { |l| l.present? }
-      end
-
-      private
-
-      # Matches a browser name and version.
-      #
-      # @param agent [String] The User-Agent header.
-      # @return [String|Symbol] The browser name or `:unknown`, if no match was found.
-      def match_name_and_version(agent)
-        catch(:name) do
-          ::Brauser::Browser.browsers.each do |tag, definition|
-            matched = definition.match(:primary, definition, agent)
-
-            if matched
-              @version = definition.match(:secondary, definition, agent)
-              throw(:name, tag)
-            end
-          end
-
-          :unknown
-        end
-      end
-
-      # Adjusts a browser version.
-      #
-      # @param version [String] The version to adjust.
-      # @return [String] The adjusted version.
-      def adjust_version(version)
-        # Adjust version
-        if version.blank?
-          "0.0"
-        elsif version.is_a?(::MatchData)
-          version.to_a.last
-        else
-          version
-        end
-      end
-
-      # Matches a browser platform.
-      #
-      # @param agent [String] The User-Agent header.
-      # @return [String|Symbol] The browser platform or `:unknown`, if no match was found.
-      def match_platform(agent)
-        catch(:platform) do
-          ::Brauser::Browser.platforms.each do |tag, definition|
-            throw(:platform, tag) if definition.match(:primary, definition, agent)
-          end
-
-          :unknown
-        end
-      end
-
-      # Parse query, getting all arguments.
-      #
-      # @param query [String] The query to issue. Use `__` to separate query and `_` in place of `.` in the version.
-      # @return [Array] And array of `[method, arguments]` entries.
-      def parse_query(query)
-        query.gsub(/\?$/, "").gsub(/(_(v|on|is))/, " \\2").split(" ").map do |part|
-          parse_query_part(part)
-        end
-      end
-
-      # Handles a part of a query.
-      #
-      # @param part [String] A part of a query.
-      # @return [Boolean|Query|nil] A query or a boolean value (if `method` ends with `?`). If the query is not valid, `NoMethodError` will be raised.
-      def parse_query_part(part)
-        method, arguments = part.split("_", 2)
-
-        if method == "v" || method == "version"
-          arguments = parse_query_version(arguments)
-        elsif !%w(is on).include?(method)
-          raise NoMethodError
-        end
-
-        [method, arguments]
-      end
-
-      # Parses the version for a query.
-      #
-      # @param version [String] The version to parse.
-      # @return [String] The parsed version.
-      def parse_query_version(version)
-        [
-          [/_?eq_?/, " == "], # Parse ==
-          [/_?lte_?/, " <= "], # Parse <=
-          [/_?gte_?/, " >= "], # Parse >=
-          [/_?lt_?/, " < "], # Parse <
-          [/_?gt_?/, " > "], # Parse >
-          [/_?and_?/, " && "], # Parse &&
-          ["_", "."], # Dot notation
-          [/\s+/, " "]
-        ].reduce(version) { |a, e| a.gsub(e[0], e[1]) }.strip
-      end
-    end
-  end
-end

data/lib/brauser/browseable/partial_querying.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the brauser gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Brauser
-  # The interface of brauser browsers.
-  module Browseable
-    # Methods to query with chaining.
-    module PartialQuerying
-      # Checks if the browser is a specific name and optionally of a specific version and platform.
-      #
-      # @see #version?
-      # @see #on?
-      #
-      # @param names [Symbol|Array] A list of specific names to match. Also, this meta-names are supported: `:capable` and `:tablet`.
-      # @param versions [String|Hash] A string in the form `operator version && ...` (example: `>= 7 && < 4`) or an hash with specific version to match against,
-      #   in form `{:operator => version}`, where operator is one of `:lt, :lte, :eq, :gt, :gte`.
-      # @param platforms [Symbol|Array] A list of specific platform to match. Valid values are all those possible for the platform attribute.
-      # @return [Query] A query which can evaluated for concatenation or result.
-      def is(names = [], versions = {}, platforms = [])
-        parse_agent(@agent) unless @name
-
-        names = adjust_names(names)
-        versions = parse_versions_query(versions)
-        platforms = platforms.ensure_array
-
-        ::Brauser::Query.new(self,
-                             (names.blank? || (names.include?(@name) && check_capable(names))) &&
-                               (versions.blank? || version?(versions)) &&
-                               (platforms.blank? || on?(platforms))
-        )
-      end
-
-      # Checks if the browser is a specific version.
-      #
-      # @param versions [String|Hash] A string in the form `operator version && ...` (example: `>= 7 && < 4`) or an hash with specific version to match against,
-      #   in form `{:operator => version}`, where operator is one of `:lt, :lte, :eq, :gt, :gte`.
-      # @return [Query] A query which can evaluated for concatenation or result.
-      def version_equals_to(versions = {})
-        parse_agent(@agent) unless @version
-        versions = versions.is_a?(String) ? parse_versions_query(versions) : versions.ensure_hash
-
-        ::Brauser::Query.new(self, versions.all? { |operator, value| Brauser::Browser.compare_versions(@version, operator, value) })
-      end
-      alias_method :v, :version_equals_to
-
-      # Check if the browser is on a specific platform.
-      #
-      # @param platforms [Symbol|Array] A list of specific platform to match.
-      # @return [Query] A query which can evaluated for concatenation or result.
-      def on(platforms = [])
-        parse_agent(@agent) unless @platform
-
-        ::Brauser::Query.new(self, platforms.blank? || platforms.ensure_array(nil, true, true, true, :to_sym).include?(@platform))
-      end
-
-      # Check if the browser accepts the specified languages.
-      #
-      # @param langs [String|Array] A list of languages to match against.
-      # @return [Query] A query which can evaluated for concatenation or result.
-      def accepts(langs = [])
-        parse_accept_language(@accept_language) unless @languages
-
-        ::Brauser::Query.new(self, (@languages & langs.ensure_array(nil, true, true, true, :to_s)).present?)
-      end
-
-      private
-
-      # Adjusts names for correct matching.
-      #
-      # @param names [Array] A list of names.
-      # @return [Array] The adjusted list of names.
-      def adjust_names(names)
-        # Adjust names
-        names = names.ensure_array(nil, true, true, true, :to_sym)
-        names << [:msie, :msie_compatibility] if names.include?(:ie) || names.include?(:msie)
-        names << [:chromium] if names.include?(:chrome)
-        names << [:chrome, :firefox, :safari, :opera, :msie] if names.include?(:capable)
-        names << [:ipad, :android, :kindle] if names.include?(:tablet)
-        names.flatten.compact.uniq
-      end
-
-      # Checks if the browser is capable.
-      #
-      # @param names [Array] A list of names.
-      # @return [Boolean] `true` if the browser is capable, `false` otherwise.
-      def check_capable(names)
-        !names.include?(:capable) || @name != :msie || Brauser::Browser.compare_versions(@version, :gte, 9)
-      end
-
-      # Parses a version query.
-      #
-      # @param versions [String|Hash] A string in the form `operator version && ...` (example: `>= 7 && < 4`) or an hash with specific version to match
-      #   against, in form `{:operator => version}`, where operator is one of `:lt, :lte, :eq, :gt, :gte`.
-      # @return [Hash] The hash representation of the query.
-      def parse_versions_query(versions)
-        versions.is_a?(::Hash) ? versions : versions.ensure_string.split(/\s*&&\s*/).reduce({}) do |prev, token|
-          operator, version = parse_versions_query_component(token)
-          prev[operator] = version if operator.present? && version.present?
-          prev
-        end
-      end
-
-      # Parses a token of a version query.
-      #
-      # @param token [String] The token to parse.
-      # @return [Array] An operator and an argument.
-      def parse_versions_query_component(token)
-        operator, version = token.strip.split(/\s+/, 2).map(&:strip)
-        [{"<" => :lt, "<=" => :lte, "=" => :eq, "==" => :eq, ">" => :gt, ">=" => :gte}.fetch(operator, nil), version]
-      end
-    end
-  end
-end

data/lib/brauser/browseable/querying.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-#
-# This file is part of the brauser gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Brauser
-  # The interface of brauser browsers.
-  module Browseable
-    # Methods to end querying.
-    module Querying
-      # Checks if the browser is a specific name and optionally of a specific version and platform.
-      #
-      # @see #v?
-      # @see #on?
-      #
-      # @param names [Symbol|Array] A list of specific names to match. Also, this meta-names are supported: `:capable` and `:tablet`.
-      # @param versions [Hash] An hash with specific version to match against. Need to be in form `{:operator => version}`, where operator
-      #   is one of `:lt, :lte, :eq, :gt, :gte`.
-      # @param platforms [Symbol|Array] A list of specific platform to match. Valid values are all those possible for the platform attribute.
-      # @return [Boolean] `true` if current browser matches, `false` otherwise.
-      def is?(names = [], versions = {}, platforms = [])
-        is(names, versions, platforms).result
-      end
-
-      # Checks if the browser is a specific version.
-      #
-      # @param versions [String|Hash] A string in the form `operator version && ...` (example: `>= 7 && < 4`) or an hash with specific version to match against,
-      #   in form `{:operator => version}`, where operator is one of `:lt, :lte, :eq, :gt, :gte`.
-      # @return [Boolean] `true` if current browser matches, `false` otherwise.
-      def version?(versions = {})
-        version(versions).result
-      end
-      alias_method :v?, :version?
-
-      # Check if the browser is on a specific platform.
-      #
-      # @param platforms [Symbol|Array] A list of specific platform to match.
-      # @return [Boolean] `true` if current browser matches, `false` otherwise.
-      def on?(platforms = [])
-        on(platforms).result
-      end
-
-      # Check if the browser accepts the specified languages.
-      #
-      # @param langs [String|Array] A list of languages to match against.
-      # @return [Boolean] `true` if current browser matches, `false` otherwise.
-      def accepts?(langs = [])
-        accepts(langs).result
-      end
-
-      # Check if the browser is supported.
-      #
-      # @param supported [Hash|String] A map of engines and minimum supported major version, or a path to YAML file containing the map.
-      # @return [Boolean] `true` if current browser is supported, `false` otherwise.
-      def supported?(supported)
-        supported = YAML.load_file(supported).symbolize_keys if supported.is_a?(String)
-        minimum = supported[name]
-        (minimum && v?(gte: minimum)).to_boolean
-      end
-    end
-  end
-end