ionfish-stylish 0.1.0 → 0.1.2

data/README.md

@@ -9,17 +9,17 @@ Creating stylesheets
 --------------------
 
     style = Stylish.generate do
-      rule ".header", background(:color => :teal, :image => "header.png")
+      rule ".header", :background => {:color => "teal", :image => "header.png"}
       rule ".content" do
-        rule "h2", font_size("2em")
-        rule "p", margin("0 0 1em 0")
+        h2 :font_size => "2em"
+        p :margin => "0 0 1em 0"
       end
     end
 
 Calling the stylesheet's `to_s` method would produce the following
 <abbr title="Cascading Stylesheets">CSS</abbr> code.
 
-    .header {background-color:#008080; background-image:url('header.png');}
+    .header {background-color:teal; background-image:url('header.png');}
     .content h2 {font-size:2em;}
     .content p {margin:0 0 1em 0;}
 
@@ -34,15 +34,15 @@ test suite passes under Ruby 1.9; the usual caveats about this apply.
 Future considerations
 ---------------------
 
-*   The core classes and code generation DSL are only partially documented;
-    this situation could be improved.
+*   Add a Border class to complement Background.
+*   Add better support for CSS3 properties to Background.
 *   Add a native mapping construct to allow symbol lookup for alternate
     stylesheets.
 *   Change stylesheet generation to a two-step process where the tree structure
     is generated in the first step and symbols (for example, those employed by
     a mapping construct) are evaluated the second.
-*   Fundamental objects like percentages and URIs need their own classes rather
-    than being dealt with in an ad-hoc manner by higher-level objects.
+*   Fundamental objects like percentages need their own classes rather than
+    being dealt with in an ad-hoc manner by higher-level objects.
 *   Add a parser so CSS can be read as well as written.
 
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:major: 0
-:patch: 0
 :minor: 1
+:patch: 2
+:major: 0

data/lib/stylish/core.rb

@@ -18,14 +18,49 @@ module Stylish
                    :col, :tbody, :thead, :tfoot, :tr, :td, :th, :form,
                    :fieldset, :label, :input, :button, :select, :datalist,
                    :optgroup, :option, :textarea, :output, :details, :datagrid,
-                   :command, :bb, :menu, :legend, :div]
+                   :command, :bb, :menu, :legend, :div, :h1, :h2, :h3, :h4,
+                   :h5, :h6]
   
+  # Rule objects represent CSS rules, and serialise to them. They possess one
+  # or more selectors, and zero or more declarations. In addition to their
+  # importance as the major building-blocks of stylesheets, they act as the
+  # leaves of Stylish's stylesheet trees.
+  #
+  # Their serialisation is controllable to some extent by altering their
+  # format attribute; this should never make them lose information when they
+  # are serialised.
+  #
+  # E.g., by changing its format to "%s {\n  %s\n}" a rule that would
+  # normally be serialised thus:
+  #
+  #     body {font-size:81%;}
+  #
+  # Would instead be serialised like this:
+  #
+  #     body {
+  #       font-size:81%;
+  #     }
+  #
   class Rule
     include Formattable, Tree::Leaf
     
     attr_reader :selectors, :declarations
     
-    def initialize(selectors, *declarations)
+    # Every Rule must have at least one selector, but may have any number of
+    # declarations. Empty rules are often used in stylesheets to indicate
+    # particular combinations of selectors which may be used to produce
+    # particular effects.
+    #
+    # In Stylish, of course, a Rule's declarations may be amended after its
+    # creation:
+    #
+    #     rule = Stylish::Rule.new([Stylish::Selector.new("body")])
+    #     rule.declarations << Stylish::Declaration.new("font-weight", "bold")
+    #     rule.to_s # => "body {font-weight:bold;}"
+    #
+    # This makes Rule objects a very flexible foundation for the higher-level
+    # data structures and APIs in Stylish.
+    def initialize(selectors, declarations)
       accept_format(/^\s*%s\s*\{\s*%s\s*\}\s*$/m, "%s {%s}")
       
       @selectors = selectors.inject(Selectors.new) do |ss, s|
@@ -39,17 +74,62 @@ module Stylish
     
     # Serialise the rule to valid CSS code.
     def to_s(scope = "")
