compass 0.8.16

data/lib/compass/commands/stamp_pattern.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'update_project')
+
+module Compass
+  module Commands
+    class StampPattern < ProjectBase
+
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super(working_path, options)
+      end
+
+      # all commands must implement perform
+      def perform
+        installer.init
+        installer.run(:skip_finalization => true)
+        UpdateProject.new(working_path, options).perform if installer.compilation_required?
+        installer.finalize(:create => is_project_creation?)
+      end
+
+      def is_project_creation?
+        false
+      end
+
+      def template_directory(pattern)
+        File.join(framework.templates_directory, pattern)
+      end
+
+    end
+  end
+end

data/lib/compass/commands/update_project.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'project_base')
+require File.join(Compass.lib_directory, 'compass', 'compiler')
+
+module Compass
+  module Commands
+    class UpdateProject < ProjectBase
+      
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        compiler = new_compiler_instance
+        if compiler.sass_files.empty?
+          message = "Nothing to compile. If you're trying to start a new project, you have left off the directory argument.\n"
+          message << "Run \"compass -h\" to get help."
+          raise Compass::Error, message
+        else
+          compiler.run
+        end
+      end
+
+      def new_compiler_instance(additional_options = {})
+        Compass::Compiler.new(working_path,
+          projectize(Compass.configuration.sass_dir),
+          projectize(Compass.configuration.css_dir),
+          Compass.sass_engine_options.merge(:quiet => options[:quiet],
+                                            :force => options[:force]).merge(additional_options))
+      end
+
+    end
+  end
+end

data/lib/compass/commands/validate_project.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'project_base')
+require File.join(File.dirname(__FILE__), 'update_project')
+
+module Compass
+  module Commands
+    class ValidateProject < ProjectBase
+      
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        require File.join(File.dirname(__FILE__), '..', 'validator')
+        UpdateProject.new(working_path, options).perform
+        Validator.new(project_css_subdirectory).validate()
+      end
+
+    end
+  end
+end

data/lib/compass/commands/watch_project.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'pathname'
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'update_project')
+
+module Compass
+  module Commands
+    class WatchProject < UpdateProject
+
+      attr_accessor :last_update_time, :last_sass_files
+
+      def perform
+        Signal.trap("INT") do
+          puts ""
+          exit 0
+        end
+
+        recompile
+
+        puts ">>> Compass is watching for changes. Press Ctrl-C to Stop."
+
+        require File.join(Compass.lib_directory, 'vendor', 'fssm')
+
+        FSSM.monitor do |monitor|
+          Compass.configuration.sass_load_paths.each do |load_path|
+            monitor.path load_path do |path|
+              path.glob '**/*.sass'
+
+              path.update &method(:recompile)
+              path.delete {|base, relative| remove_obsolete_css(base,relative); recompile(base, relative)}
+              path.create &method(:recompile)
+            end
+          end
+
+        end
+        
+      end
+
+      def remove_obsolete_css(base = nil, relative = nil)
+        compiler = new_compiler_instance(:quiet => true)
+        sass_files = compiler.sass_files
+        deleted_sass_files = (last_sass_files || []) - sass_files
+        deleted_sass_files.each do |deleted_sass_file|
+          css_file = compiler.corresponding_css_file(deleted_sass_file)
+          remove(css_file) if File.exists?(css_file)
+        end
+        self.last_sass_files = sass_files
+      end
+
+      def recompile(base = nil, relative = nil)
+        compiler = new_compiler_instance(:quiet => true)
+        if file = compiler.out_of_date?
+          begin
+            puts ">>> Change detected to: #{file}"
+            compiler.run
+          rescue StandardError => e
+            ::Compass::Exec.report_error(e, options)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/compass/commands/write_configuration.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'project_base')
+
+module Compass
+  module Commands
+    class WriteConfiguration < ProjectBase
+      
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        installer.write_configuration_files(options[:configuration_file])
+      end
+
+      def installer_args
+        [nil, project_directory, options]
+      end
+
+      def explicit_config_file_must_be_readable?
+        false
+      end
+
+    end
+  end
+end

data/lib/compass/compiler.rb

