compass 0.10.6 → 0.11.alpha.0

data/lib/compass/configuration.rb

@@ -36,7 +36,8 @@ module Compass
       :asset_cache_buster,
       :line_comments,
       :color_output,
-      :preferred_syntax
+      :preferred_syntax,
+      :disable_warnings
     ].flatten
 
   end

data/lib/compass/configuration/adapters.rb

@@ -11,7 +11,7 @@ module Compass
         locations = []
         locations << [sass_path, css_path] if sass_path && css_path
         Compass::Frameworks::ALL.each do |framework|
-          locations << [framework.stylesheets_directory, css_path || css_dir || "."]
+          locations << [framework.stylesheets_directory, File.join(css_path || css_dir || ".", framework.name)]
         end
         resolve_additional_import_paths.each do |additional_path|
           locations << [additional_path, File.join(css_path || css_dir || ".", File.basename(additional_path))]
@@ -46,6 +46,7 @@ module Compass
         engine_opts[:line_comments] = line_comments
         engine_opts[:cache] = cache
         engine_opts[:cache_location] = cache_path
+        engine_opts[:quiet] = disable_warnings if disable_warnings
         engine_opts.merge!(sass_options || {})
       end
 

data/lib/compass/configuration/comments.rb

@@ -8,7 +8,7 @@ module Compass
       end
 
       def comment_for_relative_assets
-        unless relative_assets
+        unless top_level.relative_assets
           %q{# To enable relative paths to assets via compass helper functions. Uncomment:
 # relative_assets = true
 }
@@ -17,6 +17,39 @@ module Compass
         end
       end
 
