css_dryer 0.0.1

data/lib/css_dryer/processor.rb

@@ -0,0 +1,333 @@
+# Lifted from Rails.
+# "", "   ", nil, [], and {} are blank
+class Object  #:nodoc:
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
+  end
+end
+
+
+# Converts DRY stylesheets into normal CSS ones.
+module CssDryer
+  module Processor
+
+    VERSION = '0.4.3'
+
+    # Converts a stylesheet with nested styles into a flattened,
+    # normal CSS stylesheet.  The original whitespace is preserved
+    # as much as possible.
+    #
+    # For example, the following DRY stylesheet:
+    #
+    #   div {
+    #     font-family: Verdana;
+    #     #content {
+    #       background-color: green;
+    #       p { color: red; }
+    #     }
+    #   }
+    #
+    # is converted into this CSS:
+    #
+    #   div {
+    #     font-family: Verdana;
+    #   }
+    #   div #content {
+    #     background-color: green;
+    #   }
+    #   div #content p { color: red; }
+    #
+    # Note, though, that @media blocks are preserved.  For example:
+    #
+    #   @media screen, projection {
+    #     div {font-size:100%;}
+    #   }
+    #
+    # is left unchanged.
+    #
+    # Styles may be nested to an arbitrary level.
+    def process(nested_css, indent = 2)  #:doc:
+      # 'Normalise' comma separated selectors
+      nested_css = factor_out_comma_separated_selectors(nested_css, indent)
+      structure_to_css(nested_css_to_structure(nested_css), indent)
+    end
+
+    def nested_css_to_structure(css)  #:nodoc:
+      # Implementation notes:
+      # - the correct way to do this would be using a lexer and parser
+      # - ironically there is a degree of repetition here
+      document = []
+      selectors = []
+      media_block = false
+      css.each_line do |line|
+        depth = selectors.length
+        case line.chomp!
+        # Media block (multiline) opening - treat as plain text but start
+        # watching for close of media block.
+        # Assume media blocks are never themselves nested.
+        # (This must precede the multiline selector condition.)
+        when /^(\s*@media.*)[{]\s*$/
+          media_block = true
+          document << line if depth == 0
+        # Media block inline
+        # Assume media blocks are never themselves nested.
+        when /^\s*@media.*[{].*[}]\s*$/
+          document << line if depth == 0
+        # Multiline selector opening
+        when /^\s*([^{]*?)\s*[{]\s*$/
+          hsh = StyleHash[ $1 => [] ]
+          hsh.multiline = true
+          if depth == 0
+            document << hsh
+          else
+            prev_hsh = selectors.last
+            prev_hsh.value << hsh
+          end
+          selectors << hsh
+        # Neither opening nor closing - 'plain text'
+        when /^[^{}]*$/
+          if depth == 0
+            document << line
+          else
+            hsh = selectors.last
+            hsh.value << (depth == 1 ? line : line.strip)
+          end
+        # Multiline selector closing
+        when /^([^{]*)[}]\s*$/
+          if media_block
+            media_block = false
+            if depth == 0
+              document << line
+            else
+              hsh = selectors.last
+              hsh.value << line
+            end
+          else
+            selectors.pop
+          end
+        # Inline selector
+        when /^([^{]*?)\s*[{]([^}]*)[}]\s*$/
+          key = (depth == 0 ? $1 : $1.strip)
+          hsh = StyleHash[ key => [ $2 ] ]
+          if depth == 0
+            document << hsh
+          else
+            prev_hsh = selectors.last
+            prev_hsh.value << hsh
+          end
+        end
+      end
+      document
+    end
+
+    def structure_to_css(structure, indent = 2)  #:nodoc:
+      # Implementation note: the recursion and the formatting
+      # ironically both feel repetitive; DRY them.
+      indentation = ' ' * indent
+      css = ''
+      structure.each do |elem|
+        # Top-level hash
+        if elem.kind_of? StyleHash
+          set_asides = []
+          key = elem.key
+          if elem.has_non_style_hash_children
+            css << "#{key} {"
+            css << (elem.multiline ? "\n" : '')
+          end
+          elem.value.each do |v|
+            # Nested hash, depth = 1
+            if v.kind_of? StyleHash
+              # Set aside
+              set_asides << set_aside(combo_key(key, v.key), v.value, v.multiline)
+            else
+              unless v.blank?
+                css << (elem.multiline ? "#{v}" : v)
+                css << (elem.multiline ? "\n" : '')
+              end
+            end
+          end
+          css << "}\n" if elem.has_non_style_hash_children
+          # Now write out the styles that were nested in the above hash
+          set_asides.flatten.each { |hsh|
+            next unless hsh.has_non_style_hash_children
+            css << "#{hsh.key} {"
+            css << (hsh.multiline ? "\n" : '')
+            hsh.value.each { |item|
+              unless item.blank?
+                css << (hsh.multiline ? "#{indentation}#{item}" : item)
+                css << (hsh.multiline ? "\n" : '')
+              end
+            }
+            css << "}\n"
+          }
+          set_asides.clear
+        else
+          css << "#{elem}\n"
+        end
+      end
+      css
+    end
+
+    private
+
+    def set_aside(key, value, multiline)  #:nodoc:
+      flattened = []
+      hsh = StyleHash[ key => [] ]
+      hsh.multiline = multiline
+      flattened << hsh
+      value.each { |val|
+        if val.kind_of? StyleHash
+          flattened << set_aside(combo_key(key, val.key), val.value, val.multiline)
+        else
+          hsh[key] << val
+        end
+      }
+      flattened
+    end
+
+    def combo_key(branch, leaf)  #:nodoc:
+      (leaf =~ /\A[.:#\[]/) ? "#{branch}#{leaf}" : "#{branch} #{leaf}"
+    end
+
+    def factor_out_comma_separated_selectors(css, indent = 2)  #:nodoc:
+      # TODO: replace with a nice regex
+      commas = false
+      css.each_line do |line|
+        next if line =~ /@media/
+        next if line =~ /,.*;\s*$/    # allow comma separated style values
+        commas = true if line =~ /,/
+      end
+      return css unless commas
+
+      state_machine = StateMachine.new indent
+      css.each_line { |line| state_machine.act_on line }
+      factor_out_comma_separated_selectors state_machine.result
+    end
+
+
+    class StateMachine  #:nodoc:
+      def initialize(indent = 2)
+        @state = 'flow'
+        @depth = 0
+        @output = []
+        @indent = ' ' * indent
+      end
+      def result
+        @output.join
+      end
+      def act_on(input)
+        # Implementation notes:
+        # - the correct way to do this would be to use a lexer and parser
+        if @state.eql? 'flow'
+          case input
+          when %r{/[*]}  # open comment
+            @state = 'reading_comments'
+            act_on input
+          when /^[^,]*$/    # no commas
+            @output << input
+          when /,.*;\s*$/   # comma separated style values
+            @output << input
+          when /@media/     # @media block
+            @output << input
+          when /,/          # commas
+            @state = 'reading_selectors'
+            @selectors = []
+            @styles = []
+            act_on input
+          end
+          return
+
+        elsif @state.eql? 'reading_comments'
+          # Dodgy hack: remove commas from comments so that the
+          # factor_out_comma_separated_selectors method doesn't
+          # go into an infinite loop.
+          @output << input.gsub(',', ' ')
+          if input =~ %r{[*]/}   # close comment
+            @state = 'flow'
+          end
+          return
+
+        elsif @state.eql? 'reading_selectors'
+          if input !~ /[{]/
+            @selectors << extract_selectors(input)
+          else
+            @selectors << extract_selectors($`)
+            @state = 'reading_styles'
+            act_on input
+          end
+          return
+
+        elsif @state.eql? 'reading_styles'
+          case input
+          when /\A[^{}]*\Z/           # no braces
+            @styles << input
+          when /\A[^,]*[{](.*)[}]/    # inline styles (no commas)
+            @styles << (@depth == 0 ? $1 : input)
+          when /[{](.*)[}]/           # inline styles (commas)
+            @styles << $1
+          when /[{][^}]*\Z/           # open multiline block
+            @styles << input unless @depth == 0
+            @depth += 1
+          when /[^{]*[}]/             # close multiline block
+            @depth -= 1
+            @styles << input unless @depth == 0
+          end
+          if @depth == 0 && input =~ /[}]/
+            @selectors.flatten.each { |selector|
+              # Force each style declaration onto a new line.
+              @output << "#{selector} {\n"
+              @styles.each { |style| @output << "#{@indent}#{style.chomp.strip}\n" }
+              @output << "}\n"
+            }
+            @state = 'flow'
+          end
+          return
+
+        end
+      end
+      
+      private
+
+      def extract_selectors(line)
+        line.split(',').map { |selector| selector.strip }.delete_if { |selector| selector =~ /\A\s*\Z/ }
+      end
+    end
+
+
+    class StyleHash < Hash  #:nodoc:
+      attr_accessor :multiline
+      def initialize *a, &b
+        super
+        multiline = false
+      end
+      def has_non_style_hash_children
+        value.each do |elem|
+          next if elem.kind_of? StyleHash
+          return true unless elem.blank?
+        end
+        false
+      end
+      # We only ever have one key and one value
+      def key
+        self.keys.first
+      end
+      def key=(key)
+        self.keys.first = key
+      end
+      def value
+        self.values.first
+      end
+      def value=(value)
+        self.values.first = value
+      end
+    end
+
+
+  end
+end

data/lib/rack/css_dryer.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../css_dryer/processor')
+require 'ERB'
+
+# Rack::CssDryer is a Rack middleware that serves de-nested nested
+# stylesheets (.ncss) if available.
+#
+# Nested stylesheets are run through ERB and then denested to convert them
+# into valid CSS.
+module Rack
+  class CssDryer
+    include ::CssDryer::Processor
+    File = ::File
+
+    # Options:
+    #
+    # +:url+ the parent URL of the stylesheets.  Defaults to 'css'.  In a Rails app
+    # you probably want to set this to 'stylesheets'.
+    #
+    # +:path+ the file system directory containing your nested stylesheets (.ncss).
+    # In a Rails app you probably want to set this to 'app/views/stylesheets'.
+    def initialize(app, options = {})
+      @app  = app
+      @url  = options[:url]  || 'css'
+      @path = options[:path] || 'stylesheets'
+    end
+
+    def call(env)
+      path = env['PATH_INFO']
+      if path =~ %r{/#{@url}/}
+        file = path.sub("/#{@url}", @path)
+        ncss = file.sub(/\.css$/, '.ncss')
+
+        if File.exists?(ncss)
+          nested_css = File.read(ncss)
+          nested_css = ::ERB.new(nested_css, nil, '-').result
+          css = process(nested_css)
+          length = ''.respond_to?(:bytesize) ? css.bytesize.to_s : css.size.to_s
+          [200, {'Content-Type' => 'text/css', 'Content-Length' => length}, [css]]
+        else
+          @app.call(env)
+        end
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/tasks/css_dryer_tasks.rake

@@ -0,0 +1,21 @@
+require 'erb'
+
+namespace :css_dryer do
+
+  task :to_css do
+    require File.join(RAILS_ROOT, 'app', 'helpers', 'stylesheets_helper')
+    include StylesheetsHelper
+
+    require File.join(File.dirname(__FILE__), '..', 'lib', 'css_dryer', 'processor')
+    include CssDryer::Processor
+
+    Dir.glob(File.join(RAILS_ROOT, 'app', 'views', 'stylesheets', '*')).each do |ncss|
+      @output_buffer = ''
+      ::ERB.new(File.read(ncss), nil, '-', '@output_buffer').result(binding)
+      File.open(File.join(RAILS_ROOT, 'public', 'stylesheets', File.basename(ncss, '.ncss')), 'w') do |f|
+        f.write process(@output_buffer)
+      end
+    end
+  end
+
+end