merbjedi-compass 0.5.0

data/frameworks/yui/templates/project/screen.sass

@@ -0,0 +1,4 @@
+@import yui.sass
+@import compass/reset.sass
+
++yui

data/lib/compass.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'sass'
+
+def assert_sass_version(obj)
+  unless obj.respond_to?(:version) && obj.version[:major] == 2 && obj.version[:minor] >= 1
+    raise LoadError.new("Compass requires Haml version 2.1 or greater.")
+  end
+end
+
+begin
+  assert_sass_version(Sass)
+rescue LoadError
+  require 'haml'
+  assert_sass_version(Haml)
+end
+
+require File.join(File.dirname(__FILE__), 'sass_extensions')
+
+['core_ext', 'version'].each do |file|
+  require File.join(File.dirname(__FILE__), 'compass', file)
+end
+
+module Compass
+  extend Compass::Version
+  def base_directory
+    File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  end
+  def lib_directory
+    File.expand_path(File.join(File.dirname(__FILE__)))
+  end
+  module_function :base_directory, :lib_directory
+end
+
+require File.join(File.dirname(__FILE__), 'compass', 'configuration')
+require File.join(File.dirname(__FILE__), 'compass', 'frameworks')
+
+# make sure we're running inside Merb
+require File.join(File.dirname(__FILE__), 'compass', 'merb') if defined?(Merb::Plugins)  
+

data/lib/compass/actions.rb

@@ -0,0 +1,92 @@
+module Compass
+  module Actions
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new
+    end
+
+    # copy/process a template in the compass template directory to the project directory.
+    def copy(from, to, options = nil)
+      options ||= self.options if self.respond_to?(:options)
+      contents = File.new(from).read
+      write_file to, contents, options
+    end
+
+    # create a directory and all the directories necessary to reach it.
+    def directory(dir, options = nil)
+      options ||= self.options if self.respond_to?(:options)
+      if File.exists?(dir) && File.directory?(dir)
+          logger.record :exists, basename(dir)
+      elsif File.exists?(dir)
+        msg = "#{basename(dir)} already exists and is not a directory."
+        raise Compass::FilesystemConflict.new(msg)
+      else
+        logger.record :directory, separate("#{basename(dir)}/")
+        FileUtils.mkdir_p(dir) unless options[:dry_run]
+      end          
+    end
+
+    # Write a file given the file contents as a string
+    def write_file(file_name, contents, options = nil)
+      options ||= self.options if self.respond_to?(:options)
+      skip_write = options[:dry_run]
+      if File.exists?(file_name)
+        existing_contents = File.new(file_name).read
+        if existing_contents == contents
+          logger.record :identical, basename(file_name)
+          skip_write = true
+        elsif options[:force]
+          logger.record :overwrite, basename(file_name)
+        else
+          msg = "File #{basename(file_name)} already exists. Run with --force to force overwrite."
+          raise Compass::FilesystemConflict.new(msg)
+        end
+      else
+        logger.record :create, basename(file_name)
+      end
+      open(file_name,'w') do |file|
+        file.write(contents)
+      end unless skip_write
+    end
+
+    # Compile one Sass file
+    def compile(sass_filename, css_filename, options)
+      logger.record :compile, basename(sass_filename)
+      engine = ::Sass::Engine.new(open(sass_filename).read,
+                                  :filename => sass_filename,
+                                  :line_comments => options[:environment] == :development,
+                                  :style => options[:style],
+                                  :css_filename => css_filename,
+                                  :load_paths => options[:load_paths])
+      css_content = engine.render
+      write_file(css_filename, css_content, options.merge(:force => true))
+    end
+
+    def basename(file)
+      relativize(file) {|f| File.basename(file)}
+    end
+    
+    def relativize(path)
+      if path.index(working_path+File::SEPARATOR) == 0
+        path[(working_path+File::SEPARATOR).length..-1]
+      elsif block_given?
+        yield path
+      else
+        path
+      end
+    end
+
+    # Write paths like we're on unix and then fix it
+    def separate(path)
+      path.gsub(%r{/}, File::SEPARATOR)
+    end
+
+    # Removes the trailing separator, if any, from a path.
+    def strip_trailing_separator(path)
+      (path[-1..-1] == File::SEPARATOR) ? path[0..-2] : path
+    end
+
+  end
+end

data/lib/compass/commands/base.rb

@@ -0,0 +1,29 @@
+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
+        unless Compass::Frameworks[options[:framework]]
+          raise Compass::Error.new("No such framework: #{options[:framework].inspect}")
+        end
+        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,82 @@
+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
+
+      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
+
+      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,25 @@
+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
+        Compass.configuration.set_maybe(options)
+        Compass.configuration.set_defaults!
+        Compass::Compiler.new(working_path,
+                              projectize(Compass.configuration.sass_dir),
+                              projectize(Compass.configuration.css_dir),
+                              Compass.sass_engine_options).run
+      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/commands/write_configuration.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'project_base')
+
+module Compass
+  module Commands
+    class WriteConfiguration < ProjectBase
+      
+      def initialize(working_path, options)
+        super
+        assert_project_directory_exists!
+      end
+
+      def perform
+        read_project_configuration
+        Compass.configuration.set_maybe(options)
+        Compass.configuration.set_defaults!
+        config_file = projectize("config.rb")
+        if File.exists?(config_file)
+          if options[:force]
+            logger.record(:overwrite, config_file)
+          else
+            message = "#{config_file} already exists. Run with --force to overwrite."
+            raise Compass::FilesystemConflict.new(message)
+          end
+        else
+          logger.record(:create, basename(config_file))
+        end
+        project_path, Compass.configuration.project_path = Compass.configuration.project_path, nil
+        open(config_file,'w') do |config|
+          config.puts Compass.configuration.serialize
+        end
+        Compass.configuration.project_path = project_path
+      end
+
+
+    end
+  end
+end