chriseppstein-compass 0.3.9 → 0.4.0

data/lib/compass/commands/update_project.rb

@@ -1,48 +1,27 @@
 require File.join(File.dirname(__FILE__), 'project_base')
+require File.join(Compass.lib_directory, 'compass', 'compiler')
 
 module Compass
   module Commands
     class UpdateProject < ProjectBase
       
-      Base::ACTIONS << :compile
-      Base::ACTIONS << :overwrite
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
 
       def perform
         read_project_configuration
-        Dir.glob(separate("#{project_src_directory}/**/[^_]*.sass")).each do |sass_file|
-          stylesheet_name = sass_file[("#{project_src_directory}/".length)..-6]
-          compile "#{project_src_subdirectory}/#{stylesheet_name}.sass", "#{project_css_subdirectory}/#{stylesheet_name}.css", options
-        end
-      end
-
-      # Compile one Sass file
-      def compile(sass_filename, css_filename, options)
-        sass_filename = projectize(sass_filename)
-        css_filename = projectize(css_filename)
-        if !File.directory?(File.dirname(css_filename))
-          directory basename(File.dirname(css_filename)), options.merge(:force => true) unless options[:dry_run]
-        end
-        print_action :compile, basename(sass_filename)
-        if File.exists?(css_filename)
-          print_action :overwrite, basename(css_filename)
-        else
-          print_action :create, basename(css_filename)
-        end
-        unless options[:dry_run]
-          engine = ::Sass::Engine.new(open(sass_filename).read,
-                                      :filename => sass_filename,
-                                      :line_comments => options[:environment] == :development,
-                                      :style => output_style,
-                                      :css_filename => css_filename,
-                                      :load_paths => sass_load_paths)
-          output = open(css_filename,'w')
-          output.write(engine.render)
-          output.close
-        end
+        default_options = { :style => default_output_style }
+        compilation_options = default_options.merge(options).merge(:load_paths => sass_load_paths)
+        Compass::Compiler.new(working_path,
+                              projectize(project_src_subdirectory),
+                              projectize(project_css_subdirectory),
+                              compilation_options).run
       end
       
-      def output_style
-        @output_style ||= options[:style] || if options[:environment] == :development
+      def default_output_style
+        if options[:environment] == :development
           :expanded
         else
           :compact
@@ -51,17 +30,17 @@ module Compass
 
       # where to load sass files from
       def sass_load_paths
-        @sass_load_paths ||= [project_src_directory] + Compass::Frameworks::ALL.map{|f| f.stylesheets_directory}
+        [project_src_directory] + Compass::Frameworks::ALL.map{|f| f.stylesheets_directory}
       end
       
       # The subdirectory where the sass source is kept.
       def project_src_subdirectory
-        @project_src_subdirectory ||= options[:src_dir] || "src"
+        Compass.configuration.sass_dir ||= options[:src_dir] || "src"
       end
 
       # The subdirectory where the css output is kept.
       def project_css_subdirectory
-        @project_css_subdirectory ||= options[:css_dir] || "stylesheets"
+        Compass.configuration.css_dir ||= options[:css_dir] || "stylesheets"
       end
 
       # The directory where the project source files are located.
@@ -69,6 +48,14 @@ module Compass
         @project_src_directory ||= separate("#{project_directory}/#{project_src_subdirectory}")
       end
 