-      selectors = @selectors.map do |selector|
-        (scope.empty? ? "" : scope + " ") + selector.to_s
-      end
-      
-      sprintf(@format, selectors.join, @declarations.join)
+      sprintf(@format, selectors.join(scope), @declarations.join)
     end
   end
   
+  # Comment objects form the other concrete leaves of selector trees, and allow
+  # stylesheets to be annotated at any point (outside Rules). Their
+  # serialisation format follows the well-known JavaDoc and PHPDoc style, with
+  # a header, several lines of notes, and key-value information.
+  #
+  # This format is not amendable; those desirous of their own formatting would
+  # be better served by creating their own Comment class, such as the following
+  # more basic one:
+  #
+  #     module Stylish
+  #       module Extensions
+  #         
+  #         class Comment
+  #           include Tree::Leaf
+  #           
+  #           attr_accessor :content
+  #           
+  #           def initialize(content)
+  #             @content = content
+  #           end
+  #           
+  #           def to_s(scope = "")
+  #             "/* " + content.to_s + " */"
+  #           end
+  #         end
+  #         
+  #       end
+  #     end
+  #
   class Comment
+    include Tree::Leaf
+    
     attr_reader :header, :lines, :metadata
     
+    # Each Comment can have a header, additional lines of text content (each
+    # provided as its own argument), and key-value metadata passed in as a Ruby
+    # Hash object.
+    #
+    #     comment = Comment.new("My wonderful comment",
+    #                 "It has several lines of insightful notes,",
+    #                 "filled with wisdom and the knowledge of ages.",
+    #                 {:author => "Some Egotist"})
+    #
+    #     comment.to_s # => /**
+    #                  #     * My wonderful comment
+    #                  #     *
+    #                  #     * It has several lines of insightful notes,
+    #                  #     * filled with wisdom and the knowledge of ages.
+    #                  #     *
+    #                  #     * @author Some Egotist
+    #                  #     */
+    #
     def initialize(*args)
       @lines, @metadata = [], {}
       
@@ -61,83 +141,129 @@ module Stylish
             @header = arg
           end
         elsif arg.is_a? Hash
-          @metadata.merge!(arg)
+          @metadata.merge! arg
         end
       end
-      
-      def to_s
-        if @lines.empty? && @metadata.empty?
-          sprintf("/**\n * %s\n */", @header)
-        else
-          header = sprintf(" * %s", @header) unless @header.nil?
-          lines = @lines.map {|l| ' * ' + l }.join("\n") unless @lines.empty?
-          metadata = @metadata.to_a.map {|name, value|
-            sprintf(" * @%s %s", name.to_s, value.to_s)
-          }.join("\n") unless @metadata.empty?
-          
-          sprintf("/**\n%s\n */", [
-            header || nil,
-            lines || nil,
-            metadata || nil
-          ].compact.join("\n *\n"))
-        end
+    end
+    
+    # As Comment objects are the leaves of selector trees, they must implement
+    # the serialisation API of those trees, and thus the #to_s method has a
+    # scope argument, which is in practice discarded when the serialisation of
+    # the comment occurs.
+    def to_s(scope = "")
+      if @lines.empty? && @metadata.empty?
+        sprintf("/**\n * %s\n */", @header)
+      else
+        header = sprintf(" * %s", @header) unless @header.nil?
+        lines = @lines.map {|l| ' * ' + l }.join("\n") unless @lines.empty?
+        metadata = @metadata.to_a.map {|name, value|
+          sprintf(" * @%s %s", name.to_s, value.to_s)
+        }.join("\n") unless @metadata.empty?
+        
+        sprintf("/**\n%s\n */", [
+          header || nil,
+          lines || nil,
+          metadata || nil
+        ].compact.join("\n *\n"))
       end
     end
   end
   
+  # Selector objects are just string containers, which when serialised are
+  # passed the scope in which they are situated. The Selector class is one of
+  # Stylish's most basic units, and are generally used only by internal APIs
+  # when constructing Rule objects, rather than by end users (although nothing
+  # prevents this; it is merely inconvenient to do so).
   class Selector
     
+    # Selectors are immutable once created; the value of a given Selector must
+    # be set when the object is created.
     def initialize(str)
       @selector = str.to_s
     end
     
