compass-sass37 1.1.0

data/lib/compass/commands/clean_project.rb

@@ -0,0 +1,79 @@
+require 'compass/commands/project_base'
+require 'compass/compiler'
+
+module Compass
+  module Commands
+    module CleanProjectOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass clean [path/to/project] [options]
+
+          Description:
+          Remove generated files and the sass cache.
+
+          Options:
+        }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n")
+
+        super
+      end
+    end
+
+    class CleanProject < UpdateProject
+
+      register :clean
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        compiler = new_compiler_instance
+        compiler.clean!
+        Compass::SpriteImporter.find_all_sprite_map_files(Compass.configuration.generated_images_path).each do |sprite|
+          remove sprite
+        end
+      end
+
+      def determine_cache_location
+        Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
+      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(CleanProjectOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def primary; true; end
+
+        def description(command)
+          "Remove generated files and the sass cache"
+        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 > 0
+            parser.options[:project_name] = arguments.shift if File.directory?(arguments.first)
+            unless arguments.empty?
+              parser.options[:sass_files] = arguments.dup
+              parser.options[:force] = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/create_project.rb

@@ -0,0 +1,131 @@
+require 'fileutils'
+require 'compass/commands/stamp_pattern'
+
+module Compass
+  module Commands
+    module CreateProjectOptionsParser
+      def set_options(opts)
+
+        if $command == "create"
+          opts.banner = %Q{
+            Usage: compass create path/to/project [options]
+
+            Description:
+            Create a new compass project at the path specified.
+
+            Options:
+          }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n")
+
+          opts.on_tail("--bare", "Don't generate any Sass or CSS files.") do
+            self.options[:bare] = true
+          end
+        else
+          opts.banner = %Q{
+            Usage: compass init project_type path/to/project [options]
+
+            Description:
+            Initialize an existing project at the path specified.
+
+            Supported Project Types:
+            * rails
+
+            Options:
+          }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n").strip
+        end
+
+        opts.on("--using PATTERN", "A framework's pattern to use when creating the project.") do |framework|
+          framework = framework.split('/', 2)
+          self.options[:framework] = framework[0]
+          self.options[:pattern] = framework[1]
+        end
+
+        opts.on("-x", "--syntax SYNTAX", [:sass, :scss], "Specify the syntax to use when generating stylesheets.", "One of sass or scss. Defaults to scss.") do |syntax|
+          self.options[:preferred_syntax] = syntax
+        end
+
+        opts.on("--prepare", "Prepare the project by only creating configuration files.") do
+          self.options[:prepare] = true
+        end
+
+        super
+
+      end
+    end
+
+    class CreateProject < StampPattern
+
+      register :create
+      register :init
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(CreateProjectOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          if command.to_sym == :create
+            "Create a new compass project"
+          else
+            "Add compass to an existing project"
+          end
+        end
+
+        def primary; true; end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parse_options!(parser, arguments)
+          parse_arguments!(parser, arguments)
+          if parser.options[:framework] && parser.options[:bare]
+            raise Compass::Error, "A bare project cannot be created when a framework is specified."
+          end
+          set_default_arguments(parser)
+          parser.options
+        end
+
+        def parse_init!(arguments)
+          parser = option_parser(arguments)
+          parse_options!(parser, arguments)
+          if arguments.size > 0
+            parser.options[:project_type] = arguments.shift.to_sym
+          end
+          parse_arguments!(parser, arguments)
+          set_default_arguments(parser)
+          parser.options
+        end
+
+        def parse_options!(parser, arguments)
+          parser.parse!
+          parser
+        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
+
+        def set_default_arguments(parser)
+          parser.options[:framework] ||= :compass
+          parser.options[:pattern] ||= "project"
+        end
+      end
+
+      def is_project_creation?
+        true
+      end
+
+    end
+  end
+end

data/lib/compass/commands/default.rb

@@ -0,0 +1,50 @@
+module Compass
+  module Commands
+    module DefaultOptionsParser
+      def set_options(opts)
+        opts.on("--trace") do
+          self.options[:trace] = true
+        end
+        opts.on("-?", "-h", "--help") do
+          self.options[:command] = Proc.new do
+            Help.new(working_path, options.merge(:help_command => "help"))
+          end
+        end
+        opts.on("-q", "--quiet") do
+          self.options[:quiet] = true
+        end
+        opts.on("-v", "--version") do
+          self.options[:command] = Proc.new do
+            PrintVersion.new(working_path, options)
+          end
+        end
+        super
+      end
+    end
+    class Default < Base
+      
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(DefaultOptionsParser)
+        end
+        # def usage
+        #   $stderr.puts caller.join("\n")
+        #   "XXX"
+        # end
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parser.options[:command] ||= Proc.new do
+            Help.new(working_path, options.merge(:help_command => "help"))
+          end
+          parser.options
+        end
+      end
+
+      def execute
+        instance_eval(&options[:command]).execute
+      end
+    end
+  end
+end

data/lib/compass/commands/extension_command.rb

@@ -0,0 +1,60 @@
+require 'fileutils'
+require 'compass/commands/base'
+
+module Compass
+  module Commands
+    module ExtensionsOptionParser
+      def set_options(opts)
+        opts.banner = %Q{
+Usage: compass extension install EXTENSION_NAME [options]
+       compass extension uninstall EXTENSION_NAME [options]
+       compass extension list
+
+Description:
+  Manage the list of extensions on your system.
+  Compass to all of your compass projects.
+
+Example:
+  compass extension install sassy-buttons
+  compass extension uninstall sassy-buttons
+
+}
+        super
+      end
+    end
+
+    class ExtensionCommand < Base
+
+      register :extension
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(ExtensionsOptionParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "Manage the list of compass extensions on your system"
+        end
+        def parse!(arguments)
+          {:arguments => arguments}
+        end
+      end
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super(working_path, options)
+      end
+
+      # all commands must implement perform
+      def perform
+        require 'rubygems/gem_runner'
+        Gem::GemRunner.new.run(options[:arguments])
+      end
+
+    end
+  end
+end
+

data/lib/compass/commands/help.rb

@@ -0,0 +1,85 @@
+module Compass
+  module Commands
+    module HelpOptionsParser
+      def set_options(opts)
+        banner = %Q{Usage: compass help [command]
+
+Description:
+  The Compass Stylesheet Authoring Framework helps you
+  build and maintain your stylesheets and makes it easy
+  for you to use stylesheet libraries provided by others.
+
+Donating:
+  Compass is charityware. If you find it useful please make
+  a tax deductable donation: http://umdf.org/compass
+
+To get help on a particular command please specify the command.
+
+}
+        
+        primary_commands = Compass::Commands.all.select do |c|
+          cmd = Compass::Commands[c]
+          cmd.respond_to?(:primary) && cmd.primary
+        end
+        other_commands = Compass::Commands.all - primary_commands
+
+        banner << command_list("Primary Commands:", primary_commands)
+        banner << command_list("Other Commands:", other_commands)
+ 
+        banner << "\nAvailable Frameworks & Patterns:\n\n"
+        banner << Compass::Frameworks.pretty_print
+        banner << "\nGlobal Options:\n"
+        opts.banner = banner
+
+        super
+      end
+
+      def command_list(header, commands)
+        list = "#{header}\n"
+        commands.sort_by{|c| c.to_s}.each do |command|
+          list << "  * #{command}"
+          if Compass::Commands[command].respond_to? :description
+            list << "\t- #{Compass::Commands[command].description(command)}"
+          end
+          list << "\n"
+        end
+        list
+      end
+    end
+    class Help < Base
+      register :help
+      
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(HelpOptionsParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "Get help on a compass command or extension"
+        end
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parser.options[:help_command] = arguments.shift || 'help'
+          parser.options
+        end
+      end
+
+      def execute
+        if Compass::Commands.command_exists? options[:help_command]
+          $command = options[:help_command]
+          puts Compass::Commands[options[:help_command]].usage
+          $command = "help"
+        elsif Compass::Frameworks.template_exists? options[:help_command]
+          puts Compass::Frameworks.template_usage(options[:help_command])
+        else
+          raise OptionParser::ParseError, "No such command: #{options[:help_command]}"
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/imports.rb

@@ -0,0 +1,35 @@
+module Compass
+  module Commands
+    class Imports < ProjectBase
+      attr_accessor :options
+      register :imports
+      def initialize(working_path, options)
+        super
+      end
+  
+      def execute
+        print ::Compass::Frameworks::ALL.map{|f|
+                  "-I #{f.stylesheets_directory}"
+                }.join(' ')
+      end
+      class << self
+        def description(command)
+          "Emit an imports suitable for passing to the sass command-line."
+        end
+        def usage
+          "Usage: compass imports\n\n" +
+          "Prints out the imports known to compass.\n"+
+          "Useful for passing imports to the sass command line:\n" +
+          "  sass -r compass `compass imports` a_file_using_compass.sass"
+        end
+        def parse!(arguments)
+          if arguments.join("").strip.size > 0
+            raise OptionParser::ParseError, "This command takes no options or arguments."
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/installer_command.rb

@@ -0,0 +1,32 @@
+require 'compass/installers'
+
+module Compass
+  module Commands
+    module InstallerCommand
+      include Compass::Installers
+
+      def configure!
+        add_project_configuration
+        Compass.add_configuration(options, 'command_line')
+        Compass.discover_extensions!
+        Compass.add_configuration(installer.completed_configuration, 'installer')
+      end
+
+      def app
+        @app ||= Compass::AppIntegration.lookup(Compass.configuration.project_type)
+      end
+
+      def installer
+        @installer ||= if options[:bare]
+          Compass::Installers::BareInstaller.new(*installer_args)
+        else
+          app.installer(*installer_args)
+        end
+      end
+
+      def installer_args
+        [template_directory(options[:pattern] || "project"), project_directory, options]
+      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

@@ -0,0 +1,39 @@
+module Compass
+  module Commands
+    class ListFrameworks < ProjectBase
+      attr_accessor :options
+      register :frameworks
+      def initialize(working_path, options)
+        super
+      end
+  
+      def execute
+        if options[:quiet]
+          Compass::Frameworks::ALL.each do |framework|
+            puts framework.name unless framework.name =~ /^_/
+          end
+        else
+          puts "Available Frameworks & Patterns:\n\n"
+          puts Compass::Frameworks.pretty_print
+        end
+      end
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "List the available frameworks"
+        end
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parser.options
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/print_version.rb

@@ -0,0 +1,88 @@
+module Compass
+  module Commands
+    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
+      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
+        def long_output_string
+          lines = []
+          lines << "Compass #{::Compass.version[:string]}"
+          if name = ::Compass.version[:name]
+            lines.last << " (#{name})"
+          end
+          lines << "Copyright (c) 2008-#{Time.now.year} Chris Eppstein"
+          lines << "Released under the MIT License."
+          lines << "Compass is charityware."
+          lines << "Please make a tax deductable donation for a worthy cause: http://umdf.org/compass"
+          lines.join("\n")
+        end
+      end
+
+      attr_accessor :options
+
+      def initialize(working_path, options)
+        self.options = options
+      end
+  
+      def execute
+        if options[:custom]
+          version = ""
+          version << "#{Compass.version[:major]}" if options[:major]
+          version << ".#{Compass.version[:minor]}" if options[:minor]
+          version << ".#{Compass.version[:patch]}" if options[:patch]
+          puts version
+        elsif options[:quiet]
+          puts ::Compass.version[:string]
+        else
+          puts self.class.long_output_string
+        end
+      end
+    end
+  end
+end