csscss 0.0.1 → 0.1.0

data/lib/csscss/parser/css.rb

@@ -0,0 +1,88 @@
+module Csscss
+  module Parser
+    # This is heavily based on the haskell css parser on
+    # https://github.com/yesodweb/css-text/blob/add139487c38b68845246449d01c13dbcebac39d/Text/CSS/Parse.hs
+    module Css
+      class << self
+        def parse(source)
+          Transformer.new.apply(Parser.new.parse(source))
+        end
+      end
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:comment) {
+          (space? >> str('/*') >> (str('*/').absent? >> any).repeat >> str('*/') >> space?).as(:comment)
+        }
+
+        rule(:css_space?) {
+          comment.repeat(1) | space?
+        }
+
+        rule(:attribute) {
+          match["^:{}"].repeat(1).as(:property) >>
+          str(":") >>
+          match["^;}"].repeat(1).as(:value) >>
+          str(";").maybe >>
+          space?
+        }
+
+        rule(:ruleset) {
+          (
+            match["^{}"].repeat(1).as(:selector) >>
+            str("{") >>
+            space? >>
+            (comment | attribute).repeat(0).as(:properties) >>
+            str("}") >>
+            space?
+          ).as(:ruleset)
+        }
+
+        rule(:nested_ruleset) {
+          (
+            str("@") >>
+            match["^{}"].repeat(1) >>
+            str("{") >>
+            (comment | ruleset).repeat(0) >>
+            str("}") >>
+            space?
+          ).as(:nested_ruleset)
+        }
+
+        #rule(:blocks) { (nested_ruleset.as(:nested) | ruleset).repeat(0).as(:blocks) }
+        rule(:blocks) {
+          space? >> (comment | nested_ruleset | ruleset).repeat(1).as(:blocks) >> space?
+        }
+
+        root(:blocks)
+      end
+
+      class Transformer < Parslet::Transform
+        rule(nested_ruleset: sequence(:rulesets)) {
+          rulesets
+        }
+
+        rule(comment: simple(:comment)) { nil }
+
+        rule(ruleset: {
+          selector: simple(:selector),
+          properties: sequence(:properties)
+        }) {
+          Ruleset.new(Selector.from_parser(selector), properties.compact)
+        }
+
+        rule({
+          property: simple(:property),
+          value: simple(:value)
+        }) {
+          Declaration.from_parser(property, value)
+        }
+
+        rule(blocks: subtree(:rulesets)) {|context|
+          context[:rulesets].flatten.compact
+        }
+      end
+    end
+  end
+end

data/lib/csscss/parser/font.rb

@@ -0,0 +1,96 @@
+module Csscss
+  module Parser
+    module Font
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:literal_font) {
+          symbol_list(%w(caption icon menu message-box
+                        small-caption status-bar))
+        }
+
+        rule(:font_style) { symbol_list(%w(normal italic oblique)) }
+        rule(:font_variant) { symbol_list(%w(normal small-caps)) }
+        rule(:font_weight) {
+          symbol_list(%w(normal bold bolder lighter 100 200 300 400 500 600 700 800 900))
+        }
+
+        rule(:font_size_absolute) {
+          symbol_list(%w(xx-small x-small small medium
+                         large x-large xx-large))
+        }
+
+        rule(:font_size_relative) { symbol_list(%w(larger smaller)) }
+
+        rule(:font_size) {
+          font_size_absolute | font_size_relative | length | percent
+        }
+
+        rule(:line_height) {
+          symbol("/") >> (
+            symbol("normal") | (length | percent | numbers) >> space?
+          ).as(:line_height_value)
+        }
+
+        rule(:font_family) {
+          family = identifier | any_quoted { identifier >> (space? >> identifier).repeat }
+          family >> (symbol(",") >> font_family).maybe
+        }
+
+        rule(:font) {
+          (
+           symbol("inherit") >> eof | (
+             (
+               literal_font.maybe.as(:literal_font) |
+               font_style.maybe.as(:font_style) >>
+               font_variant.maybe.as(:font_variant) >>
+               font_weight.maybe.as(:font_weight) >>
+
+               font_size.as(:font_size) >>
+               line_height.maybe.as(:line_height) >>
+               font_family.as(:font_family)
+             )
+           )
+          ).as(:font)
+        }
+        root(:font)
+      end
+
+      class Transformer < Parslet::Transform
+        rule(font: simple(:inherit)) {[]}
+        rule(font: {literal_font:simple(:literal)}) {[]}
+
+        rule(line_height_value: simple(:value)) { value }
+
+        rule(font: {
+          font_style: simple(:font_style),
+          font_variant: simple(:font_variant),
+          font_weight: simple(:font_weight),
+          font_size: simple(:font_size),
+          line_height: simple(:line_height),
+          font_family: simple(:font_family)
+        }) {|context|
+          [].tap do |declarations|
+            context.each do |property, value|
+              declarations << Declaration.from_parser(property.to_s.gsub("_", "-"), value, property != :font_family) if value
+            end
+          end
+        }
+
+        #rule(outline: {
+          #outline_width:simple(:width),
+          #outline_style:simple(:style),
+          #outline_color:simple(:color)
+        #}) {
+          #[].tap do |declarations|
+            #declarations << Declaration.from_parser("outline-width", width) if width
+            #declarations << Declaration.from_parser("outline-style", style) if style
+            #declarations << Declaration.from_parser("outline-color", color) if color
+          #end
+        #}
+      end
+    end
+  end
+end