+      def comment_for_line_comments
+        if top_level.line_comments
+          %q{# To disable debugging comments that display the original location of your selectors. Uncomment:
+# line_comments = false
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_output_style
+        unless top_level.output_style_without_default
+          %Q{# You can select your preferred output style here (can be overridden via the command line):
+# output_style = :expanded or :nested or :compact or :compressed
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_preferred_syntax
+        if top_level.preferred_syntax == :scss && top_level.sass_dir
+          %Q{
+# If you prefer the indented syntax, you might want to regenerate this
+# project again passing --syntax sass, or you can uncomment this:
+# preferred_syntax = :sass
+# and then run:
+# sass-convert -R --from scss --to sass #{top_level.sass_dir} scss && rm -rf sass && mv scss sass
+}
+        else
+          ""
+        end
+      end
     end
   end
 end

data/lib/compass/configuration/helpers.rb

@@ -54,21 +54,17 @@ module Compass
       end
 
       def configure_sass_plugin!
-        return if sass_plugin_configured?
         require 'sass/plugin'
-        @sass_plugin_configured = true
         config = sass_plugin_configuration
         locations = config.delete(:template_location)
         Sass::Plugin.options.merge!(config)
         locations.each do |sass_dir, css_dir|
-          Sass::Plugin.add_template_location sass_dir, css_dir
+          unless Sass::Plugin.engine_options[:load_paths].include?(sass_dir)
+            Sass::Plugin.add_template_location sass_dir, css_dir
+          end
         end
       end
 
-      def sass_plugin_configured?
-        @sass_plugin_configured
-      end
-
       def sass_engine_options
         configuration.to_sass_engine_options
       end

data/lib/compass/configuration/paths.rb

@@ -8,7 +8,7 @@ module Compass::Configuration::Paths
       class_eval %Q{
         def #{attr}                                # def css_dir
           path = #{attr}_with_trailing_separator   #   path = css_dir_with_trailing_separator
-          if path =~ TRAILING_SEPARATOR            #   if path =~ TRAILING_SEPARATOR
+          if path.to_s =~ TRAILING_SEPARATOR       #   if path =~ TRAILING_SEPARATOR
             path = path[0..-($1.length+1)]         #     path = path[0..-($1.length+1)]
           end                                      #   end
           path                                     #   path

data/lib/compass/exec/project_options_parser.rb

@@ -49,6 +49,10 @@ module Compass::Exec::ProjectOptionsParser
     opts.on('--relative-assets', :NONE, 'Make compass asset helpers generate relative urls to assets.') do
       self.options[:relative_assets] = true
     end
+
+    opts.on('--no-line-comments', :NONE, 'Disable line comments.') do
+      self.options[:line_comments] = false
+    end
   end
 
 end

data/lib/compass/installers/base.rb

@@ -84,7 +84,7 @@ module Compass
         to = targetize(install_location_for_stylesheet(to, options))
         contents = File.new(from).read
         if preferred_syntax.to_s != from[-4..-1]
-          logger.record :convert, basename(from)
+          # logger.record :convert, basename(from)
           tree = Sass::Engine.new(contents, Compass.sass_engine_options.merge(:syntax => from[-4..-1].intern)).to_tree
           contents = tree.send("to_#{preferred_syntax}")
           to[-4..-1] = preferred_syntax.to_s

data/lib/compass/logger.rb

@@ -16,7 +16,8 @@ module Compass
       :exists    => :green,
       :directory => :green,
       :identical => :green,
-      :convert   => :green
+      :convert   => :green,
+      :unchanged => :yellow
     }
 
 
@@ -32,8 +33,9 @@ module Compass
     def record(action, *arguments)
       msg = ""
       msg << color(ACTION_COLORS[action]) if Compass.configuration.color_output
-      msg << "#{action_padding(action)}#{action} #{arguments.join(' ')}"
+      msg << "#{action_padding(action)}#{action}"
       msg << color(:clear) if Compass.configuration.color_output
+      msg << " #{arguments.join(' ')}"
       log msg
     end
 

data/lib/compass/sass_extensions/functions.rb

@@ -2,9 +2,9 @@ module Compass::SassExtensions::Functions
 end
 
 %w(
-  selectors enumerate urls display
-  inline_image image_size gradient_support
-  font_files constants lists
+  selectors enumerate urls display if
+  inline_image image_size constants gradient_support
+  font_files lists colors trig
 ).each do |func|
   require "compass/sass_extensions/functions/#{func}"
 end
@@ -20,6 +20,9 @@ module Sass::Script::Functions
   include Compass::SassExtensions::Functions::FontFiles
   include Compass::SassExtensions::Functions::Constants
   include Compass::SassExtensions::Functions::Lists
+  include Compass::SassExtensions::Functions::Colors
+  include Compass::SassExtensions::Functions::Trig
+  include Compass::SassExtensions::Functions::If
 end
 
 # Wierd that this has to be re-included to pick up sub-modules. Ruby bug?

data/lib/compass/sass_extensions/functions/colors.rb

@@ -0,0 +1,58 @@
+module Compass::SassExtensions::Functions::Colors
+  if defined?(Sass::Util)
+    include Sass::Util
+  else
+    include Haml::Util
+  end
+
+  # a genericized version of lighten/darken so that negative values can be used.
+  def adjust_lightness(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:lightness => restrict(color.lightness + amount.value, 0..100))
+  end
+
+  # Scales a color's lightness by some percentage.
+  # If the amount is negative, the color is scaled darker, if positive, it is scaled lighter.
+  # This will never return a pure light or dark color unless the amount is 100%.
+  def scale_lightness(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:lightness => scale_color_value(color.lightness, amount.value))
+  end
+
+  # a genericized version of saturation/desaturate so that negative values can be used.
+  def adjust_saturation(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:saturation => restrict(color.saturation + amount.value, 0..100))
+  end
+
+  # Scales a color's saturation by some percentage.
+  # If the amount is negative, the color is desaturated, if positive, it is saturated.
+  # This will never return a pure saturated or desaturated color unless the amount is 100%.
+  def scale_saturation(color, amount)
+    assert_type color, :Color
+    assert_type amount, :Number
+    color.with(:saturation => scale_color_value(color.saturation, amount.value))
+  end
+
+  # returns an IE hex string for a color with an alpha channel
+  # suitable for passing to IE filters.
+  def ie_hex_str(color)
+    assert_type color, :Color
+    alpha = (color.alpha * 255).round
+    alphastr = alpha.to_s(16).rjust(2, '0')
+    Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
+  end
+
+  private
+  def scale_color_value(value, amount)
+    if amount > 0
+      value += (100 - value) * (amount / 100.0)
+    elsif amount < 0
+      value += value * amount / 100.0
+    end
+    value
+  end
+end

data/lib/compass/sass_extensions/functions/constants.rb

@@ -9,7 +9,7 @@ module Compass::SassExtensions::Functions::Constants
       when "right" then "left"
       when "center" then "center"
       else
-        raise Sass::SyntaxError, "Cannot determine the opposite of #{pos}"
+        pos
       end
     end
     Sass::Script::String.new(opposite.join(" "), position.type)

data/lib/compass/sass_extensions/functions/display.rb

@@ -2,7 +2,8 @@ module Compass::SassExtensions::Functions::Display
   DEFAULT_DISPLAY = {
     :block => %w{address blockquote center dir div dd dl dt fieldset form
                  frameset h1 h2 h3 h4 h5 h6 hr isindex menu noframes
-                 noscript ol p pre ul},
+                 noscript ol p pre ul
+                 article aside dialog figure footer header hgroup nav section},
     :inline => %w{a abbr acronym b basefont bdo big br cite code dfn em
                   font i img input kbd label q s samp select small span
                   strike strong sub sup textarea tt u var},
@@ -12,7 +13,8 @@ module Compass::SassExtensions::Functions::Display
     :"table-header-group" => %w{thead},
     :"table-footer-group" => %w{tfoot},
     :"table-row" => %w{tr},
-    :"table-cell" => %w{th td}
+    :"table-cell" => %w{th td},
+    :html5 => %w{article aside dialog figure footer header hgroup nav section}
   }
 
   # returns a comma delimited string for all the

data/lib/compass/sass_extensions/functions/gradient_support.rb

@@ -5,17 +5,32 @@ module Compass::SassExtensions::Functions::GradientSupport
     def initialize(*values)
       self.values = values
     end
+    def join_with
+      ", "
+    end
     def inspect
-      values.map{|v| v.inspect}.join(", ")
+      to_s
     end
     def to_s
-      inspect
+      values.map {|v| v.to_s }.join(join_with)
+    end
+    def size
+      values.size
+    end
+  end
+
+  class SpaceList < List
+    def join_with
+      " "
     end
   end
 
   class ColorStop < Sass::Script::Literal
     attr_accessor :color, :stop
     def initialize(color, stop = nil)
+      unless Sass::Script::Color === color || Sass::Script::Funcall === color
+        raise Sass::SyntaxError, "Expected a color. Got: #{color}"
+      end
       self.color, self.stop = color, stop
     end
     def inspect
@@ -35,9 +50,135 @@ module Compass::SassExtensions::Functions::GradientSupport
     end
   end
 
+  class RadialGradient < Sass::Script::Literal
+    attr_accessor :position_and_angle, :shape_and_size, :color_stops
+    def initialize(position_and_angle, shape_and_size, color_stops)
+      unless color_stops.values.size >= 2
+        raise Sass::SyntaxError, "At least two color stops are required for a radial-gradient"
+      end
+      self.position_and_angle = position_and_angle
+      self.shape_and_size = shape_and_size
+      self.color_stops = color_stops
+    end
+    def inspect
+      to_s
+    end
+    def to_s
+      s = "radial-gradient("
+      s << position_and_angle.to_s << ", " if position_and_angle
+      s << shape_and_size.to_s << ", " if shape_and_size
+      s << color_stops.to_s
+      s << ")"
+    end
+    def to_webkit
+      args = [
+        grad_point(position_and_angle || Sass::Script::String.new("center center")),
+        "0",
+        grad_point(position_and_angle || Sass::Script::String.new("center center")),
+        grad_end_position(color_stops, Sass::Script::Bool.new(true)),
+        grad_color_stops(color_stops)
+      ]
+      Sass::Script::String.new("-webkit-gradient(radial, #{args.join(', ')})")
+
+    end
+    def to_moz
+      Sass::Script::String.new("-moz-#{to_s}")
+    end
+    def to_svg
+      # XXX Add shape support if possible
+      radial_svg_gradient(color_stops, position_and_angle || Sass::Script::String.new("center center"))
+    end
+  end
+
+  class LinearGradient < Sass::Script::Literal
+    attr_accessor :color_stops, :position_and_angle
+    def initialize(position_and_angle, color_stops)
+      unless color_stops.values.size >= 2
+        raise Sass::SyntaxError, "At least two color stops are required for a linear-gradient"
+      end
+      self.position_and_angle = position_and_angle
+      self.color_stops = color_stops
+    end
+    def inspect
+      to_s
+    end
+    def to_s
+      s = "linear-gradient("
+      s << position_and_angle.to_s << ", " if position_and_angle
+      s << color_stops.to_s
+      s << ")"
+    end
+    def to_webkit
+      args = []
+      args << grad_point(position_and_angle || Sass::Script::String.new("top"))
+      args << grad_point(opposite_position(position_and_angle || Sass::Script::String.new("top")))
+      args << grad_color_stops(color_stops)
+      Sass::Script::String.new("-webkit-gradient(linear, #{args.join(', ')})")
+    end
+    def to_moz
+      Sass::Script::String.new("-moz-#{to_s}")
+    end
+    def to_svg
+      linear_svg_gradient(color_stops, position_and_angle || Sass::Script::String.new("top"))
+    end
+  end
+
   module Functions
+
+    def radial_gradient(position_and_angle, shape_and_size, *color_stops)
+      # Have to deal with variable length/meaning arguments.
+      if color_stop?(shape_and_size)
+        color_stops.unshift(shape_and_size)
+        shape_and_size = nil
+      elsif list_of_color_stops?(shape_and_size)
+        # Support legacy use of the color-stops() function
+        color_stops = shape_and_size.values + color_stops
+        shape_and_size = nil
+      end
+      shape_and_size = nil if shape_and_size && !shape_and_size.to_bool # nil out explictly passed falses
+      # ditto for position_and_angle
+      if color_stop?(position_and_angle)
+        color_stops.unshift(position_and_angle)
+        position_and_angle = nil
+      elsif list_of_color_stops?(position_and_angle)
+        color_stops = position_and_angle.values + color_stops
+        position_and_angle = nil
+      end
+      position_and_angle = nil if position_and_angle && !position_and_angle.to_bool
+
+      # Support legacy use of the color-stops() function
+      if color_stops.size == 1 && list_of_color_stops?(color_stops.first)
+        color_stops = color_stops.first.values
+      end
+      RadialGradient.new(position_and_angle, shape_and_size, send(:color_stops, *color_stops))
+    end
+
+    def linear_gradient(position_and_angle, *color_stops)
+      if color_stop?(position_and_angle)
+        color_stops.unshift(position_and_angle)
+        position_and_angle = nil
+      elsif list_of_color_stops?(position_and_angle)
+        color_stops = position_and_angle.values + color_stops
+        position_and_angle = nil
+      end
+      position_and_angle = nil if position_and_angle && !position_and_angle.to_bool
+
+      # Support legacy use of the color-stops() function
+      if color_stops.size == 1 && list_of_color_stops?(color_stops.first)
+        color_stops = color_stops.first.values
+      end
+      LinearGradient.new(position_and_angle, send(:color_stops, *color_stops))
+    end
+
     # returns color-stop() calls for use in webkit.
     def grad_color_stops(color_list)
+      stops = color_stops_in_percentages(color_list).map do |stop, color|
+        "color-stop(#{stop.inspect}, #{color.inspect})"
+      end
+      Sass::Script::String.new(stops.join(", "))
+    end
+
+    def color_stops_in_percentages(color_list)
       assert_list(color_list)
       normalize_stops!(color_list)
       max = color_list.values.last.stop
@@ -45,16 +186,14 @@ module Compass::SassExtensions::Functions::GradientSupport
       color_stops = color_list.values.map do |pos|
         # have to convert absolute units to percentages for use in color stop functions.
         stop = pos.stop
-        stop = stop.div(max).times(Sass::Script::Number.new(100,["%"])) if stop.numerator_units == max.numerator_units
+        stop = stop.div(max).times(Sass::Script::Number.new(100,["%"])) if stop.numerator_units == max.numerator_units && max.numerator_units != ["%"]
         # Make sure the color stops are specified in the right order.
         if last_value && last_value.value > stop.value
           raise Sass::SyntaxError.new("Color stops must be specified in increasing order")
         end
         last_value = stop
-        "color-stop(#{stop.inspect}, #{pos.color.inspect})"
+        [stop, pos.color]
       end
-      
-      Sass::Script::String.new(color_stops.join(", "))
     end
 
     # returns the end position of the gradient from the color stop
@@ -102,9 +241,11 @@ module Compass::SassExtensions::Functions::GradientSupport
       else
         case position
         when /top|bottom/
-          "left #{position}"
+          "center #{position}"
         when /left|right/
-          "#{position} top"
+          "#{position} center"
+        when /center/
+          "center center"
         else
           position
         end
@@ -120,35 +261,144 @@ module Compass::SassExtensions::Functions::GradientSupport
     def color_stops(*args)
       List.new(*args.map do |arg|
         case arg
+        when ColorStop
+          arg
         when Sass::Script::Color
           ColorStop.new(arg)
         when Sass::Script::String
           # We get a string as the result of concatenation
           # So we have to reparse the expression
-          color = stop = nil
+          parse_color_stop(arg)
+        else
+          raise Sass::SyntaxError, "Not a valid color stop: #{arg.class.name}: #{arg}"
+        end
+      end)
+    end
+
+    def linear_svg_gradient(color_stops, start)
+      x1, y1 = grad_point(start).to_s.split
+      x2, y2 = grad_point(opposite_position(start)).to_s.split
+      stops = color_stops_in_percentages(color_stops)
+
+      svg = linear_svg(stops, x1, y1, x2, y2)
+      inline_image_string(svg.gsub(/\s+/, ' '), 'image/svg+xml')
+    end
+
+    def radial_svg_gradient(color_stops, center)
+      cx, cy = grad_point(center).to_s.split
+      r = grad_end_position(color_stops,  Sass::Script::Bool.new(true))
+      stops = color_stops_in_percentages(color_stops)
+
+      svg = radial_svg(stops, cx, cy, r)
+      inline_image_string(svg.gsub(/\s+/, ' '), 'image/svg+xml')
+    end
+
+    # Returns a comma-delimited list after removing any non-true values
+    def compact(*args)
+      List.new(*args.reject{|a| !a.to_bool})
+    end
+
+    # Returns a list object from a value that was passed.
+    # This can be used to unpack a space separated list that got turned
+    # into a string by sass before it was passed to a mixin.
+    def _compass_list(arg)
+      return arg if arg.is_a?(List)
+      values = case arg
+        when Sass::Script::String
           expr = Sass::Script::Parser.parse(arg.value, 0, 0)
-          case expr
-          when Sass::Script::Color
-            color = expr
-          when Sass::Script::Funcall
-            color = expr
-          when Sass::Script::Operation
-            unless expr.instance_variable_get("@operator") == :concat
-              # This should never happen.
-              raise Sass::SyntaxError, "Couldn't parse a color stop from: #{arg.value}"
-            end
-            color = expr.instance_variable_get("@operand1")
-            stop = expr.instance_variable_get("@operand2")
+          if expr.is_a?(Sass::Script::Operation)
+            extract_list_values(expr)
+          elsif expr.is_a?(Sass::Script::Funcall)
+            expr.perform(Sass::Environment.new) #we already evaluated the args in context so no harm in using a fake env
           else
-            raise Sass::SyntaxError, "Couldn't parse a color stop from: #{arg.value}"
+            [arg]
           end
-          ColorStop.new(color, stop)
         else
-          raise Sass::SyntaxError, "Not a valid color stop: #{arg}"
+          [arg]
         end
-      end)
+
+      SpaceList.new(*values)
+    end
+
+    def _compass_list_size(list)
+      Sass::Script::Number.new(list.size)
+    end
+
+    # Get the nth value from a list
+    def _compass_nth(list, place)
+      if place.value == "last"
+        list.values.last
+      elsif place.value == "first"
+        list.values.first
+      else
+        list.values[place.value - 1]
+      end
+    end
+
+    def _compass_space_list(list)
+      if list.is_a?(List) && !list.is_a?(SpaceList)
+        SpaceList.new(*list.values)
+      elsif list.is_a?(SpaceList)
+        list
+      else
+        SpaceList.new(list)
+      end
+    end
+
+    # slice a sublist from a list
+    def _compass_slice(list, start_index, end_index = nil)
+      end_index ||= Sass::Script::Number.new(-1)
+      start_index = start_index.value
+      end_index = end_index.value
+      start_index -= 1 unless start_index < 0
+      end_index -= 1 unless end_index < 0
+      list.class.new *list.values[start_index..end_index]
+    end
+
+    %w(webkit moz o ms svg).each do |prefix|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def _#{prefix}(*args)
+          List.new(*args.map! do |a|
+                      if a.is_a?(List)
+                        a.class.new(*a.values.map{|v| v.respond_to?(:to_#{prefix}) ? v.to_#{prefix} : v})
+                      else
+                        a.respond_to?(:to_#{prefix}) ? a.to_#{prefix} : a
+                      end
+                    end)
+        end
+      RUBY
+    end
+
+    # Check if any of the arguments passed have a tendency towards vendor prefixing.
+    def prefixed(prefix, *args)
+      method = prefix.value.sub(/^-/,"to_").to_sym
+      args.map!{|a| a.is_a?(List) ? a.values : a}.flatten!
+      Sass::Script::Bool.new(args.any?{|a| a.respond_to?(method)})
     end
+
     private
+    # After using the sass script parser to parse a string, this reconstructs
+    # a list from operands to the space/concat operation
+    def extract_list_values(operation)
+      left = operation.instance_variable_get("@operand1")
+      right = operation.instance_variable_get("@operand2")
+      left = extract_list_values(left) if left.is_a?(Sass::Script::Operation)
+      right = extract_list_values(right) if right.is_a?(Sass::Script::Operation)
+      left = literalize(left) unless left.is_a?(Array)
+      right = literalize(right) unless right.is_a?(Array)
+      Array(left) + Array(right)
+    end
+    # Makes a literal from other various script nodes.
+    def literalize(node)
+      case node
+      when Sass::Script::Literal
+        node
+      when Sass::Script::Funcall
+        node.perform(Sass::Environment.new)
+      else
+        Sass::Script::String.new(node.to_s)
+      end
+    end
     def normalize_stops!(color_list)
       positions = color_list.values
       # fill in the start and end positions, if unspecified
@@ -182,9 +432,77 @@ module Compass::SassExtensions::Functions::GradientSupport
        end
       nil
     end
+
     def assert_list(value)
       return if value.is_a?(List)
       raise ArgumentError.new("#{value.inspect} is not a list of color stops. Expected: color_stops(<color> <number>?, ...)")
     end
+
+    def parse_color_stop(arg)
+      return ColorStop.new(arg) if arg.is_a?(Sass::Script::Color)
+      return nil unless arg.is_a?(Sass::Script::String)
+      color = stop = nil
+      expr = Sass::Script::Parser.parse(arg.value, 0, 0)
+      case expr
+      when Sass::Script::Color
+        color = expr
+      when Sass::Script::Funcall
+        color = expr
+      when Sass::Script::Operation
+        unless [:concat, :space].include?(expr.instance_variable_get("@operator"))
+          # This should never happen.
+          raise Sass::SyntaxError, "Couldn't parse a color stop from: #{arg.value}"
+        end
+        color = expr.instance_variable_get("@operand1")
+        stop = expr.instance_variable_get("@operand2")
+      else
+        raise Sass::SyntaxError, "Couldn't parse a color stop from: #{arg.value}"
+      end
+      ColorStop.new(color, stop)
+    end
+
+    def color_stop?(arg)
+      parse_color_stop(arg)
+    rescue
+      nil
+    end
+
+    def list_of_color_stops?(arg)
+      arg.is_a?(List) && arg.values.first.is_a?(ColorStop)
+    end
+
+    def linear_svg(color_stops, x1, y1, x2, y2)
+      gradient = %Q{<linearGradient id="grad" x1="#{x1}" y1="#{y1}" x2="#{x2}" y2="#{y2}">#{color_stops_svg(color_stops)}</linearGradient>}
+      svg(gradient)
+    end
+
+    def radial_svg(color_stops, cx, cy, r)
+      gradient = %Q{<radialGradient id="grad" gradientUnits="userSpaceOnUse" cx="#{cx}" cy="#{cy}" r="#{r}">#{color_stops_svg(color_stops)}</radialGradient>}
+      svg(gradient)
+    end
+
+    # color_stops = array of: [stop, color]
+    def color_stops_svg(color_stops)
+      color_stops.each.map{ |stop, color|
+          %{<stop offset="#{stop.to_s}" stop-color="#{color.inspect}"/>}
+      }.join
+    end
+
+    def svg(gradient)
+      svg = <<-EOS
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg"><defs>#{gradient}</defs><rect x="0" y="0" width="100%" height="100%" fill="url(#grad)" /></svg>
+EOS
+    end
+  end
+  class LinearGradient < Sass::Script::Literal
+    include Functions
+    include Compass::SassExtensions::Functions::Constants
+    include Compass::SassExtensions::Functions::InlineImage
+  end
+  class RadialGradient < Sass::Script::Literal
+    include Functions
+    include Compass::SassExtensions::Functions::Constants
+    include Compass::SassExtensions::Functions::InlineImage
   end
 end