compass-edge 0.9.1

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),
+                :resoved => 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
+          data.parse(config_file)
+          data
+        end
+
+        def new_from_string(contents, filename)
+          data = Data.new
+          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

data/lib/compass/core_ext.rb

@@ -0,0 +1,14 @@
+class String
+  unless method_defined?(:blank?)
+    # see if string has any content
+    def blank?; self.length.zero?; end
+  end
+end
+
+class NilClass
+  unless method_defined?(:blank?)
+    def blank?
+      true
+    end
+  end
+end

data/lib/compass/dependencies.rb

@@ -0,0 +1,6 @@
+begin
+  require 'sass'
+rescue LoadError
+  require 'rubygems'
+  require 'sass'
+end

data/lib/compass/errors.rb

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

data/lib/compass/exec.rb

@@ -0,0 +1,15 @@
+require 'compass/dependencies'
+require 'optparse'
+require 'compass/logger'
+require 'compass/errors'
+require 'compass/actions'
+require 'compass/commands'
+
+module Compass::Exec
+end
+
+%w(helpers switch_ui 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,37 @@
+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('-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_tail("-?", "-h", "--help", "Show this message") do
+      puts opts
+      exit
+    end
+
+  end
+
+end

data/lib/compass/exec/helpers.rb

@@ -0,0 +1,28 @@
+module Compass::Exec
+  module Helpers
+    extend self
+    def select_appropriate_command_line_ui(arguments)
+      if Compass::Commands.command_exists? arguments.first
+        SubCommandUI
+      else
+        SwitchUI
+      end
+    end
+    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,42 @@
+module Compass::Exec::ProjectOptionsParser
+  def set_options(opts)
+    super
+    set_project_options(opts)
+  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('--sass-dir SRC_DIR', "The source directory where you keep your sass stylesheets.") do |sass_dir|
+      self.options[:sass_dir] = sass_dir
+    end
+
+    opts.on('--css-dir CSS_DIR', "The target directory where you keep your css stylesheets.") do |css_dir|
+      self.options[:css_dir] = css_dir
+    end
+
+    opts.on('--images-dir IMAGES_DIR', "The directory where you keep your images.") do |images_dir|
+      self.options[:images_dir] = images_dir
+    end
+
+    opts.on('--javascripts-dir JS_DIR', "The directory where you keep your javascripts.") do |javascripts_dir|
+      self.options[:javascripts_dir] = javascripts_dir
+    end
+
+    opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment.',
+            '  One of: development, production (default)') 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
+  end
+
+end

data/lib/compass/exec/sub_command_ui.rb

@@ -0,0 +1,45 @@
+require 'compass/exec/global_options_parser'
+require 'compass/exec/project_options_parser'
+
+module Compass::Exec
+  class SubCommandUI
+
+    attr_accessor :args
+
+    def initialize(args)
+      self.args = args
+    end
+
+    def run!
+      begin
+        perform!
+      rescue Exception => e
+        raise e if e.is_a? SystemExit
+        if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
+          $stderr.puts e.message
+        else
+          ::Compass::Exec::Helpers.report_error(e, @options || {})
+        end
+        return 1
+      end
+      return 0
+    end
+    
+    protected
+    
+    def perform!
+      $command = args.shift
+      command_class = Compass::Commands[$command]
+      @options = if command_class.respond_to?("parse_#{$command}!")
+        command_class.send("parse_#{$command}!", args)
+      else
+        command_class.parse!(args)
+      end
+      command_class.new(Dir.getwd, @options).execute
+    rescue OptionParser::ParseError => e
+      puts "Error: #{e.message}"
+      puts command_class.usage
+    end
+    
+  end
+end