@@ -0,0 +1,54 @@
+module Compass
+  class Compiler
+
+    include Actions
+
+    attr_accessor :working_path, :from, :to, :options
+
+    def initialize(working_path, from, to, options)
+      self.working_path = working_path
+      self.from, self.to = from, to
+      self.logger = options.delete(:logger)
+      self.options = options
+      self.options[:cache_location] ||= File.join(from, ".sass-cache")
+    end
+
+    def sass_files
+      @sass_files || Dir.glob(separate("#{from}/**/[^_]*.sass"))
+    end
+
+    def stylesheet_name(sass_file)
+      sass_file[("#{from}/".length)..-6]
+    end
+
+    def css_files
+      @css_files ||= sass_files.map{|sass_file| corresponding_css_file(sass_file)}
+    end
+
+    def corresponding_css_file(sass_file)
+      "#{to}/#{stylesheet_name(sass_file)}.css"
+    end
+
+    def target_directories
+      css_files.map{|css_file| File.dirname(css_file)}.uniq.sort.sort_by{|d| d.length }
+    end
+
+    def out_of_date?
+      Compass.configure_sass_plugin! unless Compass.sass_plugin_configured?
+      sass_files.zip(css_files).each do |sass_filename, css_filename|
+        return sass_filename if Sass::Plugin.exact_stylesheet_needs_update?(css_filename, sass_filename)
+      end
+      false
+    end
+
+    def run
+      Compass.configure_sass_plugin! unless Compass.sass_plugin_configured?
+      target_directories.each do |dir|
+        directory dir
+      end
+      sass_files.zip(css_files).each do |sass_filename, css_filename|
+        compile sass_filename, css_filename, options
+      end
+    end
+  end
+end

data/lib/compass/configuration.rb