-    def to_s
-      @selector
+    # Each Rule possesses one or more Selectors. Rules are often placed in
+    # selector trees, and thus when serialised a Selector must be made aware
+    # of the context or scope in which it is being serialised.
+    #
+    #     Selector.new("p").to_s("body") # => "body p"
+    #
+    # The Selector class is also used internally by the Tree::SelectorScope
+    # class, to store its scope value.
+    def to_s(scope = "")
+      (scope.empty? ? "" : scope + " ") + @selector.to_s
     end
   end
   
+  # Selectors objects are simply used to group Selector objects for more
+  # convenient storage and serialisation.
   class Selectors < Array
     include Formattable
     
+    # Since a group of Selectors is just a specialised kind of array, all that
+    # is done in its initialiser, regardless of arguments, is to set the
+    # default serialisation format.
     def initialize(*args)
       accept_format(/^\s*,\s*$/m, ", ")
       super
     end
     
-    def join
-      super(@format)
+    # The join method overrides the superclass' method in order to always use a
+    # specific separator, and so that the scope that the selectors are being
+    # used in can be passed through when Rules etc. are serialised.
+    def join(scope = "")
+      self.inject("") do |ss, s|
+        (ss.empty? ? "" : ss + self.format) + s.to_s(scope)
+      end
     end
     
-    def to_s
-      self.join
+    # The to_s method alternative way of calling the join method.
+    def to_s(scope = "")
+      self.join(scope)
     end
   end
   
+  # Each Rule may have one or more Declaration objects, and usually has more
+  # than one. In a sense, declarations are the business end of stylesheets:
+  # they are where the set of elements specified by a rule's selectors are
+  # given their various attributes.
   class Declaration
     include Formattable
     
     attr_accessor :value
-        
-    def initialize(prop, val = nil)
+    
+    # Each Declaration has a property name and a value.
+    def initialize(name, value)
       accept_format(/^\s*%s\s*:\s*%s;\s*$/m, "%s:%s;")
-      self.value = val
-      self.property = prop
+      self.value = value
+      self.name  = name
     end
     
-    def property
-      @property
+    # The property name of the Declaration.
+    def name
+      @property_name
     end
     
-    def property=(prop)
-      @property = prop.to_s
+    # Property names are CSS identifiers.
+    def name=(name)
+      @property_name = name.to_s
     end
     
-    def value=(val)
-      @value = val
+    # The value of the Declaration's property.
+    def value=(value)
+      @value = value
     end
     
+    # Serialising a declaration produces a name-value pair separated by a colon
+    # and terminating with a semicolon, for instance
+    #
+    #     declaration = Declaration.new("font-style", "italic")
+    #     declaration.to_s # => "font-style:italic;"
+    #
+    # Since the formatting can be adjusted via the #format= accessor, the exact
+    # spacing of the declaration can be controlled if desired.
     def to_s
-      sprintf(@format, @property, @value)
+      sprintf(@format, @property_name.to_s, @value.to_s)
     end
   end
   
@@ -171,6 +297,24 @@ module Stylish
     end
   end
   
+  # The Background class is a specialised kind of Declaration, geared towards
+  # dealing with the oddities of the background family of declarations, which
+  # can exist in both long- and shorthand forms.
+  #
+  # For example, these longhand background declarations
+  #
+  #     background-color:  #999;
+  #     background-image:  url('bg.png');
+  #     background-repeat: repeat-x;
+  #
+  # could be compressed into a single shorthand declaration
+  #
+  #     background: #999 url('bg.png') repeat-x;
+  #
+  # The Background class allows for easy conversion between these forms. It
+  # defaults to the longhand versions, allowing rules with stronger selector
+  # weighting to only override specific parts of other rules' background
+  # declarations.
   class Background < Declaration
     attr_reader :color,
                 :image,
@@ -192,7 +336,7 @@ module Stylish
     HORIZONTAL_POSITIONS = ["left", "center", "right"]
     VERTICAL_POSITIONS   = ["top", "center", "bottom"]
     
-    # Create a new Background object
+    # Create a new Background object with the specified properties.
     def initialize(options)
       accept_format(/^\s*%s\s*:\s*%s;\s*$/m, "%s:%s;")
       self.value = options
@@ -206,7 +350,7 @@ module Stylish
     
     # Set the background image.
     def image=(path)
