chriseppstein-compass 0.1.1

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

@@ -0,0 +1,5 @@
+@import yui/screen.sass
+@import compass/reset.sass
+
+body
+  +yui

data/lib/compass.rb

@@ -0,0 +1,19 @@
+require 'sass'
+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
+  module_function :base_directory
+end
+
+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/commands/base.rb

@@ -0,0 +1,94 @@
+module Compass
+  module Commands
+    class Base
+      attr_accessor :working_directory, :options
+      def initialize(working_directory, options)
+        self.working_directory = working_directory
+        self.options = options
+      end
+      
+      def perform
+        raise StandardError.new("Not Implemented")
+      end
+
+      protected
+      
+      def projectize(path)
+        File.join(project_directory, separate(path))
+      end
+      # create a directory and all the directories necessary to reach it.
+      def directory(subdir, options = nil)
+        options ||= self.options
+        dir = subdir ? projectize(subdir) : project_directory
+        if File.exists?(dir) && File.directory?(dir) && options[:force]
+            print_action :exists, basename(dir) + File::SEPARATOR
+        elsif File.exists?(dir) && File.directory?(dir)
+          msg = "Directory #{basename(dir)} already exists. Run with --force to force project creation."
+          raise ::Compass::Exec::ExecError.new(msg)
+        elsif File.exists?(dir)
+          msg = "#{basename(dir)} already exists and is not a directory."
+          raise ::Compass::Exec::ExecError.new(msg)
+        else
+          print_action :directory, basename(dir) + File::SEPARATOR
+          FileUtils.mkdir_p(dir) unless options[:dry_run]
+        end          
+      end
+
+      # copy/process a template in the compass template directory to the project directory.
+      def template(from, to, options)
+        to = projectize(to)
+        from = File.join(templates_directory, separate(from))
+        if File.exists?(to) && !options[:force]
+          #TODO: Detect differences & provide an overwrite prompt
+          msg = "#{basename(to)} already exists."
+          raise ::Compass::Exec::ExecError.new(msg)
+        elsif File.exists?(to)
+          print_action :remove, basename(to)
+          FileUtils.rm to unless options[:dry_run]
+        end
+        print_action :create, basename(to)
+        FileUtils.cp from, to unless options[:dry_run]
+      end
+
+      def write_file(file_name, contents)
+        if File.exists?(file_name) && !options[:force]
+          msg = "File #{basename(file_name)} already exists. Run with --force to force creation."
+          raise ::Compass::Exec::ExecError.new(msg)
+        end
+        if File.exists?(file_name)
+          print_action :overwrite, basename(file_name)
+        else
+          print_action :create, basename(file_name)
+        end
+        output = open(file_name,'w')
+        output.write(contents)
+        output.close
+      end
+
+      # returns the path to the templates directory and caches it
+      def templates_directory
+        @templates_directory ||= File.expand_path(File.join(File.dirname(__FILE__), separate("../../../frameworks/#{options[:framework]}/templates")))
+      end
+
+      # Write paths like we're on unix and then fix it
+      def separate(path)
+        path.gsub(%r{/}, File::SEPARATOR)
+      end
+      
+      def basename(file, extra = 0)
+        if file.length > (working_directory.length + extra)
+          file[(working_directory.length + extra + 1)..-1]
+        else
+          File.basename(file)
+        end
+      end
+      
+      ACTIONS = [:directory, :exists, :remove, :create, :overwrite]
+      MAX_ACTION_LENGTH = ACTIONS.inject(0){|memo, a| [memo, a.to_s.length].max}
+      def print_action(action, extra)
+        puts "#{' ' * (MAX_ACTION_LENGTH - action.to_s.length)}#{action} #{extra}" if !options[:quiet] || options[:dry_run]
+      end
+      
+    end
+  end
+end

