compass 0.11.alpha.0 → 0.11.alpha.1

data/frameworks/compass/templates/pie/pie.scss

@@ -0,0 +1,74 @@
+// this file demonstrates how to use the CSS PIE extension for
+// legacy versions of Internet Explorer. In many cases, PIE will allow
+// you to style in CSS things that you'd have to do using image chops otherwise.
+//
+// Note: Each element that has PIE enabled on it will add about 10ms to your page load.
+@import "compass/css3/pie";
+@import "compass/css3";
+
+// Set this to wherever you end up putting your behavior file.
+//
+// **Note:** this file must be served as a root-relative resource or
+// else IE will interpret it as relative to the current webpage
+// instead of the stylesheet.
+//
+// **Also Note:** this file must be delivered with a mime-type of:
+//
+//    text/x-component
+$pie-behavior: url("<%= config.http_stylesheets_path %>/PIE.htc");
+
+// It is suggested that you use Sass's @extend directive to apply the PIE
+// behavior to your elements. Setting this variable will tell the `pie` mixin
+// to extend it. Or you can just extend the base class yourself.
+$pie-base-class: pie-element;
+
+// There are two approaches to creating PIE elements
+// The default approach is to make the element position: relative.
+.pie-element {
+  // relative is the default, so passing relative
+  // is redundant, but we do it here for clarity.
+  @include pie-element(relative);
+}
+
+.bordered {
+  @include pie; // Because $pie-base-class is set, this results in an extend of .pie-element. 
+  @include border-radius(5px);
+}
+
+.gradient {
+  @include pie; // Because $pie-base-class is set, this results in an extend of .pie-element.
+  @include background(linear-gradient(#f00, #00f));
+}
+
+
+// But sometimes this messes up your positioning
+// So you can also use z-indexing. In this case
+// an ancestor element before or having the first
+// opaque background should be marked as a pie-container
+// which gives it a z-index of 0 (actually any z-index
+// can be provided to the pie-container mixin).
+// And then the pie element itself should be given
+// a z-index of -1.
+.pie-container {
+  @include pie-container;
+}
+
+.z-pie-element {
+  // this will get a z-index of 0, you can pass a z-index value if you want
+  @include pie-element(z-index);
+}
+
+// This is just a simple example of how to use the z-index approach.
+.widget {
+  @extend .pie-container;
+  h3 {
+    @include pie(z-pie-element); // This will extend .z-pie-element instead of .pie-element
+  }
+}
+
+
+// Lastly, you can just include the pie-element mixin directly if you need to do a one-off:
+.has-gradient {
+  @include pie-element(relative);
+  @include background(linear-gradient(#f00, #00f));
+}

data/lib/compass.rb

@@ -1,7 +1,7 @@
 module Compass
 end
 
-%w(dependencies sass_extensions core_ext version errors).each do |lib|
+%w(dependencies util sass_extensions core_ext version errors).each do |lib|
   require "compass/#{lib}"
 end
 

data/lib/compass/exec/helpers.rb

@@ -7,7 +7,7 @@ module Compass::Exec
       else
         unless arguments.include?("-h") || arguments.include?("--help")
           Compass::Logger.new.red do
-            Haml::Util.haml_warn "WARNING: This interface is deprecated. Please use the new subcommand interface.\nSee `compass help` for more information.\n"
+            Compass::Util.compass_warn "WARNING: This interface is deprecated. Please use the new subcommand interface.\nSee `compass help` for more information.\n"
           end
         end
         SwitchUI

data/lib/compass/installers/base.rb

@@ -71,7 +71,17 @@ module Compass
         define_method "install_#{type}" do |from, to, options|
           from = templatize(from)
           to = targetize(send(loc_method, to, options))
-          copy from, to, nil, (installer_opts[:binary] || options[:binary])
+          is_binary = installer_opts[:binary] || options[:binary]
+          if is_binary
+            copy from, to, nil, is_binary
+          else
+            contents = File.new(from).read
+            if options.delete(:erb)
+              ctx = TemplateContext.ctx(:to => to, :options => options)
+              contents = process_erb(contents, ctx)
+            end
+            write_file to, contents
+          end
         end
       end
 
@@ -83,6 +93,10 @@ module Compass
         from = templatize(from)
         to = targetize(install_location_for_stylesheet(to, options))
         contents = File.new(from).read
+        if options.delete(:erb)
+          ctx = TemplateContext.ctx(:to => to, :options => options)
+          contents = process_erb(contents, ctx)
+        end
         if preferred_syntax.to_s != from[-4..-1]
           # logger.record :convert, basename(from)
           tree = Sass::Engine.new(contents, Compass.sass_engine_options.merge(:syntax => from[-4..-1].intern)).to_tree

data/lib/compass/rails.rb

@@ -0,0 +1,2 @@
+# Rails requires compass by requiring this file.
+require 'compass'

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

@@ -1,9 +1,5 @@
 module Compass::SassExtensions::Functions::Colors
-  if defined?(Sass::Util)
-    include Sass::Util
-  else
-    include Haml::Util
-  end
+  include Compass::Util
 
   # a genericized version of lighten/darken so that negative values can be used.
   def adjust_lightness(color, amount)

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

@@ -1,17 +1,58 @@
 module Compass::SassExtensions::Functions::Constants
-  # returns the opposite position of a side or corner.
-  def opposite_position(position)
-    opposite = position.value.split(/ +/).map do |pos|
-      case pos
-      when "top" then "bottom"
-      when "bottom" then "top"
-      when "left" then "right"
-      when "right" then "left"
-      when "center" then "center"
+  if defined?(Sass::Script::List)
+    # returns the opposite position of a side or corner.
+    def opposite_position(position)
+      position = unless position.is_a?(Sass::Script::List)
+        Sass::Script::List.new([position], :space)
       else
-        pos
+        Sass::Script::List.new(position.value.dup, position.separator)
       end
+      position.value.map! do |pos|
+        if pos.is_a? Sass::Script::String
+          opposite = case pos.value
+          when "top" then "bottom"
+          when "bottom" then "top"
+          when "left" then "right"
+          when "right" then "left"
+          when "center" then "center"
+          else
+            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+            pos.value
+          end
+          Sass::Script::String.new(opposite)
+        elsif pos.is_a? Sass::Script::Number
+          if pos.numerator_units == ["%"] && pos.denominator_units == []
+            Sass::Script::Number.new(100-pos.value, ["%"])
+          else
+            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+            pos
+          end
+        else
+          Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
+          pos
+        end
+      end
+      if position.value.size == 1
+        position.value.first
+      else
+        position
+      end
+    end
+  else
+    # returns the opposite position of a side or corner.
+    def opposite_position(position)
+      opposite = position.value.split(/ +/).map do |pos|
+        case pos
+        when "top" then "bottom"
+        when "bottom" then "top"
+        when "left" then "right"
+        when "right" then "left"
+        when "center" then "center"
+        else
+          pos
+        end
+      end
+      Sass::Script::String.new(opposite.join(" "), position.type)
     end
-    Sass::Script::String.new(opposite.join(" "), position.type)
   end
 end

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

@@ -1,42 +1,321 @@
 module Compass::SassExtensions::Functions::GradientSupport
 
-  class List < Sass::Script::Literal
-    attr_accessor :values
-    def initialize(*values)
-      self.values = values
+  module ListFreeSassSupport
+    class List < Sass::Script::Literal
+      attr_accessor :values
+      def children
+        values
+      end
+      def value
+        # duck type to a Sass List
+        values
+      end
+      def initialize(*values)
+        self.values = values
+      end
+      def join_with
+        ", "
+      end
+      def inspect
+        to_s
+      end
+      def to_s(options = self.options)
+        values.map {|v| v.to_s }.join(join_with)
+      end
+      def size
+        values.size
+      end
     end
-    def join_with
-      ", "
+
+    class SpaceList < List
+      def join_with
+        " "
+      end
     end
-    def inspect
-      to_s
+
+    # given a position list, return a corresponding position in percents
+    def grad_point(position)
+      position = position.is_a?(Sass::Script::String) ? position.value : position.to_s
+      position = if position[" "]
+        if position =~ /(top|bottom|center) (left|right|center)/
+          "#{$2} #{$1}"
+        else
+          position
+        end
+      else
+        case position
+        when /top|bottom/
+          "center #{position}"
+        when /left|right/
+          "#{position} center"
+        when /center/
+          "center center"
+        else
+          "#{position} center"
+        end
+      end
+      position = position.
+        gsub(/top/, "0%").
+        gsub(/bottom/, "100%").
+        gsub(/left/,"0%").
+        gsub(/right/,"100%").
+        gsub(/center/, "50%")
+      SpaceList.new(*position.split(/ /).map{|s| Sass::Script::String.new(s)})
     end
-    def to_s
-      values.map {|v| v.to_s }.join(join_with)
+
+    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
+          parse_color_stop(arg)
+        else
+          raise Sass::SyntaxError, "Not a valid color stop: #{arg.class.name}: #{arg}"
+        end
+      end)
+    end
+
+    # Returns a comma-delimited list after removing any non-true values
+    def compact(*args)
+      List.new(*args.reject{|a| !a.to_bool})
     end
-    def size
-      values.size
+
+    # 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)
+          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
+            [arg]
+          end
+        else
+          [arg]
+        end
+
+      SpaceList.new(*values)
+    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
+
+    def _compass_list_size(list)
+      Sass::Script::Number.new(list.size)
+    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
+
+    # 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
+
+    %w(webkit moz o ms svg pie).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
+
+    protected
+    def color_stop?(arg)
+      parse_color_stop(arg)
+    rescue
+      nil
+    end
+
+    def assert_list(value)
+      unless value.is_a?(List)
+        raise ArgumentError.new("#{value.inspect} is not a list")
+      end
+    end
+
   end
 
-  class SpaceList < List
-    def join_with
-      " "
+  module ListBasedSassSupport
+    # given a position list, return a corresponding position in percents
+    def grad_point(position)
+      position = unless position.is_a?(Sass::Script::List)
+        Sass::Script::List.new([position], :space)
+      else
+        Sass::Script::List.new(position.value.dup, position.separator)
+      end
+      position.value.reject!{|p| p.is_a?(Sass::Script::Number) && p.numerator_units.include?("deg")}
+      if (position.value.first.value =~ /top|bottom/) or (position.value.last.value =~ /left|right/)
+        # browsers are pretty forgiving of reversed positions so we are too.
+        position.value.reverse!
+      end
+      if position.value.size == 1
+        if position.value.first.value =~ /top|bottom/
+          position.value.unshift Sass::Script::String.new("center")
+        elsif position.value.first.value =~ /left|right/
+          position.value.push Sass::Script::String.new("center")
+        end
+      end
+      position.value.map! do |p|
+        case p.value
+        when /top|left/
+          Sass::Script::Number.new(0, ["%"])
+        when /bottom|right/
+          Sass::Script::Number.new(100, ["%"])
+        when /center/
+          Sass::Script::Number.new(50, ["%"])
+        else
+          p
+        end
+      end
+      position
+    end
+
+    def color_stops(*args)
+      Sass::Script::List.new(args.map do |arg|
+        case arg
+        when ColorStop
+          arg
+        when Sass::Script::Color
+          ColorStop.new(arg)
+        when Sass::Script::List
+          ColorStop.new(*arg.value)
+        else
+          raise Sass::SyntaxError, "Not a valid color stop: #{arg.class.name}: #{arg}"
+        end
+      end, :comma)
+    end
+
+    # Returns a comma-delimited list after removing any non-true values
+    def compact(*args)
+      Sass::Script::List.new(args.reject{|a| !a.to_bool}, :comma)
+    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)
+      if arg.is_a?(Sass::Script::List)
+        Sass::Script::List.new(arg.value.dup, arg.separator)
+      else
+        Sass::Script::List.new([arg], :space)
+      end
+    end
+
+    def _compass_space_list(list)
+      if list.is_a?(Sass::Script::List)
+        Sass::Script::List.new(list.value.dup, :space)
+      else
+        Sass::Script::List.new([list], :space)
+      end
+    end
+
+    def _compass_list_size(list)
+      assert_list list
+      Sass::Script::Number.new(list.value.size)
+    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
+      Sass::Script::List.new list.values[start_index..end_index], list.separator
+    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?(Sass::Script::List) ? a.value : a}.flatten!
+      Sass::Script::Bool.new(args.any?{|a| a.respond_to?(method)})
+    end
+
+    %w(webkit moz o ms svg pie).each do |prefix|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def _#{prefix}(*args)
+          Sass::Script::List.new(args.map! do |a|
+            a.options = options
+            if a.is_a?(Sass::Script::List)
+              Sass::Script::List.new(a.value.map do |v|
+                v.respond_to?(:to_#{prefix}) ? v.to_#{prefix} : v
+              end, a.separator)
+            else
+              a.respond_to?(:to_#{prefix}) ? a.to_#{prefix} : a
+            end
+          end, :comma)
+        end
+      RUBY
+    end
+
+    protected
+    def color_stop?(arg)
+      arg.is_a?(ColorStop) ||
+      (arg.is_a?(Sass::Script::List) && ColorStop.new(*arg.value)) ||
+      ColorStop.new(arg)
+    rescue
+      nil
     end
+
+    def assert_list(value)
+      unless value.is_a?(Sass::Script::List)
+        raise ArgumentError.new("#{value.inspect} is not a list")
+      end
+    end
+
   end
 
+
   class ColorStop < Sass::Script::Literal
     attr_accessor :color, :stop
+    def children
+      [color, stop].compact
+    end
     def initialize(color, stop = nil)
       unless Sass::Script::Color === color || Sass::Script::Funcall === color
         raise Sass::SyntaxError, "Expected a color. Got: #{color}"
       end
+      if stop && !stop.is_a?(Sass::Script::Number)
+        raise Sass::SyntaxError, "Expected a number. Got: #{stop}"
+      end
       self.color, self.stop = color, stop
     end
     def inspect
       to_s
     end
-    def to_s
+    def to_s(options = self.options)
       s = color.inspect.dup
       if stop
         s << " "
@@ -52,8 +331,11 @@ module Compass::SassExtensions::Functions::GradientSupport
 
   class RadialGradient < Sass::Script::Literal
     attr_accessor :position_and_angle, :shape_and_size, :color_stops
+    def children
+      [color_stops, position_and_angle, shape_and_size].compact
+    end
     def initialize(position_and_angle, shape_and_size, color_stops)
-      unless color_stops.values.size >= 2
+      unless color_stops.value.size >= 2
         raise Sass::SyntaxError, "At least two color stops are required for a radial-gradient"
       end
       self.position_and_angle = position_and_angle
@@ -63,37 +345,45 @@ module Compass::SassExtensions::Functions::GradientSupport
     def inspect
       to_s
     end
-    def to_s
+    def to_s(options = self.options)
       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 << position_and_angle.to_s(options) << ", " if position_and_angle
+      s << shape_and_size.to_s(options) << ", " if shape_and_size
+      s << color_stops.to_s(options)
       s << ")"
     end
-    def to_webkit
+    def to_webkit(options = self.options)
       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_point(position_and_angle || _center_position),
+        Sass::Script::String.new("0"),
+        grad_point(position_and_angle || _center_position),
         grad_end_position(color_stops, Sass::Script::Bool.new(true)),
         grad_color_stops(color_stops)
       ]
+      args.each {|a| a.options = options}
       Sass::Script::String.new("-webkit-gradient(radial, #{args.join(', ')})")
 
     end
-    def to_moz
-      Sass::Script::String.new("-moz-#{to_s}")
+    def to_moz(options = self.options)
+      Sass::Script::String.new("-moz-#{to_s(options)}")
     end
-    def to_svg
+    def to_svg(options = self.options)
       # XXX Add shape support if possible
-      radial_svg_gradient(color_stops, position_and_angle || Sass::Script::String.new("center center"))
+      radial_svg_gradient(color_stops, position_and_angle || _center_position)
+    end
+    def to_pie(options = self.options)
+      Compass::Logger.new.record(:warning, "PIE does not support radial-gradient.")
+      Sass::Script::String.new("-pie-radial-gradient(unsupported)")
     end
   end
 
   class LinearGradient < Sass::Script::Literal
     attr_accessor :color_stops, :position_and_angle
+    def children
+      [color_stops, position_and_angle].compact
+    end
     def initialize(position_and_angle, color_stops)
-      unless color_stops.values.size >= 2
+      unless color_stops.value.size >= 2
         raise Sass::SyntaxError, "At least two color stops are required for a linear-gradient"
       end
       self.position_and_angle = position_and_angle
@@ -102,29 +392,42 @@ module Compass::SassExtensions::Functions::GradientSupport
     def inspect
       to_s
     end
-    def to_s
+    def to_s(options = self.options)
       s = "linear-gradient("
-      s << position_and_angle.to_s << ", " if position_and_angle
-      s << color_stops.to_s
+      s << position_and_angle.to_s(options) << ", " if position_and_angle
+      s << color_stops.to_s(options)
       s << ")"
     end
-    def to_webkit
+    def to_webkit(options = self.options)
       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)
+      args.each{|a| a.options = options}
       Sass::Script::String.new("-webkit-gradient(linear, #{args.join(', ')})")
     end
-    def to_moz
-      Sass::Script::String.new("-moz-#{to_s}")
+    def to_moz(options = self.options)
+      Sass::Script::String.new("-moz-#{to_s(options)}")
     end
-    def to_svg
+    def to_svg(options = self.options)
       linear_svg_gradient(color_stops, position_and_angle || Sass::Script::String.new("top"))
     end
+    def to_pie(options = self.options)
+      # PIE just uses the standard rep, but the property is prefixed so
+      # the presence of this attribute helps flag when to render a special rule.
+      Sass::Script::String.new to_s(options)
+    end
   end
 
   module Functions
 
+    # While supporting sass 3.1 and older versions, we need two different implementations.
+    if defined?(Sass::Script::List)
+      include ListBasedSassSupport
+    else
+      include ListFreeSassSupport
+    end
+
     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)
