css_parser 1.7.0 → 1.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66714382244cadbf112104868d94ff8b131ac4cf007deacac52d726bee1a9f9a
-  data.tar.gz: 8ac559b1fb982da00dfbef4188b3773d2a78637f4db26393aba7cf62287b7883
+  metadata.gz: ebc43b9f09241b83ffe9a2878e0a2e5295c79f6d2e02bb20dcaf54d376f91e58
+  data.tar.gz: 5b29858923af894f1b84251c59de6a4638ae0929b63ac0b432a7607d9dd32111
 SHA512:
-  metadata.gz: ba75d2e879d80cb7c854889990fd190f5c1fb664ed96b3a47ad78614a257d2ed7acfc3ba453ea34e87612636512305089c1a73d081c8a1c729a854217b17613e
-  data.tar.gz: ff49b36b1007ae8ce0ecbfd6a2e92536d16c46062898c0a3bae402bacdb731785d6e4b80b0d08e557fcf372f2b0da2d75629c471c8ed2ce59addd13629eda9b9
+  metadata.gz: fd7a00f2be5a2ddbf730eb115dbc0e15f9ac7a71ac92e1a056161a2b418e01d7abeb757c6f8d5fabafd9e4f7dba034b209ca571012ee44ee6b377b2e4bd8100f
+  data.tar.gz: ac8aeba706f1ae35126c6d5c4a150a52862af8654f1342e6c5b36ebce8c0b71c26e0d0931d09081b3b01a70685c3d2b173031a3e1ff32a8477799c3e39e013e4

data/lib/css_parser/parser.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'strscan'
+
 module CssParser
   # Exception class used for any errors encountered while downloading remote files.
   class RemoteFileError < IOError; end
@@ -15,13 +18,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)"
-
-    STRIP_CSS_COMMENTS_RX = /\/\*.*?\*\//m
-    STRIP_HTML_COMMENTS_RX = /\<\!\-\-|\-\-\>/m
+    USER_AGENT = "Ruby CSS Parser/#{CssParser::VERSION} (https://github.com/premailer/css_parser)".freeze
+    RULESET_TOKENIZER_RX = /\s+|\\{2,}|\\?[{}\s"]|[()]|.[^\s"{}()\\]*/.freeze
+    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
 
@@ -35,10 +38,14 @@ 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,
+        rule_set_exceptions: true,
+        capture_offsets: false,
+        user_agent: USER_AGENT
+      }.merge(options)
 
       # array of RuleSets
       @rules = []
@@ -70,21 +77,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
@@ -115,9 +121,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)
 
@@ -129,19 +135,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]
@@ -161,12 +167,44 @@ module CssParser
       parse_block_into_rule_sets!(block, options)
     end
 
-    # Add a CSS rule by setting the +selectors+, +declarations+ and +media_types+.
+    # Add a CSS rule by setting the +selectors+, +declarations+
+    # and +media_types+. Optional pass +filename+ , +offset+ for source
+    # reference too.
     #
-    # +media_types+ can be a symbol or an array of symbols.
-    def add_rule!(selectors, declarations, media_types = :all)
-      rule_set = RuleSet.new(selectors, declarations)
-      add_rule_set!(rule_set, media_types)
+    # +media_types+ can be a symbol or an array of symbols. default to :all
+    # optional fields for source location for source location
+    # +filename+ can be a string or uri pointing to the file or url location.
+    # +offset+ should be Range object representing the start and end byte locations where the rule was found in the file.
+    def add_rule!(*args, selectors: nil, block: nil, filename: nil, offset: nil, media_types: :all) # rubocop:disable Metrics/ParameterLists
+      if args.any?
+        media_types = nil
+        if selectors || block || filename || offset || media_types
+          raise ArgumentError, "don't mix positional and keyword arguments arguments"
+        end
+
+        warn '[DEPRECATION] `add_rule!` with positional arguments is deprecated. ' \
+             'Please use keyword arguments instead.', uplevel: 1
+
+        case args.length
+        when 2
+          selectors, block = args
+        when 3
+          selectors, block, media_types = args
+        else
+          raise ArgumentError
+        end
+      end
+
+      begin
+        rule_set = RuleSet.new(
+          selectors: selectors, block: block,
+          offset: offset, filename: filename
+        )
+
+        add_rule_set!(rule_set, media_types)
+      rescue ArgumentError => e
+        raise e if @options[:rule_set_exceptions]
+      end
     end
 
     # Add a CSS rule by setting the +selectors+, +declarations+, +filename+, +offset+ and +media_types+.