data/lib/compass/commands/create_project.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'update_project')
+
+module Compass
+  module Commands
+    class CreateProject < Base
+      
+      attr_accessor :project_directory, :project_name
+
+      def initialize(working_directory, options)
+        super(working_directory, options)
+        self.project_name = options[:project_name]
+        self.project_directory = File.expand_path File.join(working_directory, project_name)
+      end
+      
+      # all commands must implement perform
+      def perform
+        directory nil, options
+        directory 'stylesheets', options.merge(:force => true)
+        directory 'src', options.merge(:force => true)
+        template 'project/screen.sass', 'src/screen.sass', options
+        template 'project/print.sass',  'src/print.sass', options
+        template 'project/ie.sass',     'src/ie.sass', options
+        UpdateProject.new(working_directory, options).perform
+      end
+
+    end
+  end
+end

data/lib/compass/commands/install_rails.rb

@@ -0,0 +1,115 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module Compass
+  module Commands
+    class InstallRails < Base
+      def initialize(working_directory, options)
+        super(working_directory, options)
+      end
+      def perform
+        set_install_location
+        set_output_location
+        directory options[:stylesheets_location]
+        template 'project/screen.sass', "#{options[:stylesheets_location]}/screen.sass", options
+        template 'project/print.sass',  "#{options[:stylesheets_location]}/print.sass", options
+        template 'project/ie.sass',     "#{options[:stylesheets_location]}/ie.sass", options
+        write_file projectize('config/initializers/compass.rb'), initializer_contents
+        if has_application_layout?
+          next_steps
+        else
+          write_file projectize('app/views/layouts/application.html.haml'), application_layout_contents
+        end
+      end
+      
+      def initializer
+        init_file = 
+        if File.exists?(init_file) && !options[:force]
+          msg = "File #{basename(init_file)} already exists. Run with --force to force project creation."
+          raise ::Compass::Exec::ExecError.new(msg)
+        end
+        if File.exists?(init_file)
+          print_action :overwrite, basename(init_file)
+        else
+          print_action :create, basename(init_file)
+        end
+        output = open(init_file,'w')
+        output.write(initializer_contents)
+        output.close
+      end
+      
+      def initializer_contents
+        %Q{require 'compass'
+# If you have any compass plugins, require them here.
+Sass::Plugin.options[:template_location] = {
+  "\#{RAILS_ROOT}#{File::SEPARATOR}#{options[:stylesheets_location]}" => "\#{RAILS_ROOT}#{File::SEPARATOR}#{options[:css_location]}"
+}
+Compass::Frameworks::ALL.each do |framework|
+  Sass::Plugin.options[:template_location][framework.stylesheets_directory] = "\#{RAILS_ROOT}#{File::SEPARATOR}#{options[:css_location]}"
+end
+}
+      end
+
+      def application_layout_contents
+        %Q{!!! XML
+!!!
+%html{:xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en"}
+  %head
+    %meta{'http-equiv' => "content-type", :content => "text/html;charset=UTF-8"}
+    %title= @browser_title || 'Default Browser Title'
+    = stylesheet_link_tag '#{stylesheet_prefix}screen.css', :media => 'screen, projection'
+    = stylesheet_link_tag '#{stylesheet_prefix}print.css', :media => 'print'
+    /[if IE]
+      = stylesheet_link_tag '#{stylesheet_prefix}ie.css', :media => 'screen, projection'
+  %body
+    %h1 Welcome to Compass
+    = yield
+}
+      end
+
+      def next_steps
+        puts <<NEXTSTEPS
+
+Congratulations! Your project has been configured to use Compass.
+Next add these lines to the head of your application.html.haml:
+
+%head 
+  = stylesheet_link_tag '#{stylesheet_prefix}screen.css', :media => 'screen, projection'
+  = stylesheet_link_tag '#{stylesheet_prefix}print.css', :media => 'print'
+  /[if IE]
+    = stylesheet_link_tag '#{stylesheet_prefix}ie.css', :media => 'screen, projection'
+
+(you are using haml, aren't you?)
+NEXTSTEPS
+      end
+
+      def has_application_layout?
+        File.exists?(projectize('app/views/layouts/application.rhtml')) ||
+        File.exists?(projectize('app/views/layouts/application.html.erb')) ||
+        File.exists?(projectize('app/views/layouts/application.html.haml'))
+      end
+
+      def stylesheet_prefix
+        if options[:css_location].length >= 19
+          "#{options[:css_location][19..-1]}/"
+        else
+          nil
+        end
+      end
+
+      def project_directory
+        working_directory
+      end
+      
+      def set_install_location
+        print "Compass recommends that you keep your stylesheets in app/stylesheets/ instead of the Sass default location of public/stylesheets/sass/.\nIs this OK? (Y/n) "
+        answer = gets
+        self.options[:stylesheets_location] = separate(answer.downcase[0] == ?n ? 'public/stylesheets/sass' : 'app/stylesheets')
+      end
+      def set_output_location
+        print "\nCompass recommends that you keep your compiled css in public/stylesheets/compiled/ instead the Sass default of public/stylesheets/.\nHowever, if you're exclusively using Sass, then public/stylesheets/ is recommended.\nEmit compiled stylesheets to public/stylesheets/compiled? (Y/n) "
+        answer = gets
+        self.options[:css_location] = separate(answer.downcase[0] == ?n ? 'public/stylesheets' : 'public/stylesheets/compiled')
+      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_directory, 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/update_project.rb

@@ -0,0 +1,91 @@
+require 'rubygems'
+require 'sass'
+require 'fileutils'
+require 'pathname'
+require File.join(File.dirname(__FILE__), 'base')
+
+module Compass
+  module Commands
+    class UpdateProject < Base
+      
+      Base::ACTIONS << :compile
+      Base::ACTIONS << :overwrite
+
+      attr_accessor :project_directory, :project_name, :options
+
+      def initialize(working_directory, options = {})
+        super(working_directory, options)
+        if options[:project_name]
+          options[:project_name] = options[:project_name][0..-2] if options[:project_name][-1..-1] == File::SEPARATOR
+          self.project_name = File.basename(options[:project_name])
+          if options[:project_name][0] == File::SEPARATOR
+            self.project_directory = options[:project_name]
+          elsif File.directory?(File.join(working_directory, options[:project_name]))
+            self.project_directory = File.expand_path(File.join(working_directory, options[:project_name]))
+          else
+            if File.exists?(options[:project_name]) or File.exists?(File.join(working_directory, options[:project_name]))
+              raise ::Compass::Exec::ExecError.new("#{options[:project_name]} is not a directory.")
+            elsif !(options[:force] || options[:dry_run])
+              raise ::Compass::Exec::ExecError.new("#{options[:project_name]} does not exist.")
+            end
+          end
+        else
+          self.project_name = File.basename(working_directory)
+          self.project_directory = working_directory          
+        end
+      end
+      
+      def perform
+        Dir.glob(separate("#{project_directory}/src/**/[^_]*.sass")).each do |sass_file|
+          stylesheet_name = sass_file[("#{project_directory}/src/".length)..-6]
+          compile "src/#{stylesheet_name}.sass", "stylesheets/#{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
+      end
+      
+      def output_style
+        @output_style ||= options[:style] || if options[:environment] == :development
+          :expanded
+        else
+          :compact
+        end
+      end
+      
+      # where to load sass files from
+      def sass_load_paths
+        @sass_load_paths ||= [project_src_directory] + Compass::Frameworks::ALL.map{|f| f.stylesheets_directory}
+      end
+      
+      # The directory where the project source files are located.
+      def project_src_directory
+        @project_src_directory ||= separate("#{project_directory}/src")
+      end
+
+    end
+  end
+end

data/lib/compass/commands/watch_project.rb

@@ -0,0 +1,42 @@
+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
+        super
+        self.last_update_time = most_recent_update_time
+        loop do
+          # TODO: Make this efficient by using filesystem monitoring.
+          sleep 1
+          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_directory}/src/**/*.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_directory}/src/**/*.sass")).detect {|sass_file| File.stat(sass_file).mtime >= t}
+          [file, t]
+        end
+      end
+    end
+  end
+end

data/lib/compass/core_ext.rb

@@ -0,0 +1,39 @@
+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
+  def blank?
+    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