-      @image = path if path.is_a?(String) || path.is_a?(File)
+      @image = Image.new(path) if path.is_a?(String)
     end
     
     # Set the background repeat.
@@ -228,11 +372,11 @@ module Stylish
       @attachment = val if ATTACHMENT_VALUES.include?(val)
     end
     
-    # Set this to true to generate a compressed declaration, e.g.
+    # Set this to true to generate a shorthand declaration, e.g.
     #
     #     background:#ccc url('bg.png') no-repeat 0 0;
     #
-    # As opposed to the uncompressed version:
+    # As opposed to the longhand version:
     #
     #     background-color:#ccc; background-image:url('bg.png');
     #     background-repeat:no-repeat; background-position:0 0;
@@ -241,19 +385,19 @@ module Stylish
       @compressed = val == true || nil
     end
     
-    # Override Declaration#property, since it's not compatible with the
+    # Override Declaration#name, since it's not compatible with the
     # internals of this class.
-    def property
+    def name
       PROPERTIES.reject {|n, p| p.nil? }.map {|n, p|
         value = self.send(n)
         p.to_s unless value.nil?
       }.compact
     end
     
-    # Override Declaration#property=, since it's not compatible with the
+    # Override Declaration#name=, since it's not compatible with the
     # internals of this class.
-    def property=(val)
-      raise NoMethodError, "property= is not defined for Background."
+    def name=(val)
+      raise NoMethodError, "name= is not defined for Background."
     end
     
     # Override Declaration#value, since it's not compatible with the internals

data/lib/stylish/generate.rb

@@ -1,13 +1,88 @@
 module Stylish
   
+  # The generate method is the starting point for the stylesheet generation
+  # DSL. The method should be passed a block, and the various DSL methods then
+  # called within that context, e.g. as follows:
+  #
+  #     style = Stylish.generate do
+  #       body :margin => "1em"
+  #       rule ".error" do
+  #         p :color => "#f00"
+  #         em :font_weight => "bold"
+  #       end
+  #     end
+  #
+  # When serialised, the generated stylesheet would look like this:
+  #
+  #     body {margin:1em;}
+  #     .error p {color:#f00;}
+  #     .error em {font-weight:bold;}
+  #
+  # Further examples can be found in the example/ directory and in the
+  # +GenerateTest+ class.
+  #
+  # * example/tarski.rb
+  # * test/generate_test.rb
+  #
+  # The options argument is currently unused.
   def self.generate(options = {}, &block)
     dsl = Generate::Description.new
     dsl.instance_eval(&block)
     dsl.node
   end
   
+  # The +Generate+ module is a general namespace for the stylesheet generation
+  # DSL components. It contains various modules and classes which together are
+  # used to generate the intermediate data-structures of selector trees, and
+  # ultimately CSS code.
   module Generate
     
+    # The +parse_declarations+ method deals with three things: turning the
+    # hashes passed to the +Description#rule+ method into +Declarations+
+    # objects; renaming property names to use dashes rather than underscores
+    # (since the former are correct CSS but are invalid Ruby, at least when
+    # quotation marks are not used to delimit the symbol); and handling special
+    # cases.
+    #
+    # There are currently two main special cases: colours and backgrounds. Each
+    # of these property types have their own +Stylish+ classes, and thus to
+    # create a rich datastructure which takes advantage of these powerful
+    # classes the declarations passed to the stylesheet generation DSL need to
+    # be parsed with this in mind.
+    def self.parse_declarations(declarations)
+      declarations.to_a.inject(Declarations.new) do |ds, declaration|
+        key, value = declaration
+        key        = key.to_s.sub("_", "-").to_sym
+        
+        if key == :background
+          declaration = Background.new(value)
+        elsif key == :color
+          declaration = Declaration.new("color", Color.new(value))
+        else
+          declaration = Declaration.new(key, value)
+        end
+        
+        ds << declaration
+      end
+    end
+    
+    # Often the selector associated with a call to the rule method would simply
+    # be a single HTML element name. This has been factored out by adding
+    # methods to the Description DSL class corresponding to all the HTML
+    # elements. Consider the following (contrived) example.
+    #
+    #     Stylish.generate do
+    #       body do
+    #         div do
+    #           a :font_weight => bold
+    #         end
+    #       end
+    #     end
+    #
+    # Which would then serialise to the following:
+    #
+    #     body div a {font-weight:bold;}
+    #
     module ElementMethods
       HTML_ELEMENTS.each do |element|
         next if self.respond_to?(element)
