compass-sass37 1.1.0

data/lib/compass/commands/project_base.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'pathname'
+require 'compass/commands/base'
+require 'compass/commands/installer_command'
+
+module Compass
+  module Commands
+    class ProjectBase < Base
+      attr_accessor :project_directory, :project_name, :options
+
+      def initialize(working_path, options = {})
+        super(working_path, options)
+        self.project_name = determine_project_name(working_path, options)
+        Compass.add_configuration({:project_path => determine_project_directory(working_path, options)}, "implied")
+        configure!
+      end
+
+      def execute
+        super
+      end
+
+      protected
+
+      def configure!
+        add_project_configuration
+        Compass.add_configuration(options, "command_line")
+        Compass.discover_extensions! unless skip_extension_discovery?
+      end
+
+      def add_project_configuration
+        defaults = Compass.configuration_for(options, "cli_defaults")
+        if options[:project_type]
+          project_type_config = Compass.configuration_for(options[:project_type])
+          project_type_config.inherit_from!(Compass.default_configuration)
+          defaults.inherit_from!(project_type_config)
+        end
+        Compass.add_project_configuration(options[:configuration_file], :defaults => defaults) do
+          options[:project_type]
+        end
+      end
+
+      def projectize(path)
+        Compass.projectize(path)
+      end
+
+      def project_directory
+        Compass.configuration.project_path
+      end
+
+      def project_css_subdirectory
+        Compass.configuration.css_dir
+      end
+
+      def project_src_subdirectory
+        Compass.configuration.sass_dir
+      end
+
+      def project_images_subdirectory
+        Compass.configuration.images_dir
+      end
+
+      def assert_project_directory_exists!
+        if File.exist?(project_directory) && !File.directory?(project_directory)
+          raise Compass::FilesystemConflict.new("#{project_directory} is not a directory.")
+        elsif !File.directory?(project_directory)
+          raise Compass::Error.new("#{project_directory} does not exist.")
+        end
+      end
+
+      private
+
+      def determine_project_name(working_path, options)
+        if options[:project_name]
+          File.basename(strip_trailing_separator(options[:project_name]))
+        else
+          File.basename(working_path)
+        end
+      end
+
+      def determine_project_directory(working_path, options)
+        if options[:project_name]
+          if absolute_path?(options[:project_name])
+            options[:project_name]
+          else
+            File.join(working_path, options[:project_name])
+          end
+        else
+          working_path
+        end
+      end
+
+      def absolute_path?(path)
+        # Pretty basic implementation
+        path.index(File::SEPARATOR) == 0 || path.index(':') == 1
+      end
+
+      def skip_extension_discovery?
+        false
+      end
+
+    end
+  end
+end

data/lib/compass/commands/project_stats.rb

