snitko-css_dryer_2 0.1

data/README.rdoc

@@ -0,0 +1,84 @@
+== DESCRIPTION:
+
+This gem is based on Rails plugin 'css_dryer': http://github.com/airblade/css_dryer.
+Unlike 'css_dryer', this one doesn't create any controllers and views.
+Instead, it acts more like SASS, but uses css_dryer parser (which allows you to use completely
+conventional css-synax and write one-line css rules).
+
+* Read 'install' section to find out how to use it with Rails or any other Ruby appplication.
+* Read USAGE.markdown file to learn about css_dryer parser (copypasted from css_dryer REAME).
+
+== REQUIREMENTS:
+
+* ActiveResource gem
+
+== INSTALL:
+
+1) sudo gem install css_dryer_2
+2) If you're planning to use it with rails application, then
+go to rails application folder and run 'script/generate css_dryer'.
+This will generate neccessary rake tasks.
+    
+3) Put this is config/environments/development.rb:
+
+  require 'css_dryer_2'
+
+4) In dev environment, to generate css on any changes in .ncss files, put this in ApplicationController:
+
+  CssDryer2::FilesHandler.new(:settings => :rails).run if RAILS_ENV == 'development'
+
+You can also set custom directories for files, instead of using rails shortcut option:
+
+  CssDryer2::FilesHandler.new(
+    :source_path  => 'my_css_dir/ncss',
+    :compile_path => 'my_css_dir',
+    :tmp_path     => '/tmp',
+    :force_compile => true
+  )
+
+
+5) While rails application to production, run rake task:
+
+  rake ncss:compile
+
+6) Now put your .ncss files in your 'public/stylesheets/ncss/' dir.
+The compiler will put generated css files in 'public/stylesheets/' dir.
+
+
+== HOW IT WORKS:
+
+When you fire 'run' method, CssDryer2::FileHandler object checks if the .ncss files
+changed (it stores their SHA1 in tmp dir). If they did, it recompiles them.
+
+For Rails application it assumes that you store your .ncss files in 'public/stylesheets/ncss',
+and it compiles .css files in 'public/stylesheets'.
+You might want to add 'public/stylesheets/*.css' into your '.gitignore' file 
+
+You can force reompile by providing the run method with':force_recompile => true' argument.
+You can also recompile at any time by running 'rake ncss:compile'
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/generators/css_dryer/css_dryer_generator.rb

@@ -0,0 +1,16 @@
+require 'rbconfig'
+
+class CssDryerGenerator < Rails::Generator::Base
+
+  def initialize(runtime_args, runtime_options = {})
+    Dir.mkdir('lib/tasks') unless File.directory?('lib/tasks')
+    super
+  end
+  
+  def manifest
+    record do |m|
+      m.file "css_dryer_2.rake", "lib/tasks/css_dryer_2.rake"
+    end
+  end
+
+end

data/generators/css_dryer/templates/css_dryer_2.rake

@@ -0,0 +1,10 @@
+require 'css_dryer_2'
+
+namespace(:ncss) do
+
+  desc "compile ncss files into css"
+  task :compile do
+    CssDryer2::FilesHandler.new(:force_compile => true, :settings => :rails).run
+  end
+
+end

data/lib/css_dryer_2.rb

@@ -0,0 +1,7 @@
+require 'erb'
+require 'activesupport'
+require 'tmpdir'
+require File.dirname(__FILE__) + '/css_dryer_2/processor'
+require File.dirname(__FILE__) + '/css_dryer_2/stylesheets_helper'
+require File.dirname(__FILE__) + '/css_dryer_2/ncss_handler'
+require File.dirname(__FILE__) + '/css_dryer_2/files_handler'

data/lib/css_dryer_2/files_handler.rb

@@ -0,0 +1,63 @@
+require 'digest'
+
+module CssDryer2
+  # This module is included in rake task or
+  # anywhere (for example ApplicationController of Rails app)
+  # you need to choose when and which files are compiled.
+  class FilesHandler
+
+    attr_accessor :source_path, :compile_path, :tmp_path, :force_compile
+
+    def initialize(params = {})
+
+    @force_compile = false
+
+      if params[:settings] == :rails
+        @source_path   = "#{RAILS_ROOT}/public/stylesheets/ncss"
+        @compile_path  = "#{RAILS_ROOT}/public/stylesheets"
+        @tmp_path      = "#{RAILS_ROOT}/tmp"
+      end
+
+      @source_path   = params[:source_path]   if params[:source_path] 
+      @compile_path  = params[:compile_path]  if params[:compile_path]
+      @tmp_path      ||= params[:tmp_path]      || Dir.tmpdir + '/css_dryer_2_gem/tmp'
+      
+
+      unless @source_path or @compile_path or @tmp_path
+        raise "You have to set source_path, compile_path and tmp_path"
+      end
+
+      FileUtils.mkdir_p(@tmp_path + '/css_dryer_2') unless File.exist?(@tmp_path + '/css_dryer_2')
+    end
+
+    def run(params = {})
+      files = Dir.new(@source_path + '/').entries
+      files.delete_if { |f| !File.file?(@source_path + "/#{f}") or !(f =~ /.ncss$/) }
+      files.each { |f| prepare_file(f, params[:force_compile] || @force_compile) }
+    end
+
+    def self.configure   
+      yield(self)
+    end
+
+    private
+    
+    def prepare_file(file, force_compile)
+
+      ncss = File.read(@source_path + "/#{file}")
+      hashed_content = Digest::SHA1.hexdigest(ncss)
+
+      # Check if the file has been updated since the last run
+      if File.exist?(@tmp_path + "/css_dryer_2/#{file}")
+        prev_hashed_content = File.read(@tmp_path + "/css_dryer_2/#{file}")
+        return if prev_hashed_content == hashed_content and !@force_compile
+      end        
+
+      ncss = File.read(@source_path + "/#{file}")
+      css  = CssDryer2::NcssHandler.new.compile(ncss)
+      File.open(@compile_path + "/#{file.sub(/.ncss$/, '.css')}", 'w') { |f| f.write(css) } 
+      File.open(@tmp_path + "/css_dryer_2/#{file}", 'w') { |f| f.write(hashed_content) } 
+    end
+
+  end
+end

data/lib/css_dryer_2/ncss_handler.rb

@@ -0,0 +1,19 @@
+# Handler for DRY stylesheets which can be registered with Rails
+# as a new templating system.
+#
+# DRY stylesheets are piped through ERB and then CssDryer#process.
+module CssDryer2
+
+  class NcssHandler
+    include CssDryer::Processor
+    # In case user doesn't have helper or hasn't run generator yet.
+    include StylesheetsHelper rescue nil
+
+    def compile(template)
+      output_buffer = String.new
+      erb_compiled_template = ERB.new(template, nil, nil, "@output_buffer").result(binding)
+      process(erb_compiled_template)
+    end
+  end
+
+end

data/lib/css_dryer_2/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.0'
+
+    # 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 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 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| 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