@@ -20,40 +95,98 @@ module Stylish
       end
     end
     
+    # Description objects are the core of the stylesheet generation DSL. Blocks
+    # passed into the +Stylish#generate_ method are executed in the context of
+    # a +Description+ object. All the DSL methods, +rule+, +comment+, and all
+    # the HTML element methods are all methods on instances of the
+    # +Description+ class.
     class Description
       include ElementMethods
       
-      attr_accessor :node
+      attr_reader :node
       
+      # +Description+ instances are associated with a particular node in a
+      # selector tree; if no node is assigned to them on creation, they
+      # associate with a new root, i.e. a +Stylesheet+ object.
       def initialize(context = nil)
         @node = context || Stylesheet.new
       end
       
+      # The +rule+ method is the most general and powerful part of the DSL. It
+      # can be used to add a single +Rule+, with attendant declarations, or to
+      # create a selector namespace within which further rules or namespaces
+      # can be added.
+      #
+      # The nested structure created is precisely that of a selector tree; the
+      # rule method adds +Rule+ leaves and +SelectorScope+ nodes to the tree,
+      # whose root is a +Stylesheet+ object.
+      #
+      # Either a set of declarations or a block must be passed to the method;
+      # failing to do so will result in an early return which creates no
+      # additional objects. The following example demonstrates the various ways
+      # in which the method can be used:
+      #
+      #     Stylish.generate do
+      #       rule ".section", :margin_bottom => "10px"
+      #
+      #       rule "form" do
+      #         rule ".notice", :color => "#00f"
+      #         rule "input[type=submit]", :font_weight => "normal"
+      #       end
+      #
+      #       rule "body", :padding => "0.5em" do
+      #         rule "div", :margin => "2px"
+      #       end
+      #     end
+      #
+      # This would produce a stylesheet with the following rules:
+      #
+      #     .section {margin-bottom:10px;}
+      #
+      #     form .notice {color:#00f;}
+      #     form input[type=submit] {font-weight:normal;}
+      #
+      #     body {padding:0.5em;}
+      #     body div {margin:2px;}
+      #
+      # Usefully, a call to #rule which passes in both declarations and a block
+      # will produce a single +Rule+ with the declarations attached, then
+      # create a new +SelectorScope+ node with the same selectors and execute
+      # the block in that context.
+      #
+      # If several selectors and a block are passed to +rule+, new
+      # +SelectorScope+ nodes will be created for each selector and the block
+      # will be executed in all the contexts created, not just one.
       def rule(selectors, declarations = nil, &block)
         return unless declarations || block
         
         selectors = [selectors] unless selectors.is_a?(Array)
         selectors.map! {|s| Selector.new(s) }
         
-        declarations = declarations.to_a.map do |p, v|
-          Declaration.new(p.to_s.sub("_", "-"), v)
-        end
+        declarations = Generate.parse_declarations(declarations)
         
         unless block
           @node << Rule.new(selectors, declarations)
         else
           selectors.each do |selector|
             unless declarations.empty?
-              @node << Rule.new(selector, declarations)
+              @node << Rule.new([selector], declarations)
             end
             
-            new_node = Tree::SelectorScope.new(selector.to_s)
+            new_node = Tree::SelectorScope.new(selector)
             @node << new_node
             
             self.class.new(new_node).instance_eval(&block)
           end
         end
       end
+      
+      # Adds a +Comment+ object to the current node. This method simply hands
+      # its arguments off to the +Comment+ initialiser, and hence implements
+      # its API precisely.
+      def comment(*args)
+        @node << Comment.new(*args)
+      end
     end
     
   end

data/lib/stylish/image.rb

