compass-sass37 1.1.0

data/lib/compass/logger.rb

@@ -0,0 +1,140 @@
+module Compass
+
+  class Logger
+
+    COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33, :blue => 34 }
+
+    ACTION_COLORS = {
+      :error     => :red,
+      :warning   => :yellow,
+      :info      => :green,
+      :compile   => :green,
+      :overwrite => :yellow,
+      :modified  => :yellow,
+      :clean     => :yellow,
+      :write     => :green,
+      :create    => :green,
+      :remove    => :yellow,
+      :delete    => :yellow,
+      :deleted   => :yellow,
+      :created   => :yellow,
+      :exists    => :green,
+      :directory => :green,
+      :identical => :green,
+      :convert   => :green,
+      :unchanged => :yellow
+    }
+
+    DEFAULT_ACTIONS = ACTION_COLORS.keys
+
+    ACTION_CAN_BE_QUIET = {
+      :error     => false,
+      :warning   => true,
+      :info      => true,
+      :compile   => true,
+      :overwrite => true,
+      :modified  => true,
+      :clean     => true,
+      :write     => true,
+      :create    => true,
+      :remove    => true,
+      :delete    => true,
+      :deleted   => true,
+      :created   => true,
+      :exists    => true,
+      :directory => true,
+      :identical => true,
+      :convert   => true,
+      :unchanged => true
+    }
+
+    attr_accessor :actions, :options, :time
+
+    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)
+      return if options[:quiet] && ACTION_CAN_BE_QUIET[action]
+      msg = ""
+      if time
+        msg << Time.now.strftime("%I:%M:%S.%3N %p")
+      end
+      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 green
+      wrap(:green) { yield }
+    end
+
+    def red
+      wrap(:red) { yield }
+    end
+
+    def yellow
+      wrap(:yellow) { yield }
+    end
+
+    def wrap(c, reset_to = :clear)
+      $stderr.write(color(c))
+      $stdout.write(color(c))
+      yield
+    ensure
+      $stderr.write(color(reset_to))
+      $stdout.write(color(reset_to))
+      $stdout.flush
+    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
+
+    # Emit a log message without a trailing newline
+    def emit(msg)
+      print msg
+      $stdout.flush
+    end
+
+    # Emit a log message with a trailing newline
+    def log(msg)
+      puts msg
+      $stdout.flush
+    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 < Logger
+    def record(*args)
+    end
+
+    def log(msg)
+    end
+
+    def emit(msg)
+    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_compiler.rb

