css_parser 1.5.0.pre2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bcad7a186fec9e364d7b615e821fad091db568cc
-  data.tar.gz: 4b0c9be7d82bf15144bda6bf09e1a0b328d7a5d0
+SHA256:
+  metadata.gz: c049fe40a4b774b56e00c790cf18b78c8a94298185435471893cedff65a79c17
+  data.tar.gz: fd0600e1859e8bd188a12df4ccd252a1f75f4ae2f98707249c7750e622d5e2b4
 SHA512:
-  metadata.gz: d5a2a1d8f77eb1dc9ed16d03bf6141385238d3c3fb774b9352df83d49a6c64881ba26226d8d5ff88af68130c503fef4164a44f0a0a0aa0662911659b1f1ae877
-  data.tar.gz: 451dd77df3050fe539cc7098da6ba7f07b25fe977eae29d579f3ce55f85c7e72cfe9b45f25bf93d588f97e291ad2c0b6c553782980a9032ad22566f712a7bc9c
+  metadata.gz: 53b2f435c485d393778679d3202943a99b83607af4ce5edac9a15aac4461fb252371b43d98b7bf1886254b143da9bff5a61492d7a36e74e44e77b44f8ba38318
+  data.tar.gz: ab5fb0504811ebd05eb09e830447f832b67aad5e5559dd4be9e562c20d5bb4cc786165eb961b39867e8316c72ce90015de16e1857154784b4bf0fc700b92a34b

data/lib/css_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'addressable/uri'
 require 'uri'
 require 'net/https'
@@ -12,7 +14,6 @@ require 'css_parser/regexps'
 require 'css_parser/parser'
 
 module CssParser
-
   # Merge multiple CSS RuleSets by cascading according to the CSS 2.1 cascading rules
   # (http://www.w3.org/TR/REC-CSS2/cascade.html#cascading-order).
   #
@@ -55,10 +56,10 @@ module CssParser
     @folded_declaration_cache = {}
 
     # in case called like CssParser.merge([rule_set, rule_set])
-    rule_sets.flatten! if rule_sets[0].kind_of?(Array)
+    rule_sets.flatten! if rule_sets[0].is_a?(Array)
 
-    unless rule_sets.all? {|rs| rs.kind_of?(CssParser::RuleSet)}
-      raise ArgumentError, "all parameters must be CssParser::RuleSets."
+    unless rule_sets.all? { |rs| rs.is_a?(CssParser::RuleSet) }
+      raise ArgumentError, 'all parameters must be CssParser::RuleSets.'
     end
 
     return rule_sets[0] if rule_sets.length == 1
@@ -70,38 +71,27 @@ module CssParser
       rule_set.expand_shorthand!
 
       specificity = rule_set.specificity
-      unless specificity
-        if rule_set.selectors.length == 0
-          specificity = 0
-        else
-          specificity = rule_set.selectors.map { |s| calculate_specificity(s) }.compact.max || 0
-        end
-      end
+      specificity ||= rule_set.selectors.map { |s| calculate_specificity(s) }.compact.max || 0
 
       rule_set.each_declaration do |property, value, is_important|
         # Add the property to the list to be folded per http://www.w3.org/TR/CSS21/cascade.html#cascading-order
-        if not properties.has_key?(property)
-          properties[property] = {:value => value, :specificity => specificity, :is_important => is_important}
+        if not properties.key?(property)
+          properties[property] = {value: value, specificity: specificity, is_important: is_important}
         elsif is_important
           if not properties[property][:is_important] or properties[property][:specificity] <= specificity
-            properties[property] = {:value => value, :specificity => specificity, :is_important => is_important}
+            properties[property] = {value: value, specificity: specificity, is_important: is_important}
           end
         elsif properties[property][:specificity] < specificity or properties[property][:specificity] == specificity
           unless properties[property][:is_important]
-            properties[property] = {:value => value, :specificity => specificity, :is_important => is_important}
+            properties[property] = {value: value, specificity: specificity, is_important: is_important}
           end
         end
