compass 0.8.17 → 0.10.0.pre1

data/lib/compass/configuration/defaults.rb

@@ -0,0 +1,138 @@
+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_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
+          :compact
+        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)
+          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_fonts_path
+        if (pp = top_level.project_path) && (dir = top_level.fonts_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_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
+
+      # 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/helpers.rb

@@ -0,0 +1,120 @@
+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('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)
+        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(filename, config)
+        elsif config.is_a?(String)
+          Compass::Configuration::Data.new_from_file(config)
+        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!
+        @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(*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 configuration_file_path
+
+          data = configuration_for(configuration_file_path)
+
+          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 || :stand_alone)
+        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
+
+    end
+  end
+
+  extend Configuration::Helpers
+  
+end

data/lib/compass/configuration/inheritance.rb

@@ -0,0 +1,170 @@
+module Compass
+  module Configuration
+    # The inheritance module makes it easy for configuration data to inherit from
+    # other instances of configuration data. This makes it easier for external code to layer
+    # bits of configuration from various sources.
+    module Inheritance
+
+      def self.included(base)
+        # inherited_data stores configuration data that this configuration object will
+        # inherit if not provided explicitly.
+        base.send :attr_accessor, :inherited_data, :set_attributes, :top_level
+
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def inherited_writer(*attributes)
+          attributes.each do |attribute|
+            line = __LINE__ + 1
+            class_eval %Q{
+              def #{attribute}=(value)                        # def css_dir=(value)
+                @set_attributes ||= {}                        #   @set_attributes ||= {}
+                @set_attributes[#{attribute.inspect}] = true  #   @set_attributes[:css_dir] = true
+                @#{attribute} = value                         #   @css_dir = value
+              end                                             # end
+
+              def unset_#{attribute}!                         # def unset_css_dir!
+                unset!(#{attribute.inspect})                  #   unset!(:css_dir)
+              end                                             # end
+
+              def #{attribute}_set?                           # def css_dir_set?
+                set?(#{attribute.inspect})                    #   set?(:css_dir)
+              end                                             # end
+            }, __FILE__, line
+          end
+        end
+
+        # Defines the default reader to be an inherited_reader that will look at the inherited_data for its
+        # value when not set. The inherited reader calls to a raw reader that acts like a normal attribute
+        # reader but prefixes the attribute name with "raw_".
+        def inherited_reader(*attributes)
+          attributes.each do |attribute|
+            line = __LINE__ + 1
+            class_eval %Q{
+              def raw_#{attribute}                         # def raw_css_dir
+                @#{attribute}                              #   @css_dir
+              end                                          # end
+              def #{attribute}_without_default             # def css_dir_without_default
+                read_without_default(#{attribute.inspect}) #  read_without_default(:css_dir)
+              end                                          # end
+              def #{attribute}                             # def css_dir
+                read(#{attribute.inspect})                 #  read(:css_dir)
+              end                                          # end
+            }, __FILE__, line
+          end
+        end
+
+        def inherited_accessor(*attributes)
+          inherited_reader(*attributes)
+          inherited_writer(*attributes)
+        end
+
+        
+      end
+
+      module InstanceMethods
+
+        def on_top!
+          self.set_top_level(self)
+        end
+
+        def set_top_level(new_top)
+          self.top_level = new_top
+          if self.inherited_data.respond_to?(:set_top_level)
+            self.inherited_data.set_top_level(new_top)
+          end
+        end
+
+
+        def inherit_from!(data)
+          if self.inherited_data
+            self.inherited_data.inherit_from!(data)
+          else
+            self.inherited_data = data
+          end
+          self
+        end
+
+        def unset!(attribute)
+          @set_attributes ||= {}
+          send("#{attribute}=", nil)
+          @set_attributes.delete(attribute)
+          nil
+        end
+
+        def set?(attribute)
+          @set_attributes ||= {}
+          @set_attributes[attribute]
+        end
+
+        def default_for(attribute)
+          method = "default_#{attribute}".to_sym
+          if respond_to?(method)
+            send(method)
+          end
+        end
+
+        # Read an explicitly set value that is either inherited or set on this instance
+        def read_without_default(attribute)
+          if set?(attribute)
+            send("raw_#{attribute}")
+          elsif inherited_data.respond_to?("#{attribute}_without_default")
+            inherited_data.send("#{attribute}_without_default")
+          elsif inherited_data.respond_to?(attribute)
+            inherited_data.send(attribute)
+          end
+        end
+
+        # Read a value that is either inherited or set on this instance, if we get to the bottom-most configuration instance,
+        # we ask for the default starting at the top level.
+        def read(attribute)
+          if !(v = send("#{attribute}_without_default")).nil?
+            v
+          else
+            top_level.default_for(attribute)
+          end
+        end
+
+        def method_missing(meth)
+          if inherited_data
+            inherited_data.send(meth)
+          else
+            raise NoMethodError, meth.to_s
+          end
+        end
+
+        def respond_to?(meth)
+          if super
+            true
+          elsif inherited_data
+            inherited_data.respond_to?(meth)
+          else
+            false
+          end
+        end
+
+        def debug
+          instances = [self]
+          instances << instances.last.inherited_data while instances.last.inherited_data
+          normalized_attrs = {}
+          ATTRIBUTES.each do |prop|
+            values = []
+            instances.each do |instance|
+              values << {
+                :raw => (instance.send("raw_#{prop}") rescue nil),
+                :value => (instance.send("#{prop}_without_default") rescue nil),
+                :default => (instance.send("default_#{prop}") rescue nil),
+                :resolved => instance.send(prop)
+              }
+            end
+            normalized_attrs[prop] = values
+          end
+          normalized_attrs
+        end
+
+      end
+    end
+  end
+end

data/lib/compass/configuration/serialization.rb

@@ -0,0 +1,86 @@
+module Compass
+  module Configuration
+    # The serialization module manages reading and writing the configuration file(s).
+    module Serialization
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def new_from_file(config_file)
+          data = Data.new(config_file)
+          data.parse(config_file)
+          data
+        end
+
+        def new_from_string(contents, filename)
+          data = Data.new(filename)
+          data.parse_string(contents, filename)
+          data
+        end
+      end
+
+      module InstanceMethods
+        # parses a configuration file which is a ruby script
+        def parse(config_file)
+          unless File.readable?(config_file)
+            raise Compass::Error, "Configuration file, #{config_file}, not found or not readable."
+          end
+          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 serialize
+          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}_without_default")
+            if value.is_a?(Proc)
+              $stderr.puts "WARNING: #{prop} is code and cannot be written to a file. You'll need to copy it yourself."
+            end
+            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 << serialize_property(prop, value) unless value.nil?
+            end
+          end
+          contents
+        end
+
+        def serialize_property(prop, value)
+          %Q(#{prop} = #{value.inspect}\n)
+        end
+        
+        def issue_deprecation_warnings
+          if http_images_path == :relative
+            $stderr.puts "DEPRECATION WARNING: Please set relative_assets = true to enable relative paths."
+          end
+        end
+
+      end
+    end
+  end
+end