@@ -0,0 +1,324 @@
+require 'singleton'
+
+module Compass
+  class Configuration
+    include Singleton
+
+    ATTRIBUTES = [
+      :project_type,
+      :project_path,
+      :http_path,
+      :css_dir,
+      :sass_dir,
+      :images_dir,
+      :javascripts_dir,
+      :output_style,
+      :environment,
+      :relative_assets,
+      :http_images_path,
+      :http_stylesheets_path,
+      :http_javascripts_path,
+      :additional_import_paths,
+      :sass_options
+    ]
+
+    attr_accessor *ATTRIBUTES
+
+    attr_accessor :required_libraries
+
+    def initialize
+      self.required_libraries = []
+    end
+
+    # parses a manifest file which is a ruby script
+    # evaluated in a Manifest instance context
+    def parse(config_file)
+      open(config_file) do |f|
+        parse_string(f.read, config_file)
+      end
+    end
+
+    def parse_string(contents, filename)
+      bind = binding
+      eval(contents, bind, filename)
+      ATTRIBUTES.each do |prop|
+        value = eval(prop.to_s, bind) rescue nil
+        self.send("#{prop}=", value) if value
+      end
+      if @added_import_paths
+        self.additional_import_paths ||= []
+        self.additional_import_paths += @added_import_paths
+      end
+      issue_deprecation_warnings
+    end
+
+    def set_all(options)
+      ATTRIBUTES.each do |a|
+        self.send("#{a}=", options[a]) if options.has_key?(a)
+      end
+    end
+
+    def set_maybe(options)
+      ATTRIBUTES.each do |a|
+        self.send("#{a}=", options[a]) if options[a]
+      end
+    end
+
+    def default_all(options)
+      ATTRIBUTES.each do |a|
+        set_default_unless_set(a, options[a])
+      end
+    end
+
+    def set_default_unless_set(attribute, value)
+      self.send("#{attribute}=", value) unless self.send(attribute)
+    end
+
+    def set_defaults!
+      ATTRIBUTES.each do |a|
+        set_default_unless_set(a, default_for(a))
+      end
+    end
+
+    def default_for(attribute)
+      method = "default_#{attribute}".to_sym
+      self.send(method) if respond_to?(method)
+    end
+
+    def default_sass_dir
+      "src"
+    end
+
+    def default_css_dir
+      "stylesheets"
+    end
+
+    def default_images_dir
+      "images"
+    end
+
+    def default_http_path
+      "/"
+    end
+
+    def comment_for_http_path
+      "# Set this to the root of your project when deployed:\n"
+    end
+
+    def relative_assets?
+      # the http_images_path is deprecated, but here for backwards compatibility.
+      relative_assets || http_images_path == :relative
+    end
+
+    def comment_for_relative_assets
+      unless relative_assets
+        %q{# To enable relative paths to assets via compass helper functions. Uncomment:
+# relative_assets = true
+}
+      else
+        ""
+      end
+    end
+
+    def default_output_style
+      if environment == :development
+        :expanded
+      else
+        :compact
+      end
+    end
+
+    def default_line_comments
+      environment == :development
+    end
+
+    def sass_path
+      if project_path && sass_dir
+        File.join(project_path, sass_dir)
+      end
+    end
+
+    def css_path
+      if project_path && css_dir
+        File.join(project_path, css_dir)
+      end
+    end
+
+    def root_relative(path)
+      hp = http_path || default_http_path
+      hp = hp[0..-2] if hp[-1..-1] == "/"
+      "#{hp}/#{path}"
+    end
+
+    def add_import_path(*paths)
+      # The @added_import_paths variable works around an issue where
+      # the additional_import_paths gets overwritten during parse
+      @added_import_paths ||= []
+      @added_import_paths += paths
+      self.additional_import_paths ||= []
+      self.additional_import_paths += paths
+    end
+
+    # When called with a block, defines the asset host url to be used.
+    # The block must return a string that starts with a protocol (E.g. http).
+    # The block will be passed the root-relative url of the asset.
+    # When called without a block, returns the block that was previously set.
+    def asset_host(&block)
+      if block_given?
+        @asset_host = block
+      else
+        @asset_host
+      end
+    end
+
+    # When called with a block, defines the cache buster strategy to be used.
+    # The block must return nil or a string that can be appended to a url as a query parameter.
+    # The returned string must not include the starting '?'.
+    # The block will be passed the root-relative url of the asset.
+    # If the block accepts two arguments, it will also be passed a File object
+    # that points to the asset on disk -- which may or may not exist.
+    # When called without a block, returns the block that was previously set.
+    def asset_cache_buster(&block)
+      if block_given?
+        @asset_cache_buster = block
+      else
+        @asset_cache_buster
+      end
+    end
+
+
+    def serialize
+      if asset_cache_buster
+        raise Compass::Error, "Cannot serialize a configuration with asset_cache_buster set."
+      end
+      if asset_host
+        raise Compass::Error, "Cannot serialize a configuration with asset_host set."
+      end
+      contents = ""
+      required_libraries.each do |lib|
+        contents << %Q{require '#{lib}'\n}
+      end
+      contents << "# Require any additional compass plugins here.\n"
+      contents << "\n" if required_libraries.any?
+      ATTRIBUTES.each do |prop|
+        value = send(prop)
+        if respond_to?("comment_for_#{prop}")
+          contents << send("comment_for_#{prop}")
+        end
+        if block_given? && (to_emit = yield(prop, value))
+          contents << to_emit
+        else
+          contents << Configuration.serialize_property(prop, value) unless value.nil?
+        end
+      end
+      contents
+    end
+
+    def self.serialize_property(prop, value)
+      %Q(#{prop} = #{value.inspect}\n)
+    end
+
+    def to_compiler_arguments(additional_options)
+      [project_path, sass_path, css_path, to_sass_engine_options.merge(additional_options)]
+    end
+
+    def to_sass_plugin_options
+      locations = {}
+      locations[sass_path] = css_path if sass_path && css_path
+      Compass::Frameworks::ALL.each do |framework|
+        locations[framework.stylesheets_directory] = css_path || css_dir || "."
+      end
+      resolve_additional_import_paths.each do |additional_path|
+        locations[additional_path] = File.join(css_path || css_dir || ".", File.basename(additional_path))
+      end
+      plugin_opts = {:template_location => locations}
+      plugin_opts[:style] = output_style if output_style
+      plugin_opts[:line_comments] = default_line_comments if environment
+      plugin_opts.merge!(sass_options || {})
+      plugin_opts
+    end
+
+    def resolve_additional_import_paths
+      (additional_import_paths || []).map do |path|
+        if project_path && !absolute_path?(path)
+          File.join(project_path, path)
+        else
+          path
+        end
+      end
+    end
+
+    def to_sass_engine_options
+      engine_opts = {:load_paths => sass_load_paths}
+      engine_opts[:style] = output_style if output_style
+      engine_opts[:line_comments] = default_line_comments if environment
+      engine_opts.merge!(sass_options || {})
+    end
+
+    def sass_load_paths
+      load_paths = []
+      load_paths << sass_path if sass_path
+      Compass::Frameworks::ALL.each do |framework|
+        load_paths << framework.stylesheets_directory if File.exists?(framework.stylesheets_directory)
+      end
+      load_paths += resolve_additional_import_paths
+      load_paths
+    end
+
+    # Support for testing.
+    def reset!
+      ATTRIBUTES.each do |attr|
+        send("#{attr}=", nil)
+      end
+      @asset_cache_buster = nil
+      @asset_host = nil
+      @added_import_paths = nil
+      self.required_libraries = []
+    end
+
+    def issue_deprecation_warnings
+      if http_images_path == :relative
+        puts "DEPRECATION WARNING: Please set relative_assets = true to enable relative paths."
+      end
+    end
+
+    def require(lib)
+      required_libraries << lib
+      super
+    end
+
+    def absolute_path?(path)
+      # This is only going to work on unix, gonna need a better implementation.
+      path.index(File::SEPARATOR) == 0
+    end
+  end
+
+  module ConfigHelpers
+    def configuration
+      if block_given?
+        yield Configuration.instance
+      end
+      Configuration.instance
+    end
+
+    def sass_plugin_configuration
+      configuration.to_sass_plugin_options
+    end
+
+    def configure_sass_plugin!
+      @sass_plugin_configured = true
+      Sass::Plugin.options.merge!(sass_plugin_configuration)
+    end
+
+    def sass_plugin_configured?
+      @sass_plugin_configured
+    end
+
+    def sass_engine_options
+      configuration.to_sass_engine_options
+    end
+  end
+
+  extend ConfigHelpers
+
+end