-     end
+      end
     end
 
-    merged = RuleSet.new(nil, nil)
-
-    properties.each do |property, details|
-      if details[:is_important]
-        merged[property.strip] = details[:value].strip.gsub(/\;\Z/, '') + '!important'
-      else
-        merged[property.strip] = details[:value].strip
-      end
+    merged = properties.each_with_object(RuleSet.new(nil, nil)) do |(property, details), rule_set|
+      value = details[:value].strip
+      rule_set[property.strip] = details[:is_important] ? "#{value.gsub(/;\Z/, '')}!important" : value
     end
 
     merged.create_shorthand!
@@ -122,12 +112,12 @@ module CssParser
   def self.calculate_specificity(selector)
     a = 0
     b = selector.scan(/\#/).length
-    c = selector.scan(NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX).length
-    d = selector.scan(ELEMENTS_AND_PSEUDO_ELEMENTS_RX).length
+    c = selector.scan(NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX_NC).length
+    d = selector.scan(ELEMENTS_AND_PSEUDO_ELEMENTS_RX_NC).length
 
-    (a.to_s + b.to_s + c.to_s + d.to_s).to_i
+    "#{a}#{b}#{c}#{d}".to_i
   rescue
-    return 0
+    0
   end
 
   # Make <tt>url()</tt> links absolute.
@@ -144,23 +134,25 @@ module CssParser
   #               "http://example.org/style/basic.css").inspect
   #  => "body { background: url('http://example.org/style/yellow.png?abc=123') };"
   def self.convert_uris(css, base_uri)
-    base_uri = Addressable::URI.parse(base_uri) unless base_uri.kind_of?(Addressable::URI)
+    base_uri = Addressable::URI.parse(base_uri) unless base_uri.is_a?(Addressable::URI)
 
     css.gsub(URI_RX) do
-      uri = $1.to_s
-      uri.gsub!(/["']+/, '')
+      uri = Regexp.last_match(1).to_s.gsub(/["']+/, '')
       # Don't process URLs that are already absolute
-      unless uri =~ /^[a-z]+\:\/\//i
+      unless uri.match(%r{^[a-z]+://}i)
         begin
-          uri = base_uri + uri
-        rescue; end
+          uri = base_uri.join(uri)
+        rescue
+          nil
+        end
       end
-      "url('#{uri.to_s}')"
+      "url('#{uri}')"
     end
   end
 
   def self.sanitize_media_query(raw)
-    mq = raw.to_s.gsub(/[\s]+/, ' ').strip
+    mq = raw.to_s.gsub(/\s+/, ' ')
+    mq.strip!
     mq = 'all' if mq.empty?
     mq.to_sym
   end

data/lib/css_parser/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CssParser
   # Exception class used for any errors encountered while downloading remote files.
   class RemoteFileError < IOError; end
@@ -14,13 +16,13 @@ module CssParser
   # [<tt>import</tt>] Follow <tt>@import</tt> rules. Boolean, default is <tt>true</tt>.
   # [<tt>io_exceptions</tt>] Throw an exception if a link can not be found. Boolean, default is <tt>true</tt>.
   class Parser
-    USER_AGENT   = "Ruby CSS Parser/#{CssParser::VERSION} (https://github.com/premailer/css_parser)"
+    USER_AGENT = "Ruby CSS Parser/#{CssParser::VERSION} (https://github.com/premailer/css_parser)"
 
-    STRIP_CSS_COMMENTS_RX = /\/\*.*?\*\//m
-    STRIP_HTML_COMMENTS_RX = /\<\!\-\-|\-\-\>/m
+    STRIP_CSS_COMMENTS_RX = %r{/\*.*?\*/}m.freeze
+    STRIP_HTML_COMMENTS_RX = /<!--|-->/m.freeze
 
     # Initial parsing
-    RE_AT_IMPORT_RULE = /\@import\s*(?:url\s*)?(?:\()?(?:\s*)["']?([^'"\s\)]*)["']?\)?([\w\s\,^\]\(\)]*)\)?[;\n]?/
+    RE_AT_IMPORT_RULE = /@import\s*(?:url\s*)?(?:\()?(?:\s*)["']?([^'"\s)]*)["']?\)?([\w\s,^\]()]*)\)?[;\n]?/.freeze
 
     MAX_REDIRECTS = 3
 
@@ -34,10 +36,10 @@ module CssParser
     class << self; attr_reader :folded_declaration_cache; end
 
     def initialize(options = {})
-      @options = {:absolute_paths => false,
-                  :import => true,
-                  :io_exceptions => true,
-                  :capture_offsets => false}.merge(options)
+      @options = {absolute_paths: false,
+                  import: true,
+                  io_exceptions: true,
+                  capture_offsets: false}.merge(options)
 
       # array of RuleSets
       @rules = []
@@ -69,21 +71,20 @@ module CssParser
     # Returns an array of declarations.
     def find_by_selector(selector, media_types = :all)
       out = []
-      each_selector(media_types) do |sel, dec, spec|
+      each_selector(media_types) do |sel, dec, _spec|
         out << dec if sel.strip == selector.strip
       end
       out
     end
-    alias_method :[], :find_by_selector
+    alias [] find_by_selector
 
     # Finds the rule sets that match the given selectors
     def find_rule_sets(selectors, media_types = :all)
       rule_sets = []
 
       selectors.each do |selector|
-        selector.gsub!(/\s+/, ' ')
-        selector.strip!
-        each_rule_set(media_types) do |rule_set, media_type|
+        selector = selector.gsub(/\s+/, ' ').strip
+        each_rule_set(media_types) do |rule_set, _media_type|
           if !rule_sets.member?(rule_set) && rule_set.selectors.member?(selector)
             rule_sets << rule_set
           end
@@ -114,9 +115,9 @@ module CssParser
     #   parser = CssParser::Parser.new
     #   parser.add_block!(css)
     def add_block!(block, options = {})
-      options = {:base_uri => nil, :base_dir => nil, :charset => nil, :media_types => :all, :only_media_types => :all}.merge(options)
-      options[:media_types] = [options[:media_types]].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
-      options[:only_media_types] = [options[:only_media_types]].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
+      options = {base_uri: nil, base_dir: nil, charset: nil, media_types: :all, only_media_types: :all}.merge(options)
+      options[:media_types] = [options[:media_types]].flatten.collect { |mt| CssParser.sanitize_media_query(mt) }
+      options[:only_media_types] = [options[:only_media_types]].flatten.collect { |mt| CssParser.sanitize_media_query(mt) }
 
       block = cleanup_block(block, options)
 
@@ -128,19 +129,19 @@ module CssParser
       if @options[:import]
         block.scan(RE_AT_IMPORT_RULE).each do |import_rule|
           media_types = []
-          if media_string = import_rule[-1]
-            media_string.split(/[,]/).each do |t|
+          if (media_string = import_rule[-1])
+            media_string.split(/,/).each do |t|
               media_types << CssParser.sanitize_media_query(t) unless t.empty?
             end
           else
             media_types = [:all]
           end
 
-          next unless options[:only_media_types].include?(:all) or media_types.length < 1 or (media_types & options[:only_media_types]).length > 0
+          next unless options[:only_media_types].include?(:all) or media_types.empty? or !(media_types & options[:only_media_types]).empty?
 
           import_path = import_rule[0].to_s.gsub(/['"]*/, '').strip
 
-          import_options = { :media_types => media_types }
+          import_options = {media_types: media_types}
           import_options[:capture_offsets] = true if options[:capture_offsets]
 
           if options[:base_uri]
@@ -182,20 +183,21 @@ module CssParser
     #
     # +media_types+ can be a symbol or an array of symbols.
     def add_rule_set!(ruleset, media_types = :all)
-      raise ArgumentError unless ruleset.kind_of?(CssParser::RuleSet)
+      raise ArgumentError unless ruleset.is_a?(CssParser::RuleSet)
 
-      media_types = [media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
+      media_types = [media_types] unless media_types.is_a?(Array)
+      media_types = media_types.flat_map { |mt| CssParser.sanitize_media_query(mt) }
 
-      @rules << {:media_types => media_types, :rules => ruleset}
+      @rules << {media_types: media_types, rules: ruleset}
     end
 
     # Remove a CssParser RuleSet object.
     #
     # +media_types+ can be a symbol or an array of symbols.
     def remove_rule_set!(ruleset, media_types = :all)
-      raise ArgumentError unless ruleset.kind_of?(CssParser::RuleSet)
+      raise ArgumentError unless ruleset.is_a?(CssParser::RuleSet)
 
-      media_types = [media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
+      media_types = [media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt) }
 
       @rules.reject! do |rule|
         rule[:media_types] == media_types && rule[:rules].to_s == ruleset.to_s
@@ -207,7 +209,7 @@ module CssParser
     # +media_types+ can be a symbol or an array of symbols.
     def each_rule_set(media_types = :all) # :yields: rule_set, media_types
       media_types = [:all] if media_types.nil?
-      media_types = [media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
+      media_types = [media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt) }
 
       @rules.each do |block|
         if media_types.include?(:all) or block[:media_types].any? { |mt| media_types.include?(mt) }
@@ -220,7 +222,7 @@ module CssParser
     def to_h(which_media = :all)
       out = {}
       styles_by_media_types = {}
-      each_selector(which_media) do |selectors, declarations, specificity, media_types|
+      each_selector(which_media) do |selectors, declarations, _specificity, media_types|
         media_types.each do |media_type|
           styles_by_media_types[media_type] ||= []
           styles_by_media_types[media_type] << [selectors, declarations]
@@ -242,6 +244,8 @@ module CssParser
     # +media_types+ can be a symbol or an array of symbols.
     # See RuleSet#each_selector for +options+.
     def each_selector(all_media_types = :all, options = {}) # :yields: selectors, declarations, specificity, media_types
+      return to_enum(__method__, all_media_types, options) unless block_given?
+
       each_rule_set(all_media_types) do |rule_set, media_types|
         rule_set.each_selector(options) do |selectors, declarations, specificity|
           yield selectors, declarations, specificity, media_types
@@ -251,9 +255,10 @@ module CssParser
 
     # Output all CSS rules as a single stylesheet.
     def to_s(which_media = :all)
-      out = ''
+      out = []
       styles_by_media_types = {}
-      each_selector(which_media) do |selectors, declarations, specificity, media_types|
+
+      each_selector(which_media) do |selectors, declarations, _specificity, media_types|
         media_types.each do |media_type|
           styles_by_media_types[media_type] ||= []
           styles_by_media_types[media_type] << [selectors, declarations]
@@ -262,20 +267,21 @@ module CssParser
 
       styles_by_media_types.each_pair do |media_type, media_styles|
         media_block = (media_type != :all)
-        out += "@media #{media_type} {\n" if media_block
+        out << "@media #{media_type} {" if media_block
 
         media_styles.each do |media_style|
           if media_block
-            out += "  #{media_style[0]} {\n    #{media_style[1]}\n  }\n"
+            out.push("  #{media_style[0]} {\n    #{media_style[1]}\n  }")
           else
-            out += "#{media_style[0]} {\n#{media_style[1]}\n}\n"
+            out.push("#{media_style[0]} {\n#{media_style[1]}\n}")
           end
         end
 
-        out += "}\n" if media_block
+        out << '}' if media_block
       end
 
-      out
+      out << ''
+      out.join("\n")
     end
 
     # A hash of { :media_query => rule_sets }
@@ -283,7 +289,7 @@ module CssParser
       rules_by_media = {}
       @rules.each do |block|
         block[:media_types].each do |mt|
-          unless rules_by_media.has_key?(mt)
+          unless rules_by_media.key?(mt)
             rules_by_media[mt] = []
           end
           rules_by_media[mt] << block[:rules]
@@ -295,15 +301,13 @@ module CssParser
 
     # Merge declarations with the same selector.
     def compact! # :nodoc:
-      compacted = []
-
-      compacted
+      []
     end
 
     def parse_block_into_rule_sets!(block, options = {}) # :nodoc:
       current_media_queries = [:all]
       if options[:media_types]
-        current_media_queries = options[:media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt)}
+        current_media_queries = options[:media_types].flatten.collect { |mt| CssParser.sanitize_media_query(mt) }
       end
 
       in_declarations = 0
@@ -314,44 +318,43 @@ module CssParser
       in_at_media_rule = false
       in_media_block = false
 
-      current_selectors = ''
-      current_media_query = ''
-      current_declarations = ''
+      current_selectors = String.new
+      current_media_query = String.new
+      current_declarations = String.new
 
       # once we are in a rule, we will use this to store where we started if we are capturing offsets
       rule_start = nil
       offset = nil
 
-      block.scan(/(([\\]{2,})|([\\]?[{}\s"])|(.[^\s"{}\\]*))/) do |matches|
-        token = matches[0]
-
+      block.scan(/\s+|\\{2,}|\\?[{}\s"]|.[^\s"{}\\]*/) do |token|
         # save the regex offset so that we know where in the file we are
         offset = Regexp.last_match.offset(0) if options[:capture_offsets]
 
-        if token =~ /\A"/ # found un-escaped double quote
+        if token.start_with?('"') # found un-escaped double quote
           in_string = !in_string
         end
 
         if in_declarations > 0
           # too deep, malformed declaration block
           if in_declarations > 1
-            in_declarations -= 1 if token =~ /\}/
+            in_declarations -= 1 if token.include?('}')
             next
           end
 
-          if token =~ /\{/ and not in_string
+          if !in_string && token.include?('{')
             in_declarations += 1
             next
           end
 
-          current_declarations += token
+          current_declarations << token
 
-          if token =~ /\}/ and not in_string
-            current_declarations.gsub!(/\}[\s]*$/, '')
+          if !in_string && token.include?('}')
+            current_declarations.gsub!(/\}\s*$/, '')
 
             in_declarations -= 1
+            current_declarations.strip!
 
-            unless current_declarations.strip.empty?
+            unless current_declarations.empty?
               if options[:capture_offsets]
                 add_rule_with_offsets!(current_selectors, current_declarations, options[:filename], (rule_start..offset.last), current_media_queries)
               else
@@ -359,8 +362,8 @@ module CssParser
               end
             end
 
-            current_selectors = ''
-            current_declarations = ''
+            current_selectors = String.new
+            current_declarations = String.new
 
             # restart our search for selectors and declarations
             rule_start = nil if options[:capture_offsets]
@@ -370,56 +373,54 @@ module CssParser
           in_at_media_rule = true
           current_media_queries = []
         elsif in_at_media_rule
-          if token =~ /\{/
-            block_depth = block_depth + 1
+          if token.include?('{')
+            block_depth += 1
             in_at_media_rule = false
             in_media_block = true
             current_media_queries << CssParser.sanitize_media_query(current_media_query)
-            current_media_query = ''
-          elsif token =~ /[,]/
+            current_media_query = String.new
+          elsif token.include?(',')
             # new media query begins
-            token.gsub!(/[,]/, ' ')
-            current_media_query += token.strip + ' '
+            token.tr!(',', ' ')
+            token.strip!
+            current_media_query << token << ' '
             current_media_queries << CssParser.sanitize_media_query(current_media_query)
-            current_media_query = ''
+            current_media_query = String.new
           else
-            current_media_query += token.strip + ' '
+            token.strip!
+            current_media_query << token << ' '
           end
         elsif in_charset or token =~ /@charset/i
           # iterate until we are out of the charset declaration
-          in_charset = (token =~ /;/ ? false : true)
+          in_charset = !token.include?(';')
+        elsif !in_string && token.include?('}')
+          block_depth -= 1
+
+          # reset the current media query scope
+          if in_media_block
+            current_media_queries = [:all]
+            in_media_block = false
+          end
+        elsif !in_string && token.include?('{')
+          current_selectors.strip!
+          in_declarations += 1
         else
-          if token =~ /\}/ and not in_string
-            block_depth = block_depth - 1
+          # if we are in a selector, add the token to the current selectors
+          current_selectors << token
 
-            # reset the current media query scope
-            if in_media_block
-              current_media_queries = [:all]
-              in_media_block = false
-            end
-          else
-            if token =~ /\{/ and not in_string
-              current_selectors.strip!
-              in_declarations += 1
-            else
-              # if we are in a selector, add the token to the current selectors
-              current_selectors += token
-
-              # mark this as the beginning of the selector unless we have already marked it
-              rule_start = offset.first if options[:capture_offsets] && rule_start.nil? && token =~ /^[^\s]+$/
-            end
-          end
+          # mark this as the beginning of the selector unless we have already marked it
+          rule_start = offset.first if options[:capture_offsets] && rule_start.nil? && token =~ /^[^\s]+$/
         end
       end
 
       # check for unclosed braces
-      if in_declarations > 0
-        if options[:capture_offsets]
-          add_rule_with_offsets!(current_selectors, current_declarations, options[:filename], (rule_start..offset.last), current_media_queries)
-        else
-          add_rule!(current_selectors, current_declarations, current_media_queries)
-        end
+      return unless in_declarations > 0
+
+      unless options[:capture_offsets]
+        return add_rule!(current_selectors, current_declarations, current_media_queries)
       end
+
+      add_rule_with_offsets!(current_selectors, current_declarations, options[:filename], (rule_start..offset.last), current_media_queries)
     end
 
     # Load a remote CSS file.
@@ -432,7 +433,7 @@ module CssParser
     def load_uri!(uri, options = {}, deprecated = nil)
       uri = Addressable::URI.parse(uri) unless uri.respond_to? :scheme
 
-      opts = {:base_uri => nil, :media_types => :all}
+      opts = {base_uri: nil, media_types: :all}
 
       if options.is_a? Hash
         opts.merge!(options)
@@ -452,14 +453,13 @@ module CssParser
       opts[:filename] = uri.to_s if opts[:capture_offsets]
 
       src, = read_remote_file(uri) # skip charset
-      if src
-        add_block!(src, opts)
-      end
+
+      add_block!(src, opts) if src
     end
 
     # Load a local CSS file.
     def load_file!(file_name, options = {}, deprecated = nil)
-      opts = {:base_dir => nil, :media_types => :all}
+      opts = {base_dir: nil, media_types: :all}
 
       if options.is_a? Hash
         opts.merge!(options)
@@ -482,7 +482,7 @@ module CssParser
 
     # Load a local CSS string.
     def load_string!(src, options = {}, deprecated = nil)
-      opts = {:base_dir => nil, :media_types => :all}
+      opts = {base_dir: nil, media_types: :all}
 
       if options.is_a? Hash
         opts.merge!(options)
@@ -494,9 +494,8 @@ module CssParser
       add_block!(src, opts)
     end
 
-
-
   protected
+
     # Check that a path hasn't been loaded already
     #
     # Raises a CircularReferenceError exception if io_exceptions are on,
@@ -505,10 +504,11 @@ module CssParser
       path = path.to_s
       if @loaded_uris.include?(path)
         raise CircularReferenceError, "can't load #{path} more than once" if @options[:io_exceptions]
-        return false
+
+        false
       else
         @loaded_uris << path
-        return true
+        true
       end
     end
 
@@ -528,7 +528,7 @@ module CssParser
     # Returns a string.
     def cleanup_block(block, options = {}) # :nodoc:
       # Strip CSS comments
-      utf8_block = block.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: ' ')
+      utf8_block = block.encode('UTF-8', 'UTF-8', invalid: :replace, undef: :replace, replace: ' ')
       utf8_block = ignore_pattern(utf8_block, STRIP_CSS_COMMENTS_RX, options)
 
       # Strip HTML comments - they shouldn't really be in here but
@@ -536,7 +536,7 @@ module CssParser
       utf8_block = ignore_pattern(utf8_block, STRIP_HTML_COMMENTS_RX, options)
 
       # Strip lines containing just whitespace
-      utf8_block.gsub!(/^\s+$/, "") unless options[:capture_offsets]
+      utf8_block.gsub!(/^\s+$/, '') unless options[:capture_offsets]
 
       utf8_block
     end
@@ -572,11 +572,8 @@ module CssParser
         if uri.scheme == 'file'
           # local file
           path = uri.path
-          path.gsub!(/^\//, '') if Gem.win_platform?
-          fh = open(path, 'rb')
-          src = fh.read
-          charset = fh.respond_to?(:charset) ? fh.charset : 'utf-8'
-          fh.close
+          path.gsub!(%r{^/}, '') if Gem.win_platform?
+          src = File.read(path, mode: 'rb')
         else
           # remote file
           if uri.scheme == 'https'
@@ -594,21 +591,22 @@ module CssParser
 
           if res.code.to_i >= 400
             @redirect_count = nil
-            raise RemoteFileError.new(uri.to_s) if @options[:io_exceptions]
+            raise RemoteFileError, uri.to_s if @options[:io_exceptions]
+
             return '', nil
           elsif res.code.to_i >= 300 and res.code.to_i < 400
-            if res['Location'] != nil
+            unless res['Location'].nil?
               return read_remote_file Addressable::URI.parse(Addressable::URI.escape(res['Location']))
             end
           end
 
           case res['content-encoding']
-            when 'gzip'
-              io = Zlib::GzipReader.new(StringIO.new(res.body))
-              src = io.read
-            when 'deflate'
-              io = Zlib::Inflate.new
-              src = io.inflate(res.body)
+          when 'gzip'
+            io = Zlib::GzipReader.new(StringIO.new(res.body))
+            src = io.read
+          when 'deflate'
+            io = Zlib::Inflate.new
+            src = io.inflate(res.body)
           end
         end
 
@@ -622,15 +620,17 @@ module CssParser
         end
       rescue
         @redirect_count = nil
-        raise RemoteFileError.new(uri.to_s)if @options[:io_exceptions]
+        raise RemoteFileError, uri.to_s if @options[:io_exceptions]
+
         return nil, nil
       end
 
       @redirect_count = nil
-      return src, charset
+      [src, charset]
     end
 
   private
+
     # Save a folded declaration block to the internal cache.
     def save_folded_declaration(block_hash, folded_declaration) # :nodoc:
       @folded_declaration_cache[block_hash] = folded_declaration
@@ -638,7 +638,7 @@ module CssParser
 
     # Retrieve a folded declaration block from the internal cache.
     def get_folded_declaration(block_hash) # :nodoc:
-      return @folded_declaration_cache[block_hash] ||= nil
+      @folded_declaration_cache[block_hash] ||= nil
     end
 
     def reset! # :nodoc:
@@ -652,14 +652,15 @@ module CssParser
     # passed hash
     def css_node_to_h(hash, key, val)
       hash[key.strip] = '' and return hash if val.nil?
+
       lines = val.split(';')
       nodes = {}
       lines.each do |line|
         parts = line.split(':', 2)
-        if (parts[1] =~ /:/)
+        if parts[1] =~ /:/
           nodes[parts[0]] = css_node_to_h(hash, parts[0], parts[1])
         else
-          nodes[parts[0].to_s.strip] =parts[1].to_s.strip
+          nodes[parts[0].to_s.strip] = parts[1].to_s.strip
         end
       end
       hash[key.strip] = nodes