compass-rails31 0.12.0.alpha.0.91a748a

data/lib/compass/exec/sub_command_ui.rb

@@ -0,0 +1,51 @@
+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
+        return 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
+    end
+    
+    protected
+    
+    def perform!
+      $command = args.shift
+      command_class = Compass::Commands[$command]
+      unless command_class
+        args.unshift($command)
+        $command = "help"
+        command_class = Compass::Commands::Default
+      end
+      @options = if command_class.respond_to?("parse_#{$command}!")
+        command_class.send("parse_#{$command}!", args)
+      else
+        command_class.parse!(args)
+      end
+      cmd = command_class.new(Dir.getwd, @options)
+      cmd.execute
+      cmd.successful? ? 0 : 1
+    rescue OptionParser::ParseError => e
+      puts "Error: #{e.message}"
+      puts command_class.usage if command_class.respond_to?(:usage)
+    end
+    
+  end
+end

data/lib/compass/exec/switch_ui.rb

@@ -0,0 +1,179 @@
+require 'compass/exec/global_options_parser'
+require 'compass/exec/project_options_parser'
+
+module Compass::Exec
+  class SwitchUI
+    include GlobalOptionsParser
+    include ProjectOptionsParser
+    attr_accessor :args, :options, :opts
+
+    def initialize(args)
+      self.args = args
+      self.options = {}
+      parse!
+    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!
+      if options[:command]
+        do_command(options[:command])
+      else
+        puts self.opts
+      end
+    end
+    
+    def parse!
+      self.opts = OptionParser.new(&method(:set_opts))
+      self.opts.parse!(self.args)    
+      if self.args.size > 0
+        self.options[:project_name] = trim_trailing_separator(self.args.shift)
+      end
+      self.options[:command] ||= self.options[:project_name] ? :create_project : :update_project
+      self.options[:framework] ||= :compass
+    end
+
+    def trim_trailing_separator(path)
+      path[-1..-1] == File::SEPARATOR ? path[0..-2] : path
+    end
+
+    def set_opts(opts)
+      opts.banner = <<END
+Usage: compass [options] [project]
+
+Description:
+The compass command line tool will help you create and manage the stylesheets for your project.
+
+To get started on a stand-alone project based on blueprint:
+
+  compass -f blueprint my_compass_project
+
+When you change any sass files, you must recompile your project using --update or --watch.
+END
+      opts.separator ''
+      opts.separator 'Mode Options(only specify one):'
+
+      opts.on('-i', '--install', :NONE, "Create a new compass project.",
+                                        "  The default mode when a project is provided.") do
+        self.options[:command] = :create_project
+      end
+
+      opts.on('-u', '--update', :NONE, 'Update the current project.',
+                                       '  This is the default when no project is provided.') do
+        self.options[:command] = :update_project
+      end
+
+      opts.on('-w', '--watch', :NONE, 'Monitor the current project for changes and update') do
+        self.options[:command] = :watch_project
+        self.options[:quiet] = true
+      end
+
+      opts.on('-p', '--pattern PATTERN', 'Stamp out a pattern into the current project.',
+                                         '  Must be used with -f.') do |pattern|
+        self.options[:command] = :stamp_pattern
+        self.options[:pattern] = pattern
+      end
+
+      opts.on('-h', '--help') do
+        self.options[:command] = :help
+        self.options[:help_command] = :help
+      end
+
+      opts.on('--write-configuration', "Write the current configuration to the configuration file.") do
+        self.options[:command] = :write_configuration
+      end
+
+      opts.on('--list-frameworks', "List compass frameworks available to use.") do
+        self.options[:command] = :list_frameworks
+      end
+
+      opts.on('--validate', :NONE, 'Validate your project\'s compiled css. Requires Java.') do
+        self.options[:command] = :validate_project
+      end
+
+      opts.on('--grid-img [DIMENSIONS]', 'Generate a background image to test grid alignment.',
+                                         '  Dimension is given as <column_width>+<gutter_width>x<height>.',
+                                         '  Defaults to 30+10x20. Height is optional.') do |dimensions|
+        self.options[:grid_dimensions] = dimensions || "30+10"
+        self.options[:command] = :generate_grid_background
+      end
+
+      opts.separator ''
+      opts.separator 'Install/Pattern Options:'
+
+      opts.on('-f FRAMEWORK', '--framework FRAMEWORK', 'Use the specified framework. Only one may be specified.') do |framework|
+        self.options[:framework] = framework
+      end
+
+      opts.on('-n', '--pattern-name NAME', 'The name to use when stamping a pattern.',
+                                           '  Must be used in combination with -p.') do |name|
+        self.options[:pattern_name] = name
+      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('--rails', "Sets the app type to a rails project (same as --app rails).") do
+        self.options[:project_type] = :rails
+      end
+
+      opts.on('--app APP_TYPE', 'Specify the kind of application to integrate with.') do |project_type|
+        self.options[:project_type] = project_type.to_sym
+      end
+
+      opts.separator ''
+      opts.separator 'Configuration Options:'
+
+      set_project_options(opts)
+
+      opts.separator ''
+      opts.separator 'General Options:'
+
+      set_global_options(opts)
+
+      opts.on('--imports', :NONE, 'Emit an imports suitable for passing to the sass command-line.',
+                                  '  Example: sass `compass --imports`',
+                                  '  Note: Compass\'s Sass extensions will not be available.') do
+        print ::Compass::Frameworks::ALL.map{|f| "-I #{f.stylesheets_directory}"}.join(' ')
+        exit
+      end
+
+      opts.on('--install-dir', :NONE, 'Emit the location where compass is installed.') do
+        puts ::Compass.base_directory
+        exit
+      end
+
+      opts.on_tail("-v", "--version", "Print version") do
+        self.options[:command] = :print_version
+      end
+
+      opts.on('--boring', :NONE, 'Turn off colorized output.') do
+        self.options[:color_output] = false
+      end
+
+    end
+    
+    def do_command(command)
+      command_class_name = command.to_s.split(/_/).map{|p| p.capitalize}.join('')
+      command_class = eval("::Compass::Commands::#{command_class_name}")
+      command_class.new(Dir.getwd, options).execute
+    end
+
+  end
+end

