compass-rails31 0.12.0.alpha.0.91a748a

data/lib/compass/installers/template_context.rb

@@ -0,0 +1,44 @@
+module Compass
+  module Installers
+    class TemplateContext
+
+      def self.ctx(*arguments)
+        new(*arguments).send(:get_binding)
+      end
+
+      def initialize(template, locals = {})
+        @template = template
+        @locals = locals
+      end
+
+      def http_stylesheets_path
+        config.http_stylesheets_path ||
+        config.default_for(:http_stylesheets_path) ||
+        config.http_root_relative(config.css_dir)
+      end
+
+      Compass::Configuration::ATTRIBUTES.each do |attribute|
+        unless instance_methods.include?(attribute.to_s)
+          define_method attribute do
+            config.send(attribute) || config.default_for(attribute)
+          end
+        end
+      end
+
+      def config
+        Compass.configuration
+      end
+
+      alias configuration config
+
+      protected
+
+      def get_binding
+        @locals.each do |k, v|
+          eval("#{k} = v")
+        end
+        binding
+      end
+    end
+  end
+end

data/lib/compass/logger.rb

@@ -0,0 +1,103 @@
+module Compass
+
+  class Logger
+
+    DEFAULT_ACTIONS = [:directory, :exists, :remove, :create, :overwrite, :compile, :error, :identical, :warning]
+
+    COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33 }
+
+    ACTION_COLORS = {
+      :error     => :red,
+      :warning   => :yellow,
+      :compile   => :green,
+      :overwrite => :yellow,
+      :create    => :green,
+      :remove    => :yellow,
+      :exists    => :green,
+      :directory => :green,
+      :identical => :green,
+      :convert   => :green,
+      :unchanged => :yellow
+    }
+
+
+    attr_accessor :actions, :options
+
+    def initialize(*actions)
+      self.options = actions.last.is_a?(Hash) ? actions.pop : {}
+      @actions = DEFAULT_ACTIONS.dup
+      @actions += actions
+    end
+
+    # Record an action that has occurred
+    def record(action, *arguments)
+      msg = ""
+      msg << color(ACTION_COLORS[action]) if Compass.configuration.color_output
+      msg << "#{action_padding(action)}#{action}"
+      msg << color(:clear) if Compass.configuration.color_output
+      msg << " #{arguments.join(' ')}"
+      log msg
+    end
+
+    def red
+      $stderr.write(color(:red))
+      $stdout.write(color(:red))
+      yield
+    ensure
+      $stderr.write(color(:clear))
+      $stdout.write(color(:clear))
+    end
+
+    def yellow
+      $stderr.write(color(:yellow))
+      $stdout.write(color(:yellow))
+      yield
+    ensure
+      $stderr.write(color(:clear))
+      $stdout.write(color(:clear))
+    end
+
+    def color(c)
+      if Compass.configuration.color_output && c && COLORS.has_key?(c.to_sym)
+        if defined?($boring) && $boring
+          ""
+        else
+          "\e[#{COLORS[c.to_sym]}m"
+        end
+      else
+        ""
+      end
+    end
+
+    def emit(msg)
+      print msg
+    end
+
+    # Emit a log message
+    def log(msg)
+      puts msg
+    end
+
+    # add padding to the left of an action that was performed.
+    def action_padding(action)
+      ' ' * [(max_action_length - action.to_s.length), 0].max
+    end
+
+    # the maximum length of all the actions known to the logger.
+    def max_action_length
+      @max_action_length ||= actions.inject(0){|memo, a| [memo, a.to_s.length].max}
+    end
+  end
+
+  class NullLogger
+    def record(*args)
+    end
+
+    def log(msg)
+    end
+
+    def red
+      yield
+    end
+  end
+end

data/lib/compass/quick_cache.rb

@@ -0,0 +1,15 @@
+module QuickCache
+
+  # cache a value in memory for just a few seconds
+  # This can speed up reads of values that change relatively infrequently
+  # but might be read many times in a short burst of reads.
+  def quick_cache(key, ttl = 1)
+    @quick_cache ||= {}
+    if @quick_cache[key] && @quick_cache[key].first > Time.now - ttl
+      @quick_cache[key].last
+    else
+      (@quick_cache[key] = [Time.now, yield]).last
+    end
+  end
+
+end

data/lib/compass/rails.rb

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

data/lib/compass/sass_extensions.rb

@@ -0,0 +1,10 @@
+unless Sass::Script::Functions.methods.grep(/\Adeclare\Z/).any?
+  raise LoadError, "It looks like you've got an incompatible version of Sass. This often happens when you have an old haml gem installed. Please upgrade Haml to v3.1 or above."
+end
+
+module Compass::SassExtensions
+end
+
+require 'compass/sass_extensions/functions'
+require 'compass/sass_extensions/monkey_patches'
+require 'compass/sass_extensions/sprites'

data/lib/compass/sass_extensions/functions.rb

@@ -0,0 +1,32 @@
+module Compass::SassExtensions::Functions
+end
+
+%w(
+  selectors enumerate urls display
+  inline_image image_size constants gradient_support
+  font_files lists colors trig sprites cross_browser_support
+).each do |func|
+  require "compass/sass_extensions/functions/#{func}"
+end
+
+module Sass::Script::Functions
+  include Compass::SassExtensions::Functions::Selectors
+  include Compass::SassExtensions::Functions::Enumerate
+  include Compass::SassExtensions::Functions::Urls
+  include Compass::SassExtensions::Functions::Display
+  include Compass::SassExtensions::Functions::InlineImage
+  include Compass::SassExtensions::Functions::ImageSize
+  include Compass::SassExtensions::Functions::GradientSupport::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::Sprites
+  include Compass::SassExtensions::Functions::CrossBrowserSupport
+end
+
+# Wierd that this has to be re-included to pick up sub-modules. Ruby bug?
+class Sass::Script::Functions::EvaluationContext
+  include Sass::Script::Functions
+end

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

