compass-rails31 0.12.0.alpha.0.91a748a

data/lib/compass/configuration/comments.rb

@@ -0,0 +1,59 @@
+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
+        unless top_level.http_path_without_default
+          "# Set this to the root of your project when deployed:\nhttp_path = #{top_level.http_path.to_s.inspect}\n"
+        else
+          ""
+        end
+      end
+
+      def comment_for_relative_assets
+        unless top_level.relative_assets
+          %q{# To enable relative paths to assets via compass helper functions. Uncomment:
+# relative_assets = true
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_line_comments
+        if top_level.line_comments
+          %q{# To disable debugging comments that display the original location of your selectors. Uncomment:
+# line_comments = false
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_output_style
+        unless top_level.output_style_without_default
+          %Q{# You can select your preferred output style here (can be overridden via the command line):
+# output_style = :expanded or :nested or :compact or :compressed
+}
+        else
+          ""
+        end
+      end
+
+      def comment_for_preferred_syntax
+        if top_level.preferred_syntax == :scss && top_level.sass_dir
+          %Q{
+# If you prefer the indented syntax, you might want to regenerate this
+# project again passing --syntax sass, or you can uncomment this:
+# preferred_syntax = :sass
+# and then run:
+# sass-convert -R --from scss --to sass #{top_level.sass_dir} scss && rm -rf sass && mv scss sass
+}
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/compass/configuration/data.rb

@@ -0,0 +1,164 @@
+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_reader :name
+
+      include Compass::Configuration::Inheritance
+      include Compass::Configuration::Serialization
+      include Compass::Configuration::Adapters
+      extend  Compass::Configuration::Paths
+
+      inherited_accessor *ATTRIBUTES
+      inherited_accessor :required_libraries, :loaded_frameworks, :framework_path #XXX we should make these arrays add up cumulatively.
+
+      strip_trailing_separator *ATTRIBUTES.select{|a| a.to_s =~ /dir|path/}
+
+      def initialize(name, attr_hash = nil)
+        raise "I need a name!" unless name
+        @name = name
+        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
+          if @asset_host
+            @asset_host
+          elsif inherited_data.respond_to?(:asset_host)
+            inherited_data.asset_host
+          end
+        end
+      end
+
+      # When called with a block, defines the cache buster strategy to be used.
+      # If the block returns nil or a string, then it is appended to the url as a query parameter.
+      # In this case, the returned string must not include the starting '?'.
+      # The block may also return a hash with :path and/or :query values and it
+      # will replace the original path and query string with the busted values returned.
+      # 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.
+      #
+      # To disable the asset cache buster:
+      #
+      #     asset_cache_buster :none
+      def asset_cache_buster(simple = nil, &block)
+        if block_given?
+          @asset_cache_buster = block
+        elsif !simple.nil?
+          if simple == :none
+            @asset_cache_buster = Proc.new {|_,_| nil}
+          else
+            raise ArgumentError, "Unexpected argument: #{simple.inspect}"
+          end
+        else
+          if @asset_cache_buster
+            @asset_cache_buster
+          elsif inherited_data.respond_to?(:asset_cache_buster)
+            inherited_data.asset_cache_buster
+          end
+        end
+      end
+
+      def watch(glob, &block)
+        @watches ||= []
+        @watches << [glob, block]
+      end
+      
+      def watches
+        if defined?(@watches)
+          @watches
+        elsif inherited_data.respond_to?(:watches)
+          inherited_data.watches
+        else
+          []
+        end
+      end
+
+      # Require a compass plugin and capture that it occured so that the configuration serialization works next time.
+      def require(lib)
+        (self.required_libraries ||= []) << lib
+        super
+      end
+
+      def load(framework_dir)
+        (self.loaded_frameworks ||= []) << framework_dir
+        Compass::Frameworks.register_directory framework_dir
+      end
+
+      # Finds all extensions within a directory and registers them.
+      def discover(frameworks_dir)
+        (self.framework_path ||= []) << frameworks_dir
+        Compass::Frameworks.discover frameworks_dir
+      end
+
+      def relative_assets?
+        # the http_images_path is deprecated, but here for backwards compatibility.
+        relative_assets || http_images_path == :relative
+      end
+
+      def run_callback(event, *args)
+        begin
+          send(:"run_#{event}", *args)
+        rescue NoMethodError => e
+          unless e.message =~ /run_#{event}/
+            raise
+          end
+        end
+      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,168 @@
+module Compass
+  module Configuration
+    module Defaults
+
+      def default_project_path
+        "."
+      end
+
+      def default_project_type
+        :stand_alone
+      end
+
+      def default_http_path
+        "/"
+      end
+
+      def default_extensions_dir
+        "extensions"
+      end
+
+      def default_fonts_dir
+        File.join(top_level.css_dir, "fonts")
+      end
+
+      def default_environment
+        :development
+      end
+
+      def default_output_style
+        if top_level.environment == :development
+          :expanded
+        else
+          :compressed
+        end
+      end
+
+      def default_line_comments
+        top_level.environment == :development
+      end
+
+      def default_color_output
+        true
+      end
+
+      def default_sass_path
+        if (pp = top_level.project_path) && (dir = top_level.sass_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_css_path
+        if (pp = top_level.project_path) && (dir = top_level.css_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_images_path
+        if (pp = top_level.project_path) && (dir = top_level.images_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_javascripts_path
+        if (pp = top_level.project_path) && (dir = top_level.javascripts_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_extensions_path
+        if (pp = top_level.project_path) && (dir = top_level.extensions_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_fonts_path
+        if (pp = top_level.project_path) && (dir = top_level.fonts_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+      def default_cache_path
+        if (pp = top_level.project_path) && (dir = top_level.cache_dir)
+          Compass.projectize(dir, pp)
+        end
+      end
+
+
+      def default_http_images_dir
+        top_level.images_dir
+      end
+      
+      def default_sprite_search_path
+        [top_level.images_path]
+      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_fonts_dir
+        if fd = top_level.fonts_dir_without_default
+          fd
+        else
+          "#{top_level.http_stylesheets_dir}/fonts"
+        end
+      end
+
+      def default_http_fonts_path
+        http_root_relative top_level.http_fonts_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
+
+      def default_cache
+        true
+      end
+
+      def default_preferred_syntax
+        :scss
+      end
+      
+      def default_sprite_engine
+        :chunky_png
+      end
+      
+      def default_chunky_png_options
+        {:compression => Zlib::BEST_COMPRESSION}
+      end
+      
+      # helper functions
+
+      def http_join(*segments)
+        segments.map do |segment|
+          next unless 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/file_data.rb

@@ -0,0 +1,43 @@
+module Compass
+  module Configuration
+    class FileData < Data
+      extend Sass::Callbacks
+
+      # on_sprite_generated
+      # yields the filename
+      # usage: on_sprite_save {|filename| do_somethign(filename) }
+      define_callback :sprite_saved
+
+      # on_sprite_generated
+      # yields 'ChunkyPNG::Image'
+      # usage: on_sprite_generated {|sprite_data| do_something(sprite_data) }
+      define_callback :sprite_generated
+
+      # on_stylesheet_saved
+      # yields the filename
+      # usage: on_stylesheet_saved {|filename| do_something(filename) }
+      define_callback :stylesheet_saved
+
+      # on_stylesheet_error
+      # yields the filename & message
+      # usage: on_stylesheet_error {|filename, message| do_something(filename, message) }
+      define_callback :stylesheet_error
+
+      def self.new_from_file(config_file, defaults = nil)
+        data = new(config_file)
+        data.with_defaults(defaults) do
+          data._parse(config_file)
+        end
+        data
+      end
+
+      def self.new_from_string(contents, filename, defaults = nil)
+        data = new(filename)
+        data.with_defaults(defaults) do
+          data.parse_string(contents, filename)
+        end
+        data
+      end
+    end
+  end
+end

data/lib/compass/configuration/helpers.rb

@@ -0,0 +1,159 @@
+module Compass
+  module Configuration
+    @callbacks_loaded = false
+    # 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('defaults').extend(Defaults).extend(Comments)
+      end
+
+      def add_configuration(config, filename = nil)
+        return if config.nil?
+
+
+        data = configuration_for(config, filename)
+
+        # puts "New configuration: #{data.name}"
+        # puts caller.join("\n")
+        data.inherit_from!(configuration)
+        data.on_top!
+        @configuration = data
+      end
+
+      def configuration_for(config, filename = nil, defaults = nil)
+        if config.nil?
+          nil
+        elsif config.is_a?(Compass::Configuration::Data)
+          config
+        elsif config.respond_to?(:read)
+          filename ||= config.to_s if config.is_a?(Pathname)
+          Compass::Configuration::FileData.new_from_string(config.read, filename, defaults)
+        elsif config.is_a?(Hash)
+          Compass::Configuration::Data.new(filename, config)
+        elsif config.is_a?(String)
+          Compass::Configuration::FileData.new_from_file(config, defaults)
+        elsif config.is_a?(Symbol)
+          Compass::AppIntegration.lookup(config).configuration
+        else
+          raise "I don't know what to do with: #{config.inspect}"
+        end
+      end
+
+      # Support for testing.
+      def reset_configuration!
+        @configuration = nil
+      end
+
+      def sass_plugin_configuration
+        configuration.to_sass_plugin_options
+      end
+
+      def configure_sass_plugin!
+        require 'sass/plugin'
+        config = sass_plugin_configuration
+        locations = config.delete(:template_location)
+        Sass::Plugin.options.merge!(config)
+        locations.each do |sass_dir, css_dir|
+          unless Sass::Plugin.engine_options[:load_paths].include?(sass_dir)
+            Sass::Plugin.add_template_location sass_dir, css_dir
+          end
+        end
+        unless @callbacks_loaded
+          Sass::Plugin.on_updating_stylesheet do |sass_file, css_file|
+            Compass.configuration.run_callback(:stylesheet_saved, css_file)
+          end
+          Sass::Plugin.on_compilation_error do |e, filename, css|
+            Compass.configuration.run_callback(:stylesheet_error, filename, e.message)
+          end
+          @callbacks_loaded = true
+        end
+      end
+
+      def configure_rails!(app)
+        app.config.compass.to_sass_engine_options.each do |key, value|
+          app.config.sass.send(:"#{key}=", value)
+        end
+      end
+
+      def sass_engine_options
+        configuration.to_sass_engine_options
+      end
+
+      # Read the configuration file for this project
+      def add_project_configuration(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        configuration_file_path = args.shift || detect_configuration_file
+        raise ArgumentError, "Too many arguments" if args.any?
+        if data = configuration_for(configuration_file_path, nil, configuration_for(options[:defaults]))
+          if data.raw_project_type
+            add_configuration(data.raw_project_type.to_sym)
+          elsif options[:project_type]
+            add_configuration(options[:project_type])
+          else
+            add_configuration(:stand_alone)
+          end
+
+          add_configuration(data)
+        else
+          add_configuration(options[:project_type] || configuration.project_type_without_default || (yield if block_given?) || :stand_alone)
+        end
+      end
+
+      def discover_extensions!
+        Compass.shared_extension_paths.each do |extensions_path|
+          if File.directory?(extensions_path)
+            Compass::Frameworks.discover(extensions_path)
+          end
+        end
+        if File.directory?(configuration.extensions_path)
+          Compass::Frameworks.discover(configuration.extensions_path)
+        end
+      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
+
+      def deprojectize(path, project_path = nil)
+        project_path ||= configuration.project_path
+        if path[0..(project_path.size - 1)] == project_path
+          path[(project_path.size + 1)..-1]
+        else
+          path
+        end
+      end
+
+      # TODO: Deprecate the src/config.rb location.
+      KNOWN_CONFIG_LOCATIONS = ['config/compass.rb', ".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
+
+      def handle_configuration_change!
+        if (compiler = Compass.compiler).new_config?
+          compiler.clean!
+        end
+      end
+
+      def compiler
+        Compass::Compiler.new(*Compass.configuration.to_compiler_arguments)
+      end
+    end
+  end
+
+  extend Configuration::Helpers
+  
+end