compass-edge 0.9.1

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,38 @@
+module Compass
+  module Configuration
+
+    ATTRIBUTES = [
+      :project_type,
+      :project_path,
+      :css_dir,
+      :sass_dir,
+      :images_dir,
+      :javascripts_dir,
+      :extensions_dir,
+      :css_path,
+      :sass_path,
+      :images_path,
+      :javascripts_path,
+      :extensions_path,
+      :http_path,
+      :http_images_dir,
+      :http_stylesheets_dir,
+      :http_javascripts_dir,
+      :http_images_path,
+      :http_stylesheets_path,
+      :http_javascripts_path,
+      :output_style,
+      :environment,
+      :relative_assets,
+      :additional_import_paths,
+      :sass_options,
+      :asset_host,
+      :asset_cache_buster
+    ]
+
+  end
+end
+
+['adapters', 'comments', 'defaults', 'helpers', 'inheritance', 'serialization', 'data'].each do |lib|
+  require "compass/configuration/#{lib}"
+end

data/lib/compass/configuration/adapters.rb

@@ -0,0 +1,59 @@
+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] = 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] = 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 absolute_path?(path)
+        # This is only going to work on unix, gonna need a better implementation.
+        path.index(File::SEPARATOR) == 0
+      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 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
+        end
+        load_paths += resolve_additional_import_paths
+        load_paths
+      end
+    end
+  end
+end

data/lib/compass/configuration/comments.rb

@@ -0,0 +1,22 @@
+module Compass
+  module Configuration
+    # Comments are emitted into the configuration file when serialized and make it easier to understand for new users.
+    module Comments
+
+      def comment_for_http_path
+        "# Set this to the root of your project when deployed:\n"
+      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
+
+    end
+  end
+end

data/lib/compass/configuration/data.rb

@@ -0,0 +1,103 @@
+module Compass
+  module Configuration
+    # The Compass configuration data storage class manages configuration data that comes from a variety of
+    # different sources and aggregates them together into a consistent API
+    # Some of the possible sources of configuration data:
+    #   * Compass default project structure for stand alone projects
+    #   * App framework specific project structures for rails, etc.
+    #   * User supplied explicit configuration
+    #   * Configuration data provided via the command line interface
+    #
+    # There are two kinds of configuration data that doesn't come from the user:
+    #
+    # 1. Configuration data that is defaulted as if the user had provided it themselves.
+    #    This is useful for providing defaults that the user is likely to want to edit
+    #    but shouldn't have to provide explicitly when getting started
+    # 2. Configuration data that is defaulted behind the scenes because _some_ value is
+    #    required.
+    class Data
+
+      attr_accessor :required_libraries
+
+      include Compass::Configuration::Inheritance
+      include Compass::Configuration::Serialization
+      include Compass::Configuration::Adapters
+
+      inherited_accessor *ATTRIBUTES
+
+      def initialize(attr_hash = nil)
+        self.required_libraries = []
+        set_all(attr_hash) if attr_hash
+        self.top_level = self
+      end
+
+      def set_all(attr_hash)
+        # assert_valid_keys!(attr_hash)
+        attr_hash.each do |a, v|
+          if self.respond_to?("#{a}=")
+            self.send("#{a}=", v)
+          end
+        end
+      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
+
+      # Require a compass plugin and capture that it occured so that the configuration serialization works next time.
+      def require(lib)
+        required_libraries << lib
+        super
+      end
+
+      def relative_assets?
+        # the http_images_path is deprecated, but here for backwards compatibility.
+        relative_assets || http_images_path == :relative
+      end
+
+      private
+
+      def assert_valid_keys!(attr_hash)
+        illegal_attrs = attr_hash.keys - ATTRIBUTES
+        if illegal_attrs.size == 1
+          raise Error, "#{illegal_attrs.first.inspect} is not a valid configuration attribute."
+        elsif illegal_attrs.size > 0
+          raise Error, "Illegal configuration attributes: #{illegal_attrs.map{|a| a.inspect}.join(", ")}"
+        end
+      end
+
+    end
+  end
+end

data/lib/compass/configuration/defaults.rb