@@ -132,7 +435,7 @@ module Compass::SassExtensions::Functions::GradientSupport
         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
+        color_stops = shape_and_size.value + 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
@@ -141,14 +444,14 @@ module Compass::SassExtensions::Functions::GradientSupport
         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
+        color_stops = position_and_angle.value + 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
+        color_stops = color_stops.first.value
       end
       RadialGradient.new(position_and_angle, shape_and_size, send(:color_stops, *color_stops))
     end
@@ -158,14 +461,14 @@ module Compass::SassExtensions::Functions::GradientSupport
         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
+        color_stops = position_and_angle.value + 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
+        color_stops = color_stops.first.value
       end
       LinearGradient.new(position_and_angle, send(:color_stops, *color_stops))
     end
@@ -180,10 +483,10 @@ module Compass::SassExtensions::Functions::GradientSupport
 
     def color_stops_in_percentages(color_list)
       assert_list(color_list)
-      normalize_stops!(color_list)
-      max = color_list.values.last.stop
+      color_list = normalize_stops(color_list)
+      max = color_list.value.last.stop
       last_value = nil
-      color_stops = color_list.values.map do |pos|
+      color_stops = color_list.value.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 && max.numerator_units != ["%"]
@@ -200,12 +503,12 @@ module Compass::SassExtensions::Functions::GradientSupport
     def grad_end_position(color_list, radial = Sass::Script::Bool.new(false))
       assert_list(color_list)
       default = Sass::Script::Number.new(100)