+      def assert_project_directory_exists!
+        if File.exists?(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
+
     end
   end
 end

data/lib/compass/commands/watch_project.rb

@@ -8,7 +8,9 @@ require File.join(File.dirname(__FILE__), 'update_project')
 module Compass
   module Commands
     class WatchProject < UpdateProject
+
       attr_accessor :last_update_time
+
       def perform
         puts ">>> Compiling all stylesheets."
         super
@@ -34,9 +36,11 @@ module Compass
           end
         end
       end
+
       def most_recent_update_time
         Dir.glob(separate("#{project_src_directory}/**/*.sass")).map {|sass_file| File.stat(sass_file).mtime}.max
       end
+
       def should_update?
         t = most_recent_update_time
         if t > last_update_time

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,52 @@
+require 'singleton'
+
+module Compass
+  class Configuration
+    include Singleton
+    attr_accessor :project_path, :css_dir, :sass_dir, :images_dir, :javascripts_dir
+
+    # parses a manifest file which is a ruby script
+    # evaluated in a Manifest instance context
+    def parse(config_file)
+      open(config_file) do |f|
+        eval(f.read, instance_binding, config_file)
+      end
+    end
+
+    def reset!
+      [:project_path, :css_dir, :sass_dir, :images_dir, :javascripts_dir].each do |attr|
+        send("#{attr}=", nil)
+      end
+    end
+
+    def instance_binding
+      binding
+    end
+  end
+
+  module ConfigHelpers
+    def configuration
+      if block_given?
+        yield Configuration.instance
+      end
+      Configuration.instance
+    end
+
+    def sass_plugin_configuration
+      proj_sass_path = File.join(configuration.project_path, configuration.sass_dir)
+      proj_css_path = File.join(configuration.project_path, configuration.css_dir)
+      locations = {proj_sass_path => proj_css_path}
+      Compass::Frameworks::ALL.each do |framework|
+        locations[framework.stylesheets_directory] = proj_css_path
+      end
+      {:template_location => locations}
+    end
+
+    def configure_sass_plugin!
+      Sass::Plugin.options.merge!(sass_plugin_configuration)
+    end
+  end
+
+  extend ConfigHelpers
+
+end

data/lib/compass/core_ext.rb

@@ -1,21 +1,8 @@
 class String
+
   # see if string has any content
   def blank?; self.length.zero?; end
   
-  # strip space after :, remove newlines, replace multiple spaces with only one space, remove comments
-  def strip_space!
-    replace self.gsub(/:\s*/, ':').gsub(/\n/, '').gsub(/\s+/, ' ').gsub(/(\/\*).*?(\*\/)/, '')
-  end
-  
-  # remove newlines, insert space after comma, replace two spaces with one space after comma
-  def strip_selector_space!
-    replace self.gsub(/(\n)/, '').gsub(',', ', ').gsub(',  ', ', ')
-  end
-  
-  # remove leading whitespace, remove end whitespace
-  def strip_side_space!
-    replace self.gsub(/^\s+/, '').gsub(/\s+$/, $/)
-  end
 end
 
 class NilClass
@@ -23,17 +10,3 @@ class NilClass
     true
   end
 end
-
-class File
-  # string output from file
-  def self.path_to_string(path)
-    File.new(path).read
-  end
-  
-  # saves a string to a specified file path
-  def self.string_to_file(string, path)
-    directory = File.dirname(path)
-    FileUtils.mkdir_p directory unless File.directory?(directory)
-    File.open(path, 'w') { |f| f << string }
-  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

@@ -1,15 +1,13 @@
 require 'optparse'
 require 'rubygems'
 require 'haml'
+require File.join(Compass.lib_directory, 'compass', 'logger')
+require File.join(Compass.lib_directory, 'compass', 'configuration')
+require File.join(Compass.lib_directory, 'compass', 'errors')
+require File.join(Compass.lib_directory, 'compass', 'actions')
 
 module Compass
   module Exec
-    class ExecError < StandardError
-    end
-
-    class DirectoryExistsError < ExecError
-    end
-
 
     def report_error(e, options)
       $stderr.puts "#{e.class} on line #{get_line e} of #{get_file e}: #{e.message}"
@@ -48,7 +46,7 @@ module Compass
           perform!
         rescue Exception => e
           raise e if e.is_a? SystemExit
-          if e.is_a?(ExecError) || e.is_a?(OptionParser::ParseError)
+          if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
             $stderr.puts e.message
           else
             ::Compass::Exec.report_error(e, @options)
@@ -77,6 +75,7 @@ module Compass
         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)
@@ -131,8 +130,8 @@ END
           require library
         end
         
-        opts.on('--rails', "Install compass into your Ruby on Rails project found in the current directory.") do
-          self.options[:command] = :install_rails
+        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

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,117 @@
+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')
+        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
+
+      def set_css_dir
+        recommended_location = separate("public/stylesheets/compiled")
+        default_location = separate("public/stylesheets")
+        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
+
+      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

data/lib/compass/installers/stand_alone.rb

@@ -0,0 +1,76 @@
+module Compass
+  module Installers
+    
+    class StandAloneInstaller < Base
+
+      def configure
+        if File.exists?(config_file)
+          Compass.configuration.parse(config_file)
+        elsif File.exists?(old_config_file)
+          Compass.configuration.parse(old_config_file)
+        end
+        super
+      end
+
+      def init
+        directory targetize("")
+        directory targetize(css_dir)
+        directory targetize(sass_dir)
+      end
+
+      def prepare
+        directory targetize(images_dir) if manifest.has_image?
+        directory targetize(javascripts_dir) if manifest.has_javascript?
+      end
+
+      def default_css_dir
+        Compass.configuration.css_dir || "stylesheets"
+      end
+
+      def default_sass_dir
+        Compass.configuration.sass_dir ||"src"
+      end
+
+      def default_images_dir
+        Compass.configuration.images_dir || "images"
+      end
+
+      def default_javascripts_dir
+        Compass.configuration.javascripts_dir || "javascripts"
+      end
+
+      # Read the configuration file for this project
+      def config_file
+        @config_file ||= targetize('config.rb')
+      end
+
+      def old_config_file
+        @old_config_file ||= targetize('src/config.rb')
+      end
+
+      def finalize(options = {})
+        if options[:create]
+          puts <<-NEXTSTEPS
+
+Congratulations! Your compass project has been created.
+You must recompile your sass stylesheets when they change.
+This can be done in one of the following ways:
+  1. From within your project directory run:
+     compass
+  2. From any directory run:
+     compass -u path/to/project
+  3. To monitor your project for changes and automatically recompile:
+     compass --watch [path/to/project]
+
+NEXTSTEPS
+        end
+        puts "To import your new stylesheets add the following lines of HTML (or equivalent) to your webpage:"
+        puts stylesheet_links
+      end
+
+      def compilation_required?
+        true
+      end
+    end
+  end
+end