compass-sourcemaps 0.12.2.sourcemaps.57a186c

data/lib/compass/configuration/helpers.rb

@@ -0,0 +1,160 @@
+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
+          on_saved = Proc.new do |sass_file, css_file|
+                       Compass.configuration.run_stylesheet_saved(css_file)
+                     end
+          if Sass::Plugin.respond_to?(:on_updated_stylesheet)
+            Sass::Plugin.on_updated_stylesheet(&on_saved)
+          else
+            Sass::Plugin.on_updating_stylesheet(&on_saved)
+          end
+          
+          Sass::Plugin.on_compilation_error do |e, filename, css|
+            Compass.configuration.run_stylesheet_error(filename, e.message)
+          end
+          
+          @callbacks_loaded = true
+        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 AppIntegration.default? && 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

data/lib/compass/configuration/inheritance.rb

@@ -0,0 +1,304 @@
+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
+
+        class ArrayProxy
+          def initialize(data, attr)
+            @data, @attr = data, attr
+          end
+          def to_ary
+            @data.send(:"read_inherited_#{@attr}_array")
+          end
+          def to_a
+            to_ary
+          end
+          def <<(v)
+            @data.send(:"add_to_#{@attr}", v)
+          end
+          def >>(v)
+            @data.send(:"remove_from_#{@attr}", v)
+          end
+          def serialize_to_config(prop)
+            if v = @data.raw(prop)
+              "#{prop} = #{v.inspect}"
+            else
+              s = ""
+              if added = @data.instance_variable_get("@added_to_#{@attr}")
+                added.each do |a|
+                  s << "#{prop} << #{a.inspect}\n"
+                end
+              end
+              if removed = @data.instance_variable_get("@removed_from_#{@attr}")
+                removed.each do |r|
+                  s << "#{prop} >> #{r.inspect}\n"
+                end
+              end
+              if s[-1..-1] == "\n"
+                s[0..-2]
+              else
+                s
+              end
+            end
+          end
+          def method_missing(m, *args, &block)
+            a = to_ary
+            if a.respond_to?(m)
+              a.send(m,*args, &block)
+            else
+              super
+            end
+          end
+        end
+
+        def inherited_array(*attributes)
+          inherited_reader(*attributes)
+          inherited_writer(*attributes)
+          attributes.each do |attr|
+            line = __LINE__ + 1
+            class_eval %Q{
+              def #{attr}                                          # def sprite_load_paths
+                ArrayProxy.new(self, #{attr.inspect})              #   ArrayProxy.new(self, :sprite_load_paths)
+              end                                                  # end
+              def #{attr}=(value)                                  # def sprite_load_paths=(value)
+                @set_attributes ||= {}                             #   @set_attributes ||= {}
+                @set_attributes[#{attr.inspect}] = true            #   @set_attributes[:sprite_load_paths] = true
+                @#{attr} = Array(value)                            #   @sprite_load_paths = Array(value)
+                @added_to_#{attr} = []                             #   @added_to_sprite_load_paths = []
+                @removed_from_#{attr} = []                         #   @removed_from_sprite_load_paths = []
+              end                                                  # end
+              def read_inherited_#{attr}_array                     # def read_inherited_sprite_load_paths_array
+                if #{attr}_set?                                    #  if sprite_load_paths_set?
+                  @#{attr}                                         #    Array(@#{attr})
+                else                                               #  else
+                  value = if inherited_data                        #    value = Array(read(:sprite_load_paths))
+                    Array(inherited_data.#{attr})
+                  else
+                    Array(read(#{attr.inspect}))
+                  end
+                  value -= Array(@removed_from_#{attr})            #    value -= Array(@removed_from_sprite_load_paths)
+                  Array(@added_to_#{attr}) + value                 #    Array(@added_to_sprite_load_paths) + value
+                end                                                #  end
+              end                                                  # end
+              def add_to_#{attr}(v)                                # def add_to_sprite_load_paths(v)
+                if #{attr}_set?                                    #   if sprite_load_paths_set?
+                  raw_#{attr} << v                                 #     raw_sprite_load_paths << v
+                else                                               #   else
+                  (@added_to_#{attr} ||= []) << v                  #     (@added_to_sprite_load_paths ||= []) << v
+                end                                                #   end
+              end                                                  # end
+              def remove_from_#{attr}(v)                           # def remove_from_sprite_load_paths(v)
+                if #{attr}_set?                                    #   if sprite_load_paths_set?
+                  raw_#{attr}.reject!{|e| e == v}                  #     raw_sprite_load_path.reject!{|e| e == v}s
+                else                                               #   else
+                  (@removed_from_#{attr} ||= []) << v              #     (@removed_from_sprite_load_paths ||= []) << v
+                end                                                #   end
+              end                                                  # end
+            }, __FILE__, line
+          end
+        end
+
+        def chained_method(method)
+          line = __LINE__ + 1
+          class_eval %Q{
+            alias_method :_chained_#{method}, method
+            def #{method}(*args, &block)
+              _chained_#{method}(*args, &block)
+              if inherited_data
+                inherited_data.#{method}(*args, &block)
+              end
+            end
+          }, __FILE__, line
+        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 reset_inheritance!
+          self.inherited_data = nil
+        end
+
+        def with_defaults(data)
+          inherit_from!(data)
+          yield
+          reset_inheritance!
+        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 any_attributes_set?
+          @set_attributes && @set_attributes.size > 0
+        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.nil?
+            nil
+          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
+
+        # Reads the raw value that was set on this object.
+        # you generally should call raw_<attribute>() instead.
+        def raw(attribute)
+          instance_variable_get("@#{attribute}")
+        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, *args, &block)
+          if inherited_data
+            inherited_data.send(meth, *args, &block)
+          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 chain
+          instances = [self]
+          instances << instances.last.inherited_data while instances.last.inherited_data
+          instances
+        end
+
+        def debug
+          normalized_attrs = {}
+          ATTRIBUTES.each do |prop|
+            values = []
+            chain.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