-      grad_position(color_list, Sass::Script::Number.new(color_list.values.size), default, radial)
+      grad_position(color_list, Sass::Script::Number.new(color_list.value.size), default, radial)
     end
 
     def grad_position(color_list, index, default, radial = Sass::Script::Bool.new(false))
       assert_list(color_list)
-      stop = color_list.values[index.value - 1].stop
+      stop = color_list.value[index.value - 1].stop
       if stop && radial.to_bool
         orig_stop = stop
         if stop.unitless?
@@ -217,8 +520,8 @@ module Compass::SassExtensions::Functions::GradientSupport
             stop = stop.times(Sass::Script::Number.new(1, ["px"]))
           end
         end
-        if stop.numerator_units == ["%"] && color_list.values.last.stop && color_list.values.last.stop.numerator_units == ["px"]
-          stop = stop.times(color_list.values.last.stop).div(Sass::Script::Number.new(100, ["%"]))
+        if stop.numerator_units == ["%"] && color_list.value.last.stop && color_list.value.last.stop.numerator_units == ["px"]
+          stop = stop.times(color_list.value.last.stop).div(Sass::Script::Number.new(100, ["%"]))
         end
         Compass::Logger.new.record(:warning, "Webkit only supports pixels for the start and end stops for radial gradients. Got: #{orig_stop}") if stop.numerator_units != ["px"]
         stop.div(Sass::Script::Number.new(1, stop.numerator_units, stop.denominator_units))
