compass 0.8.17 → 0.10.0.pre1

data/lib/compass/commands/installer_command.rb

@@ -1,4 +1,4 @@
-require File.join(Compass.lib_directory, 'compass', 'installers')
+require 'compass/installers'
 
 module Compass
   module Commands
@@ -6,26 +6,33 @@ module Compass
       include Compass::Installers
 
       def configure!
-        read_project_configuration
-        Compass.configuration.set_maybe(options)
-        Compass.configuration.default_all(installer.configuration_defaults)
-        Compass.configuration.set_defaults!
+        if respond_to?(:is_project_creation?) && is_project_creation?
+          Compass.add_configuration(options.delete(:project_type) || :stand_alone)
+        else
+          Compass.add_project_configuration(:project_type => options.delete(:project_type))
+        end
+        Compass.add_configuration(options, 'command_line')
+        if File.exists?(Compass.configuration.extensions_path)
+          Compass::Frameworks.discover(Compass.configuration.extensions_path)
+        end
+        Compass.add_configuration(installer.completed_configuration, 'installer')
+      end
+
+      def app
+        @app ||= Compass::AppIntegration.lookup(Compass.configuration.project_type)
       end
 
       def installer
-        @installer ||= case options[:project_type]
-        when :stand_alone
-          StandAloneInstaller.new *installer_args
-        when :rails
-          RailsInstaller.new *installer_args
+        @installer ||= if options[:bare]
+          Compass::Installers::BareInstaller.new(*installer_args)
         else
-          raise "Unknown project type: #{options[:project_type].inspect}"
+          app.installer(*installer_args)
         end
       end
 
       def installer_args
-        [template_directory(options[:pattern]), project_directory, options]
+        [template_directory(options[:pattern] || "project"), project_directory, options]
       end
     end
   end
-end
+end

data/lib/compass/commands/interactive.rb

