dcss 0.3

data/CHANGES

@@ -0,0 +1,3 @@
+= Version 0.1
+* Initial release
+* Descendant selector {{ }}

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005 Lukasz 'Bragi Ragnarson' Piestrzeniewicz
+
+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/README

@@ -0,0 +1,202 @@
+= DCSS - CSS extensions that make writing stylesheets less verbose
+
+Information for version 0.3.0
+
+Main features:
+
+* Create rich CSS files using:
+
+  * ERB templates
+
+  * Server-side constants
+
+  * Server-side classes (preliminary)
+
+* Process DCSS files off-line using command line executable
+
+* Also available as a rails plugin
+
+=== ERB templates
+
+Example
+
+  <% template_color = "#000"
+     template_background = "#fff"
+     template_highlight = "#fa3"
+  %> 
+  body {
+  	color: <%= template_color %>;
+  	background-color: <%= template_background %>;  	
+  }
+  
+  h1 {
+  	color: <%= template_background %>;
+  	background-color: <%= template_highlight %>;
+  }
+
+=== Server-side Constants
+
+Server-side Constants were originally developed by Shaun Inman in PHP. SSC 
+extends CSS syntax in a simple way. SCC is cross-platform and easy to use.
+
+DCSS uses the constants implementation from RCSS[http://rcss.rubyforge.org/] which also allows constants to include spaces and commas.
+
+Example
+
+  @server constants {
+    template_color: #000;
+    template_background: #fff;
+    template_highlight: #fa3;
+
+    // Rcss specific (note spaces and commas)
+    template_font: "Trebuchet MS", "Bitstream Vera Sans", helvetica, sans-serif;
+  }
+
+  body {
+  	color: template_color;
+  	background-color: template_background;
+  	font-family: template_font;
+  }
+  
+  h1 {
+  	color: template_background;
+  	background-color: template_highlight;
+  	font-family: template_font;
+  }
+
+There might be several constants/variables blocks in the same file. It does not 
+matter where in CSS file they appear, their contents are still applied to whole 
+file. 
+
+When a constant is redefined only later occurrence is taken into account so:
+
+  template_color: #fff;
+  ...
+  template_color: #000;
+
+...will result in <code>template_color</code> having value <code>#000</code> in all places.
+
+To use constant's value simply type it's name anywhere in the code:
+
+  body {
+    color: constant_name;
+  }
+
+*Note* that since anything can be constant's value it is also possible to use it
+to hold attribute or even selector:
+
+  @server constants {
+  	body: #fff;
+  }
+
+  body {
+  	color: body;
+  }
+
+This will be evaluated to
+
+  #fff {
+    color: #fff;
+  }
+
+..which probably is not what one might expect. For that reason avoid using CSS 
+selector and attribute names as constant names.
+
+=== Nested Descendant Selectors
+
+DCSS introduces the following <tt>{{ }}</tt> syntax:
+
+  #someid { color: blue } {{
+    a { color: green; }
+  }}
+
+Which renders to:
+
+  #someid { color: blue }
+   #someid a { color: green; }
+
+Leaving out the parent properties is ok:
+
+  #someid {{
+    a { color: green; }
+  }}
+
+becomes:
+
+  #someid a { color: green; }
+
+Nested and comma separated selectors also work:
+
+  body.home, #specialpage { margin: 10px auto; width: 700px; } {{
+    h1 { font-family: Arial, sans-serif; } 
+    a, a:visited { color: blue; }
+    p > span { font-size: 1.2em; }
+    #someid { background: red; } {{
+      h1 { font-family: Georgia, serif; }
+    }}
+  }}
+
+renders to:
+
+  body.home, #specialpage { margin: 10px auto; width: 700px; }
+   body.home h1, #specialpage h1 { font-family: Arial, sans-serif; }
+   body.home a, body.home a:visited, #specialpage a, #specialpage a:visited { color: blue; }
+   body.home p > span, #specialpage p > span { font-size: 1.2em; }
+   body.home #someid, #specialpage #someid { background: red; }
+    body.home #someid h1, #specialpage #someid h1 { font-family: Georgia, serif; }
+
+== Installation
+
+=== Using RubyGems
+
+Download and install DCSS with the following command (won't work until I rubyforge account is created, see below):
+
+   gem install --remote dcss
+   
+=== Manual
+
+Download the gem file from {my website}[http://myles.id.au] while I wait for my rubyforge account to get activated. After that it will be available at the {project page}[http://rubyforge.org/projects/dcss/]. Install it with following command
+
+  gem install dcss-0.3.0.gem
+   
+== Usage
+
+=== Command line
+
+NAME
+     dcss - process rich CSS files
+
+SYNOPSIS
+     dcss [DCSSFile]
+     
+DESCRIPTION
+     Reads and processes DCSS files. Processed file is printed to standard
+     output. If no file is given standard input is processed instead.
+            
+EXAMPLE
+     dcss default.dcss > default.css
+     
+=== Rails
+
+Run
+
+  ./script/install http://svn.ducknewmedia.com.au/public/rails_plugins/dcss
+
+
+== Credits
+
+[<b>Shaun Inman</b>] For the original PHP version of CSS-SSC[http://www.shauninman.com/post/heap/2005/08/09/css_constants]
+[<b>Lukasz 'Bragi Ragnason' Piestrzeniewicz</b>] For RCSS[http://rcss.rubyforge.org/]
+
+== License
+
+DCSS is available under an MIT-style license.
+
+:include: MIT-LICENSE
+
+== Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantibility and fitness for a particular
+purpose.

data/Rakefile

@@ -0,0 +1,245 @@
+require 'rubygems'
+
+Gem::manage_gems
+
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+require File.dirname(__FILE__) + '/lib/dcss'
+
+PROJECT_SUMMARY = "DCSS - CSS extensions that make writing stylesheets less verbose"
+
+# need to set up rubyforge project
+PKG_NAME           = "dcss"
+PKG_VERSION        = DuckCSS::VERSION
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "dcss"
+RUBY_FORGE_USER    = "mylesb"
+PKG_FILES = FileList[
+  'README',
+  'CHANGES',
+  'TODO',
+  'MIT-LICENSE',
+  'Rakefile',
+  'lib/**/*.rb',
+  'bin/**/*',
+  'test/**/*'
+]
+
+desc "Builds everything"
+task :default => [:test, :gem, :rdoc]
+
+task :gem => :test
+
+rd = Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = PROJECT_SUMMARY
+  rdoc.options  << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'MIT-LICENSE', 'TODO', 'CHANGES')
+  rdoc.rdoc_files.include('lib/dcss.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = PKG_NAME
+  s.version           = PKG_VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = PROJECT_SUMMARY
+  s.files             = PKG_FILES.to_a
+  s.executables       << 'dcss'
+  s.require_path      = 'lib'
+  s.autorequire       = 'dcss'
+  s.author            = "Myles Byrne, Bragi Ragnarson"
+  s.email             = "myles@ducknewmedia.com.au, bragi.ragnarson@gmail.com"
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.homepage          = "http://myles.id.au/more/#DCSS" # needs its own page
+  s.has_rdoc          = true
+  s.rdoc_options      <<
+    '--title' <<  PROJECT_SUMMARY <<
+    '--main' << 'README' <<
+    '--line-numbers'
+  s.extra_rdoc_files  = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+    
+end
+
+def run_test(testfile)
+  testname = testfile.gsub(/test\/data\/(.*)\.in\.rcss/, '\1')
+  rcss = DuckCSS::CSSParser.new(File.read(testfile)).to_css
+  css = File.read(testfile.gsub(/\.in\.rcss/ , ".out.css"))
+  if rcss.strip == css.strip # damn newlines
+    puts "Test \"#{testname}\" passed"
+  else
+    puts "Test \"#{testname}\" failed"
+    puts "--- RESULT ---"
+    puts rcss
+    puts "--- EXPECTED ---"
+    puts css
+    puts "---"
+    raise
+  end
+end
+
+desc "Run all tests - use only=test1 as an argument to run just test1"
+task :test do |t|
+  puts "Testing"
+  if ENV.include?('only')
+    run_test "test/data/#{ENV['only']}.in.rcss"
+  else
+    # units
+    tests = File.read('test/units.dcss')\
+    .split('/* ----------------------------------------------')[1..-1]\
+    .map do |test|
+      ret = { :title => test.slice!(/.*\*\//)[0..-3] }
+      ret[:input], ret[:expected] = test.split('/* -- expected: */').map {|s| s.strip}
+      ret
+    end\
+    .each do |test|
+      result = DuckCSS::CSSParser.new(test[:input]).to_css
+      if result == test[:expected]
+        puts "#{test[:title]} - passed"
+      else
+        puts "#{test[:title]} - failed"
+        puts "--- RESULT ---"
+        puts result
+        puts "--- EXPECTED ---"
+        puts test[:expected]
+        puts "---"
+        raise
+      end
+    end
+    # whole files
+    Dir[ 'test/data/*.in.rcss' ].each do |testfile|
+      run_test testfile
+    end
+  end
+end 
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip     = true
+  pkg.need_tar_gz  = true
+  pkg.need_tar_bz2 = true
+end
+# 
+# desc "Publish the API documentation"
+# task :pdoc => [:rdoc] do
+#   Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
+# end
+# 
+# desc 'Publish the gem and API docs'
+# task :publish => [:pdoc, :rubyforge_upload]
+# 
+# desc "Publish the release files to RubyForge."
+# task :rubyforge_upload => :package do
+#   files = %w(gem tgz).map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+# 
+#   if RUBY_FORGE_PROJECT then
+#     require 'net/http'
+#     require 'open-uri'
+# 
+#     project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+#     project_data = open(project_uri) { |data| data.read }
+#     group_id = project_data[/[?&]group_id=(\d+)/, 1]
+#     raise "Couldn't get group id" unless group_id
+# 
+#     # This echos password to shell which is a bit sucky
+#     if ENV["RUBY_FORGE_PASSWORD"]
+#       password = ENV["RUBY_FORGE_PASSWORD"]
+#     else
+#       print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+#       password = STDIN.gets.chomp
+#     end
+# 
+#     login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+#       data = [
+#         "login=1",
+#         "form_loginname=#{RUBY_FORGE_USER}",
+#         "form_pw=#{password}"
+#       ].join("&")
+#       http.post("/account/login.php", data)
+#     end
+# 
+#     cookie = login_response["set-cookie"]
+#     raise "Login failed" unless cookie
+#     headers = { "Cookie" => cookie }
+# 
+#     release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+#     release_data = open(release_uri, headers) { |data| data.read }
+#     package_id = release_data[/[?&]package_id=(\d+)/, 1]
+#     raise "Couldn't get package id" unless package_id
+# 
+#     first_file = true
+#     release_id = ""
+# 
+#     files.each do |filename|
+#       basename  = File.basename(filename)
+#       file_ext  = File.extname(filename)
+#       file_data = File.open(filename, "rb") { |file| file.read }
+# 
+#       puts "Releasing #{basename}..."
+# 
+#       release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+#         release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+#         type_map = {
+#           ".zip"    => "3000",
+#           ".tgz"    => "3110",
+#           ".gz"     => "3110",
+#           ".gem"    => "1400"
+#         }; type_map.default = "9999"
+#         type = type_map[file_ext]
+#         boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+# 
+#         query_hash = if first_file then
+#           {
+#             "group_id" => group_id,
+#             "package_id" => package_id,
+#             "release_name" => PKG_FILE_NAME,
+#             "release_date" => release_date,
+#             "type_id" => type,
+#             "processor_id" => "8000", # Any
+#             "release_notes" => "",
+#             "release_changes" => "",
+#             "preformatted" => "1",
+#             "submit" => "1"
+#           }
+#         else
+#           {
+#             "group_id" => group_id,
+#             "release_id" => release_id,
+#             "package_id" => package_id,
+#             "step2" => "1",
+#             "type_id" => type,
+#             "processor_id" => "8000", # Any
+#             "submit" => "Add This File"
+#           }
+#         end
+# 
+#         query = "?" + query_hash.map do |(name, value)|
+#           [name, URI.encode(value)].join("=")
+#         end.join("&")
+# 
+#         data = [
+#           "--" + boundary,
+#           "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+#           "Content-Type: application/octet-stream",
+#           "Content-Transfer-Encoding: binary",
+#           "", file_data, ""
+#           ].join("\x0D\x0A")
+# 
+#         release_headers = headers.merge(
+#           "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+#         )
+# 
+#         target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+#         http.post(target + query, data, release_headers)
+#       end
+# 
+#       if first_file then
+#         release_id = release_response.body[/release_id=(\d+)/, 1]
+#         raise("Couldn't get release id") unless release_id
+#       end
+# 
+#       first_file = false
+#     end
+#   end
+#end

data/TODO

@@ -0,0 +1,4 @@
+= DuckCSS TODO list
+
+== Future development
+* Implement Include - syntax should be: #somdiv { include: .someclass, .somotherclass; color: blue; }

data/bin/dcss

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/dcss'
+puts DuckCSS::CSSParser.new( ARGF.read ).to_css

data/bin/test

@@ -0,0 +1,11 @@
+@server constants { 
+  titles_font: "Trebuchet MS", Verdana, sans-serif; 
+  link_color: #0A5F9E;
+}
+
+#menu { padding: 10px; } {{
+ #archives, #links { font-size: 0.9em; } {{
+   h2 { font-family: titles_font; }
+   a { color: link_color; }
+ }} 
+}}

data/lib/dcss.rb

@@ -0,0 +1,155 @@
+$: << File.dirname(__FILE__) # adds the directory of this file to the load path
+
+require 'lexer'
+require 'erb'
+require 'rubygems'
+
+module DuckCSS #:nodoc:
+
+  VERSION = "0.3"
+
+  # Implements DCSS in Ruby.
+  class CSSParser < String
+    
+    SERVER_CONSTANTS = /@server\s+(?:variables|constants)\s*\{\s*([^\}]+)\s*\}\s*/m
+    SERVER_CONSTANT = /([^:\s]+)\s*:\s*([^;]+)\s*;/m
+    
+    def self.parse
+      new(self).to_css
+    end
+        
+    # Generates CSS from DCSS contents
+    #
+    # When binding is provided it is used to evaluate ERB template
+    #
+    #  template = <<-TXT
+    #    @server constants { my_color: #fff; }
+    #    body { color: my_color; }
+    #  TXT
+    #  dcss = DCSS::CSSParser.new(template)
+    #  dcss.to_css
+    #    #=> "body { color: #fff; }
+    def to_css(binding=nil) # :nodoc:
+      process_erb(binding)
+      process_constants
+      process_descendant_selectors      
+      @dcss
+    end
+    
+    protected
+        
+    def process_erb(binding=nil)
+      @dcss = ERB.new(self.dup, nil, '-').result(binding)
+    end
+    
+    def process_constants
+      constants = {}
+      # 1. Find and collect all server-side constants
+      @dcss.gsub!(SERVER_CONSTANTS) do
+        $1.scan(SERVER_CONSTANT) do
+          constants[$1]=$2 
+        end
+        ""
+      end
+      # 2. Substitute constants with values
+      @dcss.gsub!(/[^:;\s]+/) do
+        constants[$&] or $&
+      end
+    end
+    
+    # Here's an untransformed CSS file:
+    # 
+    #   #notes { color: red; } {{
+    #     p { font-size: 2em; }
+    #   }}
+    # 
+    #   #footer { color: blue } {{
+    #     a { font-size: 1em; }
+    #   }}
+    # 
+    # Split into a token and element array it looks like this:
+    # 
+    #   tokens   = "sp{sp}sp{sp}"
+    #   elements = [ '#notes', '{ color: red; }', '{{', 'p', 
+    #    '{ font-size: 2em; }', '}}', '#footer', '{ color: blue }', 
+    #    '{{', 'a', '{ font-size: 1em;}', '}}' ]
+    #
+    # 
+    # Note that tokens is both a string and an array because an array is just
+    # a string of characters. So tokens[0] corresponds to the first selector
+    # token (represented by the 's' character) and also the first selector in
+    # the elements array:
+    # 
+    #   >> tokens[0]
+    #   => 115
+    #   >> tokens[0].chr
+    #   => "s"
+    #   >> elements[0]
+    #   => "#notes"
+    # 
+    # Lined up they look like:
+    # 
+    #     s         p                  {     s   ...
+    #   ['#notes', '{ color: red; }', '{{', 'p'  ...
+    # 
+    # Now we can run quick regexes on the tokens string to figure what elements
+    # need modification. Once an element has been modified the token is
+    # changed to 'X' so the same element is not modified again on an
+    # additional pass of the tokens string.
+    #  
+    # When every transformation is complete, we just combine the elements
+    # array into one large string and discard the tokens array.
+    #
+    def process_descendant_selectors
+      tokenmap = [
+        [ /\s+/,            ?\s ],   # skip whitespace
+        [ /\/\*.*\*\//,     ?\s ],   # skip comments
+        [ /\/\*.*?\*\//m,   ?\s ],   # skip multiline comments (i don't know why I need to do this)
+        [ /[^\{\}]+/,       ?s  ],   # selector e.g. #somediv a > span
+        [ /\{([^\{\}]*)\}/, ?p  ],   # properties e.g. { color: blue, background: green; }
+        [ /\{\{/,           ?{  ],   # descendant open {{
+        [ /\}\}/,           ?}  ]    # descendant close }}
+      ].map { |a| [ /\A#{a[0]}/, a[1] ] } # all tokens anchored at start (\A) of scanned string
+
+      tokens, elements = Lexer.new(tokenmap).scan(@dcss)
+
+      descendant_selector = /(s) (p){0,1} (\{) ([spX<>]+) (\})/mx
+                          #   1   2        3    4        5
+      
+      while tokens =~ descendant_selector
+        match = tokens.match(descendant_selector)
+        parent_scope = elements[match.begin(1)]
+        start_children, end_children = match.offset(4)
+        (start_children...end_children).each do |pos|
+          if tokens[pos] == ?s
+            elements[pos] = parent_scope.split(',').map do |p_scope|
+              elements[pos].split(',').map { |selector| "#{p_scope.strip} #{selector.strip}" }.join(', ')
+            end.join(', ')
+          end
+        end
+        tokens[match.begin(3)], tokens[match.begin(5)] = ?< , ?> # mark the two { } symbols as processed
+        elements[match.begin(3)] = elements[match.begin(5)] = ''
+        # clear out parent selectors with no properties of their own. Eg. #somdiv {{ p { ... } }}
+        if match.begin(2).nil?
+          tokens[match.begin(1)] = tokens[match.begin(3)] = tokens[match.begin(5)] = ?X 
+          elements[match.begin(1)] = ''
+        end
+      end
+      
+      # formatting ... could be prettier
+      tabsize = 0
+      tokens.size.times do |pos|
+        case tokens[pos]
+        when ?< : tabsize += 1
+        when ?> : tabsize -= 1
+        when ?p : elements[pos] = " #{elements[pos].strip}\n"
+        when ?s : elements[pos] = (0...tabsize).map { " " }.to_s + elements[pos].strip 
+        end
+      end
+      
+      @dcss = elements.to_s.strip
+    end
+    
+  end
+
+end

data/lib/lexer.rb

@@ -0,0 +1,228 @@
+# Source: http://rubyforge.org/frs/?group_id=127&release_id=282
+
+# Little Lexer, a very small very simple lexical scanner and parser class
+#
+# I wrote this in the middle of the night because the idea was sooo cute.
+#
+#     Copyright (C) 2004  John Carter
+     
+#     This library is free software; you can redistribute it and/or modify it
+#     under the terms of the GNU Lesser General Public License as published by
+#     the Free Software Foundation; either version 2.1 of the License, or (at
+#     your option) any later version.
+     
+#     This library is distributed in the hope that it will be useful, but
+#     WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+     
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
+#     USA.
+
+class LexerJammed < Exception
+end
+
+# A tiny very very simple Lexer/Parser class.
+#
+# Feed it an array of [regex,char] pairs and it
+# scans an input string returning a string of char's matching 
+# the tokens found.
+
+# What makes this such a very very very cute idea (apart from the fact
+# it so very small) is...  Traditionally Lexical scanners such as flex
+# yield a stream of tokens id's (usully an int or an enum) and the
+# token (usually a string). I have chosen (this is the smart bit) to
+# make each token id a character (which limits the number of possible
+# token id's a bit, but certainly not for any practical use), and not
+# return a stream of token id's and tokens, but an array.
+
+# Now an array of token id's is just an array of char which is just a
+# string!
+
+# WAKE UP! This is VERY cute! Thus the output of the lexical scanner
+# is just a string which can be used as the input to a lexical scanner.
+
+# Thus we can use the very same class as both a lexical scanner _AND_
+# a parser!
+
+# I _told_ you it was cute.
+
+# See the tests for examples.
+#
+class Lexer
+
+  # Constructs a Lexer that can be used and reused
+  # to scan a string for tokens.
+  #
+  #  Parameters
+  #   regex_to_char is an enumeration of [regex,char] pairs.
+  #                 The 'next_token' method tries to match each 
+  #                 regex in order, if one matches, the matching 
+  #                 token and corresponding char is returned.
+  #   skip_white_space - If true, token that corresponds to ?\s (space)
+  #                 will be skipped.
+  # 
+  def initialize(regex_to_char,skip_white_space = true)
+    @skip_white_space = skip_white_space
+    @regex_to_char = regex_to_char
+  end
+
+  # Scans a string for tokens
+  #
+  # Parameters
+  #   string - String to scan for tokens
+  #   string_token_list - token list output by first pass.
+  #
+  # Returns a string of token id's and a token list.
+  #
+  # If string_token_list is nil, (the default) then...
+  #   The input string is scanned and broken up into tokens as
+  #   follows.  Each regex in the regex to char list is tried in order
+  #   until either one matches, in which case the corresponding token
+  #   id char is appended to the output string, and the token is
+  #   appended to the token list.  The token is removed from the front
+  #   of the string and the it then tries again until all tokens have
+  #   been found or no regex matches.  If no regex in the regex to
+  #   char list matches, then the Lexer jam's and throws a LexerJammed
+  #   exception
+
+  # If the input string is the output string of a another Lexer
+  # instance's scan and the string_token_list is the matching token
+  # list, then the output token list is a list of pairs. The first
+  # element in each pair is a subarray of the string_token_list that
+  # matches the token matched. The token matched is in the second
+  # element of the pair. Thus a parser can work make to the original
+  # token's found by the lexer.
+
+  def scan(string,string_token_list=nil)
+    result_string  = ''
+    token_list = []
+    
+    if string_token_list
+      next_token(string) do |t,token, tail|
+        result_string << t
+        token_list << [string_token_list[0...tail], string[0...tail]]
+        string = string[tail..-1]
+        string_token_list = string_token_list[tail..-1]
+      end
+    else
+      next_token(string) do |t,token, tail|
+        result_string << t
+        token_list << token
+      end
+    end
+    return result_string, token_list
+  end
+
+  private
+
+  # Private method for scan that finds the next token.
+  #
+  # Parameters 
+  #   string - input string to be scanned.
+  #   block - yield's the token id char, token and offset of the end of the token.
+  #
+  # Throws LexerJammed if fails, details holds string it failed on.
+  #
+  # Returns void
+  def next_token( string)
+    match_data = nil
+    while string != ''
+      failed = true
+      @regex_to_char.each do |regex,char|
+        match_data = regex.match(string)
+        next unless match_data
+        token = match_data[0]
+        yield char,token, match_data.end(0) unless char == ?\s && @skip_white_space 
+        string = match_data.post_match
+        failed = false
+        break
+      end
+      raise LexerJammed, string if failed
+    end
+    
+  rescue RegexpError => details
+    raise RegexpError, "Choked while '#{@scanner}' was trying to match '#{string}' : #{details}"
+  end
+
+end
+
+if $0 == __FILE__ then
+  require 'test/unit'
+  require 'DiGraphTest'
+  require 'DiGraphParser'
+  require 'HtmlParser'
+  require 'CParser'
+  require 'pp'
+
+  class TC_TestLex < Test::Unit::TestCase
+    def test_own
+      lexer, tag_lexer = HtmlParser::create_parser
+
+      result_string, token_list = lexer.scan( '<!DOCTYPE html 
+PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"><head><!-- Vignette V6 Sat Jan 31 01:00:06 2004 -->
+<html>
+<script foo="fah"> 
+  <!-- if a < b  -->
+</script>
+<!-- comment -->
+</body>')
+
+      assert_equal( "dsscfsfsfcfefcfe", result_string)
+      html_tag = token_list[1]
+      rtag,ttag = tag_lexer.scan( html_tag)
+
+      assert_equal( '<ii=ti=ti=t>', rtag)
+      assert_equal( 'html', ttag[1])
+    end
+
+    include DiGraphTest
+
+    def test_lex
+      lexer, parser = DiGraphParser::create_parser
+      string,list = lexer.scan(example_digraph) 
+#      pp string
+#      pp list
+      assert_equal( "di{i[i=i];i[i=i];i>i;i>i;i>i;i>i;i>i;i>i;i>i;i>i;};", string)
+      assert_equal( 'digraph', list[0])
+
+      p_string, p_list = parser.scan(string,list)
+      assert_equal( 'hnneeeeeeeet', p_string)
+      assert_equal( 'di{', p_list[0][1])
+    end
+
+    def test_c
+      clexer = CParser::create_parser
+      src =  " foo 
+dang //
+//blast 
+/**/
+/***/
+/* */
+/* * */
+ /* goo
+**/ /* bah /* * ** / * /
+test //gah
+*/
+"
+      pp src
+      string,list = clexer.scan(src)
+      assert_equal( 'dppndndcdcdcdcd', string)
+      assert_equal( "//\n",  list[1])
+      pp string
+      pp list
+    end
+
+    def test_fail
+      lexer, tag_lexer = HtmlParser::create_parser
+
+      result_string, token_list = tag_lexer.scan( '<f%%k>')
+      assert( false)
+    rescue LexerJammed
+      assert(true)
+    end
+
+  end
+end

data/lib/rcss.original.rb

@@ -0,0 +1,120 @@
+require 'erb'
+
+require 'rubygems'
+
+module Rcss #:nodoc:
+
+  VERSION = "0.3.1"
+
+  # Implements CSS-SSC in Ruby.
+  #
+  # Main features:
+  #
+  # * Create rich CSS files using:
+  #
+  #   * ERB templates
+  #
+  #   * Server-side constants
+  #
+  #   * Server-side classes (preliminary)
+  #
+  # * Simply add Rcss files to any Rails application
+  #
+  # * Process Rcss files off-line using command line executable
+  #
+  class Ssc < String
+  
+    @@SERVER_CONSTANTS = /@server\s+(?:variables|constants)\s*\{\s*([^\}]+)\s*\}\s*/m
+    
+    @@SERVER_CONSTANT = /([^:\s]+)\s*:\s*([^;]+)\s*;/m
+    
+    @@SERVER_CLASS = /@server\s+(\&\w?[-_\w\d]*)\s+\{([^\}]*)\}/m
+
+    @@EXTENDS_ATTRIBUTE = /extends\s*:\s*(\&\w?[-_\w\d]*);/m
+    
+    def initialize(string) # :nodoc:
+      super(string)      
+    end
+    
+    def parse(text, binding) # :nodoc:
+      classes = Hash.new
+      constants = Hash.new
+      
+      # Apply ERB as it has the highest priority
+      rcss = ERB.new(text, nil, '-').result(binding)
+      
+      # Apply SSC in two steps:
+      
+      # 1. Find and collect all server-side constants
+      rcss.gsub!(@@SERVER_CONSTANTS) do
+        $1.scan(@@SERVER_CONSTANT) do
+          constants[$1]=$2 
+        end
+        ""
+      end
+      
+      # 2. Substitute constants with values
+      rcss.gsub!(/[^:;\s]+/) do
+        constants[$&] or $&
+      end
+      
+      # Apply server-side classes
+      rcss.gsub!(@@SERVER_CLASS) do 
+        class_name = $1
+        body = $2
+        body.gsub!(@@EXTENDS_ATTRIBUTE) { classes[$1] }
+        classes[class_name] = body.strip
+        ""
+      end
+      rcss.gsub!(@@EXTENDS_ATTRIBUTE) { classes[$1] }
+      
+      rcss
+    end
+    
+    # Generates CSS from Rcss contents
+    #
+    # When binding is provided it is used to evaluate ERB template
+    #
+    #  template = <<-TXT
+    #    @server constants { my_color: #fff; }
+    #    body { color: my_color; }
+    #  TXT
+    #  rcss = Rcss::Ssc.new(template)
+    #  rcss.to_css
+    #    #=> "body { color: #fff; }
+    #
+    def to_css(binding=nil)
+      parse(self.dup, binding)
+    end
+
+    private :parse
+  end
+  
+  # Rails handler for Rcss files
+  class RcssHandler
+    include ERB::Util
+    
+    def initialize(action_view) #:nodoc:
+      @action_view = action_view
+    end
+    
+    # Renders given template using local_assigns for evaluation
+    #
+    # Modifies response headers:
+    #
+    #  Content-Type: text/css
+    #
+    def render(template, local_assigns)
+      @action_view.controller.headers["Content-Type"] = 'text/css'
+      b = binding
+  
+      local_assigns.stringify_keys!
+      local_assigns.each { |key, value| eval "#{key} = local_assigns[\"#{key}\"]", b }
+      Ssc.new(template).to_css(b)
+    end
+  end
+end
+
+if Object.const_defined? "ActionView"
+  ActionView::Base::register_template_handler 'rcss', Rcss::RcssHandler
+end

data/test/data/complex_descendants.in.rcss

@@ -0,0 +1,32 @@
+body.page { width: 400px; }
+
+#somediv { background: green; }
+
+body.home, #specialpage { margin: 10px auto; width: 700px; } {{
+  h1 { font-family: Arial, sans-serif; } 
+  a, a:visited { color: blue; }
+  p > span { font-size: 1.2em; }
+  #someid { background: red; } {{
+    h1 { font-family: Georgia, serif; }
+  }}
+}}
+
+body.home #someotherdiv { color: orange; }
+
+#header { background: white; } {{
+  h2 { color: yellow; }
+}}
+
+#header, #footer { } {{
+  p { line-height: 1.5; }
+}}
+
+#header, 
+#footer {{
+  p {{
+    li { 
+      line-height: 1.5;
+      color: orange;
+    }
+  }} 
+}}