data/lib/csscss/parser/list_style.rb

@@ -0,0 +1,44 @@
+module Csscss
+  module Parser
+    module ListStyle
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:type) {
+          symbol_list(%w(disc circle square decimal decimal-leading-zero lower-roman upper-roman lower-greek lower-latin upper-latin armenian georgian lower-alpha upper-alpha none inherit)).as(:type)
+        }
+
+        rule(:position) { symbol_list(%w(inside outside inherit)).as(:position) }
+        rule(:image) { (url | symbol_list(%w(none inherit))).as(:image) }
+
+        rule(:list_style) {
+          (
+           symbol("inherit") >> eof | (
+            type.maybe.as(:list_style_type) >>
+            position.maybe.as(:list_style_position) >>
+            image.maybe.as(:list_style_image)
+           )
+          ).as(:list_style)
+        }
+        root(:list_style)
+      end
+
+      class Transformer < Parslet::Transform
+        rule(:list_style => simple(:inherit)) {[]}
+        rule(type:simple(:type)) { Declaration.from_parser("list-style-type", type) }
+        rule(position:simple(:position)) { Declaration.from_parser("list-style-position", position) }
+        rule(image:simple(:image)) { Declaration.from_parser("list-style-image", image) }
+
+        rule(list_style: {
+          list_style_type:simple(:type),
+          list_style_position:simple(:position),
+          list_style_image:simple(:image)
+        }) {
+          [type, position, image].compact
+        }
+      end
+    end
+  end
+end

data/lib/csscss/parser/margin.rb

@@ -0,0 +1,32 @@
+module Csscss
+  module Parser
+    module Margin
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:margin_side) {
+          length | percent | symbol_list(%w(inherit auto))
+        }
+
+        rule(:margin) {
+          (
+           symbol("inherit") >> eof | (
+             margin_side.maybe.as(:top)    >>
+             margin_side.maybe.as(:right)  >>
+             margin_side.maybe.as(:bottom) >>
+             margin_side.maybe.as(:left)
+           )
+          ).as(:margin)
+        }
+        root(:margin)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :margin
+        extend MultiSideTransformer
+      end
+    end
+  end
+end

data/lib/csscss/parser/multi_side_transformer.rb