@@ -0,0 +1,152 @@
+require 'sass/plugin'
+
+class Compass::SassCompiler
+
+  include Compass::Actions
+
+  attr_writer :logger
+  attr_reader :quiet
+  attr_reader :error_count
+  attr_accessor :config
+  attr_accessor :display_compilation_times
+  attr_accessor :working_path
+  attr_accessor :only_sass_files
+
+  def initialize(options = {}, config = Compass.configuration)
+    options = options.dup
+    self.config = config
+    self.display_compilation_times = options.delete(:time)
+    self.working_path = options.delete(:working_path) || Dir.pwd
+    self.only_sass_files = options.delete(:only_sass_files) || []
+    @quiet = options[:quiet]
+    plugin_options = config.to_sass_plugin_options.merge(options)
+    if only_sass_files.any?
+      plugin_options[:template_location] = []
+      plugin_options[:load_paths] = config.sass_load_paths
+    end
+    plugin_options[:always_update] = true if options.delete(:force)
+    plugin_options[:compass] ||= {}
+    plugin_options[:compass][:logger] = logger
+    @compiler = Sass::Plugin::Compiler.new(plugin_options)
+    @start_times = {}
+    @error_count = 0
+
+    public_methods(true).grep(/^when_/).each do |callback|
+      @compiler.send(callback.to_s.sub(/^when_/, 'on_')) {|*args| send(callback, *args) }
+    end
+  end
+
+  def compile!
+    @compiler.update_stylesheets(individual_files)
+  end
+
+  def watch!(options = {}, &block)
+    skip_initial_update = options.fetch(:skip_initial_update, false)
+    begin
+      @compiler.watch(individual_files, options.merge(:skip_initial_update => skip_initial_update), &block)
+    rescue Sass::SyntaxError => e
+      skip_initial_update = true
+      retry
+    end
+  end
+
+  def individual_files
+    only_sass_files.map {|sass_file| [sass_file, corresponding_css_file(sass_file)]}
+  end
+
+  def clean!
+    @compiler.clean(individual_files)
+  end
+
+  def file_list
+    @compiler.file_list(individual_files)
+  end
+
+  def when_updating_stylesheets(individual_files)
+    @start_times = {}
+    @error_count = 0
+  end
+
+  def when_compilation_starting(sass_file, css, sourcemap)
+    @start_times[sass_file] = Time.now
+  end
+
+  def when_template_created(sass_file)
+    logger.record :created, relativize(sass_file)
+  end
+
+  def when_template_deleted(sass_file)
+    logger.record :deleted, relativize(sass_file)
+  end
+
+  def when_template_modified(sass_file)
+    logger.record :modified, relativize(sass_file)
+  end
+
+  def when_updated_stylesheet(sass_file, css, sourcemap)
+    if css && display_compilation_times && @start_times[sass_file]
+      duration = ((Time.now - @start_times[sass_file]) * 1000).round / 1000.0
+      logger.record :write, "#{relativize(css)} (#{duration}s)"
+    else
+      logger.record :write, relativize(css) if css
+    end
+    config.run_stylesheet_saved(css) if css
+
+    logger.record :write, relativize(sourcemap) if sourcemap
+    config.run_sourcemap_saved(sourcemap) if sourcemap
+  end
+
+  def when_creating_directory(dirname)
+    logger.record :directory, relativize(dirname)
+  end
+
+  def when_deleting_css(filename)
+    logger.record :delete, relativize(filename)
+    config.run_stylesheet_removed(filename) if filename
+  end
+
+  def when_deleting_sourcemap(filename)
+    logger.record :delete, relativize(filename)
+    config.run_sourcemap_removed(filename) if filename
+  end
+
+  def when_compilation_error(error, sass_file, css_file, sourcemap_file)
+    @error_count += 1
+    if error.respond_to?(:sass_filename)
+      error_filename = error.sass_filename || sass_file
+      if relativize(error_filename) == relativize(sass_file)
+        logger.record :error, "#{relativize(sass_file)} (Line #{error.sass_line}: #{error.message})"
+      else
+        logger.record :error, "#{relativize(sass_file)} (Line #{error.sass_line} of #{relativize(error_filename)}: #{error.message})"
+      end
+    else
+      logger.record :error, "#{relativize(sass_file)} (#{error.backtrace.first}: #{error.message})"
+    end
+    config.run_stylesheet_error(sass_file, error.message)
+  end
+
+  def logger
+    @logger ||= Compass::Logger.new(:quiet => quiet)
+  end
+
+  def corresponding_css_file(sass_file)
+    "#{config.css_path}/#{stylesheet_name(sass_file)}.css"
+  end
+
+  def stylesheet_name(sass_file)
+    if sass_file.index(config.sass_path) == 0
+      sass_file[(config.sass_path.length + 1)..-6].sub(/\.css$/,'')
+    else
+      raise Compass::Error, "Individual stylesheets must be in the sass directory."
+    end
+  end
+
+  def sass_files(options = {})
+    @compiler.template_location_array.map do |(sass_dir, css_dir)|
+      glob = options[:include_partials] ?
+               File.join("**","*.s[ac]ss*") :
+               File.join("**","[^_]*.s[ac]ss*")
+      Dir.glob(File.join(sass_dir, glob))
+    end.flatten
+  end
+end

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