@@ -175,29 +213,32 @@ module CssParser
     # +offset+ should be Range object representing the start and end byte locations where the rule was found in the file.
     # +media_types+ can be a symbol or an array of symbols.
     def add_rule_with_offsets!(selectors, declarations, filename, offset, media_types = :all)
-      rule_set = OffsetAwareRuleSet.new(filename, offset, selectors, declarations)
-      add_rule_set!(rule_set, media_types)
+      warn '[DEPRECATION] `add_rule_with_offsets!` is deprecated. Please use `add_rule!` instead.', uplevel: 1
+      add_rule!(
+        selectors: selectors, block: declarations, media_types: media_types,
+        filename: filename, offset: offset
+      )
     end
 
     # Add a CssParser RuleSet object.
     #
     # +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] unless Array === media_types
-      media_types = media_types.flat_map { |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
@@ -209,7 +250,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) }
@@ -222,7 +263,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]
@@ -244,7 +285,7 @@ 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(:each_selector) unless block_given?
+      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|
@@ -255,9 +296,10 @@ module CssParser
 
     # Output all CSS rules as a single stylesheet.
     def to_s(which_media = :all)
-      out = String.new
+      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]
@@ -266,20 +308,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 }
@@ -287,7 +330,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]
@@ -299,15 +342,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
@@ -318,17 +359,21 @@ module CssParser
       in_at_media_rule = false
       in_media_block = false
 
-      current_selectors = String.new
-      current_media_query = String.new
-      current_declarations = String.new
+      current_selectors = +''
+      current_media_query = +''
+      current_declarations = +''
 
       # 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
+      start_offset = nil
+      end_offset = nil
 
-      block.scan(/\s+|[\\]{2,}|[\\]?[{}\s"]|.[^\s"{}\\]*/) do |token|
+      scanner = StringScanner.new(block)
+      until scanner.eos?
         # save the regex offset so that we know where in the file we are
-        offset = Regexp.last_match.offset(0) if options[:capture_offsets]
+        start_offset = scanner.pos
+        token = scanner.scan(RULESET_TOKENIZER_RX)
+        end_offset = scanner.pos
 
         if token.start_with?('"') # found un-escaped double quote
           in_string = !in_string
@@ -349,82 +394,95 @@ module CssParser
           current_declarations << token
 
           if !in_string && token.include?('}')
-            current_declarations.gsub!(/\}[\s]*$/, '')
+            current_declarations.gsub!(/\}\s*$/, '')
 
             in_declarations -= 1
             current_declarations.strip!
 
             unless current_declarations.empty?
+              add_rule_options = {
+                selectors: current_selectors, block: current_declarations,
+                media_types: current_media_queries
+              }
               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)
+                add_rule_options[:filename] = options[:filename]
+                add_rule_options[:offset] = rule_start..end_offset
               end
+              add_rule!(**add_rule_options)
             end
 
-            current_selectors = String.new
-            current_declarations = String.new
+            current_selectors = +''
+            current_declarations = +''
 
             # restart our search for selectors and declarations
             rule_start = nil if options[:capture_offsets]
           end
-        elsif token =~ /@media/i
+        elsif /@media/i.match?(token)
           # found '@media', reset current media_types
           in_at_media_rule = true
           current_media_queries = []
         elsif in_at_media_rule
           if token.include?('{')
-            block_depth = block_depth + 1
+            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 = String.new
+            current_media_query = +''
           elsif token.include?(',')
             # new media query begins
             token.tr!(',', ' ')
             token.strip!
             current_media_query << token << ' '
             current_media_queries << CssParser.sanitize_media_query(current_media_query)
