csscss 0.0.1 → 0.1.0

data/.gitignore

@@ -4,7 +4,6 @@
 .config
 .yardoc
 .rspec
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 ##
+
+* Initial project release.

data/Gemfile

@@ -5,5 +5,9 @@ gemspec
 
 gem "rake", :require => false
 gem "debugger"
+
+gem "minitest"
 gem "m"
 gem "minitest-rg"
+
+gem "ruby-prof"

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    csscss (0.1.0)
+      parslet (~> 1.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    blankslate (2.1.2.4)
+    columnize (0.3.6)
+    debugger (1.5.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.0)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.0)
+    m (1.3.1)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (0.8.1)
+    minitest (2.12.1)
+    minitest-rg (1.1.0)
+    parslet (1.5.0)
+      blankslate (~> 2.0)
+    rake (10.0.3)
+    ruby-prof (0.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  csscss!
+  debugger
+  m
+  minitest
+  minitest-rg
+  rake
+  ruby-prof

data/README.md

@@ -1,25 +1,60 @@
-# Csscss
-
 [![Build Status](https://travis-ci.org/zmoazeni/csscss.png?branch=master)](https://travis-ci.org/zmoazeni/csscss)
 
-A CSS redundancy analyzer that analyzes redundancy. My first attempt was
-in Haskell with https://github.com/zmoazeni/csscss-haskell this is the
-second in Ruby.
+## What is it? ##
+
+csscss will parse any CSS files you give it and let you know which
+rulesets have duplicated declarations.
+
+## What is it for? ##
+
+One of the best strategies for me to maintain CSS is to reduce
+duplication as much as possible. It's not a silver bullet, but it sure
+helps.
 
-## (Not ready yet) Installation
+To do that, you need to have all the rulesets in your head at all times.
+That's hard, csscss is easy. Let it tell you what is redundant.
 
-(Soon) Install it as:
+## How do I use it? ##
+
+First you need to install it. It is currently packaged as a ruby gem:
 
     $ gem install csscss
 
-## Usage
+Then you can run it in at the command line against CSS files.
+
+    $ csscss path/to/styles.css path/to/other-styles.css
+
+Run it in a verbose mode to see all the duplicated styles.
+
+    $ csscss -v path/to/styles.css
+
+You can also choose a minimum number of matches, which will ignore any
+rulesets that have fewer matches.
+
+    $ csscss -n 10 -v path/to/style.css # ignores rulesets with < 10 matches
+
+## I found bugs ##
+
+This is still a new and evolving project. I heartily welcome feedback.
+If you find any issues, please report them on
+[github](https://github.com/zmoazeni/csscss/issues).
+
+Please include the smallest CSS snippet to describe the issue and the
+output you expect to see.
+
+## Who are you? ##
+
+My name is [Zach Moazeni](https://twitter.com/zmoazeni). I work for [an
+awesome company](http://www.getharvest.com/), which [is
+hiring!](http://www.getharvest.com/careers).
 
-TODO: Write usage instructions here
+## I'm a dev, I can help ##
 
-## Contributing
+Awesome! Thanks! Here are the steps I ask:
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+4. Make sure the tests pass (`bundle exec rake test`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/bin/csscss

@@ -1,5 +1,4 @@
 #! /usr/bin/env ruby
 
-require "debugger"
 require "csscss"
 Csscss::CLI.run(ARGV)

data/csscss.gemspec

@@ -9,14 +9,13 @@ Gem::Specification.new do |gem|
   gem.authors       = ["Zach Moazeni"]
   gem.email         = ["zach.moazeni@gmail.com"]
   gem.description   = %q{A CSS redundancy analyzer that analyzes redundancy.}
-  gem.summary       = %q{A CSS redundancy analyzer that analyzes redundancy.}
-  gem.homepage      = ""
+  gem.summary       = %q{csscss will parse any CSS files you give it and let you know which rulesets have duplicated declarations.}
+  gem.homepage      = "http://zmoazeni.github.com/csscss/"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "csspool", "~> 3.0"
   gem.add_dependency "parslet", "~> 1.5"
 end

data/lib/csscss/cli.rb

@@ -27,7 +27,16 @@ module Csscss
         end
       end
 
-      puts Reporter.new(combined_redundancies).report(@verbose)
+      if @json
+        puts JSONReporter.new(combined_redundancies).report
+      else
+        puts Reporter.new(combined_redundancies).report(@verbose)
+      end
+
+    rescue Parslet::ParseFailed => e
+      puts "Had a problem parsing the css"
+      puts e.cause.ascii_tree
+      exit 1
     end
 
     def parse(argv)

data/lib/csscss/json_reporter.rb

@@ -0,0 +1,17 @@
+module Csscss
+  class JSONReporter
+    def initialize(redundancies)
+      @redundancies = redundancies
+    end
+
+    def report
+      JSON.dump(@redundancies.map {|selector_groups, declarations|
+        {
+          "selectors"    => selector_groups.map(&:to_s),
+          "count"        => declarations.count,
+          "declarations" => declarations.map(&:to_s)
+        }
+      })
+    end
+  end
+end

data/lib/csscss/parser/background.rb

@@ -0,0 +1,72 @@
+module Csscss
+  module Parser
+    module Background
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Color
+
+        rule(:bg_color)  { color | symbol("inherit") }
+        rule(:bg_image)  { (url | symbol("none") | symbol("inherit")).as(:image_literal) }
+        rule(:bg_repeat) { symbol_list(%w(repeat-x repeat-y repeat no-repeat inherit)).as(:repeat) }
+        rule(:bg_attachment) { symbol_list(%w(scroll fixed inherit)).as(:attachment) }
+
+        rule(:bg_position) {
+          lcr_symbols = symbol_list(%w(left center right))
+          tcb_symbols = symbol_list(%w(top center bottom))
+
+          (symbol("inherit") | (
+            lcr = (percent | length | lcr_symbols)
+            tcb = (percent | length | tcb_symbols)
+
+            lcr >> tcb | lcr | tcb
+          )).as(:position)
+        }
+
+        rule(:background) {
+          (
+           symbol("inherit") >> eof | (
+            bg_color.maybe.as(:bg_color)           >>
+            bg_image.maybe.as(:bg_image)           >>
+            bg_repeat.maybe.as(:bg_repeat)         >>
+            bg_attachment.maybe.as(:bg_attachment) >>
+            bg_position.maybe.as(:bg_position)
+           )
+          ).as(:background)
+        }
+        root(:background)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :background_color
+        extend Color::Transformer
+
+        rule(image_literal:simple(:value)) {Declaration.from_parser("background-image", value) }
+
+        rule(:repeat => simple(:repeat)) {
+          Declaration.from_parser("background-repeat", repeat)
+        }
+
+        rule(:attachment => simple(:attachment)) {
+          Declaration.from_parser("background-attachment", attachment)
+        }
+
+        rule(:position => simple(:position)) {
+          Declaration.from_parser("background-position", position)
+        }
+
+        rule(:background => simple(:inherit)) {[]}
+
+        rule(background: {
+          bg_color:simple(:color),
+          bg_image:simple(:url),
+          bg_repeat:simple(:repeat),
+          bg_attachment:simple(:attachment),
+          bg_position:simple(:position)
+        }) {
+          [color, url, repeat, attachment, position].compact
+        }
+      end
+    end
+  end
+end

data/lib/csscss/parser/base.rb

@@ -0,0 +1,13 @@
+module Csscss
+  module Parser
+    module Base
+      def parse(_, inputs)
+        input = Array(inputs).join(" ")
+
+        if parsed = self::Parser.new.try_parse(input)
+          self::Transformer.new.apply(parsed)
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/border.rb

@@ -0,0 +1,45 @@
+module Csscss
+  module Parser
+    module Border
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Color
+
+        rule(:border_side) { BorderSide::Parser.new(:top).border_side_anonymous }
+
+        rule(:border) {
+          (
+           symbol("inherit") >> eof |
+           border_side.maybe.as(:side)
+          ).as(:border)
+        }
+
+        root(:border)
+      end
+
+      class Transformer < Parslet::Transform
+        extend Color::Transformer
+        extend Color::PlainColorValue
+        extend BorderSide::Transformer::Helpers
+
+        rule(border: simple(:inherit)) {[]}
+        rule(border: {
+          side: {
+            width:simple(:width),
+            style:simple(:style),
+            color:simple(:color)
+          }
+        }) {|context|
+          [].tap do |declarations|
+            [:top, :right, :bottom, :left].each do |side|
+              declarations << transform_side(side, context)
+            end
+
+            declarations.flatten!
+          end
+        }
+      end
+    end
+  end
+end

data/lib/csscss/parser/border_color.rb

@@ -0,0 +1,41 @@
+module Csscss
+  module Parser
+    module BorderColor
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Color
+
+        rule(:border_color_side) {
+          color | symbol("transparent")
+        }
+
+        rule(:border_color) {
+          (
+           symbol("inherit") >> eof | (
+             border_color_side.maybe.as(:top)    >>
+             border_color_side.maybe.as(:right)  >>
+             border_color_side.maybe.as(:bottom) >>
+             border_color_side.maybe.as(:left)
+           )
+          ).as(:border_color)
+        }
+
+        root(:border_color)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :border_color
+        extend MultiSideTransformer
+        extend Color::Transformer
+        extend Color::PlainColorValue
+
+        class << self
+          def side_declaration(side, value)
+            Declaration.from_parser("border-#{side}-color", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/border_side.rb

@@ -0,0 +1,91 @@
+module Csscss
+  module Parser
+    module BorderSide
+      class << self
+        def parse(property, inputs)
+          input = Array(inputs).join(" ")
+          side = find_side(property)
+
+          if parsed = self::Parser.new(side).try_parse(input)
+            self::Transformer.new.apply(parsed)
+          end
+        end
+
+        def find_side(property)
+          case property
+          when "border-top"    then :top
+          when "border-right"  then :right
+          when "border-bottom" then :bottom
+          when "border-left"   then :left
+          else raise "Unknown property #{property}"
+          end
+        end
+      end
+
+      class Parser < Parslet::Parser
+        include Common
+
+        attr_reader :side
+        def initialize(side)
+          @side = side.to_sym
+        end
+
+        rule(:border_width) { BorderWidth::Parser.new.border_width_side }
+        rule(:border_style) { BorderStyle::Parser.new.border_style_side }
+        rule(:border_color) { BorderColor::Parser.new.border_color_side }
+
+        rule(:border_side_anonymous) {
+          border_width.maybe.as(:width) >>
+          border_style.maybe.as(:style) >>
+          border_color.maybe.as(:color)
+        }
+
+        rule(:border_side) {
+          (
+           symbol("inherit") >> eof |
+           border_side_anonymous.as(side)
+          ).as(:border_side)
+        }
+
+        root(:border_side)
+      end
+
+      class Transformer < Parslet::Transform
+        extend Color::Transformer
+        extend Color::PlainColorValue
+
+        module Helpers
+          def transform_top(context);    transform_side("top", context);    end
+          def transform_right(context);  transform_side("right", context);  end
+          def transform_bottom(context); transform_side("bottom", context); end
+          def transform_left(context);   transform_side("left", context);   end
+
+          def transform_side(side, context)
+            width = context[:width]
+            style = context[:style]
+            color = context[:color]
+
+            [].tap do |declarations|
+              declarations << Declaration.from_parser("border-#{side}-width", width) if width
+              declarations << Declaration.from_parser("border-#{side}-style", style) if style
+              declarations << Declaration.from_parser("border-#{side}-color", color) if color
+            end
+          end
+        end
+        extend Helpers
+
+        rule(border_side: simple(:inherit)) {[]}
+
+        [:top, :right, :bottom, :left].each do |side|
+          rule(border_side: {
+            side => {
+              width:simple(:width),
+              style:simple(:style),
+              color:simple(:color)
+            }
+          }, &method("transform_#{side}"))
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/border_style.rb

@@ -0,0 +1,41 @@
+module Csscss
+  module Parser
+    module BorderStyle
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:border_style_side) {
+          symbol_list(%w(none hidden dotted dashed solid
+                         double groove ridge inset outset
+                      ))
+        }
+
+        rule(:border_style) {
+          (
+           symbol("inherit") >> eof | (
+             border_style_side.maybe.as(:top)    >>
+             border_style_side.maybe.as(:right)  >>
+             border_style_side.maybe.as(:bottom) >>
+             border_style_side.maybe.as(:left)
+           )
+          ).as(:border_style)
+        }
+
+        root(:border_style)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :border_style
+        extend MultiSideTransformer
+
+        class << self
+          def side_declaration(side, value)
+            Declaration.from_parser("border-#{side}-style", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/border_width.rb

@@ -0,0 +1,37 @@
+module Csscss
+  module Parser
+    module BorderWidth
+      extend Parser::Base
+
+      class Parser < Parslet::Parser
+        include Common
+
+        rule(:border_width_side) {
+          symbol_list(%w(thin medium thick inherit)) | length
+        }
+
+        rule(:border_width) {
+          (
+           symbol("inherit") >> eof | (
+             border_width_side.maybe.as(:top)    >>
+             border_width_side.maybe.as(:right)  >>
+             border_width_side.maybe.as(:bottom) >>
+             border_width_side.maybe.as(:left)
+           )
+          ).as(:border_width)
+        }
+
+        root(:border_width)
+      end
+
+      class Transformer < Parslet::Transform
+        @property = :border_width
+        extend MultiSideTransformer
+
+        def self.side_declaration(side, value)
+          Declaration.from_parser("border-#{side}-width", value)
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/color.rb

@@ -0,0 +1,53 @@
+module Csscss
+  module Parser
+    module Color
+      include Parslet
+      include Common
+
+      rule(:color) { (hexcolor | rgb | color_keyword).as(:color) }
+      rule(:rgb) { (rgb_with(numbers) | rgb_with(percent)).as(:rgb) }
+      rule(:hexcolor) { (str("#") >> match["a-fA-F0-9"].repeat(1)).as(:hexcolor) >> space? }
+      rule(:color_keyword) {
+        colors = %w(inherit black silver gray white maroon
+        red purple fuchsia green lime olive
+        yellow navy blue teal aqua)
+        colors.map {|c| symbol(c) }.reduce(:|).as(:keyword)
+      }
+
+      private
+        def rgb_with(parser)
+          symbol("rgb") >> parens do
+            parser >> space? >>
+            symbol(",") >>
+            parser >> space? >>
+            symbol(",") >>
+            parser >> space?
+          end
+        end
+
+      module Transformer
+        def self.extended(base)
+          base.instance_eval do
+            extend ClassMethods
+
+            rule(color:{rgb:simple(:value)}) {|c| transform_color(c)}
+            rule(color:{keyword:simple(:value)}) {|c| transform_color(c)}
+            rule(color:{hexcolor:simple(:value)}) {|c| transform_color(c)}
+          end
+        end
+
+        module ClassMethods
+          def transform_color(context)
+            Declaration.from_parser(@property.to_s.gsub("_", "-"), context[:value])
+          end
+        end
+      end
+
+      module PlainColorValue
+        def transform_color(context)
+          context[:value]
+        end
+      end
+    end
+  end
+end

data/lib/csscss/parser/common.rb

@@ -0,0 +1,86 @@
+module Csscss
+  module Parser
+    module Common
+      include Parslet
+
+      UNITS = %w(px em ex in cm mm pt pc)
+
+      rule(:space)      { match['\s'].repeat(1) }
+      rule(:space?)     { space.maybe }
+      rule(:number)     { match["0-9"] }
+      rule(:numbers)    { number.repeat(1) }
+      rule(:decimal)    { numbers >> str(".").maybe >> numbers.maybe }
+      rule(:percent)    { decimal >> stri("%") >> space? }
+      rule(:length)     { decimal >> stri_list(UNITS) >> space?  }
+      rule(:identifier) { match["a-zA-Z"].repeat(1) }
+      rule(:inherit)    { stri("inherit") }
+      rule(:eof)        { any.absent? }
+      rule(:nada)       { any.repeat.as(:nada) }
+
+      rule(:http) {
+        (match['a-zA-Z.:/'] | str('\(') | str('\)')).repeat >> space?
+      }
+
+      rule(:url) {
+        stri("url") >> parens do
+          (any_quoted { http } >> space?) |
+          http
+        end
+      }
+
+      def stri(str)
+        key_chars = str.split(//)
+        key_chars.
+          collect! { |char|
+            if char.upcase == char.downcase
+              str(char)
+            else
+              match["#{char.upcase}#{char.downcase}"]
+            end
+          }.reduce(:>>)
+      end
+
+      def symbol(s, label = nil)
+        if label
+          stri(s).as(label) >> space?
+        else
+          stri(s) >> space?
+        end
+      end
+
+      def between(left, right)
+        raise "block not given" unless block_given?
+        symbol(left) >> yield >> symbol(right)
+      end
+
+      def parens(&block)
+        between("(", ")", &block)
+      end
+
+      def double_quoted(&block)
+        between('"', '"', &block)
+      end
+
+      def single_quoted(&block)
+        between("'", "'", &block)
+      end
+
+      def any_quoted(&block)
+        double_quoted(&block) | single_quoted(&block)
+      end
+
+      def stri_list(list)
+        list.map {|u| stri(u) }.reduce(:|)
+      end
+
+      def symbol_list(list)
+        list.map {|u| symbol(u) }.reduce(:|)
+      end
+
+      def try_parse(input)
+        parsed = (root | nada).parse(input)
+        parsed[:nada] ? false : parsed
+      end
+    end
+  end
+end