@@ -0,0 +1,47 @@
+module Csscss
+  module Parser
+    module MultiSideTransformer
+      def self.extended(base)
+        base.instance_eval do
+          extend ClassMethods
+
+          rule(@property => simple(:inherit)) {[]}
+
+          rule({@property => {
+            top:simple(:top),
+            right:simple(:right),
+            bottom:simple(:bottom),
+            left:simple(:left)
+          }}, &method(:transform_sides))
+        end
+      end
+
+      module ClassMethods
+        def side_declaration(side, value)
+          Declaration.from_parser("#{@property}-#{side}", value)
+        end
+
+        def transform_sides(context)
+          values = [context[:top], context[:right], context[:bottom], context[:left]].compact
+          case values.size
+          when 4
+            %w(top right bottom left).zip(values).map {|side, value| side_declaration(side, value) }
+          when 3
+            %w(top right bottom).zip(values).map {|side, value| side_declaration(side, value) }.tap do |declarations|
+              declarations << side_declaration("left", values[1])
+            end
+          when 2
+            %w(top right).zip(values).map {|side, value| side_declaration(side, value) }.tap do |declarations|
+              declarations << side_declaration("bottom", values[0])
+              declarations << side_declaration("left", values[1])
+            end
+          when 1
+            %w(top right bottom left).map do |side|
+              side_declaration(side, values[0])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/outline.rb

@@ -0,0 +1,45 @@
+module Csscss
+  module Parser
+    module Outline
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Color
+
+        rule(:outline_width) { BorderWidth::Parser.new.border_width_side }
+        rule(:outline_style) { BorderStyle::Parser.new.border_style_side }
+        rule(:outline_color) { BorderColor::Parser.new.border_color_side }
+
+        rule(:outline) {
+          (
+           symbol("inherit") >> eof | (
+             outline_width.maybe.as(:outline_width) >>
+             outline_style.maybe.as(:outline_style) >>
+             outline_color.maybe.as(:outline_color)
+           )
+          ).as(:outline)
+        }
+        root(:outline)
+      end
+
+      class Transformer < Parslet::Transform
+        extend Color::Transformer
+        extend Color::PlainColorValue
+
+        rule(outline: simple(:inherit)) {[]}
+
+        rule(outline: {
+          outline_width:simple(:width),
+          outline_style:simple(:style),
+          outline_color:simple(:color)
+        }) {
+          [].tap do |declarations|
+            declarations << Declaration.from_parser("outline-width", width) if width
+            declarations << Declaration.from_parser("outline-style", style) if style
+            declarations << Declaration.from_parser("outline-color", color) if color
+          end
+        }
+      end
+    end
+  end
+end

data/lib/csscss/parser/padding.rb

@@ -0,0 +1,32 @@
+module Csscss
+  module Parser
+    module Padding
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:padding_side) {
+          length | percent | symbol("inherit")
+        }
+
+        rule(:padding) {
+          (
+           symbol("inherit") >> eof | (
+             padding_side.maybe.as(:top)    >>
+             padding_side.maybe.as(:right)  >>
+             padding_side.maybe.as(:bottom) >>
+             padding_side.maybe.as(:left)
+           )
+          ).as(:padding)
+        }
+        root(:padding)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :padding
+        extend MultiSideTransformer
+      end
+    end
+  end
+end

data/lib/csscss/parslet_optimizations.rb

