compass 0.10.0.pre5 → 0.10.0.pre6

data/lib/compass/configuration/helpers.rb

@@ -31,6 +31,7 @@ module Compass
         if config.is_a?(Compass::Configuration::Data)
           config
         elsif config.respond_to?(:read)
+          filename ||= config.to_s if config.is_a?(Pathname)
           Compass::Configuration::Data.new_from_string(config.read, filename)
         elsif config.is_a?(Hash)
           Compass::Configuration::Data.new(filename, config)
@@ -88,6 +89,12 @@ module Compass
         end
       end
 
+      def discover_extensions!
+        if File.exists?(configuration.extensions_path)
+          Compass::Frameworks.discover(configuration.extensions_path)
+        end
+      end
+
       # Returns a full path to the relative path to the project directory
       def projectize(path, project_path = nil)
         project_path ||= configuration.project_path
@@ -112,6 +119,15 @@ module Compass
         possible_files.detect{|f| File.exists?(f)}
       end
 
+      def handle_configuration_change!
+        if (compiler = Compass.compiler).new_config?
+          compiler.clean!
+        end
+      end
+
+      def compiler
+        Compass::Compiler.new(*Compass.configuration.to_compiler_arguments)
+      end
     end
   end
 

data/lib/compass/configuration/inheritance.rb

@@ -145,13 +145,17 @@ module Compass
           end
         end
 
-        def debug
+        def chain
           instances = [self]
           instances << instances.last.inherited_data while instances.last.inherited_data
+          instances
+        end
+
+        def debug
           normalized_attrs = {}
           ATTRIBUTES.each do |prop|
             values = []
