bsherman-compass 0.5.2

data/lib/compass/compiler.rb

@@ -0,0 +1,40 @@
+module Compass
+  class Compiler
+
+    include Actions
+
+    attr_accessor :working_path, :from, :to, :options
+
+    def initialize(working_path, from, to, options)
+      self.working_path = working_path
+      self.from, self.to = from, to
+      self.logger = options.delete(:logger)
+      self.options = options
+    end
+
+    def sass_files
+      @sass_files || Dir.glob(separate("#{from}/**/[^_]*.sass"))
+    end
+
+    def stylesheet_name(sass_file)
+      sass_file[("#{from}/".length)..-6]
+    end
+
+    def css_files
+      @css_files || sass_files.map{|sass_file| "#{to}/#{stylesheet_name(sass_file)}.css"}
+    end
+
+    def target_directories
+      css_files.map{|css_file| File.dirname(css_file)}.uniq.sort.sort_by{|d| d.length }
+    end
+
+    def run
+      target_directories.each do |dir|
+        directory dir
+      end
+      sass_files.zip(css_files).each do |sass_filename, css_filename|
+        compile sass_filename, css_filename, options
+      end
+    end
+  end
+end

data/lib/compass/configuration.rb

@@ -0,0 +1,167 @@
+require 'singleton'
+
+module Compass
+  class Configuration
+    include Singleton
+
+    ATTRIBUTES = [
+      :project_path,
+      :css_dir,
+      :sass_dir,
+      :images_dir,
+      :javascripts_dir,
+      :output_style,
+      :environment
+    ]
+
+    attr_accessor *ATTRIBUTES
+
+    attr_accessor :required_libraries
+
+    def initialize
+      self.required_libraries = []
+    end
+
+    # parses a manifest file which is a ruby script
+    # evaluated in a Manifest instance context
+    def parse(config_file)
+      open(config_file) do |f|
+        parse_string(f.read, config_file)
+      end
+    end
+
+    def parse_string(contents, filename)
+      eval(contents, binding, filename)
+      ATTRIBUTES.each do |prop|
+        value = eval(prop.to_s, binding) rescue nil
+        self.send("#{prop}=", value) if value
+      end
+    end
+
+    def set_all(options)
+      ATTRIBUTES.each do |a|
+        self.send("#{a}=", options[a]) if options.has_key?(a)
+      end
+    end
+
+    def set_maybe(options)
+      ATTRIBUTES.each do |a|
+        self.send("#{a}=", options[a]) if options[a]
+      end
+    end
+
+    def default_all(options)
+      ATTRIBUTES.each do |a|
+        self.send("#{a}=", options[a]) unless self.send(a)
+      end
+    end
+
+    def set_defaults!
+      default_all(ATTRIBUTES.inject({}){|m, a| m[a] = default_for(a); m})
+    end
+
+    def default_for(attribute)
+      method = "default_#{attribute}".to_sym
+      self.send(method) if respond_to?(method)
+    end
+
+    def default_sass_dir
+      "src"
+    end
+
+    def default_css_dir
+      "stylesheets"
+    end
+
+    def default_output_style
+      if environment == :development
+        :expanded
+      else
+        :compact
+      end
+    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)
+        unless value.nil?
+          contents << %Q(#{prop} = #{value.inspect}\n)
+        end
+      end
+      contents
+    end
+
+    def to_sass_plugin_options
+      if project_path && sass_dir && css_dir
+        proj_sass_path = File.join(project_path, sass_dir)
+        proj_css_path = File.join(project_path, css_dir)
+        locations = {proj_sass_path => proj_css_path}
+      else
+        locations = {}
+      end
+      Compass::Frameworks::ALL.each do |framework|
+        locations[framework.stylesheets_directory] = proj_css_path || css_dir || "."
+      end
+      plugin_opts = {:template_location => locations}
+      plugin_opts[:style] = output_style if output_style
+      plugin_opts
+    end
+
+    def to_sass_engine_options
+      load_paths = []
+      if project_path && sass_dir
+        load_paths << File.join(project_path, sass_dir)
+      end
+      Compass::Frameworks::ALL.each do |framework|
+        load_paths << framework.stylesheets_directory
+      end
+      engine_opts = {:load_paths => load_paths}
+      engine_opts[:style] = output_style if output_style
+      engine_opts
+    end
+
+    # Support for testing.
+    def reset!
+      ATTRIBUTES.each do |attr|
+        send("#{attr}=", nil)
+      end
+      self.required_libraries = []
+    end
+
+    def require(lib)
+      required_libraries << lib
+      super
+    end
+
+  end
+
+  module ConfigHelpers
+    def configuration
+      if block_given?
+        yield Configuration.instance
+      end
+      Configuration.instance
+    end
+
+    def sass_plugin_configuration
+      configuration.to_sass_plugin_options
+    end
+
+    def configure_sass_plugin!
+      Sass::Plugin.options.merge!(sass_plugin_configuration)
+    end
+
+    def sass_engine_options
+      configuration.to_sass_engine_options
+    end
+  end
+
+  extend ConfigHelpers
+
+end

data/lib/compass/core_ext.rb

@@ -0,0 +1,12 @@
+class String
+
+  # see if string has any content
+  def blank?; self.length.zero?; end
+  
+end
+
+class NilClass
+  def blank?
+    true
+  end
+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,184 @@
+require 'optparse'
+require 'rubygems'
+require 'haml'
+require File.join(Compass.lib_directory, 'compass', 'logger')
+require File.join(Compass.lib_directory, 'compass', 'errors')
+require File.join(Compass.lib_directory, 'compass', 'actions')
+
+module Compass
+  module Exec
+
+    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)
+      # SyntaxErrors have weird line reporting
+      # when there's trailing whitespace,
+      # which there is for Haml documents.
+      return exception.message.scan(/:(\d+)/)[0] if exception.is_a?(::Haml::SyntaxError)
+      exception.backtrace[0].scan(/:(\d+)/)[0]
+    end
+    module_function :report_error, :get_file, :get_line
+
+    class Compass
+      
+      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.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[:environment] ||= :production
+        self.options[:framework] ||= :compass
+        self.options[:project_type] ||= :stand_alone
+      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:
+  When project is given, generates a new project of that name as a subdirectory of
+  the current directory.
+  
+  If you change any source files, you can update your project using --update.
+
+Options:
+END
+        opts.on('-u', '--update', :NONE, 'Update the current project') 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
+        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('--list-frameworks', "List compass frameworks available to use.") do
+          self.options[:command] = :list_frameworks
+        end
+
+        opts.on('-c', '--write-configuration', "Write the current configuration to the configuration file.") do
+          self.options[:command] = :write_configuration
+        end
+
+        opts.on('-f FRAMEWORK', '--framework FRAMEWORK', 'Set up a new project using the specified framework.') do |framework|
+          self.options[:framework] = framework
+        end
+
+        opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment: 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 (nested, expanded, compact, compressed)') do |style|
+          self.options[:output_style] = style
+        end
+
+        opts.on('-r LIBRARY', '--require LIBRARY', "Require LIBRARY before running commands. This is used to access compass plugins.") do |library|
+          require library
+        end
+        
+        opts.on('--rails', "Sets the project type to a rails project.") do
+          self.options[:project_type] = :rails
+        end
+
+        opts.on('-q', '--quiet', :NONE, 'Quiet mode.') do
+          self.options[:quiet] = 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('--trace', :NONE, 'Show a full stacktrace on error') do
+          self.options[:trace] = true
+        end
+        
+        opts.on('--force', :NONE, 'Force. Allows some commands to succeed when they would otherwise fail.') do
+          self.options[:force] = true
+        end
+
+        opts.on('--imports', :NONE, 'Emit an import path suitable for use with the Sass command-line tool.') do
+          #XXX cross platform support?
+          print ::Compass::Frameworks::ALL.map{|f| "-I #{f.stylesheets_directory}"}.join(' ')
+          exit
+        end
+
+        opts.on_tail("-?", "-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          self.options[:command] = :print_version
+        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).perform
+      end
+
+    end
+  end
+end
+
+Dir.glob(File.join(File.dirname(__FILE__), 'commands', "*.rb")).each do |file|
+  require file
+end

data/lib/compass/frameworks.rb

@@ -0,0 +1,29 @@
+module Compass
+  module Frameworks
+    ALL = []
+    class Framework
+      attr_accessor :name
+      attr_accessor :templates_directory, :stylesheets_directory
+      def initialize(name, *arguments)
+        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+        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
+    end
+    def register(name, *arguments)
+      ALL << Framework.new(name, *arguments)
+    end
+    def [](name)
+      ALL.detect{|f| f.name.to_s == name.to_s}
+    end
+    module_function :register, :[]
+  end
+end
+
+# Import all of the default frameworks.
+default_frameworks_directory = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'frameworks'))
+Dir.glob(File.join(default_frameworks_directory, "*.rb")).each do |framework|
+  require framework
+end

data/lib/compass/installers.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'installers', 'manifest')
+require File.join(File.dirname(__FILE__), 'installers', 'base')
+require File.join(File.dirname(__FILE__), 'installers', 'stand_alone')
+require File.join(File.dirname(__FILE__), 'installers', 'rails')
+