@@ -0,0 +1,77 @@
+# These are my multibyte optimizations for parslet.
+# More information can be found: 
+# https://github.com/kschiess/parslet/issues/73
+# https://github.com/kschiess/parslet/pull/74
+# https://github.com/zmoazeni/parslet/tree/optimized-multibyte-parsing
+
+require 'strscan'
+require 'forwardable'
+
+module Parslet
+  class Source
+    extend Forwardable
+
+    def initialize(str)
+      raise ArgumentError unless str.respond_to?(:to_str)
+
+      @str = StringScanner.new(str)
+
+      @line_cache = LineCache.new
+      @line_cache.scan_for_line_endings(0, str)
+    end
+
+    def matches?(pattern)
+      regexp = pattern.is_a?(String) ? Regexp.new(Regexp.escape(pattern)) : pattern
+      !@str.match?(regexp).nil?
+    end
+    alias match matches?
+
+    def consume(n)
+      original_pos = @str.pos
+      slice_str = n.times.map { @str.getch }.join
+      slice = Parslet::Slice.new(
+        slice_str,
+        original_pos,
+        @line_cache)
+
+      return slice
+    end
+
+    def chars_left
+      @str.rest_size
+    end
+
+    def_delegator :@str, :pos
+    def pos=(n)
+      if n > @str.string.bytesize
+        @str.pos = @str.string.bytesize
+      else
+        @str.pos = n
+      end
+    end
+
+
+    class LineCache
+      def scan_for_line_endings(start_pos, buf)
+        return unless buf
+
+        buf = StringScanner.new(buf)
+        return unless buf.exist?(/\n/)
+
+        ## If we have already read part or all of buf, we already know about
+        ## line ends in that portion. remove it and correct cur (search index)
+        if @last_line_end && start_pos < @last_line_end
+          # Let's not search the range from start_pos to last_line_end again.
+          buf.pos = @last_line_end - start_pos
+        end
+
+        ## Scan the string for line endings; store the positions of all endings
+        ## in @line_ends. 
+        while buf.skip_until(/\n/)
+          @last_line_end = start_pos + buf.pos
+          @line_ends << @last_line_end
+        end
+      end
+    end
+  end
+end

data/lib/csscss/redundancy_analyzer.rb

@@ -5,19 +5,44 @@ module Csscss
     end
 
     def redundancies(minimum = nil)
-      rule_sets = CSSPool.CSS(@raw_css).rule_sets
+      rule_sets = Parser::Css.parse(@raw_css)
       matches = {}
+      parents = {}
       rule_sets.each do |rule_set|
         rule_set.declarations.each do |dec|
-          dec.property.downcase!
-          dec.expressions do |exp|
-            exp.value.downcase!
+          sel = rule_set.selectors
+
+          if parser = shorthand_parser(dec.property)
+            if new_decs = parser.parse(dec.property, dec.value)
+              if dec.property == "border"
+                %w(border-top border-right border-bottom border-left).each do |property|
+                  border_dec = Declaration.new(property, dec.value)
+                  parents[border_dec] ||= []
+                  (parents[border_dec] << dec).uniq!
+                  border_dec.parents = parents[border_dec]
+
+                  matches[border_dec] ||= []
+                  matches[border_dec] << sel
+                  matches[border_dec].uniq!
+                end
+              end
+
+              new_decs.each do |new_dec|
+                # replace any non-derivatives with derivatives
+                existing = matches.delete(new_dec) || []
+                existing << sel
+                parents[new_dec] ||= []
+                (parents[new_dec] << dec).uniq!
+                new_dec.parents = parents[new_dec]
+                matches[new_dec] = existing
+                matches[new_dec].uniq!
+              end
+            end
           end
 
-          dec_key = Declaration.from_csspool(dec)
-          sel = Selector.new(rule_set.selectors.map(&:to_s))
-          matches[dec_key] ||= []
-          matches[dec_key] << sel
+          matches[dec] ||= []
+          matches[dec] << sel
+          matches[dec].uniq!
         end
       end
 
@@ -31,12 +56,35 @@ module Csscss
         end
       end
 
+
+      # trims any derivative declarations alongside shorthand
+      inverted_matches.each do |selectors, declarations|
+        redundant_derivatives = declarations.select do |dec|
+          dec.derivative? && declarations.detect {|dec2| dec2 > dec }
+        end
+        unless redundant_derivatives.empty?
+          inverted_matches[selectors] = declarations - redundant_derivatives
+        end
+
+        # border needs to be reduced even more
+        %w(width style color).each do |property|
+          decs = inverted_matches[selectors].select do |dec|
+            dec.derivative? && dec.property =~ /border-\w+-#{property}/
+          end
+          if decs.size == 4 && decs.map(&:value).uniq.size == 1
+            inverted_matches[selectors] -= decs
+            inverted_matches[selectors] << Declaration.new("border-#{property}", decs.first.value)
+          end
+        end
+      end
+
       if minimum
         inverted_matches.delete_if do |key, declarations|
           declarations.size < minimum
         end
       end
 