@@ -0,0 +1,305 @@
+module Compass::SassExtensions::Functions::Sprites
+
+  extend Compass::SassExtensions::Functions::SassDeclarationHelper
+  extend Sass::Script::Value::Helpers
+  include Sass::Script::Value::Helpers
+
+  ZERO = number(0)
+  BOOL_FALSE = bool(false)
+  VALID_SELECTORS = %w(hover active target focus)
+
+  # Provides a consistent interface for getting a variable in ruby
+  # from a keyword argument hash that accounts for underscores/dash equivalence
+  # and allows the caller to pass a symbol instead of a string.
+  module VariableReader
+    def get_var(variable_name)
+      self[variable_name.to_s.gsub(/-/,"_")]
+    end
+  end
+
+  # Returns the width of the generated sprite map
+  def sprite_width(map, sprite=nil)
+    verify_map(map, 'sprite-width')
+    file = get_sprite_file(map, sprite)
+    width, _ = image_dimensions(file)
+    number(width, "px")
+  end
+  declare :sprite_width, [:map]
+  declare :sprite_width, [:map, :sprite]
+  
+  # Returns the height of the generated sprite map
+  def sprite_height(map, sprite=nil)
+    verify_map(map, 'sprite-height')
+    file = get_sprite_file(map, sprite)
+    _, height = image_dimensions(file)
+    number(height, "px")
+  end
+  declare :sprite_height, [:map]
+  declare :sprite_height, [:map, :sprite]
+
+  # Returns a list of all sprite names
+  def sprite_names(map)
+    verify_map(map, 'sprite-names')
+    list(map.sprite_names.map { |f| identifier(f) }, :comma)
+  end
+  declare :sprite_names, [:map]
+
+  # Returns the system path of the sprite file
+  def sprite_path(map)
+    verify_map(map, 'sprite-path')
+    identifier(map.filename)
+  end
+  declare :sprite_path, [:map]
+
+  # Returns the sprite file as an inline image
+  #    @include "icon/*.png";
+  #     #{$icon-sprite-base-class} {
+  #       background-image: inline-sprite($icon-sprites);
+  #      }
+  def inline_sprite(map)
+    verify_map(map, "sprite-url")
+    map.generate
+    path = map.filename
+    inline_image_string(data(path), compute_mime_type(path))
+  end
+  declare :inline_sprite, [:map]
+
+  # Creates a Compass::SassExtensions::Sprites::SpriteMap object. A sprite map, when used in a property is the same
+  # as calling sprite-url. So the following background properties are equivalent:
+  #
+  #     $icons: sprite-map("icons/*.png");
+  #     background: sprite-url($icons) no-repeat;
+  #     background: $icons no-repeat;
+  #
+  # The sprite map object will generate the sprite map image, if necessary,
+  # the first time it is converted to a url. Simply constructing it has no side-effects.
+  def sprite_map(glob, kwargs = {})
+    kwargs.extend VariableReader
+    Compass::SassExtensions::Sprites::SpriteMap.from_uri(glob, self, kwargs)
+  end
+  declare :sprite_map, [:glob], :var_kwargs => true
+
+  # Returns the image and background position for use in a single shorthand property:
+  #
+  #     $icons: sprite-map("icons/*.png"); // contains icons/new.png among others.
+  #     background: sprite($icons, new) no-repeat;
+  #
+  # Becomes:
+  #
+  #     background: url('/images/icons.png?12345678') 0 -24px no-repeat;
+  #
+  # If the `use_percentages` parameter is passed as true, percentages will be
+  # used to position the sprite. Example output:
+  #     
+  #     background: url('/images/icons.png?12345678') 0 50% no-repeat;
+  #
+  def sprite(map, sprite, offset_x = ZERO, offset_y = ZERO, use_percentages = BOOL_FALSE)
+    sprite = convert_sprite_name(sprite)
+    verify_map(map)
+    verify_sprite(sprite)
+    url = sprite_url(map)
+    position = sprite_position(map, sprite, offset_x, offset_y, use_percentages)
+    list([url] + position.value, :space)
+  end
+  declare :sprite, [:map, :sprite]
+  declare :sprite, [:map, :sprite, :offset_x]
+  declare :sprite, [:map, :sprite, :offset_x, :offset_y]
+  declare :sprite, [:map, :sprite, :offset_x, :offset_y, :use_percentages]
+
+  # Returns the name of a sprite map
+  # The name is derived from the folder than contains the sprites.
+  def sprite_map_name(map)
+    verify_map(map, "sprite-map-name")
+    identifier(map.name)
+  end
+  declare :sprite_name, [:sprite]
+
+  # Returns the path to the original image file for the sprite with the given name
+  def sprite_file(map, sprite)
+    sprite = convert_sprite_name(sprite)
+    verify_map(map, "sprite")
+    verify_sprite(sprite)
+    if image = map.image_for(sprite.value)
+      image_path = Pathname.new(File.expand_path(image.file))
+      images_path = Pathname.new(File.expand_path(Compass.configuration.images_path))
+      quoted_string(image_path.relative_path_from(images_path).to_s)
+    else
+      missing_image!(map, sprite)
+    end
+  end
+  declare :sprite_file, [:map, :sprite]
+
+  # Returns boolean if sprite has a parent
+  def sprite_does_not_have_parent(map, sprite)
+    sprite = convert_sprite_name(sprite)
+    verify_map map
+    verify_sprite sprite
+    bool(map.image_for(sprite.value).parent.nil?)
+  end
+  declare :sprite_does_not_have_parent, [:map, :sprite]
+
+  #return the name of the selector file
+  def sprite_selector_file(map, sprite, selector)
+    sprite = convert_sprite_name(sprite)
+    image = map.image_for(sprite)
+    if map.send(:"has_#{selector.value}?", sprite.value)
+      return identifier(image.send(selector.value).name)
+    end
+
+    raise Sass::SyntaxError, "Sprite: #{sprite.value} does not have a #{selector} state"
+  end
+
+  declare :sprite_selector_file, [:map, :sprite, :selector]
+
+  # Returns boolean if sprite has the selector
+  def sprite_has_selector(map, sprite, selector)
+    sprite = convert_sprite_name(sprite)
+    verify_map map
+    verify_sprite sprite
+    unless VALID_SELECTORS.include?(selector.value)
+      raise Sass::SyntaxError, "Invalid Selctor did you mean one of: #{VALID_SELECTORS.join(', ')}"
+    end
+    bool map.send(:"has_#{selector.value}?", sprite.value)
+  end
+  
+  declare :sprite_has_selector, [:map, :sprite, :selector]
+
+  # Determines if the CSS selector is valid
+  IDENTIFIER_RX = /\A#{Sass::SCSS::RX::IDENT}\Z/
+  def sprite_has_valid_selector(selector)
+    unless selector.value =~ IDENTIFIER_RX
+      raise Sass::SyntaxError, "#{selector} must be a legal css identifier"
+    end
+    bool true
+  end
+
+  # Returns a url to the sprite image.
+  def sprite_url(map)
+    verify_map(map, "sprite-url")
+    map.generate
+    generated_image_url(identifier("#{map.path}-s#{map.uniqueness_hash}.png"))
+  end
+  declare :sprite_url, [:map]
+
+  # Returns the position for the original image in the sprite.
+  # This is suitable for use as a value to background-position:
+  #
+  #     $icons: sprite-map("icons/*.png");
+  #     background-position: sprite-position($icons, new);
+  #
+  # Might generate something like:
+  #
+  #     background-position: 0 -34px;
+  #
+  # You can adjust the background relative to this position by passing values for
+  # `$offset-x` and `$offset-y`:
+  #
+  #     $icons: sprite-map("icons/*.png");
+  #     background-position: sprite-position($icons, new, 3px, -2px);
+  #
+  # Would change the above output to:
+  #
+  #     background-position: 3px -36px;
+  #
+  # If you set the `use_percentages` parameter to true, the position will be
+  # expressed in percentages. An example:
+  #
+  #     background-position: sprite-position($icons, new, 0, 0, true);
+  #
+  # Would result in something like this:
+  #
+  #     background-position: 0 42%;
+  # 
+  def sprite_position(map, sprite = nil, offset_x = ZERO, offset_y = ZERO, use_percentages = BOOL_FALSE)
+    assert_type offset_x, :Number
+    assert_type offset_y, :Number
+    sprite = convert_sprite_name(sprite)
+    verify_map(map, "sprite-position")
+    unless sprite.is_a?(Sass::Script::Value::String) || sprite.is_a?(Sass::Script::Value::Number)
+      raise Sass::SyntaxError, %Q(The second argument to sprite-position must be a sprite name. See http://beta.compass-style.org/help/tutorials/spriting/ for more information.)
+    end
+    image = map.image_for(sprite.value)
+    unless image
+      missing_image!(map, sprite)
+    end
+    if use_percentages.value
+      xdivis = map.width - image.width;
+      x = (offset_x.value + image.left.to_f) / (xdivis.nonzero? || 1) * 100
+      x = x == 0 ? number(x) : number(x, "%")
+      ydivis = map.height - image.height;
+      y = (offset_y.value + image.top.to_f) / (ydivis.nonzero? || 1) * 100
+      y = y == 0 ? number(y) : number(y, "%")
+    else
+      if offset_x.unit_str == "%"
+        x = offset_x # CE: Shouldn't this be a percentage of the total width?
+      else
+        x = offset_x.value - image.left
+        x = x == 0 ? number(x) : number(x, "px")
+      end
+      y = offset_y.value - image.top
+      y = y == 0 ? number(y) : number(y, "px")
+    end
+    list(x, y, :space)
+  end
+  declare :sprite_position, [:map]
+  declare :sprite_position, [:map, :sprite]
+  declare :sprite_position, [:map, :sprite, :offset_x]
+  declare :sprite_position, [:map, :sprite, :offset_x, :offset_y]
+  declare :sprite_position, [:map, :sprite, :offset_x, :offset_y, :use_percentages]
+
+protected
+
+  def get_sprite_file(map, sprite=nil)
+    if sprite
+      map.image_for(sprite).file
+    else
+      map.filename
+    end
+  end
+
+  def reversed_color_names
+    if Sass::Script::Value::Color.const_defined?(:HTML4_COLORS_REVERSE)
+      Sass::Script::Value::Color::HTML4_COLORS_REVERSE
+    else
+      Sass::Script::Value::Color::COLOR_NAMES_REVERSE
+    end
+  end
+
+  def convert_sprite_name(sprite)
+    case sprite
+      when Sass::Script::Value::Color
+        rgb = if reversed_color_names.keys.first.size == 3
+                sprite.rgb
+              else
+                # Sass 3.3 includes the alpha channel
+                sprite.rgba
+              end
+        identifier(reversed_color_names[rgb])
+      when Sass::Script::Value::Bool
+        identifier(sprite.to_s)
+      else
+        sprite
+    end
+  end
+
+  def verify_map(map, error = "sprite")
+    unless map.is_a?(Compass::SassExtensions::Sprites::SpriteMap)
+      missing_sprite!(error)
+    end
+  end
+
+  def verify_sprite(sprite)
+    unless sprite.is_a?(Sass::Script::Value::String) || sprite.is_a?(Sass::Script::Value::Number)
+      raise Sass::SyntaxError, %Q(The second argument to sprite() must be a sprite name. See http://beta.compass-style.org/help/tutorials/spriting/ for more information.)
+    end
+  end
+
+  def missing_image!(map, sprite)
+    raise Sass::SyntaxError, "No sprite called #{sprite} found in sprite map #{map.path}/#{map.name}. Did you mean one of: #{map.sprite_names.join(", ")}"
+  end
+
+  def missing_sprite!(function_name)
+    raise Sass::SyntaxError, %Q(The first argument to #{function_name}() must be a sprite map. See http://beta.compass-style.org/help/tutorials/spriting/ for more information.)
+  end
+
+end

data/lib/compass/sass_extensions/functions.rb

@@ -0,0 +1,15 @@
+module Compass::SassExtensions::Functions
+  module SassDeclarationHelper
+    def declare(*args)
+      Sass::Script::Functions.declare(*args)
+    end
+  end
+end
+
+%w(sprites).each do |func|
+  require "compass/sass_extensions/functions/#{func}"
+end
+
+module Sass::Script::Functions
+  include Compass::SassExtensions::Functions::Sprites
+end

data/lib/compass/sass_extensions/sprites/engines/chunky_png_engine.rb

@@ -0,0 +1,35 @@
+begin
+  require 'oily_png'
+rescue LoadError
+  require 'chunky_png'
+end
+
+module Compass
+  module SassExtensions
+    module Sprites
+      class ChunkyPngEngine < Compass::SassExtensions::Sprites::Engine
+
+        def construct_sprite
+          @canvas = ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+          images.each do |image|
+            input_png = begin
+              ChunkyPNG::Image.from_file(image.file)
+            rescue ChunkyPNG::SignatureMismatch
+              raise Compass::SpriteException, "You have provided a file that does not have a PNG signature. Only PNG files are supported by the default sprite engine"
+            end
+            canvas.replace! input_png, image.left, image.top
+          end
+        end    
+        
+        def save(filename)
+          if canvas.nil?
+            construct_sprite
+          end
+          
+          canvas.save(filename,  Compass.configuration.chunky_png_options)
+        end
+        
+      end
+    end
+  end
+end  

data/lib/compass/sass_extensions/sprites/engines.rb

@@ -0,0 +1,25 @@
+module Compass
+  module SassExtensions
+    module Sprites
+      class Engine
+        attr_accessor :width, :height, :images, :canvas
+        def initialize(width, height, images)
+          @width, @height, @images = width, height, images
+          @canvas = nil
+        end
+        
+        def construct_sprite
+          raise ::Compass::Error, "You must implement construct_sprite"
+        end
+        
+        def save(filename)
+          raise ::Compass::Error, "You must implement save(filename)"
+        end
+        
+      end
+    end
+  end
+end
+
+
+require 'compass/sass_extensions/sprites/engines/chunky_png_engine'