compass-rails31 0.12.0.alpha.0.91a748a

data/lib/compass/configuration/inheritance.rb

@@ -0,0 +1,188 @@
+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 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.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, *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

data/lib/compass/configuration/paths.rb

@@ -0,0 +1,19 @@
+module Compass::Configuration::Paths
+
+  TRAILING_SEPARATOR = %r{.(/|#{Regexp.escape(File::SEPARATOR)})$}
+
+  def strip_trailing_separator(*attributes)
+    attributes.each do |attr|
+      alias_method "#{attr}_with_trailing_separator".to_sym, attr
+      class_eval %Q{
+        def #{attr}                                # def css_dir
+          path = #{attr}_with_trailing_separator   #   path = css_dir_with_trailing_separator
+          if path.to_s =~ TRAILING_SEPARATOR       #   if path =~ TRAILING_SEPARATOR
+            path = path[0..-($1.length+1)]         #     path = path[0..-($1.length+1)]
+          end                                      #   end
+          path                                     #   path
+        end                                        # end
+      }
+    end
+  end
+end

data/lib/compass/configuration/serialization.rb

@@ -0,0 +1,78 @@
+module Compass
+  module Configuration
+    # The serialization module manages reading and writing the configuration file(s).
+    module Serialization
+      def parse(config_file)
+        raise Compass::Error, "Compass.configuration.parse(filename) has been removed. Please call Compass.add_project_configuration(filename) instead."
+      end
+
+      # 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
+          value = value.to_s if value.is_a?(Pathname)
+          self.send("#{prop}=", value) unless value.nil?
+        end
+        if @added_import_paths
+          self.additional_import_paths ||= []
+          self.additional_import_paths += @added_import_paths
+          self.additional_import_paths.uniq!
+        end
+        issue_deprecation_warnings
+      end
+
+      def serialize
+        contents = ""
+        (required_libraries || []).each do |lib|
+          contents << %Q{require '#{lib}'\n}
+        end
+        (loaded_frameworks || []).each do |lib|
+          contents << %Q{load '#{lib}'\n}
+        end
+        (framework_path || []).each do |lib|
+          contents << %Q{discover '#{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 << "\n"
+            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

data/lib/compass/dependencies.rb

@@ -0,0 +1,12 @@
+begin
+  require 'sass'
+rescue LoadError
+  require 'rubygems'
+  begin
+    require 'sass'
+  rescue LoadError
+    puts "Unable to load Sass. Please install it with one of the following commands:"
+    puts "  gem install sass --pre"
+    raise
+  end
+end

data/lib/compass/errors.rb

@@ -0,0 +1,10 @@
+module Compass
+  class Error < StandardError
+  end
+
+  class FilesystemConflict < Error
+  end
+
+  class MissingDependency < Error
+  end
+end

data/lib/compass/exec.rb

@@ -0,0 +1,23 @@
+require 'compass/dependencies'
+require 'optparse'
+require 'compass/logger'
+require 'compass/errors'
+require 'compass/actions'
+require 'compass/installers'
+require 'compass/commands'
+require 'rbconfig'
+require 'pathname'
+begin
+  require 'win32console' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+rescue LoadError
+  $boring = true
+end
+
+module Compass::Exec
+end
+
+%w(helpers sub_command_ui
+   global_options_parser project_options_parser
+   command_option_parser).each do |lib|
+  require "compass/exec/#{lib}"
+end

data/lib/compass/exec/command_option_parser.rb

@@ -0,0 +1,23 @@
+module Compass::Exec
+  class CommandOptionParser
+    attr_accessor :options, :arguments, :opts
+    def initialize(arguments)
+      self.arguments = arguments
+      self.options = {}
+    end
+    def parse!
+      opts.parse!(arguments)
+    end
+    def opts
+      OptionParser.new do |opts|
+        self.set_options(opts)
+      end
+    end
+    def set_options(opts)
+
+    end
+    def to_s
+      opts.to_s
+    end
+  end
+end

data/lib/compass/exec/global_options_parser.rb

@@ -0,0 +1,56 @@
+module Compass::Exec::GlobalOptionsParser
+  def set_options(opts)
+    super
+    set_global_options(opts)
+  end
+  def set_global_options(opts)
+    opts.on('-r LIBRARY', '--require LIBRARY',
+            "Require the given ruby LIBRARY before running commands.",
+            "  This is used to access compass plugins without having a",
+            "  project configuration file."
+      ) do |library|
+        ::Compass.configuration.require library
+      end
+
+    opts.on('-l FRAMEWORK_DIR', '--load FRAMEWORK_DIR',
+            "Load the framework or extensions found in the FRAMEWORK directory."
+      ) do |framework_dir|
+        require 'pathname'
+        ::Compass.configuration.load Pathname.new(framework_dir).realpath
+      end
+
+    opts.on('-L FRAMEWORKS_DIR', '--load-all FRAMEWORKS_DIR',
+            "Load all the frameworks or extensions found in the FRAMEWORKS_DIR directory."
+      ) do |frameworks_dir|
+        require 'pathname'
+        ::Compass.configuration.discover Pathname.new(frameworks_dir).realpath
+      end
+
+    opts.on('-q', '--quiet', :NONE, 'Quiet mode.') do
+      self.options[:quiet] = true
+    end
+
+    opts.on('--trace', :NONE, 'Show a full stacktrace on error') do
+      self.options[:trace] = true
+    end
+
+    opts.on('--force', :NONE, 'Allows some failing commands to succeed instead.') do
+      self.options[:force] = true
+    end
+
+    opts.on('--dry-run', :NONE, 'Dry Run. Tells you what it plans to do.') do
+      self.options[:dry_run] = true
+    end
+
+    opts.on('--boring', :NONE, 'Turn off colorized output.') do
+      self.options[:color_output] = false
+    end
+
+    opts.on_tail("-?", "-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+
+  end
+
+end

data/lib/compass/exec/helpers.rb

@@ -0,0 +1,21 @@
+module Compass::Exec
+  module Helpers
+    extend self
+    def report_error(e, options)
+      $stderr.puts "#{e.class} on line #{get_line e} of #{get_file e}: #{e.message}"
+      if options[:trace]
+        e.backtrace[1..-1].each { |t| $stderr.puts "  #{t}" }
+      else
+        $stderr.puts "Run with --trace to see the full backtrace"
+      end
+    end
+
+    def get_file(exception)
+      exception.backtrace[0].split(/:/, 2)[0]
+    end
+
+    def get_line(exception)
+      exception.backtrace[0].scan(/:(\d+)/)[0]
+    end
+  end
+end

data/lib/compass/exec/project_options_parser.rb

@@ -0,0 +1,58 @@
+module Compass::Exec::ProjectOptionsParser
+  def set_options(opts)
+    super
+    set_project_options(opts)
+  end
+  def set_dir_or_path(type, dir)
+    if Pathname.new(dir).absolute?
+      self.options[:"#{type}_path"] = dir.tr('\\','/')
+    else
+      self.options[:"#{type}_dir"] = dir.tr('\\','/')
+    end
+  end
+
+  def set_project_options(opts)
+    opts.on('-c', '--config CONFIG_FILE', 'Specify the location of the configuration file explicitly.') do |configuration_file|
+      self.options[:configuration_file] = configuration_file
+    end
+
+    opts.on('--app APP', 'Tell compass what kind of application it is integrating with. E.g. rails') do |project_type|
+      self.options[:project_type] = project_type.to_sym
+    end
+
+    opts.on('--sass-dir SRC_DIR', "The source directory where you keep your sass stylesheets.") do |sass_dir|
+      set_dir_or_path(:sass, sass_dir)
+    end
+
+    opts.on('--css-dir CSS_DIR', "The target directory where you keep your css stylesheets.") do |css_dir|
+      set_dir_or_path(:css, css_dir)
+    end
+
+    opts.on('--images-dir IMAGES_DIR', "The directory where you keep your images.") do |images_dir|
+      set_dir_or_path(:images, images_dir)
+    end
+
+    opts.on('--javascripts-dir JS_DIR', "The directory where you keep your javascripts.") do |javascripts_dir|
+      set_dir_or_path(:javascripts, javascripts_dir)
+    end
+
+    opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment.',
+            '  One of: development (default), production') do |env|
+      self.options[:environment] = env
+    end
+
+    opts.on('-s STYLE', '--output-style STYLE', [:nested, :expanded, :compact, :compressed], 'Select a CSS output mode.',
+            '  One of: nested, expanded, compact, compressed') do |style|
+      self.options[:output_style] = style
+    end
+
+    opts.on('--relative-assets', :NONE, 'Make compass asset helpers generate relative urls to assets.') do
+      self.options[:relative_assets] = true
+    end
+
+    opts.on('--no-line-comments', :NONE, 'Disable line comments.') do
+      self.options[:line_comments] = false
+    end
+  end
+
+end