jsmestad-compass 0.4.2.1

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('--source SRC_DIR', "The source directory (where you keep your sass stylesheets).") do |src_dir|
+          self.options[:src_dir] = src_dir
+        end
+
+        opts.on('--target 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('-f FRAMEWORK', '--framework FRAMEWORK', 'Set up a new project using the selected framework. Legal values: compass (default), blueprint') 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[: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('-y', "Answers yes to normall asked generator questions. Designed for rails-templates.") do
+          self.options[:answer_yes] = true
+        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 traceback 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')
+

data/lib/compass/installers/base.rb

@@ -0,0 +1,135 @@
+module Compass
+  module Installers
+
+    class Base
+
+      include Actions
+
+      attr_accessor :template_path, :target_path, :working_path
+      attr_accessor :options
+      attr_accessor :manifest
+      attr_accessor :css_dir, :sass_dir, :images_dir, :javascripts_dir
+
+      def initialize(template_path, target_path, options = {})
+        @template_path = template_path
+        @target_path = target_path
+        @working_path = Dir.getwd
+        @options = options
+        @manifest = Manifest.new(manifest_file)
+        self.logger = options[:logger]
+        configure
+      end
+
+      def manifest_file
+        @manifest_file ||= File.join(template_path, "manifest.rb")
+      end
+
+      # Initializes the project to work with compass
+      def init
+      end
+
+      # Runs the installer.
+      # Every installer must conform to the installation strategy of prepare, install, and then finalize.
+      # A default implementation is provided for each step.
+      def run(options = {})
+        prepare
+        install
+        finalize unless options[:skip_finalization]
+      end
+
+      # The default configure method -- it sets up directories from the options
+      # and corresponding default_* methods for those not found in the options hash.
+      # It can be overridden it or augmented for reading config files,
+      # prompting the user for more information, etc.
+      def configure
+        unless @configured
+          [:css_dir, :sass_dir, :images_dir, :javascripts_dir].each do |opt|
+            configure_option_with_default opt
+          end
+        end
+      ensure
+        @configured = true
+      end
+
+      # The default prepare method -- it is a no-op.
+      # Generally you would create required directories, etc.
+      def prepare
+      end
+
+      def configure_option_with_default(opt)
+        value = options[opt]
+        value ||= begin
+          default_method = "default_#{opt}".to_sym
+          send(default_method) if respond_to?(default_method)
+        end
+        send("#{opt}=", value)
+      end
+
+      # The default install method. Calls install_<type> methods in the order specified by the manifest.
+      def install
+        manifest.each do |entry|
+          send("install_#{entry.type}", entry.from, entry.to, entry.options)
+        end
+      end
+
+      # The default finalize method -- it is a no-op.
+      # This could print out a message or something.
+      def finalize
+      end
+
+      def compilation_required?
+        false
+      end
+
+      def self.installer(type, &locator)
+        locator ||= lambda{|to| to}
+        loc_method = "install_location_for_#{type}".to_sym
+        define_method loc_method, locator
+        define_method "install_#{type}" do |from, to, options|
+          copy templatize(from), targetize(send(loc_method, to))
+        end
+      end
+
+      installer :stylesheet do |to|
+        "#{sass_dir}/#{to}"
+      end
+
+      installer :image do |to|
+        "#{images_dir}/#{to}"
+      end
+
+      installer :script do |to|
+        "#{javascripts_dir}/#{to}"
+      end
+
+      installer :file
+
+      # returns an absolute path given a path relative to the current installation target.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def targetize(path)
+        strip_trailing_separator File.join(target_path, separate(path))
+      end
+
+      # returns an absolute path given a path relative to the current template.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def templatize(path)
+        strip_trailing_separator File.join(template_path, separate(path))
+      end
+
+      def stylesheet_links
+        html = "<head>\n"
+        manifest.each_stylesheet do |stylesheet|
+          media = if stylesheet.options[:media]
+            %Q{ media="#{stylesheet.options[:media]}"}
+          end
+          ss_line = %Q{  <link href="/stylesheets/#{stylesheet.to.sub(/\.sass$/,'.css')}"#{media} rel="stylesheet" type="text/css" />}
+          if stylesheet.options[:ie]
+            ss_line = "  <!--[if IE]>\n    #{ss_line}\n  <![endif]-->"
+          end
+          html << ss_line + "\n"
+        end
+        html << "</head>"
+      end
+    end
+  end
+end

data/lib/compass/installers/manifest.rb

@@ -0,0 +1,57 @@
+module Compass
+  module Installers
+
+    class Manifest
+
+      # A Manifest entry
+      class Entry < Struct.new(:type, :from, :options)
+        def to
+          options[:to] || from
+        end
+      end
+
+      def initialize(manifest_file = nil)
+        @entries = []
+        parse(manifest_file) if manifest_file
+      end
+
+      def self.type(t)
+        eval <<-END
+          def #{t}(from, options = {})
+             @entries << Entry.new(:#{t}, from, options)
+          end
+          def has_#{t}?
+            @entries.detect {|e| e.type == :#{t}}
+          end
+          def each_#{t}
+            @entries.select {|e| e.type == :#{t}}.each {|e| yield e}
+          end
+        END
+      end
+
+      type :stylesheet
+      type :image
+      type :javascript
+      type :file
+
+      # Enumerates over the manifest files
+      def each
+        @entries.each {|e| yield e}
+      end
+
+
+      protected
+      # parses a manifest file which is a ruby script
+      # evaluated in a Manifest instance context
+      def parse(manifest_file)
+        open(manifest_file) do |f|
+          eval(f.read, instance_binding, manifest_file)
+        end
+      end
+      def instance_binding
+        binding
+      end
+    end
+
+  end
+end

data/lib/compass/installers/rails.rb

@@ -0,0 +1,125 @@
+module Compass
+  module Installers
+    
+    class RailsInstaller < Base
+
+      def configure
+        configuration_file = targetize('config/initializers/compass.rb')
+        if File.exists?(configuration_file)
+          open(configuration_file) do |config|
+            eval(config.read, nil, configuration_file)
+          end
+        end
+      end
+
+      def init
+        set_sass_dir unless sass_dir
+        set_css_dir unless css_dir
+        directory targetize(css_dir)
+        directory targetize(sass_dir)
+        write_file targetize('config/initializers/compass.rb'), initializer_contents
+      end
+
+      def prepare
+      end
+
+      def finalize(options = {})
+        if options[:create]
+          puts <<-NEXTSTEPS
+
+Congratulations! Your rails project has been configured to use Compass.
+Sass will automatically compile your stylesheets during the next
+page request and keep them up to date when they change.
+Make sure you restart your server!
+
+Next add these lines to the head of your layouts:
+
+NEXTSTEPS
+        end
+        puts stylesheet_links
+        puts "\n(You are using haml, aren't you?)"
+      end
+
+      def sass_dir
+        Compass.configuration.sass_dir
+      end
+
+      def css_dir
+        Compass.configuration.css_dir
+      end
+
+      def images_dir
+        separate "public/images"
+      end
+
+      def javascripts_dir
+        separate "public/javascripts"
+      end
+
+      def set_sass_dir
+        recommended_location = separate('app/stylesheets')
+        default_location = separate('public/stylesheets/sass')
+        if @options[:answer_yes]
+          Compass.configuration.sass_dir = recommended_location
+        else
+          print %Q{Compass recommends that you keep your stylesheets in #{recommended_location}
+instead of the Sass default location of #{default_location}.
+Is this OK? (Y/n) }
+          answer = gets.downcase[0]
+          Compass.configuration.sass_dir = answer == ?n ? default_location : recommended_location
+        end
+      end
+
+      def set_css_dir
+        recommended_location = separate("public/stylesheets/compiled")
+        default_location = separate("public/stylesheets")
+        if @options[:answer_yes]
+          Compass.configuration.css_dir = recommended_location
+        else
+          puts
+          print %Q{Compass recommends that you keep your compiled css in #{recommended_location}/
+instead the Sass default of #{default_location}/.
+However, if you're exclusively using Sass, then #{default_location}/ is recommended.
+Emit compiled stylesheets to #{recommended_location}/? (Y/n) }
+          answer = gets.downcase[0]
+          Compass.configuration.css_dir = answer == ?n ? default_location : recommended_location
+        end
+      end
+
+      def initializer_contents
+        %Q{require 'compass'
+# If you have any compass plugins, require them here.
+Compass.configuration do |config|
+  config.project_path = RAILS_ROOT
+  config.sass_dir = "#{sass_dir}"
+  config.css_dir = "#{css_dir}"
+end
+Compass.configure_sass_plugin!
+}
+      end
+
+      def stylesheet_prefix
+        if css_dir.length >= 19
+          "#{css_dir[19..-1]}/"
+        else
+          nil
+        end
+      end
+
+      def stylesheet_links
+        html = "%head\n"
+        manifest.each_stylesheet do |stylesheet|
+          ss_line = "  = stylesheet_link_tag '#{stylesheet_prefix}#{stylesheet.to.sub(/\.sass$/,'.css')}'"
+          if stylesheet.options[:media]
+            ss_line += ", :media => '#{stylesheet.options[:media]}'"
+          end
+          if stylesheet.options[:ie]
+            ss_line = "  /[if IE]\n  " + ss_line
+          end
+          html << ss_line + "\n"
+        end
+        html
+      end
+    end
+  end
+end