-            instances.each do |instance|
+            chain.each do |instance|
               values << {
                 :raw => (instance.send("raw_#{prop}") rescue nil),
                 :value => (instance.send("#{prop}_without_default") rescue nil),

data/lib/compass/configuration/serialization.rb

@@ -10,7 +10,7 @@ module Compass
       module ClassMethods
         def new_from_file(config_file)
           data = Data.new(config_file)
-          data.parse(config_file)
+          data._parse(config_file)
           data
         end
 
@@ -22,8 +22,12 @@ module Compass
       end
 
       module InstanceMethods
-        # parses a configuration file which is a ruby script
         def parse(config_file)
+          raise Compass::Error, "Compass.configuration.parse(filename) has been removed. Please call Compass.add_project_configuration(filename) instead."
+        end
+
+        # parses a configuration file which is a ruby script
+        def _parse(config_file)
           unless File.readable?(config_file)
             raise Compass::Error, "Configuration file, #{config_file}, not found or not readable."
           end
@@ -37,6 +41,7 @@ module Compass
           eval(contents, bind, filename)
           ATTRIBUTES.each do |prop|
             value = eval(prop.to_s, bind) rescue nil
+            value = value.to_s if value.is_a?(Pathname)
             self.send("#{prop}=", value) unless value.nil?
           end
           if @added_import_paths
@@ -73,7 +78,7 @@ module Compass
         def serialize_property(prop, value)
           %Q(#{prop} = #{value.inspect}\n)
         end
-        
+
         def issue_deprecation_warnings
           if http_images_path == :relative
             $stderr.puts "DEPRECATION WARNING: Please set relative_assets = true to enable relative paths."

data/lib/compass/exec.rb

@@ -6,7 +6,11 @@ require 'compass/actions'
 require 'compass/installers'
 require 'compass/commands'
 require 'rbconfig'
-require 'win32console' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+begin
+  require 'win32console' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+rescue LoadError
+  $boring = true
+end
 
 module Compass::Exec
 end

data/lib/compass/frameworks.rb

@@ -27,11 +27,20 @@ module Compass
       end
     end
 
+    def detect_registration
+      @registered = nil
+      yield
+      @registered
+    ensure
+      @registered = nil
+    end
+
     def register(name, *arguments)
+      @registered = Framework.new(name, *arguments)
       if idx = ALL.index(self[name])
-        ALL[idx] = Framework.new(name, *arguments)
+        ALL[idx] = @registered
       else
-        ALL << Framework.new(name, *arguments)
+        ALL << @registered
       end
     end
 
@@ -54,9 +63,10 @@ module Compass
         File.join(directory, File.basename(directory)+".rb")
       ]
       loader = loaders.detect{|l| File.exists?(l)}
-      if loader
-        require loader
-      else
+      registered_framework = detect_registration do
+        require loader if loader
+      end
+      unless registered_framework
         register File.basename(directory), directory
       end
     end

data/lib/compass/logger.rb

@@ -2,12 +2,13 @@ module Compass
 
   class Logger
 
-    DEFAULT_ACTIONS = [:directory, :exists, :remove, :create, :overwrite, :compile, :error, :identical]
+    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,
@@ -36,7 +37,6 @@ module Compass
     end
 
     def red
-      return yield unless Compass.configuration.color_output
       $stderr.write(color(:red))
       $stdout.write(color(:red))
       yield
@@ -46,8 +46,12 @@ module Compass
     end
 
     def color(c)
-      if c && COLORS.has_key?(c.to_sym)
-        "\e[#{COLORS[c.to_sym]}m"
+      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

data/lib/compass/sass_extensions/functions.rb

@@ -1,7 +1,7 @@
 module Compass::SassExtensions::Functions
 end
 
-%w(selectors enumerate urls display inline_image color_stop font_files).each do |func|
+%w(selectors enumerate urls display inline_image image_size gradient_support font_files).each do |func|
   require "compass/sass_extensions/functions/#{func}"
 end
 
@@ -11,7 +11,8 @@ module Sass::Script::Functions
   include Compass::SassExtensions::Functions::Urls
   include Compass::SassExtensions::Functions::Display
   include Compass::SassExtensions::Functions::InlineImage
-  include Compass::SassExtensions::Functions::ColorStop
+  include Compass::SassExtensions::Functions::ImageSize
+  include Compass::SassExtensions::Functions::GradientSupport::Functions
   include Compass::SassExtensions::Functions::FontFiles
 end
 

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

@@ -0,0 +1,186 @@
+module Compass::SassExtensions::Functions::GradientSupport
+
+  class List < Sass::Script::Literal
+    attr_accessor :values
+    def initialize(*values)
+      self.values = values
+    end
+    def inspect
+      to_s
+    end
+    def to_s
+      values.map{|v| v.to_s}.join(", ")
+    end
+  end
+
+  class ColorStop < Sass::Script::Literal
+    attr_accessor :color, :stop
+    def initialize(color, stop = nil)
+      self.color, self.stop = color, stop
+    end
+    def inspect
+      to_s
+    end
+    def to_s
+      s = "#{color}"
+      if stop
+        s << " "
+        if stop.unitless?
+          s << stop.times(Sass::Script::Number.new(100, ["%"])).to_s
+        else
+          s << stop.to_s
+        end
+      end
+      s
+    end
+  end
+
+  module Functions
+    # returns the opposite position of a side or corner.
+    def grad_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
+          raise Sass::SyntaxError, "Cannot determine the opposite of #{pos}"
+        end
+      end
+      Sass::Script::String.new(opposite.join(" "))
+    end
+
+    # returns color-stop() calls for use in webkit.
+    def grad_color_stops(color_list)
+      normalize_stops!(color_list)
+      max = color_list.values.last.stop
+      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
+        "color-stop(#{stop}, #{pos.color})"
+      end
+      Sass::Script::String.new(color_stops.join(", "))
+    end
+    
+    # returns the end position of the gradient from the color stop
+    def grad_end_position(color_list, radial = Sass::Script::Bool.new(false))
+      default = Sass::Script::Number.new(100)
+      grad_position(color_list, Sass::Script::Number.new(color_list.values.size), default, radial)
+    end
+
+    def grad_position(color_list, index, default, radial = Sass::Script::Bool.new(false))
+      stop = color_list.values[index.value - 1].stop
+      if stop && radial.to_bool
+        orig_stop = stop
+        if stop.unitless?
+          if stop.value <= 1
+            # A unitless number is assumed to be a percentage when it's between 0 and 1
+            stop = stop.times(Sass::Script::Number.new(100, ["%"]))
+          else
+            # Otherwise, a unitless number is assumed to be in pixels
+            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, ["%"]))
+        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))
+      elsif stop
+        stop
+      else
+        default
+      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/
+          "left #{position}"
+        when /left|right/
+          "#{position} top"
+        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 Sass::Script::Color
+          ColorStop.new(arg)
+        when Sass::Script::String
+          color, stop = arg.value.split(/ +/, 2)
+          color = Sass::Script::Parser.parse(color, 0, 0)
+          if stop =~ /^(\d+)?(?:\.(\d+))?(%)?$/
+            integral, decimal, percent = $1, $2, $3
+            number = "#{integral || 0}.#{decimal || 0}".to_f
+            number = number / 100 if percent
+            if number > 1
+              raise Sass::SyntaxError, "A color stop location must be between 0#{"%" if percent} and 1#{"00%" if percent}. Got: #{stop}"
+            end
+            stop = Sass::Script::Number.new(number)
+          elsif !stop.nil?
+            number = Sass::Script::Parser.parse(stop, 0, 0)
+            unless number.is_a?(Sass::Script::Number)
+              raise Sass::SyntaxError, "A color stop location must be a number. Got: #{stop}"
+            end
+            stop = number
+          end
+          ColorStop.new(color, stop)
+        else
+          raise Sass::SyntaxError, "Not a valid color stop: #{arg}"          
+        end
+      end)
+    end
+    private
+    def normalize_stops!(color_list)
+      positions = color_list.values
+      # 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
+      # fill in empty values
+      for i in 0...positions.size
+        if positions[i].stop.nil?
+          num = 2.0
+          for j in (i+1)...positions.size
+            if positions[j].stop
+              positions[i].stop = positions[i-1].stop.plus((positions[j].stop.minus(positions[i-1].stop)).div(Sass::Script::Number.new(num)))
+              break
+            else
+              num += 1
+            end
+          end
+        end
+      end
+      # normalize unitless numbers
+      positions.each do |pos|
+        if pos.stop.unitless? && pos.stop.value <= 1
+          pos.stop = pos.stop.times(Sass::Script::Number.new(100, ["%"]))
+        elsif pos.stop.unitless?
+          pos.stop = pos.stop.times(Sass::Script::Number.new(1, ["px"]))
+        end
+      end
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Compass::SassExtensions::Functions::ImageSize
+  # Returns the width of the image relative to the images directory
+  def image_width(image_file)
+    image_path = real_path(image_file)
+    width = ImageProperties.new(image_path).size.first
+    Sass::Script::Number.new(width,["px"])
+  end
+
+  # Returns the height of the image relative to the images directory
+  def image_height(image_file)
+    image_path = real_path(image_file)
+    height = ImageProperties.new(image_path).size.last
+    Sass::Script::Number.new(height, ["px"])
+  end
+
+private
+  def real_path(image_file)
+    path = image_file.value
+    # Compute the real path to the image on the file stystem if the images_dir is set.
+    if Compass.configuration.images_path
+      File.join(Compass.configuration.images_path, path)
+    else
+      File.join(Compass.configuration.project_path, path)
+    end
+  end
+
+  class ImageProperties
+    def initialize(file)
+      @file = file
+      @file_type = File.extname(@file)[1..-1]
+    end
+
+    def size
+      @dimensions ||= send(:"get_size_for_#{@file_type}")
+    rescue NoMethodError
+      raise Sass::SyntaxError, "Unrecognized file type: #{@file_type}"
+    end
+
+  private
+    def get_size_for_png
+      IO.read(@file)[0x10..0x18].unpack('NN')
+    end
+
+    def get_size_for_gif
+      size = IO.read(@file)[6..10].unpack('SS')
+    end
+
+    def get_size_for_jpg
+      get_size_for_jpeg
+    end
+
+    def get_size_for_jpeg
+      jpeg = JPEG.new(@file)
+      [jpeg.width, jpeg.height]
+    end
+  end
+
+  class JPEG
+    attr_reader :width, :height, :bits
+
+    def initialize(file)
+      if file.kind_of? IO
+        examine(file)
+      else
+        File.open(file, 'rb') { |io| examine(io) }
+      end
+    end
+
+  private
+    def examine(io)
+      raise 'malformed JPEG' unless io.getc == 0xFF && io.getc == 0xD8 # SOI
+
+      class << io
+        def readint; (readchar << 8) + readchar; end
+        def readframe; read(readint - 2); end
+        def readsof; [readint, readchar, readint, readint, readchar]; end
+        def next
+          c = readchar while c != 0xFF
+          c = readchar while c == 0xFF
+          c
+        end
+      end
+
+      while marker = io.next
+        case marker
+          when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF # SOF markers
+            length, @bits, @height, @width, components = io.readsof
+            raise 'malformed JPEG' unless length == 8 + components * 3
+          when 0xD9, 0xDA then  break # EOI, SOS
+          when 0xFE then @comment = io.readframe # COM
+          when 0xE1 then io.readframe # APP1, contains EXIF tag
+          else io.readframe # ignore frame
+        end
+      end
+    end
+end
+end