compass-edge 0.9.1

data/lib/compass/installers/manifest.rb

@@ -0,0 +1,79 @@
+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.type(t)
+        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
+      type :image
+      type :javascript
+      type :file
+      type :html
+
+      # 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
+
+      # parses a manifest file which is a ruby script
+      # evaluated in a Manifest instance context
+      def parse(manifest_file)
+        open(manifest_file) do |f|
+          eval(f.read, instance_binding, manifest_file)
+        end
+      end
+      def instance_binding
+        binding
+      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,42 @@
+module Compass
+  class Logger
+
+    DEFAULT_ACTIONS = [:directory, :exists, :remove, :create, :overwrite, :compile]
+
+    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)
+      log "#{action_padding(action)}#{action} #{arguments.join(' ')}"
+    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
+  end
+end

data/lib/compass/sass_extensions.rb

@@ -0,0 +1,5 @@
+module Compass::SassExtensions
+end
+
+require 'compass/sass_extensions/functions'
+require 'compass/sass_extensions/monkey_patches'

data/lib/compass/sass_extensions/functions.rb

@@ -0,0 +1,19 @@
+module Compass::SassExtensions::Functions
+end
+
+%w(selectors enumerate urls display inline_image).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
+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/display.rb

@@ -0,0 +1,22 @@
+module Compass::SassExtensions::Functions::Display
+  DEFAULT_DISPLAY = {
+    :block => %w{address blockquote center dir div dd dl dt fieldset form
+                 frameset h1 h2 h3 h4 h5 h6 hr isindex menu noframes
+                 noscript ol p pre ul},
+    :inline => %w{a abbr acronym b basefont bdo big br cite code dfn em
+                  font i img input kbd label q s samp select small span
+                  strike strong sub sup textarea tt u var},
+    :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}
+  }
+
+  # 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,6 @@
+module Compass::SassExtensions::Functions::Enumerate
+  def enumerate(prefix, from, through)
+    selectors = (from.value..through.value).map{|i| "#{prefix.value}-#{i}"}.join(", ")
+    Sass::Script::String.new(selectors)
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'base64'
+module Compass::SassExtensions::Functions::InlineImage
+
+  def inline_image(path, mime_type = nil)
+    path = path.value
+    real_path = File.join(Compass.configuration.project_path, Compass.configuration.images_dir, path)
+    url = "url('data:#{compute_mime_type(path,mime_type)};base64,#{data(real_path)}')"
+    Sass::Script::String.new(url)
+  end
+
+private
+  def compute_mime_type(path, mime_type)
+    return mime_type if mime_type
+    case path
+    when /\.png$/i
+      'image/png'
+    when /\.jpe?g$/i
+      'image/jpeg'
+    when /\.gif$/i
+      'image/gif'
+    when /\.([a-zA-Z]+)$/
+      "image/#{Regexp.last_match(1).downcase}"
+    else
+      raise Compass::Error, "A mime type could not be determined for #{path}, please specify one explicitly."
+    end
+  end
+
+  def data(real_path)
+    if File.readable?(real_path)
+      Base64.encode64(File.read(real_path)).gsub("\n","")
+    else
+      raise Compass::Error, "File not found or cannot be read: #{real_path}"
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Compass::SassExtensions::Functions::Selectors
+  COMMA_SEPARATOR = /\s*,\s*/
+
+  # Permute multiple selectors each of which may be comma delimited, the end result is
+  # a new selector that is the equivalent of nesting each under the previous selector.
+  # To illustrate, the following mixins are equivalent:
+  # =mixin-a(!selector1, !selector2, !selector3)
+  #   #{!selector1}
+  #     #{selector2}
+  #       #{selector3}
+  #         width: 2px
+  # =mixin-b(!selector1, !selector2)
+  #   #{nest(!selector, !selector2, !selector3)}
+  #     width: 2px
+  def nest(*arguments)
+    nested = arguments.map{|a| a.value}.inject do |memo,arg|
+      ancestors = memo.split(COMMA_SEPARATOR)
+      descendants = arg.split(COMMA_SEPARATOR)
+      ancestors.map{|a| descendants.map{|d| "#{a} #{d}"}.join(", ")}.join(", ")
+    end
+    Sass::Script::String.new(nested)
+  end
+
+  # Permute two selectors, the first may be comma delimited.
+  # The end result is a new selector that is the equivalent of nesting the second
+  # selector under the first one in a sass file and preceding it with an &.
+  # To illustrate, the following mixins are equivalent:
+  # =mixin-a(!selector, !to_append)
+  #   #{!selector}
+  #     &#{!to_append}
+  #       width: 2px
+  # =mixin-b(!selector, !to_append)
+  #   #{append_selector(!selector, !to_append)}
+  #     width: 2px
+  def append_selector(selector, to_append)
+    ancestors = selector.value.split(COMMA_SEPARATOR)
+    descendants = to_append.value.split(COMMA_SEPARATOR)
+    nested = ancestors.map{|a| descendants.map{|d| "#{a}#{d}"}.join(", ")}.join(", ")
+    Sass::Script::String.new(nested)
+  end
+
+end

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