@@ -229,55 +532,9 @@ module Compass::SassExtensions::Functions::GradientSupport
       end
     end
 
-    # the given a position, return a point in percents
-    def grad_point(position)
-      position = position.value
-      position = if position[" "]
-        if position =~ /(top|bottom|center) (left|right|center)/
-          "#{$2} #{$1}"
-        else
-          position
-        end
-      else
-        case position
-        when /top|bottom/
-          "center #{position}"
-        when /left|right/
-          "#{position} center"
-        when /center/
-          "center center"
-        else
-          position
-        end
-      end
-      Sass::Script::String.new(position.
-        gsub(/top/, "0%").
-        gsub(/bottom/, "100%").
-        gsub(/left/,"0%").
-        gsub(/right/,"100%").
-        gsub(/center/, "50%"))
-    end
-
-    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
-          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
+      x1, y1 = *grad_point(start).value
+      x2, y2 = *grad_point(opposite_position(start)).value
       stops = color_stops_in_percentages(color_stops)
 
       svg = linear_svg(stops, x1, y1, x2, y2)
@@ -285,7 +542,7 @@ module Compass::SassExtensions::Functions::GradientSupport
     end
 
     def radial_svg_gradient(color_stops, center)
-      cx, cy = grad_point(center).to_s.split
+      cx, cy = *grad_point(center).value
       r = grad_end_position(color_stops,  Sass::Script::Bool.new(true))
       stops = color_stops_in_percentages(color_stops)
 