@@ -0,0 +1,53 @@
+module Compass::SassExtensions::Functions::Colors
+
+  # 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 => Compass::Util.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 => Compass::Util.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

@@ -0,0 +1,65 @@
+module Compass::SassExtensions::Functions::Constants
+  if defined?(Sass::Script::List)
+    POSITIONS = /top|bottom|left|right|center/
+    def is_position(position)
+      Sass::Script::Bool.new(position.is_a?(Sass::Script::String) && !!(position.value =~ POSITIONS))
+    end
+    def is_position_list(position_list)
+      Sass::Script::Bool.new(position_list.is_a?(Sass::Script::List) && position_list.value.all?{|p| is_position(p).to_bool})
+    end
+    # 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
+        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
+  end
+end

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

@@ -0,0 +1,70 @@
+module Compass::SassExtensions::Functions::CrossBrowserSupport
+
+  class CSS2FallbackValue < Sass::Script::Literal
+    attr_accessor :value, :css2_value
+    def children
+      [value, css2_value]
+    end
+    def initialize(value, css2_value)
+      self.value = value
+      self.css2_value = css2_value
+    end
+    def inspect
+      to_s
+    end
+    def to_s(options = self.options)
+      value.to_s(options)
+    end
+    def supports?(aspect)
+      aspect == "css2"
+    end
+    def has_aspect?
+      true
+    end
+    def to_css2(options = self.options)
+      css2_value
+    end
+  end
+
+  # Check if any of the arguments passed require a vendor prefix.
+  def prefixed(prefix, *args)
+    aspect = prefix.value.sub(/^-/,"")
+    needed = args.any?{|a| a.respond_to?(:supports?) && a.supports?(aspect)}
+    Sass::Script::Bool.new(needed)
+  end
+
+  %w(webkit moz o ms svg pie css2 owg).each do |prefix|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      # Syntactic sugar to apply the given prefix
+      # -moz($arg) is the same as calling prefix(-moz, $arg)
+      def _#{prefix}(*args)
+        prefix("#{prefix}", *args)
+      end
+    RUBY
+  end
+
+  def prefix(prefix, *objects)
+    prefix = prefix.value if prefix.is_a?(Sass::Script::String)
+    prefix = prefix[1..-1] if prefix[0] == ?-
+    if objects.size > 1
+      self.prefix(prefix, Sass::Script::List.new(objects, :comma))
+    else
+      object = objects.first
+      if object.is_a?(Sass::Script::List)
+        Sass::Script::List.new(object.value.map{|e|
+          self.prefix(prefix, e)
+        }, object.separator)
+      elsif object.respond_to?(:supports?) && object.supports?(prefix) && object.respond_to?(:"to_#{prefix}")
+        object.options = options
+        object.send(:"to_#{prefix}")
+      else
+        object
+      end
+    end
+  end
+
+  def css2_fallback(value, css2_value)
+    CSS2FallbackValue.new(value, css2_value)
+  end
+
+end

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

@@ -0,0 +1,26 @@
+module Compass::SassExtensions::Functions::Display
+  DEFAULT_DISPLAY = {
+    :block => %w{address article aside blockquote center dir div dd details dl dt fieldset
+                  figcaption figure form footer frameset h1 h2 h3 h4 h5 h6 hr header hgroup
+                  isindex menu nav noframes noscript ol p pre section summary ul},
+    :inline => %w{a abbr acronym audio b basefont bdo big br canvas cite code command
+                  datalist dfn em embed font i img input keygen kbd label mark meter output
+                  progress q rp rt ruby s samp select small span strike strong sub
+                  sup textarea time tt u var video wbr},
+    :table => %w{table},
+    :"list-item" => %w{li},
+    :"table-row-group" => %w{tbody},
+    :"table-header-group" => %w{thead},
+    :"table-footer-group" => %w{tfoot},
+    :"table-row" => %w{tr},
+    :"table-cell" => %w{th td},
+    :"html5-block" => %w{article aside details figcaption figure footer header hgroup menu nav section summary},
+    :"html5-inline" => %w{audio canvas command datalist embed keygen mark meter output progress rp rt ruby time video wbr},
+  }
+  DEFAULT_DISPLAY[:html5] = (DEFAULT_DISPLAY[:"html5-block"] + DEFAULT_DISPLAY[:"html5-inline"]).sort
+  # returns a comma delimited string for all the
+  # elements according to their default css3 display value.
+  def elements_of_type(display)
+    Sass::Script::String.new(DEFAULT_DISPLAY.fetch(display.value.to_sym).join(", "))
+  end
+end

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

@@ -0,0 +1,7 @@
+module Compass::SassExtensions::Functions::Enumerate
+  def enumerate(prefix, from, through, separator = nil)
+    separator ||= Sass::Script::String.new("-", :string)
+    selectors = (from.value..through.value).map{|i| "#{prefix.value}#{separator.value}#{i}"}.join(", ")
+    Sass::Script::String.new(selectors)
+  end
+end

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

@@ -0,0 +1,10 @@
+module Compass::SassExtensions::Functions::FontFiles
+  def font_files(*args)
+    raise Sass::SyntaxError, "An even number of arguments must be passed to font_files()" unless args.size % 2 == 0
+    files = []
+    while args.size > 0
+      files << "#{font_url(args.shift)} format('#{args.shift}')"
+    end
+    Sass::Script::String.new(files.join(", "))
+  end
+end