data/lib/compass/frameworks.rb

@@ -0,0 +1,127 @@
+module Compass
+  module Frameworks
+    extend self
+
+    ALL = []
+    DEFAULT_FRAMEWORKS_PATH = File.join(Compass.base_directory, 'frameworks')
+
+    class Framework
+      attr_accessor :name
+      attr_accessor :path
+      attr_accessor :templates_directory, :stylesheets_directory
+      def initialize(name, *arguments)
+        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+        self.path = path = options[:path] || arguments.shift
+        @name = name
+        @templates_directory = options[:templates_directory] || File.join(path, 'templates')
+        @stylesheets_directory = options[:stylesheets_directory] || File.join(path, 'stylesheets')
+      end
+      def template_directories
+        Dir.glob(File.join(templates_directory, "*")).map{|f| File.basename(f)}
+      end
+      def manifest_file(pattern)
+        File.join(templates_directory, pattern.to_s, "manifest.rb")
+      end
+      def manifest(pattern, options = {})
+        options[:pattern_name] ||= pattern
+        Compass::Installers::Manifest.new(manifest_file(pattern), options)
+      end
+    end
+
+    def detect_registration
+      @registered = nil
+      yield
+      @registered
+    ensure
+      @registered = nil
+    end
+
+    def register(name, *arguments)
+      @registered = Framework.new(name, *arguments)
+      if idx = ALL.index(self[name])
+        ALL[idx] = @registered
+      else
+        ALL << @registered
+      end
+    end
+
+    def [](name)
+      ALL.detect{|f| f.name.to_s == name.to_s}
+    end
+
+    def discover(frameworks_directory)
+      frameworks_directory = DEFAULT_FRAMEWORKS_PATH if frameworks_directory == :defaults
+      frameworks_directory = Dir.new(frameworks_directory) unless frameworks_directory.is_a?(Dir)
+      dirs = frameworks_directory.entries.reject{|e| e =~ /^\./}.sort_by{|n| n =~ /^_/ ? n[1..-1] : n}
+      dirs.each do |framework|
+        register_directory File.join(frameworks_directory.path, framework)
+      end
+    end
+
+    def register_directory(directory)
+      loaders = [
+        File.join(directory, "compass_init.rb"),
+        File.join(directory, 'lib', File.basename(directory)+".rb"),
+        File.join(directory, File.basename(directory)+".rb")
+      ]
+      loader = loaders.detect{|l| File.exists?(l)}
+      registered_framework = detect_registration do
+        require loader if loader
+      end
+      unless registered_framework
+        register File.basename(directory), directory
+      end
+    end
+
+    def template_exists?(template)
+      framework_name, template = template.split(%r{/}, 2)
+      template ||= "project"
+      if framework = self[framework_name]
+        return File.directory?(File.join(framework.templates_directory, template))
+      end
+      false
+    end
+
+    def template_usage(template)
+      framework_name, template = template.split(%r{/}, 2)
+      framework = self[framework_name]
+      template ||= "project"
+      usage_file = File.join(framework.templates_directory, template, "USAGE.markdown")
+      if File.exists?(usage_file)
+        File.read(usage_file)
+      elsif help = framework.manifest(template).help
+        help
+      else
+        <<-END.gsub(/^ {8}/, '')
+          No Usage!
+        END
+      end
+    end
+
+    def pretty_print(skip_patterns = false)
+      result = ""
+      max = Compass::Frameworks::ALL.inject(0) do |gm, framework|
+        fm = framework.template_directories.inject(0) do |lm,pattern|
+          [lm, 7 + framework.name.size + pattern.size].max
+        end
+        [gm, fm].max
+      end
+      Compass::Frameworks::ALL.each do |framework|
+        next if framework.name =~ /^_/
+        result << "  * #{framework.name}\n"
+        unless skip_patterns
+          framework.template_directories.each do |pattern|
+            result << "    - #{framework.name}/#{pattern}".ljust(max)
+            if description = framework.manifest(pattern).description
+              result << " - #{description}"
+            end
+            result << "\n"
+          end
+        end
+      end
+      result
+    end
+  end
+end
+
+Compass::Frameworks.discover(:defaults)

