jsmestad-compass 0.4.2.1

data/lib/compass/commands/base.rb

@@ -0,0 +1,26 @@
+module Compass
+  module Commands
+    class Base
+
+      include Actions
+
+      attr_accessor :working_path, :options
+
+      def initialize(working_path, options)
+        self.working_path = working_path
+        self.options = options
+      end
+      
+      def perform
+        raise StandardError.new("Not Implemented")
+      end
+
+      protected
+
+      def framework
+        Compass::Frameworks[options[:framework]]
+      end
+
+    end
+  end
+end

data/lib/compass/commands/create_project.rb

@@ -0,0 +1,41 @@
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'update_project')
+require File.join(Compass.lib_directory, 'compass', 'installers')
+
+module Compass
+  module Commands
+    class CreateProject < ProjectBase
+
+      include Compass::Installers
+
+      attr_accessor :installer
+
+      def initialize(working_path, options)
+        super(working_path, options)
+        installer_args = [project_template_directory, project_directory, self.options]
+        @installer = case options[:project_type]
+        when :stand_alone
+          StandAloneInstaller.new *installer_args
+        when :rails
+          RailsInstaller.new *installer_args
+        else
+          raise "Unknown project type: #{project_type}"
+        end
+      end
+      
+      # all commands must implement perform
+      def perform
+        installer.init
+        installer.run(:skip_finalization => true)
+        UpdateProject.new(working_path, options).perform if installer.compilation_required?
+        installer.finalize(:create => true)
+      end
+
+      def project_template_directory
+        File.join(framework.templates_directory, "project")
+      end
+
+    end
+  end
+end

data/lib/compass/commands/list_frameworks.rb

@@ -0,0 +1,16 @@
+module Compass
+  module Commands
+    class ListFrameworks
+      attr_accessor :options
+      def initialize(working_path, options)
+        self.options = options
+      end
+  
+      def perform
+        Compass::Frameworks::ALL.each do |framework|
+          puts framework.name
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/print_version.rb

@@ -0,0 +1,23 @@
+module Compass
+  module Commands
+    class PrintVersion
+      attr_accessor :options
+      def initialize(working_path, options)
+        self.options = options
+      end
+  
+      def perform
+        if options[:quiet]
+          # The quiet option may make scripting easier
+          puts ::Compass.version[:string]
+        else
+          lines = []
+          lines << "Compass #{::Compass.version[:string]}"
+          lines << "Copyright (c) 2008 Chris Eppstein"
+          lines << "Released under the MIT License."
+          puts lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/compass/commands/project_base.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'sass'
+require 'fileutils'
+require 'pathname'
+require File.join(File.dirname(__FILE__), 'base')
+
+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.configuration.project_path = determine_project_directory(working_path, options)
+      end
+
+      protected
+
+      def projectize(path)
+        File.join(project_directory, separate(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
+
+      # Read the configuration file for this project
+      def read_project_configuration
+        if File.exists?(projectize('config.rb'))
+          Compass.configuration.parse(projectize('config.rb'))
+        elsif File.exists?(projectize('src/config.rb'))
+          Compass.configuration.parse(projectize('src/config.rb'))
+        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)
+        # This is only going to work on unix, gonna need a better implementation.
+        path.index(File::SEPARATOR) == 0
+      end
+
+    end
+  end
+end

data/lib/compass/commands/update_project.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'project_base')
+require File.join(Compass.lib_directory, 'compass', 'compiler')
+
+module Compass
+  module Commands
+    class UpdateProject < ProjectBase
+      
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        read_project_configuration
+        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 default_output_style
+        if options[:environment] == :development
+          :expanded
+        else
+          :compact
+        end
+      end
+
+      # where to load sass files from
+      def sass_load_paths
+        [project_src_directory] + Compass::Frameworks::ALL.map{|f| f.stylesheets_directory}
+      end
+      
+      # The subdirectory where the sass source is kept.
+      def project_src_subdirectory
+        Compass.configuration.sass_dir ||= options[:src_dir] || "src"
+      end
+
+      # The subdirectory where the css output is kept.
+      def project_css_subdirectory
+        Compass.configuration.css_dir ||= options[:css_dir] || "stylesheets"
+      end
+
+      # The directory where the project source files are located.
+      def project_src_directory
+        @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

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'sass'
+require 'fileutils'
+require 'pathname'
+require File.join(File.dirname(__FILE__), 'base')
+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
+        self.last_update_time = most_recent_update_time
+        puts ">>> Compass is now watching for changes. Press Ctrl-C to Stop."
+        loop do
+          # TODO: Make this efficient by using filesystem monitoring.
+          begin
+            sleep 1
+          rescue Interrupt
+            puts ""
+            exit 0
+          end
+          file, t = should_update?
+          if t
+            begin
+              puts ">>> Change detected to: #{file}"
+              super
+            rescue StandardError => e
+              ::Compass::Exec.report_error(e, options)
+            end
+            self.last_update_time = t
+          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
+          file = Dir.glob(separate("#{project_src_directory}/**/*.sass")).detect {|sass_file| File.stat(sass_file).mtime >= t}
+          [file, t]
+        end
+      end
+    end
+  end
+end

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,92 @@
+require 'singleton'
+
+module Compass
+  class Configuration
+    include Singleton
+    attr_accessor :project_path, :css_dir, :sass_dir, :images_dir, :javascripts_dir, :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)
+      [:css_dir, :sass_dir, :images_dir, :javascripts_dir].each do |prop|
+        value = eval(prop.to_s, binding) rescue nil
+        self.send("#{prop}=", value) if value
+      end
+    end
+
+    def serialize
+      contents = ""
+      required_libraries.each do |lib|
+        contents << %Q{require '#{lib}'\n}
+      end
+      contents << "\n" if required_libraries.any?
+      [:css_dir, :sass_dir, :images_dir, :javascripts_dir].each do |prop|
+        value = send(prop)
+        contents << %Q(#{prop} = "#{value}"\n) if value
+      end
+      contents
+    end
+
+    # Support for testing.
+    def reset!
+      [:project_path, :css_dir, :sass_dir, :images_dir, :javascripts_dir].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
+      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
+
+    def sass_engine_options
+      load_paths = []
+      if configuration.project_path && configuration.sass_dir
+        load_paths << File.join(configuration.project_path, configuration.sass_dir)
+      end
+      Compass::Frameworks::ALL.each do |framework|
+        load_paths << framework.stylesheets_directory
+      end
+      {:load_paths => load_paths}
+    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