compass 0.8.16

data/lib/compass/installers/manifest.rb

@@ -0,0 +1,58 @@
+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
+
+      def initialize(manifest_file = nil)
+        @entries = []
+        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
+
+      # Enumerates over the manifest files
+      def each
+        @entries.each {|e| yield e}
+      end
+
+
+      protected
+      # 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/rails.rb

@@ -0,0 +1,135 @@
+module Compass
+  module Installers
+    
+    class RailsInstaller < Base
+
+      def configuration_defaults
+        {
+          :sass_dir => (sass_dir || prompt_sass_dir),
+          :css_dir => (css_dir || prompt_css_dir),
+          :images_dir => default_images_dir,
+          :javascripts_dir => default_javascripts_dir,
+          :http_stylesheets_path => default_http_stylesheets_path,
+          :http_javascripts_path => default_http_javascripts_path,
+          :http_images_path => default_http_images_path
+        }
+      end
+
+      def write_configuration_files(config_file = nil)
+        config_file ||= targetize('config/compass.config')
+        write_file config_file, config_contents
+        write_file targetize('config/initializers/compass.rb'), initializer_contents
+      end
+
+      def config_files_exist?
+        File.exists?(targetize('config/compass.config')) &&
+        File.exists?(targetize('config/initializers/compass.rb'))
+      end
+
+      def prepare
+        write_configuration_files unless config_files_exist?
+      end
+
+      def finalize(options = {})
+        if options[:create]
+          puts <<-NEXTSTEPS
+
+Congratulations! Your rails project has been configured to use Compass.
+Sass will automatically compile your stylesheets during the next
+page request and keep them up to date when they change.
+Make sure you restart your server!
+NEXTSTEPS
+        end
+        puts "\nNext add these lines to the head of your layouts:\n\n"
+        puts stylesheet_links
+        puts "\n(You are using haml, aren't you?)"
+      end
+
+      def default_images_dir
+        separate("public/images")
+      end
+
+      def default_javascripts_dir
+        separate("public/javascripts")
+      end
+
+      def default_http_images_path
+        "/images"
+      end
+
+      def default_http_javascripts_path
+        "/javascripts"
+      end
+
+      def default_http_stylesheets_path
+        "/stylesheets"
+      end
+
+      def prompt_sass_dir
+        recommended_location = separate('app/stylesheets')
+        default_location = separate('public/stylesheets/sass')
+        print %Q{Compass recommends that you keep your stylesheets in #{recommended_location}
+instead of the Sass default location of #{default_location}.
+Is this OK? (Y/n) }
+        answer = gets.downcase[0]
+        answer == ?n ? default_location : recommended_location
+      end
+
+      def prompt_css_dir
+        recommended_location = separate("public/stylesheets/compiled")
+        default_location = separate("public/stylesheets")
+        puts
+        print %Q{Compass recommends that you keep your compiled css in #{recommended_location}/
+instead the Sass default of #{default_location}/.
+However, if you're exclusively using Sass, then #{default_location}/ is recommended.
+Emit compiled stylesheets to #{recommended_location}/? (Y/n) }
+        answer = gets.downcase[0]
+        answer == ?n ? default_location : recommended_location
+      end
+
+      def config_contents
+        Compass.configuration.serialize do |prop, value|
+          if prop == :project_path
+            "project_path = RAILS_ROOT if defined?(RAILS_ROOT)\n"
+          elsif prop == :output_style
+            ""
+          end
+        end
+      end
+
+      def initializer_contents
+        %Q{require 'compass'
+# If you have any compass plugins, require them here.
+Compass.configuration.parse(File.join(RAILS_ROOT, "config", "compass.config"))
+Compass.configuration.environment = RAILS_ENV.to_sym
+Compass.configure_sass_plugin!
+}
+      end
+
+      def stylesheet_prefix
+        if css_dir.length >= 19
+          "#{css_dir[19..-1]}/"
+        else
+          nil
+        end
+      end
+
+      def stylesheet_links
+        html = "%head\n"
+        manifest.each_stylesheet do |stylesheet|
+          # Skip partials.
+          next if File.basename(stylesheet.from)[0..0] == "_"
+          ss_line = "  = stylesheet_link_tag '#{stylesheet_prefix}#{stylesheet.to.sub(/\.sass$/,'.css')}'"
+          if stylesheet.options[:media]
+            ss_line += ", :media => '#{stylesheet.options[:media]}'"
+          end
+          if stylesheet.options[:condition]
+            ss_line = "  /[if #{stylesheet.options[:condition]}]\n  " + ss_line
+          end
+          html << ss_line + "\n"
+        end
+        html
+      end
+    end
+  end
+end

data/lib/compass/installers/stand_alone.rb

@@ -0,0 +1,60 @@
+module Compass
+  module Installers
+    
+    class StandAloneInstaller < Base
+
+      def init
+        directory targetize("")
+        super
+      end
+
+      def write_configuration_files(config_file = nil)
+        config_file ||= targetize('config.rb')
+        write_file config_file, config_contents
+      end
+
+      def config_files_exist?
+        File.exists? targetize('config.rb')
+      end
+
+      def config_contents
+        project_path, Compass.configuration.project_path = Compass.configuration.project_path, nil
+        Compass.configuration.serialize
+      ensure
+        Compass.configuration.project_path = project_path
+      end
+
+      def prepare
+        write_configuration_files unless config_files_exist?
+      end
+
+      # We want to rely on the defaults provided by Configuration
+      def configuration_defaults
+        {}
+      end
+
+      def finalize(options = {})
+        if options[:create]
+          puts <<-NEXTSTEPS
+
+Congratulations! Your compass project has been created.
+You must recompile your sass stylesheets when they change.
+This can be done in one of the following ways:
+  1. From within your project directory run:
+     compass
+  2. From any directory run:
+     compass -u path/to/project
+  3. To monitor your project for changes and automatically recompile:
+     compass --watch [path/to/project]
+NEXTSTEPS
+        end
+        puts "\nTo import your new stylesheets add the following lines of HTML (or equivalent) to your webpage:"
+        puts stylesheet_links
+      end
+
+      def compilation_required?
+        true
+      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 File.join(File.dirname(__FILE__), 'sass_extensions', 'functions')
+require File.join(File.dirname(__FILE__), 'sass_extensions', 'monkey_patches')

data/lib/compass/sass_extensions/functions.rb

@@ -0,0 +1,19 @@
+module Compass::SassExtensions::Functions
+end
+
+['selectors', 'enumerate', 'urls', 'display', 'inline_image'].each do |func|
+  require File.join(File.dirname(__FILE__), '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,39 @@
+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)
+    Sass::Script::String.new(selector.value.split(COMMA_SEPARATOR).map{|s| "#{s}#{to_append}"}.join(", "))
+  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.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.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