compass-sourcemaps 0.12.2.sourcemaps.57a186c

data/lib/compass/installers/manifest.rb

@@ -0,0 +1,161 @@
+module Compass
+  module Installers
+
+    class Manifest
+      include Enumerable
+
+      # A Manifest entry
+      class Entry < Struct.new(:type, :from, :options)
+        def to
+          options[:to] || from
+        end
+      end
+
+      attr_reader :options
+      def initialize(manifest_file = nil, options = {})
+        @entries = []
+        @options = options
+        @generate_config = true
+        @compile_after_generation = true
+        parse(manifest_file) if manifest_file
+      end
+
+      def self.known_extensions
+        @known_extensions ||= {}
+      end
+
+      def self.plural_types
+        @plural_types ||= {}
+      end
+
+      def self.type(t, options = {})
+        Array(options[:extensions]).each do |ext|
+          self.known_extensions[ext] = t
+        end
+        self.plural_types[options[:plural]] = t if options[:plural]
+        eval <<-END
+          def #{t}(from, options = {})
+             @entries << Entry.new(:#{t}, from, options)
+          end
+          def has_#{t}?
+            @entries.detect {|e| e.type == :#{t}}
+          end
+          def each_#{t}
+            @entries.select {|e| e.type == :#{t}}.each {|e| yield e}
+          end
+        END
+      end
+
+      type :stylesheet, :plural => :stylesheets, :extensions => %w(scss sass)
+      type :image,      :plural => :images,      :extensions => %w(png gif jpg jpeg tiff gif)
+      type :javascript, :plural => :javascripts, :extensions => %w(js)
+      type :font,       :plural => :fonts,       :extensions => %w(eot otf woff ttf)
+      type :html,       :plural => :html,        :extensions => %w(html haml)
+      type :file,       :plural => :files
+      type :directory,  :plural => :directories
+
+      def discover(type)
+        type = self.class.plural_types[type] || type
+        dir = File.dirname(@manifest_file)
+        Dir.glob("#{dir}/**/*").each do |file|
+          next if /manifest\.rb/ =~ file
+          short_name = file[(dir.length+1)..-1]
+          options = {}
+          ext = if File.extname(short_name) == ".erb"
+            options[:erb] = true
+            File.extname(short_name[0..-5])
+          else
+            File.extname(short_name)
+          end[1..-1]
+          file_type = self.class.known_extensions[ext]
+          file_type = :file if file_type.nil?
+          file_type = :directory if File.directory?(file)
+          if type == :all || type == file_type
+            send(file_type, short_name, options)
+          end
+        end
+      end
+
+      def help(value = nil)
+        if value
+          @help = value
+        else
+          @help
+        end
+      end
+
+      attr_reader :welcome_message_options
+
+      def welcome_message(value = nil, options = {})
+        if value
+          @welcome_message = value
+          @welcome_message_options = options
+        else
+          @welcome_message
+        end
+      end
+
+      def welcome_message_options
+        @welcome_message_options || {}
+      end
+
+      def description(value = nil)
+        if value
+          @description = value
+        else
+          @description
+        end
+      end
+
+      # Enumerates over the manifest files
+      def each
+        @entries.each {|e| yield e}
+      end
+
+      def generate_config?
+        @generate_config
+      end
+
+      def compile?
+        @compile_after_generation
+      end
+
+      protected
+
+      def no_configuration_file!
+        @generate_config = false
+      end
+
+      def skip_compilation!
+        @compile_after_generation = false
+      end
+
+      def with_manifest(manifest_file)
+        @manifest_file = manifest_file
+        yield
+      ensure
+        @manifest_file = nil
+      end
+
+      # parses a manifest file which is a ruby script
+      # evaluated in a Manifest instance context
+      def parse(manifest_file)
+        with_manifest(manifest_file) do
+          if File.exists?(manifest_file)
+            open(manifest_file) do |f| 
+              eval(f.read, instance_binding, manifest_file)
+            end 
+          else
+              eval("discover :all", instance_binding, manifest_file)
+          end 
+        end 
+      end 
+
+
+      def instance_binding
+        binding
+      end
+    end
+
+  end
+end

data/lib/compass/installers/manifest_installer.rb

@@ -0,0 +1,61 @@
+module Compass
+  module Installers
+
+    class ManifestInstaller < Base
+
+      attr_accessor :manifest
+
+      def initialize(template_path, target_path, options = {})
+        super
+        @manifest = Manifest.new(manifest_file, options) if template_path
+      end
+
+      def manifest_file
+        @manifest_file ||= File.join(template_path, "manifest.rb")
+      end
+
+      # Initializes the project to work with compass
+      def init
+        dirs = manifest.map do |entry|
+          unless entry.type == :directory
+            loc = send("install_location_for_#{entry.type}", entry.to, entry.options)
+            File.dirname(loc)
+          end
+        end.compact
+
+        if manifest.has_stylesheet?
+          dirs << sass_dir
+          dirs << css_dir
+        end
+
+        dirs.uniq.sort.each do |dir|
+          directory targetize(dir)
+        end
+      end
+
+      # The default install method. Calls install_<type> methods in the order specified by the manifest.
+      def install
+        manifest.each do |entry|
+          send("install_#{entry.type}", entry.from, entry.to, entry.options)
+        end
+      end
+
+      def stylesheet_links
+        html = "<head>\n"
+        manifest.each_stylesheet do |stylesheet|
+          # Skip partials.
+          next if File.basename(stylesheet.from)[0..0] == "_"
+          media = if stylesheet.options[:media]
+            %Q{ media="#{stylesheet.options[:media]}"}
+          end
+          ss_line = %Q{  <link href="#{http_stylesheets_path}/#{stylesheet.to.sub(/\.s[ac]ss$/,'.css')}"#{media} rel="stylesheet" type="text/css" />}
+          if stylesheet.options[:condition]
+            ss_line = "  <!--[if #{stylesheet.options[:condition]}]>\n    #{ss_line}\n  <![endif]-->"
+          end
+          html << ss_line + "\n"
+        end
+        html << "</head>"
+      end
+    end
+  end
+end

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,34 @@
+module Compass::SassExtensions::Functions
+end
+
+%w(
+  selectors    enumerate  urls      display
+  inline_image image_size constants gradient_support
+  font_files   lists      colors    math
+  sprites      env        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::Math
+  include Compass::SassExtensions::Functions::Sprites
+  include Compass::SassExtensions::Functions::CrossBrowserSupport
+  include Compass::SassExtensions::Functions::Env
+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,67 @@
+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
+
+  def shade(color, percentage)
+    assert_type color, :Color
+    assert_type percentage, :Number
+    black = Sass::Script::Color.new([0, 0, 0])
+    mix(black, color, percentage)
+  end
+
+  def tint(color, percentage)
+    assert_type color, :Color
+    assert_type percentage, :Number
+    white = Sass::Script::Color.new([255, 255, 255])
+    mix(white, color, percentage)
+  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