@@ -0,0 +1,107 @@
+module Compass
+  module Configuration
+    module Defaults
+
+      def default_project_type
+        :stand_alone
+      end
+
+      def http_path_without_default
+        "/"
+      end
+
+      def default_extensions_dir
+        "extensions"
+      end
+
+      def default_output_style
+        if top_level.environment == :development
+          :expanded
+        else
+          :compact
+        end
+      end
+
+      def default_line_comments
+        top_level.environment == :development
+      end
+
+      def default_sass_path
+        if (pp = top_level.project_path) && (dir = top_level.sass_dir)
+          File.join(pp, dir)
+        end
+      end
+
+      def default_css_path
+        if (pp = top_level.project_path) && (dir = top_level.css_dir)
+          File.join(pp, dir)
+        end
+      end
+
+      def default_images_path
+        if (pp = top_level.project_path) && (dir = top_level.images_dir)
+          File.join(pp, dir)
+        end
+      end
+
+      def default_javascripts_path
+        if (pp = top_level.project_path) && (dir = top_level.javascripts_dir)
+          File.join(pp, dir)
+        end
+      end
+
+      def default_extensions_path
+        if (pp = top_level.project_path) && (dir = top_level.extensions_dir)
+          File.join(pp, dir)
+        end
+      end
+
+
+      def default_http_images_dir
+        top_level.images_dir
+      end
+
+      def default_http_images_path
+        http_root_relative top_level.http_images_dir
+      end
+
+      def default_http_stylesheets_dir
+        top_level.css_dir
+      end
+
+      def default_http_stylesheets_path
+        http_root_relative top_level.http_stylesheets_dir
+      end
+
+      def default_http_javascripts_dir
+        top_level.javascripts_dir
+      end
+
+      def default_http_javascripts_path
+        http_root_relative top_level.http_javascripts_dir
+      end
+
+      # helper functions
+
+      def http_join(*segments)
+        segments.map do |segment|
+          segment = http_pathify(segment)
+          segment[-1..-1] == "/" ? segment[0..-2] : segment
+        end.join("/")
+      end
+
+      def http_pathify(path)
+        if File::SEPARATOR == "/"
+          path
+        else
+          path.gsub(File::SEPARATOR, "/")
+        end
+      end
+
+      def http_root_relative(path)
+        http_join top_level.http_path, path
+      end
+
+    end
+  end
+end

data/lib/compass/configuration/helpers.rb

@@ -0,0 +1,83 @@
+module Compass
+  module Configuration
+    # The helpers are available as methods on the Compass module. E.g. Compass.configuration
+    module Helpers
+      def configuration
+        @configuration ||= default_configuration
+        if block_given?
+          yield @configuration
+        end
+        @configuration
+      end
+
+      def default_configuration
+        Data.new.extend(Defaults).extend(Comments)
+      end
+
+      def add_configuration(config, filename = nil)
+        return if config.nil?
+        data = if config.is_a?(Compass::Configuration::Data)
+          config
+        elsif config.respond_to?(:read)
+          Compass::Configuration::Data.new_from_string(config.read, filename)
+        elsif config.is_a?(Hash)
+          Compass::Configuration::Data.new(config)
+        elsif config.is_a?(String)
+          Compass::Configuration::Data.new_from_file(config)
+        else
+          raise "I don't know what to do with: #{config.inspect}"
+        end
+        data.inherit_from!(configuration)
+        data.on_top!
+        @configuration = data
+      end
+
+      # Support for testing.
+      def reset_configuration!
+        @configuration = nil
+      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
+
+      # Read the configuration file for this project
+      def add_project_configuration(configuration_file_path = nil)
+        configuration_file_path ||= detect_configuration_file
+        Compass.add_configuration(configuration_file_path) if configuration_file_path
+      end
+
+      # Returns a full path to the relative path to the project directory
+      def projectize(path, project_path = nil)
+        project_path ||= configuration.project_path
+        File.join(project_path, *path.split('/'))
+      end
+
+      # TODO: Deprecate the src/config.rb location.
+      KNOWN_CONFIG_LOCATIONS = [".compass/config.rb", "config/compass.config", "config.rb", "src/config.rb"]
+
+      # Finds the configuration file, if it exists in a known location.
+      def detect_configuration_file(project_path = nil)
+        possible_files = KNOWN_CONFIG_LOCATIONS.map{|f| projectize(f, project_path) }
+        possible_files.detect{|f| File.exists?(f)}
+      end
+
+    end
+  end
+
+  extend Configuration::Helpers
+  
+end