compass-rails31 0.12.0.alpha.0.91a748a

data/lib/compass/commands/write_configuration.rb

@@ -0,0 +1,125 @@
+require 'compass/commands/project_base'
+
+module Compass
+  module Commands
+    module ConfigurationOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass config [path/to/config_file.rb] [options]
+
+          Description:
+            Generate a configuration file for the options specified.
+            Compass will recognize configuration files in the
+            following locations relative to the project root:
+              * #{Compass::Configuration::Helpers::KNOWN_CONFIG_LOCATIONS.join("
+              * ")}
+            Any other location, and you'll need to specify it when working with the command line tool using the -c option.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+        opts.on("--debug [PROPERTY]", "Debug your configuration by printing out details.") do |prop|
+          self.options[:debug] = prop.nil? ? true : prop.to_sym
+        end
+        opts.on("-p PROPERTY", "--property PROPERTY", "Print out the value of a particular configuration property") do |prop|
+          self.options[:display] = prop.to_sym
+        end
+
+        super
+      end
+    end
+    class WriteConfiguration < ProjectBase
+
+      register :config
+
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def add_project_configuration
+        Compass.add_project_configuration
+      end
+
+      def perform
+        if options[:display]
+          if Compass.configuration.respond_to?(options[:display])
+            puts Compass.configuration.send(options[:display])
+          else
+            raise Compass::Error, "ERROR: configuration property '#{options[:display]}' does not exist"
+          end
+        elsif options[:debug]
+          puts "Configuration sources:"
+          c = Compass.configuration
+          while c
+            print c.name
+            c = c.inherited_data
+            print ", " if c
+          end
+          print "\n"
+          Compass.configuration.debug.each do |prop, values|
+            if options[:debug].is_a?(Symbol)
+              next unless prop == options[:debug]
+            end
+            puts "***** #{prop} = #{values.first[:resolved].inspect} *****"
+            [:default, :value, :raw, :resolved].each do |kind|
+              puts "#{kind}: " + values.inject([]){|m, v| m << v[kind]}.map{|v| v.nil? ? '-' : v.inspect}.join(", ")
+            end
+          end
+        else
+          config_file = options[:configuration_file]
+          config_file ||= Compass.detect_configuration_file
+          config_file ||= Compass::Configuration::Helpers::KNOWN_CONFIG_LOCATIONS.first
+          directory File.dirname(config_file)
+          installer.write_configuration_files(config_file)
+        end
+      end
+
+      def installer_args
+        [nil, project_directory, options]
+      end
+
+      def explicit_config_file_must_be_readable?
+        false
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(ConfigurationOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Generate a configuration file for the provided command line options."
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size == 1
+            parser.options[:configuration_file] = arguments.shift
+          elsif arguments.size == 0
+            # default to the current directory.
+          else
+            raise Compass::Error, "Too many arguments were specified."
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/compiler.rb

@@ -0,0 +1,183 @@
+module Compass
+  class Compiler
+
+    include Actions
+
+    attr_accessor :working_path, :from, :to, :options, :sass_options, :staleness_checker, :importer
+
+    def initialize(working_path, from, to, options)
+      self.working_path = working_path.to_s
+      self.from, self.to = File.expand_path(from), to
+      self.logger = options.delete(:logger)
+      sass_opts = options.delete(:sass) || {}
+      self.options = options
+      self.sass_options = options.dup
+      self.sass_options.update(sass_opts)
+      self.sass_options[:cache_location] ||= determine_cache_location
+      self.sass_options[:importer] = self.importer = Sass::Importers::Filesystem.new(from)
+      self.staleness_checker = Sass::Plugin::StalenessChecker.new(sass_options)
+    end
+
+    def determine_cache_location
+      Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
+    end
+
+    def sass_files(options = {})
+      exclude_partials = options.fetch(:exclude_partials, true)
+      @sass_files = self.options[:sass_files] || Dir.glob(separate("#{from}/**/#{'[^_]' if exclude_partials}*.s[ac]ss"))
+    end
+
+    def relative_stylesheet_name(sass_file)
+      sass_file[(from.length + 1)..-1]
+    end
+
+    def stylesheet_name(sass_file)
+      if sass_file.index(from) == 0
+        sass_file[(from.length + 1)..-6]
+      else
+        raise Compass::Error, "You must compile individual stylesheets from the project directory."
+      end
+    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
+
+    # Returns the sass file that needs to be compiled, if any.
+    def out_of_date?
+      sass_files.zip(css_files).each do |sass_filename, css_filename|
+        return sass_filename if needs_update?(css_filename, sass_filename)
+      end
+      false
+    end
+
+    def needs_update?(css_filename, sass_filename)
+      staleness_checker.stylesheet_needs_update?(css_filename, File.expand_path(sass_filename), importer)
+    end
+
+    # Determines if the configuration file is newer than any css file
+    def new_config?
+      config_file = Compass.detect_configuration_file
+      return false unless config_file
+      config_mtime = File.mtime(config_file)
+      css_files.each do |css_filename|
+        return config_file if File.exists?(css_filename) && config_mtime > File.mtime(css_filename)
+      end
+      nil
+    end
+
+    def clean!
+      remove options[:cache_location]
+      css_files.each do |css_file|
+        remove css_file
+      end
+    end
+
+    def run
+      failure_count = 0
+      if new_config?
+        # Wipe out the cache and force compilation if the configuration has changed.
+        remove options[:cache_location] if options[:cache_location]
+        options[:force] = true
+      end
+
+      # Make sure the target directories exist
+      target_directories.each {|dir| directory dir}
+
+      # Compile each sass file.
+      result = timed do
+        sass_files.zip(css_files).each do |sass_filename, css_filename|
+          begin
+            compile_if_required sass_filename, css_filename
+          rescue Sass::SyntaxError => e
+            failure_count += 1
+            handle_exception(sass_filename, css_filename, e)
+          end
+        end
+      end
+      if options[:time]
+        puts "Compilation took #{(result.__duration * 1000).round / 1000.0}s"
+      end
+      return failure_count
+    end
+
+    def compile_if_required(sass_filename, css_filename)
+      if should_compile?(sass_filename, css_filename)
+        compile sass_filename, css_filename
+      else
+        logger.record :unchanged, basename(sass_filename) unless options[:quiet]
+      end
+    end
+
+    def timed
+      start_time = Time.now
+      res = yield
+      end_time = Time.now
+      res.instance_variable_set("@__duration", end_time - start_time)
+      def res.__duration
+        @__duration
+      end
+      res
+    end
+
+    # Compile one Sass file
+    def compile(sass_filename, css_filename)
+      start_time = end_time = nil
+      css_content = logger.red do
+        timed do
+          engine(sass_filename, css_filename).render
+        end
+      end
+      duration = options[:time] ? "(#{(css_content.__duration * 1000).round / 1000.0}s)" : ""
+      write_file(css_filename, css_content, options.merge(:force => true, :extra => duration))
+      Compass.configuration.run_callback(:stylesheet_saved, css_filename)
+    end
+
+    def should_compile?(sass_filename, css_filename)
+      options[:force] || needs_update?(css_filename, sass_filename)
+    end
+
+    # A sass engine for compiling a single file.
+    def engine(sass_filename, css_filename)
+      syntax = (sass_filename =~ /\.(s[ac]ss)$/) && $1.to_sym || :sass
+      opts = sass_options.merge(:filename => sass_filename, :css_filename => css_filename, :syntax => syntax)
+      Sass::Engine.new(open(sass_filename).read, opts)
+    end
+
+    # Place the syntax error into the target css file,
+    # formatted to display in the browser (in development mode)
+    # if there's an error.
+    def handle_exception(sass_filename, css_filename, e)
+      formatted_error = "(Line #{e.sass_line}: #{e.message})"
+      file = basename(sass_filename)
+      logger.record :error, file, formatted_error
+      Compass.configuration.run_callback(:stylesheet_error, sass_filename, formatted_error)
+      write_file css_filename, error_contents(e, sass_filename), options.merge(:force => true)
+    end
+
+    # Haml refactored this logic in 2.3, this is backwards compatibility for either one
+    def error_contents(e, sass_filename)
+      if Sass::SyntaxError.respond_to?(:exception_to_css)
+        e.sass_template = sass_filename
+        Sass::SyntaxError.exception_to_css(e, :full_exception => show_full_exception?)
+      else
+        Sass::Plugin.options[:full_exception] ||= show_full_exception?
+        Sass::Plugin.send(:exception_string, e)
+      end
+    end
+
+    # We don't want to show the full exception in production environments.
+    def show_full_exception?
+      Compass.configuration.environment == :development
+    end
+
+  end
+end

data/lib/compass/configuration.rb

@@ -0,0 +1,85 @@
+module Compass
+  module Configuration
+
+    def self.attributes_for_directory(dir_name, http_dir_name = dir_name)
+      [
+        "#{dir_name}_dir",
+        "#{dir_name}_path",
+        ("http_#{http_dir_name}_dir" if http_dir_name),
+        ("http_#{http_dir_name}_path" if http_dir_name)
+      ].compact.map{|a| a.to_sym}
+    end
+
+    ATTRIBUTES = [
+      # What kind of project?
+      :project_type,
+      # Where is the project?
+      :project_path,
+      :http_path,
+      # Where are the various bits of the project
+      attributes_for_directory(:css, :stylesheets),
+      attributes_for_directory(:sass, nil),
+      attributes_for_directory(:images),
+      attributes_for_directory(:javascripts),
+      attributes_for_directory(:fonts),
+      attributes_for_directory(:extensions, nil),
+      # Compilation options
+      :sprite_search_path,
+      :output_style,
+      :environment,
+      :relative_assets,
+      :additional_import_paths,
+      :sass_options,
+      attributes_for_directory(:cache, nil),
+      :cache,
+      # Helper configuration
+      :asset_host,
+      :asset_cache_buster,
+      :line_comments,
+      :color_output,
+      :preferred_syntax,
+      :disable_warnings,
+      :sprite_engine,
+      :chunky_png_options
+    ].flatten
+
+    # Registers a new configuration property.
+    # Extensions can use this to add new configuration options to compass.
+    #
+    # @param [Symbol] name The name of the property.
+    # @param [String] comment A comment for the property.
+    # @param [Proc] default A method to calculate the default value for the property.
+    #                       The proc is executed in the context of the project's configuration data.
+    def self.add_configuration_property(name, comment = nil, &default)
+      ATTRIBUTES << name
+      if comment.is_a?(String)
+        unless comment[0..0] == "#"
+          comment = "# #{comment}"
+        end
+        unless comment[-1..-1] == "\n"
+          comment = comment + "\n"
+        end
+        Data.class_eval <<-COMMENT
+          def comment_for_#{name}
+            #{comment.inspect}
+          end
+        COMMENT
+      end
+      Data.send(:define_method, :"default_#{name}", &default) if default
+      Data.inherited_accessor(name)
+      if name.to_s =~ /dir|path/
+        strip_trailing_separator(name)
+      end
+    end
+
+    # For testing purposes
+    def self.remove_configuration_property(name)
+      ATTRIBUTES.delete(name)
+    end
+
+  end
+end
+
+['adapters', 'comments', 'defaults', 'helpers', 'inheritance', 'serialization', 'paths', 'data', 'file_data'].each do |lib|
+  require "compass/configuration/#{lib}"
+end

data/lib/compass/configuration/adapters.rb

@@ -0,0 +1,71 @@
+module Compass
+  module Configuration
+    # The adapters module provides methods that make configuration data from a compass project
+    # adapt to various consumers of configuration data
+    module Adapters
+      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, File.join(css_path || css_dir || ".", framework.name)]
+        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] = line_comments
+        plugin_opts[:cache] = cache unless cache.nil?
+        plugin_opts[:cache_location] = cache_path unless cache_path.nil?
+        plugin_opts.merge!(sass_options || {})
+        plugin_opts[:load_paths] ||= []
+        plugin_opts[:load_paths] << Compass::SpriteImporter.new
+        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 absolute_path?(path)
+        # Pretty basic implementation
+        path.index(File::SEPARATOR) == 0 || path.index(':') == 1
+      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] = line_comments
+        engine_opts[:cache] = cache
+        engine_opts[:cache_location] = cache_path
+        engine_opts[:quiet] = disable_warnings if disable_warnings
+        engine_opts.merge!(sass_options || {})
+      end
+
+      def sass_load_paths
+        load_paths = []
+        load_paths << sass_path if sass_path
+        Compass::Frameworks::ALL.each do |f|
+          load_paths << f.stylesheets_directory if File.directory?(f.stylesheets_directory)
+        end
+        load_paths += resolve_additional_import_paths
+        load_paths.map! do |p|
+          next p if p.respond_to?(:find_relative)
+          Sass::Importers::Filesystem.new(p.to_s)
+        end
+        load_paths << Compass::SpriteImporter.new
+        load_paths
+      end
+    end
+  end
+end