@@ -293,90 +550,20 @@ module Compass::SassExtensions::Functions::GradientSupport
       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)
-          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
-            [arg]
-          end
-        else
-          [arg]
-        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
+      assert_list list
+      if place.value == "first"
+        list.value.first
+      elsif place.value == "last"
+        list.value.last
       else
-        list.values[place.value - 1]
+        list.value[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)
@@ -399,8 +586,8 @@ module Compass::SassExtensions::Functions::GradientSupport
         Sass::Script::String.new(node.to_s)
       end
     end
-    def normalize_stops!(color_list)
-      positions = color_list.values
+    def normalize_stops(color_list)
+      positions = color_list.value.map{|obj| obj.dup}
       # fill in the start and end positions, if unspecified
       positions.first.stop = Sass::Script::Number.new(0) unless positions.first.stop
       positions.last.stop = Sass::Script::Number.new(100, ["%"]) unless positions.last.stop
@@ -430,12 +617,11 @@ module Compass::SassExtensions::Functions::GradientSupport
          positions.last.stop.eq(Sass::Script::Number.new(0, ["%"])).to_bool)
          raise Sass::SyntaxError.new("Color stops must be specified in increasing order")
        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>?, ...)")
+      if defined?(Sass::Script::List)
+        Sass::Script::List.new(positions, color_list.separator)
+      else
+        color_list.class.new(*positions)
+      end
     end
 
     def parse_color_stop(arg)
@@ -461,14 +647,8 @@ module Compass::SassExtensions::Functions::GradientSupport
       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)
+      arg.value.is_a?(Array) && arg.value.all?{|a| a.is_a?(ColorStop)}
     end
 
     def linear_svg(color_stops, x1, y1, x2, y2)
@@ -494,6 +674,18 @@ module Compass::SassExtensions::Functions::GradientSupport
 <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
+
+    def _center_position
+      if defined?(Sass::Script::List)
+        Sass::Script::List.new([
+          Sass::Script::String.new("center"),
+          Sass::Script::String.new("center")
+        ],:space)
+      else
+        Sass::Script::String.new("center center")
+      end
+    end
+
   end
   class LinearGradient < Sass::Script::Literal
     include Functions