@@ -0,0 +1,32 @@
+module Stylish
+  
+  # Instances of the Image class are used to represent paths to images,
+  # generally background images.
+  class Image
+    include Formattable
+    
+    attr_accessor :path
+    
+    # Image instances are serialised to URI values. The path to the image file
+    # can be surrounded by either single quotes, double quotes or neither;
+    # single quotes are the default in Stylish.
+    def initialize(path)
+      accept_format(/^url\(\s*('|")?%s\1\s*\)$/, "url('%s')")
+      @path = path
+    end
+    
+    # Serialising Image objects to a string produces the URI values seen in
+    # background-image declarations, e.g.
+    #
+    #     image = Image.new("test.png")
+    #     image.to_s # => "url('test.png')"
+    #
+    #     background = Stylish::Background.new(:image => "test.png")
+    #     background.to_s # => "background-image:url('test.png');"
+    #
+    def to_s
+      sprintf(@format, path.to_s)
+    end
+  end
+  
+end

data/lib/stylish/tree.rb

@@ -1,11 +1,5 @@
 module Stylish
   
-  def self.generate(options = {}, &block)
-    dsl = Tree::Description.new
-    dsl.instance_eval(&block)
-    dsl.node
-  end
-  
   # The objects defined in the Tree module allow for the creation of nested
   # trees of selector scopes. These intermediate data structures can be used to
   # help factor out some of the repetitiveness of CSS code, and can be easily
@@ -51,7 +45,7 @@ module Stylish
       def initialize(selector)
         accept_format(/\s*/m, "\n")
         
-        @scope = selector
+        @scope = Selector.new(selector)
         @nodes = []
       end
             
@@ -92,7 +86,7 @@ module Stylish
       # Recursively serialise the selector tree.
       def to_s(scope = "")
         return "" if @nodes.empty?
-        scope = scope.empty? ? @scope : scope + " " + @scope
+        scope = scope.empty? ? @scope.to_s : scope + " " + @scope.to_s
         @nodes.map {|node| node.to_s(scope) }.join(@format)
       end
       
@@ -106,17 +100,22 @@ module Stylish
         leaves(Rule)
       end
       
+      # Recursively return all the comments in the selector tree.
+      def comments
+        leaves(Comment)
+      end
+      
       # Recursively return all the leaves of any, or a given type in a selector
       # tree.
       def leaves(type = nil)
-        @nodes.inject([]) do |rules, node|
+        @nodes.inject([]) do |leaves, node|
           if node.leaf?
-            rules << node if type.nil? || node.is_a?(type)
-          elsif node.is_a?(SelectorScope)
-            rules.concat(node.rules)
+            leaves << node if type.nil? || node.is_a?(type)
+          else
+            leaves.concat(node.leaves(type))
           end
           
-          rules
+          leaves
         end
       end
     end

data/lib/stylish.rb

@@ -6,5 +6,6 @@ require 'stylish/formattable'
 require 'stylish/tree'
 require 'stylish/core'
 require 'stylish/stylesheet'
+require 'stylish/image'
 require 'stylish/color'
 require 'stylish/generate'

data/test/background_test.rb

@@ -11,19 +11,17 @@ class BackgroundTest < Test::Unit::TestCase
   
   def test_valid_background_colors
     assert_equal("#ccc", @composite.color.to_hex)
-    assert_equal("black", Stylish::Background.new(:color => :black).color.to_s)
+    assert_equal("black", Stylish::Background.new(:color => "black").color.to_s)
   end
   
   def test_background_transparencies
-    assert_equal([0, 0, 0, 0], Stylish::Background.new(:color => :transparent).color.value)
+    assert_equal([0, 0, 0, 0], Stylish::Background.new(:color => "transparent").color.value)
   end
   
   def test_valid_background_images
-    assert_equal("images/test.png", @composite.image)
-    assert_equal("background.jpg", Stylish::Background.new(:image => "background.jpg").image)
-    File.open(__FILE__) do |file|
-      assert_not_nil(Stylish::Background.new(:image => file))
-    end
+    assert_equal("images/test.png", @composite.image.path)
+    assert_equal("background.jpg",
+      Stylish::Background.new(:image => "background.jpg").image.path)
   end
   
   def test_valid_background_repeats
@@ -42,12 +40,13 @@ class BackgroundTest < Test::Unit::TestCase
   
   def test_valid_background_attachments
     assert_equal("scroll", @composite.attachment)
-    assert_equal("fixed", Stylish::Background.new(:attachment => "fixed").attachment)
+    assert_equal("fixed",
+      Stylish::Background.new(:attachment => "fixed").attachment)
   end
   
   def test_invalid_background_colors
     assert_raise ArgumentError do
-      Stylish::Background.new(:color => 'sky-blue')
+      Stylish::Background.new(:color => "sky-blue")
     end
   end
   
@@ -78,36 +77,44 @@ class BackgroundTest < Test::Unit::TestCase
   
   def test_declaration_property
     assert_equal(["background-color", "background-repeat"],
-      Stylish::Background.new(:color => "red", :repeat => "no-repeat").property)
+      Stylish::Background.new(:color => "red", :repeat => "no-repeat").name)
   end
   
   def test_declaration_property_assignment
-    background = Stylish::Background.new(:color => "red", :repeat => "no-repeat")
+    background = Stylish::Background.new(:color => "red",
+      :repeat => "no-repeat")
     
     assert_raise(NoMethodError) do
-      background.property = "display"
+      background.name = "display"
     end
   end
   
   def test_declaration_value
-    background = Stylish::Background.new(:color => "red", :repeat => "no-repeat")
+    background = Stylish::Background.new(:color => "red",
+      :repeat => "no-repeat")
     
     assert_equal("no-repeat", background.value[1])
     assert_equal("red", background.value[0].to_s)
   end
   
   def test_declaration_value_assignment
-    background = Stylish::Background.new(:color => "red", :repeat => "no-repeat")
+    background = Stylish::Background.new(:color => "red")
     background.value = {:image => "mondrian.jpg"}
     
-    assert_equal("mondrian.jpg", background.image)
+    assert_equal("mondrian.jpg", background.image.path)
   end
   
   def test_declaration_value_assignment_errors
-    background = Stylish::Background.new(:color => "red", :repeat => "no-repeat")
+    background = Stylish::Background.new(:color => "red")
     
     assert_raise ArgumentError do
       background.value = "mondrian.jpg"
     end
   end
+  
+  def test_image_declaration_serialisation
+    background = Stylish::Background.new(:image => "test.png")
+    
+    assert_equal("background-image:url('test.png');", background.to_s)
+  end
 end

data/test/declaration_test.rb

@@ -2,16 +2,20 @@ require 'test/unit'
 require './lib/stylish'
 
 class DeclarationTest < Test::Unit::TestCase
-    
-  def test_empty_value
-    hollow = Stylish::Declaration.new("cursor")
-    
-    assert_not_nil(hollow.property)
-    assert_nil(hollow.value)
+  
+  def setup
+    @declaration = Stylish::Declaration.new("color", Stylish::Color.new("000"))
+  end
+  
+  def test_naming
+    assert_equal("color", @declaration.name)
+  end
+  
+  def test_value
+    assert_equal("#000", @declaration.value.to_s)
   end
   
   def test_to_string
-    dec = Stylish::Declaration.new("color", "#000")
-    assert_equal("color:#000;", dec.to_s)
+    assert_equal("color:#000;", @declaration.to_s)
   end
 end

data/test/declarations_test.rb

@@ -10,10 +10,12 @@ class DeclarationsTest < Test::Unit::TestCase
   end
   
   def test_join
-    assert_equal("border-color:red; background-color:blue; background-image:test.png;", @ds.join)
+    assert_equal("border-color:red; background-color:blue; " +
+                 "background-image:url('test.png');", @ds.join)
   end
   
   def test_to_string
-    assert_equal("border-color:red; background-color:blue; background-image:test.png;", @ds.to_s)
+    assert_equal("border-color:red; background-color:blue; " +
+                 "background-image:url('test.png');", @ds.to_s)
   end
 end

data/test/generate_test.rb

@@ -13,6 +13,15 @@ class GenerateTest < Test::Unit::TestCase
       ".unchecked {font-style:italic;}", style.to_s)
   end
   
+  def test_compound_rules
+    style = Stylish.generate do
+      rule ["abbr", "acronym"], :margin_bottom => "2em"
+    end
+    
+    assert_equal(1, style.rules.length)
+    assert_equal("abbr, acronym {margin-bottom:2em;}", style.rules.first.to_s)
+  end
+  
   def test_nested_rules
     style = Stylish.generate do
       rule "body" do
@@ -51,4 +60,24 @@ class GenerateTest < Test::Unit::TestCase
     
     assert_equal("body div p {line-height:1.5;}", style.to_s)
   end
+  
+  def test_nested_declarations
+    style = Stylish.generate do
+      fieldset :background => {:color => [0, 0, 255], :image => "fieldset.png"}
+    end
+    
+    assert_instance_of(Stylish::Background,
+      style.rules.first.declarations.first)
+  end
+  
+  def test_comments
+    style = Stylish.generate do
+      comment "A glorious comment!"
+      comment "An inglorious comment.", "An additional note."
+    end
+    
+    assert_equal(2, style.comments.length)
+    assert_equal("A glorious comment!", style.comments[0].header)
+    assert_equal("An additional note.", style.comments[1].lines[0])
+  end
 end

data/test/image_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require './lib/stylish'
+
+class ImageTest < Test::Unit::TestCase
+  
+  def setup
+    @image = Stylish::Image.new("test.png")
+  end
+  
+  def test_image_path
+    assert_equal("test.png", @image.path)
+  end
+  
+  def test_image_serialisation
+    assert_equal("url('test.png')", @image.to_s)
+  end
+end

data/test/rule_test.rb

@@ -6,8 +6,8 @@ class RuleTest < Test::Unit::TestCase
   def setup
     @rule = Stylish::Rule.new([
       Stylish::Selector.new("div .alert, body .error")],
-      Stylish::Declaration.new("font-style", "italic"),
-      Stylish::Declaration.new("font-weight", "bold"))
+      [Stylish::Declaration.new("font-style", "italic"),
+      Stylish::Declaration.new("font-weight", "bold")])
   end
   
   def test_rule_serialisation