+      # combines selector keys by common declarations
       final_inverted_matches = inverted_matches.dup
       inverted_matches.to_a[0..-2].each_with_index do |(selector_group1, declarations1), index|
         inverted_matches.to_a[(index + 1)..-1].each do |selector_group2, declarations2|
@@ -50,6 +98,7 @@ module Csscss
         end
       end
 
+      # sort hash by number of matches
       sorted_array = final_inverted_matches.sort {|(_, v1), (_, v2)| v2.size <=> v1.size }
       {}.tap do |sorted_hash|
         sorted_array.each do |key, value|
@@ -57,5 +106,23 @@ module Csscss
         end
       end
     end
+
+    private
+    def shorthand_parser(property)
+      case property
+      when "background"   then Parser::Background
+      when "list-style"   then Parser::ListStyle
+      when "margin"       then Parser::Margin
+      when "padding"      then Parser::Padding
+      when "border"       then Parser::Border
+      when "border-width" then Parser::BorderWidth
+      when "border-style" then Parser::BorderStyle
+      when "border-color" then Parser::BorderColor
+      when "outline"      then Parser::Outline
+      when "font"         then Parser::Font
+      when "border-top", "border-right", "border-bottom", "border-left"
+        Parser::BorderSide
+      end
+    end
   end
 end

data/lib/csscss/reporter.rb

@@ -7,14 +7,12 @@ module Csscss
     def report(verbose = false)
       io = StringIO.new
       @redundancies.each do |selector_groups, declarations|
-        selector_groups = selector_groups.map {|selectors| "{#{selectors.selectors.join(", ")}}" }
+        selector_groups = selector_groups.map {|selectors| "{#{selectors}}" }
         last_selector = selector_groups.pop
         count = declarations.size
         io.puts %Q(#{selector_groups.join(", ")} and #{last_selector} share #{count} rule#{"s" if count > 1})
         if verbose
-          declarations.each do |dec|
-            io.puts "  - #{dec.property}: #{dec.value}"
-          end
+          declarations.each {|dec| io.puts "  - #{dec}" }
         end
       end
 

data/lib/csscss/types.rb

@@ -1,17 +1,92 @@
 module Csscss
-  class Declaration < Struct.new(:property, :value)
+  class Declaration < Struct.new(:property, :value, :parents)
     def self.from_csspool(dec)
-      new(dec.property.to_s, dec.expressions.join(" "))
+      new(dec.property.to_s.downcase, dec.expressions.join(" ").downcase)
+    end
+
+    def self.from_parser(property, value, clean = true)
+      value = value.to_s
+      property = property.to_s
+      if clean
+        value = value.downcase
+        property = property.downcase
+      end
+      new(property, value.strip)
+    end
+
+    def derivative?
+      !parents.nil?
+    end
+
+    def without_parents
+      if derivative?
+        dup.tap do |duped|
+          duped.parents = nil
+        end
+      else
+        self
+      end
+    end
+
+    def ==(other)
+      if other.respond_to?(:property) && other.respond_to?(:value)
+        property == other.property && value == other.value
+      else
+        false
+      end
+    end
+
+    def hash
+      [property, value].hash
+    end
+
+    def eql?(other)
+      hash == other.hash
     end
 
     def <=>(other)
       property <=> other.property
     end
+
+    def >(other)
+      other.derivative? && other.parents.include?(self)
+    end
+
+    def <(other)
+      other > self
+    end
+
+    def to_s
+      "#{property}: #{value}"
+    end
+
+    def inspect
+      if parents
+        "<#{self.class} #{to_s} (parents: #{parents})>"
+      else
+        "<#{self.class} #{to_s}>"
+      end
+    end
   end
 
   class Selector < Struct.new(:selectors)
+    def self.from_parser(selectors)
+      new(selectors.to_s.strip)
+    end
+
     def <=>(other)
       selectors <=> other.selectors
     end
+
+    def to_s
+      selectors
+    end
+
+    def inspect
+      "<#{self.class} #{selectors}>"
+    end
+  end
+
+  class Ruleset < Struct.new(:selectors, :declarations)
   end
 end