data/lib/compass/grid_builder.rb

@@ -0,0 +1,102 @@
+require 'zlib'
+
+module Compass
+
+  # A simple class to represent and create a PNG-File
+  # No drawing features given
+  # Just subclass and write [R,G,B]-Byte-Values into the <tt>@data</tt> matrix
+  # Build for compactness, so not much error checking!
+  #
+  # Code based on seattlerb's png, see http://seattlerb.rubyforge.org/png/
+  class PNG
+    CRC_TABLE = (0..255).map do |n|
+      (0...8).inject(n){|x,i| x = ((x & 1) == 1) ? 0xedb88320 ^ (x >> 1) : x >> 1}
+    end
+
+    class << self
+      def crc(chunkdata='')
+        chunkdata.unpack('C*').inject(0xffffffff){|crc, byte| CRC_TABLE[(crc ^ byte)  & 0xff] ^ (crc >> 8) } ^  0xffffffff
+      end
+
+      def chunk(type, data="")
+        [data.size, type, data, crc(type + data)].pack("Na*a*N")
+      end
+    end
+
+    # Initiates a new PNG-Object
+    # * <tt>width</tt>: Width of the image in pixels
+    # * <tt>height</tt>: Height of the image in pixels
+    # * <tt>background</tt>: Background-color represented as [R,G,B]-Byte-Array
+    def initialize(width, height, background = [255,255,255])
+      @height = height
+      @width = width
+      @data = Array.new(@height) { |x| Array.new(@width, background) }
+    end
+
+    BITS    = 8
+    RGB     = 2 # Color Types ( RGBA = 6)
+    NONE    = 0 # Filter
+
+    # binary representation of the PNG, write to file with binary mode
+    def to_blob
+      blob = []
+      blob <<  [137, 80, 78, 71, 13, 10, 26, 10].pack("C*")
+      blob << PNG.chunk('IHDR', [@width, @height, BITS, RGB, NONE, NONE, NONE].pack("N2C5"))
+      blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(self.png_join))
+      blob << PNG.chunk('IEND', '')
+      blob.join
+    end
+
+    def png_join
+      @data.map { |row| "\0" + row.map { |p| "%c%c%c" % p}.join }.join
+    end
+  end
+
+  class GridBuilder < PNG
+    include Actions
+
+    attr_reader :column_width, :gutter_width, :filename, :able_to_generate, :options
+
+    # ==== Options
+    # * <tt>options</tt>
+    #   * <tt>:column_width</tt> -- Width (in pixels) of current grid column
+    #   * <tt>:gutter_width</tt> -- Width (in pixels) of current grid gutter
+    #   * <tt>:height</tt> -- Height (in pixels) of a row
+    #   * <tt>:filename</tt> -- Output path of grid.png file
+    def initialize(options={})
+      @column_width = options[:column_width] || 0
+      gutter_width = options[:gutter_width] || 0
+
+      height = options[:height] || 20
+      width = @column_width + gutter_width
+      width = 10 if width == 0
+
+      @filename = options[:filename]
+      @options = options
+
+      super(width, height, [0xe9,0xe9,0xe9])
+    end
+
+    def working_path
+      options[:working_path]
+    end
+
+    # generates (overwriting if necessary) grid.png image to be tiled in background
+    def generate!
+      (0...@height-1).each do |line|
+        @data[line] = Array.new(@width){|x| x < @column_width ? [0xe8, 0xef, 0xfb] : [0xff,0xff,0xff] }
+      end
+
+      if File.exists?(filename)
+        if options[:force]
+          overwrite = true
+        else
+          msg = "#{filename} already exists. Overwrite with --force."
+          raise Compass::FilesystemConflict.new(msg)
+        end
+      end
+      directory File.dirname(filename)
+      write_file(filename, self.to_blob, options, true)
+    end
+  end
+end