data/test/stylesheet_test.rb

@@ -8,7 +8,7 @@ class StylesheetTest < Test::Unit::TestCase
     @node  = Stylish::Tree::SelectorScope.new("div")
     @onde  = Stylish::Tree::SelectorScope.new("span")
     @rule  = Stylish::Rule.new([Stylish::Selector.new("em")],
-               Stylish::Declaration.new("font-weight", "bold"))
+               [Stylish::Declaration.new("font-weight", "bold")])
   end
   
   def test_node_addition

data/test/tree_test.rb

@@ -4,10 +4,12 @@ require './lib/stylish'
 class TreeTest < Test::Unit::TestCase
   
   def setup
-    @tree = Stylish::Stylesheet.new
-    @node = Stylish::Tree::SelectorScope.new(".test")
-    @rule = Stylish::Rule.new([Stylish::Selector.new("p")],
-      Stylish::Declaration.new("font-weight", "bold"))
+    @tree    = Stylish::Stylesheet.new
+    @node    = Stylish::Tree::SelectorScope.new(".test")
+    @rule    = Stylish::Rule.new([Stylish::Selector.new("p")],
+                 [Stylish::Declaration.new("font-weight", "bold")])
+    @comment = Stylish::Comment.new("Comment header",
+                 {:author => "Some Body"})
   end
   
   def test_appending