data/test/data/complex_descendants.out.css

@@ -0,0 +1,17 @@
+body.page { width: 400px; }
+#somediv { background: green; }
+body.home, #specialpage { margin: 10px auto; width: 700px; }
+ body.home h1, #specialpage h1 { font-family: Arial, sans-serif; }
+ body.home a, body.home a:visited, #specialpage a, #specialpage a:visited { color: blue; }
+ body.home p > span, #specialpage p > span { font-size: 1.2em; }
+ body.home #someid, #specialpage #someid { background: red; }
+  body.home #someid h1, #specialpage #someid h1 { font-family: Georgia, serif; }
+body.home #someotherdiv { color: orange; }
+#header { background: white; }
+ #header h2 { color: yellow; }
+#header, #footer { }
+ #header p, #footer p { line-height: 1.5; }
+#header p li, #footer p li { 
+      line-height: 1.5;
+      color: orange;
+    }

data/test/data/with_comments.in.rcss

@@ -0,0 +1,9 @@
+/* comment here! */
+body.home { margin: 10px auto; width: 700px; } {{
+  /* and here! */
+  h1 { font-family: Arial, sans-serif; } 
+}}
+/* anohter one here */
+p { line-height: 1; } {{
+  a { color: orange; }
+}}

data/test/data/with_comments.out.css