@@ -0,0 +1,105 @@
+module Compass::SassExtensions::Functions::Urls
+
+  def stylesheet_url(path)
+    # Compute the path to the stylesheet, either root relative or stylesheet relative
+    # or nil if the http_images_path is not set in the configuration.
+    http_stylesheets_path = if relative?
+      compute_relative_path(Compass.configuration.css_dir)
+    elsif Compass.configuration.http_stylesheets_path
+      Compass.configuration.http_stylesheets_path
+    else
+      Compass.configuration.http_root_relative(Compass.configuration.css_dir)
+    end
+
+    url("#{http_stylesheets_path}/#{path}")
+  end
+
+  def image_url(path)
+    path = path.value # get to the string value of the literal.
+    # Short curcuit if they have provided an absolute url.
+    if absolute_path?(path)
+      return Sass::Script::String.new("url(#{path})")
+    end
+
+    # Compute the path to the image, either root relative or stylesheet relative
+    # or nil if the http_images_path is not set in the configuration.
+    http_images_path = if relative?
+      compute_relative_path(Compass.configuration.images_dir)
+    elsif Compass.configuration.http_images_path
+      Compass.configuration.http_images_path
+    else
+      Compass.configuration.http_root_relative(Compass.configuration.images_dir)
+    end
+
+    # Compute the real path to the image on the file stystem if the images_dir is set.
+    real_path = if Compass.configuration.images_dir
+      File.join(Compass.configuration.project_path, Compass.configuration.images_dir, path)
+    end
+
+    # prepend the path to the image if there's one
+    if http_images_path
+      http_images_path = "#{http_images_path}/" unless http_images_path[-1..-1] == "/"
+      path = "#{http_images_path}#{path}"
+    end
+
+    # Compute the asset host unless in relative mode.
+    asset_host = if !relative? && Compass.configuration.asset_host
+      Compass.configuration.asset_host.call(path)
+    end
+
+    # Compute and append the cache buster if there is one.
+    if buster = compute_cache_buster(path, real_path)
+      path += "?#{buster}"
+    end
+
+    # prepend the asset host if there is one.
+    path = "#{asset_host}#{'/' unless path[0..0] == "/"}#{path}" if asset_host
+
+    url(path)
+  end
+
+  # Emits a url, taking off any leading "./"
+  def url(url)
+    url = url.to_s
+    url = url[0..1] == "./" ? url[2..-1] : url
+    Sass::Script::String.new("url('#{url}')")
+  end
+
+  private
+
+  def relative?
+    Compass.configuration.relative_assets?
+  end
+
+  def absolute_path?(path)
+    path[0..0] == "/" || path[0..3] == "http"
+  end
+
+  def compute_relative_path(dir)
+    if (target_css_file = options[:css_filename])
+      path = File.join(Compass.configuration.project_path, dir)
+      Pathname.new(path).relative_path_from(Pathname.new(File.dirname(target_css_file))).to_s
+    end
+  end
+
+  def compute_cache_buster(path, real_path)
+    if Compass.configuration.asset_cache_buster
+      args = [path]
+      if Compass.configuration.asset_cache_buster.arity > 1
+        args << (File.new(real_path) if real_path)
+      end
+      Compass.configuration.asset_cache_buster.call(*args)
+    elsif real_path
+      default_cache_buster(path, real_path)
+    end
+  end
+
+  def default_cache_buster(path, real_path)
+    if File.readable?(real_path)
+      File.mtime(real_path).strftime("%s") 
+    else
+      $stderr.puts "WARNING: '#{File.basename(path)}' was not found (or cannot be read) in #{File.dirname(real_path)}"
+    end
+  end
+
+end

data/lib/compass/sass_extensions/monkey_patches.rb

@@ -0,0 +1,3 @@
+%w(stylesheet_updating).each do |patch|
+  require "compass/sass_extensions/monkey_patches/#{patch}"
+end

data/lib/compass/sass_extensions/monkey_patches/stylesheet_updating.rb

@@ -0,0 +1,23 @@
+require 'sass/plugin'
+
+# XXX: We can remove this monkeypatch once Sass 2.2 is released.
+module Sass::Plugin
+  class << self
+    unless method_defined?(:exact_stylesheet_needs_update?)
+      def stylesheet_needs_update?(name, template_path, css_path)
+        css_file = css_filename(name, css_path)
+        template_file = template_filename(name, template_path)
+        exact_stylesheet_needs_update?(css_file, template_file)
+      end
+      def exact_stylesheet_needs_update?(css_file, template_file)
+        if !File.exists?(css_file)
+          return true
+        else
+          css_mtime = File.mtime(css_file)
+          File.mtime(template_file) > css_mtime ||
+            dependencies(template_file).any?(&dependency_updated?(css_mtime))
+        end
+      end
+    end
+  end
+end

data/lib/compass/test_case.rb

@@ -0,0 +1,38 @@
+module Compass
+  # Write your unit test like this if you want to make sure all your stylesheets compile.
+  #
+  # require 'compass/test_case'
+  # class StylesheetsTest < Compass::TestCase
+  #   def test_stylesheets
+  #     my_sass_files.each do |sass_file|
+  #       assert_compiles(sass_file) do |result|
+  #         assert_not_blank result
+  #       end
+  #     end
+  #   end
+  #   protected
+  #   def my_sass_files
+  #     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../..", "app/stylesheets/**/[^_]*.sass")))
+  #   end
+  # end
+  class TestCase < (defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase)
+
+    def setup
+      super
+      @last_compile = nil
+    end
+
+    def compile(stylesheet)
+      input =  open(stylesheet)
+      template = input.read()
+      input.close()
+      @last_compile = ::Sass::Engine.new(template, ::Sass::Plugin.engine_options(:filename => stylesheet)).render
+      yield @last_compile if block_given?
+    end
+
+    def assert_compiles(stylesheet, &block)
+      compile(stylesheet, &block)
+    end
+
+  end
+end