@@ -28,11 +30,13 @@ class TreeTest < Test::Unit::TestCase
   def test_rules_collation
     @node << @rule
     @node << @rule
+    @node << @comment
     @tree << @node
     @tree << @node
     
+    assert_equal(6, @tree.leaves.length)
     assert_equal(4, @tree.rules.length)
-    assert_equal(4, @tree.leaves.length)
+    assert_equal(2, @tree.comments.length)
   end
   
   def test_node_reader

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ionfish-stylish
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Benedict Eastaugh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-11 00:00:00 -07:00
+date: 2009-04-13 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +30,7 @@ files:
 - lib/stylish/core.rb
 - lib/stylish/formattable.rb
 - lib/stylish/generate.rb
+- lib/stylish/image.rb
 - lib/stylish/stylesheet.rb
 - lib/stylish/tree.rb
 - test/background_test.rb
@@ -39,6 +40,7 @@ files:
 - test/declarations_test.rb
 - test/formattable_test.rb
 - test/generate_test.rb
+- test/image_test.rb
 - test/rule_test.rb
 - test/selector_test.rb
 - test/selectors_test.rb
@@ -78,6 +80,7 @@ test_files:
 - test/declarations_test.rb
 - test/formattable_test.rb
 - test/generate_test.rb
+- test/image_test.rb
 - test/rule_test.rb
 - test/selector_test.rb
 - test/selectors_test.rb