@@ -0,0 +1,61 @@
+
+require 'compass/commands/project_base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module InteractiveOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass interactive [path/to/project] [options]
+
+          Description:
+            Interactively evaluate SassScript
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+
+        super
+      end
+    end
+    class Interactive < ProjectBase
+
+      register :interactive
+
+      def initialize(working_path, options)
+        super
+      end
+
+      def perform
+        require 'sass/repl'
+        Sass::Repl.new.run
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(InteractiveOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Interactively evaluate SassScript"
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parser.options
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/commands/list_frameworks.rb

@@ -1,9 +1,9 @@
 module Compass
   module Commands
-    class ListFrameworks
+    class ListFrameworks < ProjectBase
       attr_accessor :options
       def initialize(working_path, options)
-        self.options = options
+        super
       end
   
       def execute

data/lib/compass/commands/print_version.rb

@@ -1,14 +1,82 @@
 module Compass
   module Commands
-    class PrintVersion
+    module VersionOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{Usage: compass version [options]
+
+Options:
+}
+        opts.on_tail("-?", "-h", "--help", "Print out this message.") do
+          puts opts
+          exit
+        end
+        opts.on("-q", "--quiet", "Just print the version string.") do
+          self.options[:quiet] = true
+        end
+        opts.on("--major", "Print the major version number") do
+          self.options[:major] = true
+          self.options[:custom] = true
+        end
+        opts.on("--minor", "Print up to the minor version number") do
+          self.options[:major] = true
+          self.options[:minor] = true
+          self.options[:custom] = true
+        end
+        opts.on("--patch", "Print up to the patch version number") do
+          self.options[:major] = true
+          self.options[:minor] = true
+          self.options[:patch] = true
+          self.options[:custom] = true
+        end
+        opts.on("--revision", "Include the source control revision") do
+          self.options[:revision] = true
+          self.options[:custom] = true
+        end
+      end
+    end
+
+    class PrintVersion < Base
+      register :version
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(VersionOptionsParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "Print out version information"
+        end
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parser.options
+        end
+      end
+
       attr_accessor :options
+
       def initialize(working_path, options)
         self.options = options
       end
   
       def execute
-        if options[:quiet]
-          # The quiet option may make scripting easier
+        if options[:custom]
+          version = ""
+          version << "#{Compass.version[:major]}" if options[:major]
+          version << ".#{Compass.version[:minor]}" if options[:minor]
+          version << ".#{Compass.version[:teeny]}" if options[:patch]
+          if options[:revision]
+            if version.size > 0
+              version << " [#{Compass.version[:rev][0..6]}]"
+            else
+              version << Compass.version[:rev]
+            end
+          end
+          puts version
+        elsif options[:quiet]
           puts ::Compass.version[:string]
         else
           lines = []
@@ -20,4 +88,4 @@ module Compass
       end
     end
   end
-end
+end

data/lib/compass/commands/project_base.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 require 'pathname'
-require File.join(File.dirname(__FILE__), 'base')
-require File.join(File.dirname(__FILE__), 'installer_command')
+require 'compass/commands/base'
+require 'compass/commands/installer_command'
 
 module Compass
   module Commands
@@ -11,24 +11,29 @@ module Compass
       def initialize(working_path, options = {})
         super(working_path, options)
         self.project_name = determine_project_name(working_path, options)
-        Compass.configuration.project_path = determine_project_directory(working_path, options)
+        Compass.add_configuration({:project_path => determine_project_directory(working_path, options)}, "implied")
+        configure!
       end
 
       def execute
-        configure!
         super
       end
 
       protected
 
       def configure!
-        read_project_configuration
-        Compass.configuration.set_maybe(options)
-        Compass.configuration.set_defaults!
+        add_project_configuration
+        if File.exists?(Compass.configuration.extensions_path)
+          Compass::Frameworks.discover(Compass.configuration.extensions_path)
+        end
+      end
+
+      def add_project_configuration
+        Compass.add_project_configuration(options[:configuration_file])
       end
 
       def projectize(path)
-        File.join(project_directory, separate(path))
+        Compass.projectize(path)
       end
 
       def project_directory
@@ -47,31 +52,6 @@ module Compass
         Compass.configuration.images_dir
       end
 
-      # Read the configuration file for this project
-      def read_project_configuration
-        if file = detect_configuration_file
-          Compass.configuration.parse(file) if File.readable?(file)
-        end
-      end
-
-      def explicit_config_file_must_be_readable?
-        true
-      end
-
-      # TODO: Deprecate the src/config.rb location.
-      KNOWN_CONFIG_LOCATIONS = [".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
-        if options[:configuration_file]
-          if explicit_config_file_must_be_readable? && !File.readable?(options[:configuration_file])
-            raise Compass::Error, "Configuration file, #{file}, not found or not readable."
-          end
-          return options[:configuration_file]
-        end
-        KNOWN_CONFIG_LOCATIONS.map{|f| projectize(f)}.detect{|f| File.exists?(f)}
-      end
-
       def assert_project_directory_exists!
         if File.exists?(project_directory) && !File.directory?(project_directory)
           raise Compass::FilesystemConflict.new("#{project_directory} is not a directory.")
@@ -109,4 +89,4 @@ module Compass
 
     end
   end
-end
+end

data/lib/compass/commands/project_stats.rb

@@ -0,0 +1,162 @@
+require 'compass/commands/project_base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module StatsOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass stats [path/to/project] [options]
+
+          Description:
+            Compile project at the path specified (or the current
+            directory if not specified) and then compute statistics
+            for the sass and css files in the project.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+
+        super
+      end
+    end
+    class ProjectStats < UpdateProject
+
+      register :stats
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        super
+        require 'compass/stats'
+        compiler = new_compiler_instance
+        sass_files = sorted_sass_files(compiler)
+        rows       = [[           :-,           :-,           :-,            :-,            :-,            :-,               :- ],
+                      [   'Filename',      'Rules', 'Properties', 'Mixins Defs', 'Mixins Used',   'CSS Rules', 'CSS Properties' ],
+                      [           :-,           :-,           :-,            :-,            :-,            :-,               :- ]]
+        maximums   =  [            8,            5,           10,            14,            11,             9,               14 ]
+        alignments =  [        :left,       :right,       :right,        :right,        :right,        :right,           :right ]
+        delimiters =  [ ['| ', ' |'],  [' ', ' |'],  [' ', ' |'],   [' ', ' |'],   [' ', ' |'],   [' ', ' |'],      [' ', ' |'] ]
+        totals     =  [ "Total (#{sass_files.size} files):", 0, 0,            0,             0,             0,                0 ]
+
+        sass_files.each do |sass_file|
+          css_file = compiler.corresponding_css_file(sass_file) unless sass_file[0..0] == '_'
+          row = filename_columns(sass_file)
+          row += sass_columns(sass_file)
+          row += css_columns(css_file)
+          row.each_with_index do |c, i|
+            maximums[i] = [maximums[i].to_i, c.size].max
+            totals[i] = totals[i] + c.to_i if i > 0
+          end
+          rows << row
+        end
+        rows << [:-] * 7
+        rows << totals.map{|t| t.to_s}
+        rows << [:-] * 7
+        rows.each do |row|
+          row.each_with_index do |col, i|
+            print pad(col, maximums[i], :align => alignments[i], :left => delimiters[i].first, :right => delimiters[i].last)
+          end
+          print "\n"
+        end
+        if @missing_css_parser
+          puts "\nInstall css_parser to enable stats on your css files:\n\n\tgem install css_parser"
+        end
+      end
+
+      def pad(c, max, options = {})
+        options[:align] ||= :left
+        if c == :-
+          filler = '-'
+          c = ''
+        else
+          filler = ' '
+        end
+        spaces = max - c.size
+        filled = filler * [spaces,0].max
+        "#{options[:left]}#{filled if options[:align] == :right}#{c}#{filled if options[:align] == :left}#{options[:right]}"
+      end
+
+      def sorted_sass_files(compiler)
+        sass_files = compiler.sass_files(:exclude_partials => false)
+        sass_files.map! do |s| 
+          filename = Compass.deprojectize(s, File.join(Compass.configuration.project_path, Compass.configuration.sass_dir))
+          [s, File.dirname(filename), File.basename(filename)]
+        end
+        sass_files = sass_files.sort_by do |s,d,f|
+          File.join(d, f[0] == ?_ ? f[1..-1] : f)
+        end
+        sass_files.map!{|s,d,f| s}
+      end
+
+      def filename_columns(sass_file)
+        filename = Compass.deprojectize(sass_file, working_path)
+        [filename]
+      end
+
+      def sass_columns(sass_file)
+        sf = Compass::Stats::SassFile.new(sass_file)
+        sf.analyze!
+        %w(rule_count prop_count mixin_def_count mixin_count).map do |t|
+          sf.send(t).to_s
+        end
+      end
+
+      def css_columns(css_file)
+        if File.exists?(css_file)
+          cf = Compass::Stats::CssFile.new(css_file)
+          cf.analyze!
+          %w(selector_count prop_count).map do |t|
+            cf.send(t).to_s
+          end
+        else
+          return [ '--', '--' ]
+        end
+      rescue LoadError
+        @missing_css_parser = true
+        return [ 'DISABLED', 'DISABLED' ]
+      end
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(StatsOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Report statistics about your stylesheets"
+        end
+
+        def primary; false; end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          if arguments.size == 1
+            parser.options[:project_name] = arguments.shift
+          elsif arguments.size == 0
+            # default to the current directory.
+          else
+            raise Compass::Error, "Too many arguments were specified."
+          end
+        end
+
+      end
+
+    end
+  end
+end