-            current_media_query = String.new
+            current_media_query = +''
           else
             token.strip!
-            current_media_query << token << ' '
+            # special-case the ( and ) tokens to remove inner-whitespace
+            # (eg we'd prefer '(width: 500px)' to '( width: 500px )' )
+            case token
+            when '('
+              current_media_query << token
+            when ')'
+              current_media_query.sub!(/ ?$/, token)
+            else
+              current_media_query << token << ' '
+            end
           end
-        elsif in_charset or token =~ /@charset/i
+        elsif in_charset or /@charset/i.match?(token)
           # iterate until we are out of the charset declaration
           in_charset = !token.include?(';')
-        else
-          if !in_string && token.include?('}')
-            block_depth = block_depth - 1
-
-            # reset the current media query scope
-            if in_media_block
-              current_media_queries = [:all]
-              in_media_block = false
-            end
-          else
-            if !in_string && token.include?('{')
-              current_selectors.strip!
-              in_declarations += 1
-            else
-              # if we are in a selector, add the token to the current selectors
-              current_selectors << token
+        elsif !in_string && token.include?('}')
+          block_depth -= 1
 
-              # 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
+          # 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 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 = start_offset if options[:capture_offsets] && rule_start.nil? && /^[^\s]+$/.match?(token)
         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
+
+      add_rule_options = {
+        selectors: current_selectors, block: current_declarations,
+        media_types: current_media_queries
+      }
+      if options[:capture_offsets]
+        add_rule_options[:filename] = options[:filename]
+        add_rule_options[:offset] = rule_start..end_offset
       end
+      add_rule!(**add_rule_options)
     end
 
     # Load a remote CSS file.
@@ -437,11 +495,13 @@ 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)
       else
+        warn '[DEPRECATION] `load_uri!` with positional arguments is deprecated. ' \
+             'Please use keyword arguments instead.', uplevel: 1
         opts[:base_uri] = options if options.is_a? String
         opts[:media_types] = deprecated if deprecated
       end
@@ -457,18 +517,19 @@ 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)
       else
+        warn '[DEPRECATION] `load_file!` with positional arguments is deprecated. ' \
+             'Please use keyword arguments instead.', uplevel: 1
         opts[:base_dir] = options if options.is_a? String
         opts[:media_types] = deprecated if deprecated
       end
@@ -477,7 +538,7 @@ module CssParser
       return unless File.readable?(file_name)
       return unless circular_reference_check(file_name)
 
-      src = IO.read(file_name)
+      src = File.read(file_name)
 
       opts[:filename] = file_name if opts[:capture_offsets]
       opts[:base_dir] = File.dirname(file_name)
@@ -487,11 +548,13 @@ 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)
       else
+        warn '[DEPRECATION] `load_file!` with positional arguments is deprecated. ' \
+             'Please use keyword arguments instead.', uplevel: 1
         opts[:base_dir] = options if options.is_a? String
         opts[:media_types] = deprecated if deprecated
       end
@@ -499,9 +562,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,
@@ -510,10 +572,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
 
@@ -533,7 +596,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
@@ -541,7 +604,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
@@ -577,11 +640,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'
@@ -593,49 +653,47 @@ module CssParser
             http = Net::HTTP.new(uri.host, uri.port)
           end
 
-          res = http.get(uri.request_uri, {'User-Agent' => USER_AGENT, 'Accept-Encoding' => 'gzip'})
+          res = http.get(uri.request_uri, {'User-Agent' => @options[:user_agent], 'Accept-Encoding' => 'gzip'})
           src = res.body
           charset = res.respond_to?(:charset) ? res.encoding : 'utf-8'
 
           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
 
         if charset
-          if String.method_defined?(:encode)
-            src.encode!('UTF-8', charset)
-          else
-            ic = Iconv.new('UTF-8//IGNORE', charset)
-            src = ic.iconv(src)
-          end
+          src.encode!('UTF-8', charset)
         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
@@ -643,7 +701,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:
@@ -657,14 +715,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].include?(':')
           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