@@ -0,0 +1,178 @@
+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)
+        total_label = "Total (#{sass_files.size} files):"
+        rows       = [[           :-,           :-,           :-,            :-,            :-,          :-,              :-,               :-,             :- ],
+                      [   'Filename',      'Rules', 'Properties', 'Mixins Defs', 'Mixins Used',  'Filesize', 'CSS Selectors', 'CSS Properties', 'CSS Filesize' ],
+                      [           :-,           :-,           :-,            :-,            :-,          :-,              :-,               :-,             :- ]]
+        maximums   =  [ total_label.length,      5,           10,            14,            11,          13,              13,               14,             14 ]
+        alignments =  [        :left,       :right,       :right,        :right,        :right,      :right,          :right,           :right,         :right ]
+        delimiters =  [ ['| ', ' |'],  [' ', ' |'],  [' ', ' |'],   [' ', ' |'],   [' ', ' |'], [' ', ' |'],     [' ', ' |'],      [' ', ' |'],    [' ', ' |'] ]
+        formatters =  [          nil,          nil,          nil,           nil,           nil,         :kb,             nil,             nil,             :kb ]
+        totals     =  [ total_label,             0,            0,             0,             0,           0,               0,                0,              0 ]
+
+        columns = rows.first.size
+
+        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 << [:-] * columns
+        rows << totals.map{|t| t.to_s}
+        rows << [:-] * columns
+        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, :formatter => formatters[i])
+          end
+          print "\n"
+        end
+        if @missing_css_parser
+          puts "\nInstall #{@missing_css_parser} to enable stats on your css files:\n\n\tgem install #{@missing_css_parser}"
+        end
+      end
+
+      def pad(c, max, options = {})
+        options[:align] ||= :left
+        if c == :-
+          filler = '-'
+          c = ''
+        else
+          filler = ' '
+        end
+        c = send(:"format_#{options[:formatter]}", c) if options[:formatter]
+        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 format_kb(v)
+        return v unless v =~ /^\d+$/
+        v = Integer(v)
+        if v < 1024
+          "#{v} B"
+        else
+          v = v / 1024.0
+          "#{v.ceil} KB"
+        end
+      end
+
+      def sorted_sass_files(compiler)
+        sass_files = compiler.sass_files
+        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 file_size).map do |t|
+          sf.send(t).to_s
+        end
+      end
+
+      def css_columns(css_file)
+        if File.exist?(css_file)
+          cf = Compass::Stats::CssFile.new(css_file)
+          cf.analyze!
+          %w(selector_count prop_count file_size).map do |t|
+            cf.send(t).to_s
+          end
+        else
+          return [ '--', '--' , '--']
+        end
+      rescue LoadError => e
+        @missing_css_parser = e.message =~ /iconv/ ? "iconv" : "css_parser"
+        return [ 'DISABLED', '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

data/lib/compass/commands/project_structure.rb

@@ -0,0 +1,93 @@
+require 'compass/commands/project_base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module StructureOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{
+          Usage: compass structure [path/to/project] [options]
+
+          Description:
+            Display the import structure of your stylesheets.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+
+        super
+      end
+    end
+    class ProjectStats < UpdateProject
+
+      register :structure
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        @compiler = new_compiler_instance
+        (options[:sass_files] || sorted_sass_files).each do |sass_file|
+          print_tree(Compass.projectize(sass_file))
+        end
+      end
+
+      def print_tree(file, depth = 0, importer = @compiler.importer)
+        puts ((depth > 0 ? "|  " : "   ") * depth) + "+- " + Compass.deprojectize(file)
+        @compiler.staleness_checker.send(:compute_dependencies, file, importer).each do |(dep, dep_importer)|
+          print_tree(dep, depth + 1, dep_importer)# unless Compass.deprojectize(dep)[0...1] == "/"
+        end
+      end
+
+      def sorted_sass_files
+        sass_files = @compiler.sass_files
+        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
+
+      class << self
+
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(StructureOptionsParser)
+        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 > 0
+            parser.options[:project_name] = arguments.shift if File.directory?(arguments.first)
+            parser.options[:sass_files] = arguments
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/compass/commands/registry.rb

@@ -0,0 +1,40 @@
+module Compass::Commands
+  module Registry
+    def register(name, command_class)
+      @commands ||= Hash.new
+      @commands[name.to_sym] = command_class
+    end
+    def get(name)
+      return unless name
+      @commands ||= Hash.new
+      @commands[name.to_sym] || @commands[abbreviation_of(name)]
+    end
+    def abbreviation_of(name)
+      re = /^#{Regexp.escape(name)}/
+      matching = @commands.keys.select{|k| k.to_s =~ re}
+      if matching.size == 1
+        matching.first
+      elsif name =~ /^-/
+        nil
+      elsif matching.size > 1
+        raise Compass::Error, "Ambiguous abbreviation '#{name}'. Did you mean one of: #{matching.join(", ")}"
+      else
+        raise Compass::Error, "Command not found: #{name}"
+      end
+    end
+    def abbreviation?(name)
+      re = /^#{Regexp.escape(name)}/
+      @commands.keys.detect{|k| k.to_s =~ re}
+    end
+    def command_exists?(name)
+      @commands ||= Hash.new
+      name && (@commands.has_key?(name.to_sym) || abbreviation?(name))
+    end
+    def all
+      @commands.keys
+    end
+    alias_method :[], :get
+    alias_method :[]=, :register
+  end
+  extend Registry
+end

data/lib/compass/commands/sprite.rb

@@ -0,0 +1,89 @@
+require 'compass/commands/project_base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module SpriteOptionsParser
+      def set_options(opts)
+        opts.on("-f SPRITE_FILE") do |output_file|
+          self.options[:output_file] = output_file
+        end
+        opts.on("--skip-overrides", "Skip the generation of sprite overrides") do |skip_overrides|
+          self.options[:skip_overrides] = skip_overrides
+        end
+        opts.banner = %Q{
+          Usage: compass sprite [options] "images/path/to/sprites/*.png"
+
+          Description:
+            Generate a sprite import based on the given sprite directory.
+            Alternatively, you can simply do this in your sass files:
+
+                @import "sprite-folder/*.png"
+
+            And a magical, custom made sprite file will be imported.
+
+          Options:
+        }.strip.split("\n").map{|l| l.gsub(/^ {0,10}/,'')}.join("\n")
+
+        super
+      end
+    end
+    class Sprite < ProjectBase
+
+      register :sprite
+
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        relative_uri = options[:uri].gsub(/^#{Compass.configuration.images_dir}\//, '')
+        name = Compass::SpriteImporter.sprite_name(relative_uri)
+        sprites = Compass::SpriteImporter.new
+        options[:output_file] ||= File.join(Compass.configuration.sass_path, "sprites", "_#{name}.#{Compass.configuration.preferred_syntax}")
+        options[:skip_overrides] ||= false
+        contents = Compass::SpriteImporter.content_for_images(relative_uri, name, options[:skip_overrides])
+        if options[:output_file][-4..-1] != "scss"
+          contents = Sass::Engine.new(contents, Compass.sass_engine_options.merge(:syntax => :scss)).to_tree.to_sass
+        end
+        directory File.dirname(options[:output_file])
+        write_file options[:output_file], contents
+      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(SpriteOptionsParser)
+        end
+
+        def usage
+          option_parser([]).to_s
+        end
+
+        def description(command)
+          "Generate an import for your sprites."
+        end
+
+        def parse!(arguments)
+          parser = option_parser(arguments)
+          parser.parse!
+          parse_arguments!(parser, arguments)
+          parser.options
+        end
+
+        def parse_arguments!(parser, arguments)
+          parser.options[:uri] = arguments.shift
+          unless arguments.size == 0
+            raise Compass::Error, "Please specify at least one image to sprite."
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/compass/commands/stamp_pattern.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+require 'compass/commands/base'
+require 'compass/commands/update_project'
+
+module Compass
+  module Commands
+    module StampPatternOptionsParser
+      def set_options(opts)
+        opts.banner = %Q{Usage: compass install extension/pattern [path/to/project] [options]
+
+Description:
+  Install an extension's pattern into your compass project
+
+Example:
+  compass install blueprint/buttons
+
+Options:
+}
+        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
+
+        super
+      end
+    end
+
+    class StampPattern < ProjectBase
+
+      register :install
+
+      class << self
+        def option_parser(arguments)
+          parser = Compass::Exec::CommandOptionParser.new(arguments)
+          parser.extend(Compass::Exec::GlobalOptionsParser)
+          parser.extend(Compass::Exec::ProjectOptionsParser)
+          parser.extend(StampPatternOptionsParser)
+        end
+        def usage
+          option_parser([]).to_s
+        end
+        def description(command)
+          "Install an extension's pattern into your compass project"
+        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
+            raise OptionParser::ParseError, "Please specify a pattern."
+          end
+          pattern = arguments.shift.split('/', 2)
+          parser.options[:framework] = pattern[0]
+          parser.options[:pattern] = pattern[1]
+          if arguments.size > 0
+            parser.options[:project_name] = arguments.shift
+          end
+          if arguments.size > 0
+            raise OptionParser::ParseError, "Unexpected trailing arguments: #{arguments.join(" ")}"
+          end
+        end
+
+      end
+      include InstallerCommand
+
+      def initialize(working_path, options)
+        super(working_path, options)
+      end
+
+      # all commands must implement perform
+      def perform
+        installer.init
+        installer.run(:skip_finalization => true, :skip_preparation => !is_project_creation?)
+        UpdateProject.new(working_path, options).perform if installer.compilation_required?
+        installer.finalize(options.merge(:create => is_project_creation?))
+      end
+
+      def is_project_creation?
+        false
+      end
+
+      def template_directory(pattern)
+        File.join(framework.templates_directory, pattern)
+      end
+
+    end
+  end
+end