@@ -0,0 +1,4 @@
+body.home { margin: 10px auto; width: 700px; }
+ body.home h1 { font-family: Arial, sans-serif; }
+p { line-height: 1; }
+ p a { color: orange; }

data/test/units.dcss

@@ -0,0 +1,185 @@
+/* ----------------------------------------------
+  should leave normal css alone */
+
+#someselector { someproperty: somevalue; }
+
+/* -- expected: */
+
+#someselector { someproperty: somevalue; }
+
+/* ----------------------------------------------
+  should leave normal multi-line css alone */
+
+#someselector,
+#anotherselector { 
+  someproperty: somevalue; 
+}
+
+/* -- expected: */
+
+#someselector,
+#anotherselector { 
+  someproperty: somevalue; 
+}
+
+/* ----------------------------------------------
+  should render erb */
+
+#someselector { someproperty: <%= "somevalue" %>; }
+
+/* -- expected: */
+
+#someselector { someproperty: somevalue; }
+
+/* ----------------------------------------------
+  should render erb */
+
+#someselector { someproperty: <%= "somevalue" %>; }
+
+/* -- expected: */
+
+#someselector { someproperty: somevalue; }
+
+/* ----------------------------------------------
+  should not screw up when one constant contains the name of another */
+
+@server constants { gray: #ccc; lightgray: #eee;}
+#someselector { color: gray; background: lightgray; }
+
+/* -- expected: */
+
+#someselector { color: #ccc; background: #eee; }
+
+/* ----------------------------------------------
+  should convert constants */
+
+@server constants { gray: #ccc; }
+#someselector { color: gray; }
+
+/* -- expected: */
+
+#someselector { color: #ccc; }
+
+/* ----------------------------------------------
+  should handle single level nesting */
+
+#someselector { color: red; } {{ 
+  #anotherselector { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector { color: red; }
+ #someselector #anotherselector { color: blue; }
+
+/* ----------------------------------------------
+  should do the right thing with commas on the parent selector */
+
+#someselector, #select2 { color: red; } {{ 
+ #anotherselector { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector, #select2 { color: red; }
+ #someselector #anotherselector, #select2 #anotherselector { color: blue; }
+
+/* ----------------------------------------------
+  should do the right thing with commas on the child selector */
+
+#someselector { color: red; } {{ 
+ #anotherselector, #select2 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector { color: red; }
+ #someselector #anotherselector, #someselector #select2 { color: blue; }
+
+/* ----------------------------------------------
+  commas everywhere! */
+
+#someselector, #select2 { color: red; } {{ 
+ #anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector, #select2 { color: red; }
+ #someselector #anotherselector, #someselector #select3, #select2 #anotherselector, #select2 #select3 { color: blue; }
+
+/* ----------------------------------------------
+  should do the right thing with empty parent selectors (right thing may change) */
+
+#someselector {} {{
+#anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector {}
+ #someselector #anotherselector, #someselector #select3 { color: blue; }
+
+/* ----------------------------------------------
+  should allow parent selectors without properties (i.e. they are used to specify scope only) */
+
+#someselector {{ 
+ #anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector #anotherselector, #someselector #select3 { color: blue; }
+
+/* ----------------------------------------------
+  should allow comma separated parent selectors without properties */
+
+#someselector, #select2 {{ 
+ #anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector #anotherselector, #someselector #select3, #select2 #anotherselector, #select2 #select3 { color: blue; }
+
+/* ----------------------------------------------
+  should strip comments outside of property lists only */
+
+/* some comment */
+#someselector {{ /* some comment */
+ #anotherselector, #select3 { color: blue; /* some comment */ }
+/* some comment */}}
+
+/* -- expected: */
+
+#someselector #anotherselector, #someselector #select3 { color: blue; /* some comment */ }
+
+/* ----------------------------------------------
+  should strip multiline comments */
+
+/* multiline
+ comment */
+#someselector {{
+ #anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+#someselector #anotherselector, #someselector #select3 { color: blue; }
+
+/* ----------------------------------------------
+  should not be greedy when stripping multiline comments */
+
+/* multiline
+ comment */
+a { color: yellow; }
+/* another 
+comment */
+#someselector {{
+ #anotherselector, #select3 { color: blue; }
+}}
+
+/* -- expected: */
+
+a { color: yellow; }
+#someselector #anotherselector, #someselector #select3 { color: blue; }

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: dcss
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-12-12 00:00:00 +11:00
+summary: DCSS - CSS extensions that make writing stylesheets less verbose
+require_paths: 
+- lib
+email: myles@ducknewmedia.com.au, bragi.ragnarson@gmail.com
+homepage: http://myles.id.au/more/#DCSS
+rubyforge_project: dcss
+description: 
+autorequire: dcss
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Myles Byrne, Bragi Ragnarson
+files: 
+- README
+- CHANGES
+- TODO
+- MIT-LICENSE
+- Rakefile
+- lib/dcss.rb
+- lib/lexer.rb
+- lib/rcss.original.rb
+- bin/dcss
+- bin/test
+- test/data
+- test/units.dcss
+- test/data/complex_descendants.in.rcss
+- test/data/complex_descendants.out.css
+- test/data/with_comments.in.rcss
+- test/data/with_comments.out.css
+test_files: []
+
+rdoc_options: 
+- --title
+- DCSS - CSS extensions that make writing stylesheets less verbose
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+- TODO
+- CHANGES
+executables: 
+- dcss
+extensions: []
+
+requirements: []
+
+dependencies: []
+