compass-rails 1.0.0.rc.1

data/lib/compass-rails/railties.rb

@@ -0,0 +1,11 @@
+if defined?(::Rails)
+  if CompassRails.rails2?
+    require "compass-rails/railties/2_3"
+  elsif CompassRails.rails31? || CompassRails.rails32?
+    require "compass-rails/railties/3_1"
+  elsif CompassRails.rails3?
+    require "compass-rails/railties/3_0"
+  else
+    $stderr.puts "Unsupported rails environment for compass"
+  end
+end

data/lib/compass-rails/railties/2_3.rb

@@ -0,0 +1,56 @@
+#rails 2.x doesn't have railties so gona do this the long way
+require "sass/plugin/rack" #unless defined?(Sass::Plugin::Rack)
+
+module ActionController
+  class Base
+    def process_with_compass(*args)
+      Sass::Plugin.rails_controller = self
+      begin
+        process_without_compass(*args)
+      ensure
+        Sass::Plugin.rails_controller = nil
+      end
+    end
+    alias_method_chain :process, :compass
+  end
+end
+
+
+module Sass::Plugin
+  class << self
+    attr_accessor :rails_controller
+  end
+end
+
+module Compass::SassExtensions::Functions::Urls::ImageUrl
+  def image_url_with_rails_integration(path, only_path = Sass::Script::Bool.new(false), cache_buster = Sass::Script::Bool.new(true))
+    if (@controller = Sass::Plugin.rails_controller) && @controller.respond_to?(:request) && @controller.request
+      begin
+        if only_path.to_bool
+          Sass::Script::String.new image_path(path.value)
+        else
+          Sass::Script::String.new "url(#{image_path(path.value)})"
+        end
+      ensure
+        @controller = nil
+      end
+    else
+      image_url_without_rails_integration(path, only_path, cache_buster)
+    end
+  end
+  alias_method_chain :image_url, :rails_integration
+end
+
+
+class Sass::Script::Functions::EvaluationContext
+  include Sass::Script::Functions
+  private
+  include ActionView::Helpers::AssetTagHelper
+end
+
+unless Compass.detect_configuration_file.nil?
+  Compass.add_configuration(CompassRails.configuration)
+  CompassRails.initialize!
+else
+  CompassRails.initialize!(CompassRails.configuration)
+end

data/lib/compass-rails/railties/3_0.rb

@@ -0,0 +1,48 @@
+#3.0.11
+require 'compass'
+require 'rails'
+
+class Rails::Railtie::Configuration
+  # Adds compass configuration accessor to the application configuration.
+  #
+  # If a configuration file for compass exists, it will be read in and
+  # the project's configuration values will already be set on the config
+  # object.
+  #
+  # For example:
+  #
+  #     module MyApp
+  #       class Application < Rails::Application
+  #          config.compass.line_comments = !Rails.env.production?
+  #          config.compass.fonts_dir = "app/assets/fonts"
+  #       end
+  #     end
+  #
+  # It is suggested that you create a compass configuration file if you
+  # want a quicker boot time when using the compass command line tool.
+  #
+  # For more information on available configuration options see:
+  # http://compass-style.org/help/tutorials/configuration-reference/
+  def compass
+    @compass ||= begin
+      data = if (config_file = Compass.detect_configuration_file) && (config_data = Compass.configuration_for(config_file))
+        config_data
+      else
+        Compass::Configuration::Data.new("project")
+      end
+      data.project_type = :rails # Forcing this makes sure all the rails defaults will be loaded.
+      data
+    end
+  end
+end
+
+module CompassRails
+  class Railtie < Rails::Railtie
+
+    initializer "compass.initialize_rails" do |app|
+      # Configure compass for use within rails, and provide the project configuration
+      # that came via the rails boot process.
+      CompassRails.initialize!(app.config.compass)
+    end
+  end
+end

data/lib/compass-rails/railties/3_1.rb

@@ -0,0 +1,90 @@
+#3.1.3
+require 'compass'
+require 'rails/railtie'
+
+class Rails::Railtie::Configuration
+  # Adds compass configuration accessor to the application configuration.
+  #
+  # If a configuration file for compass exists, it will be read in and
+  # the project's configuration values will already be set on the config
+  # object.
+  #
+  # For example:
+  #
+  #     module MyApp
+  #       class Application < Rails::Application
+  #          config.compass.line_comments = !Rails.env.production?
+  #          config.compass.fonts_dir = "app/assets/fonts"
+  #       end
+  #     end
+  #
+  # It is suggested that you create a compass configuration file if you
+  # want a quicker boot time when using the compass command line tool.
+  #
+  # For more information on available configuration options see:
+  # http://compass-style.org/help/tutorials/configuration-reference/
+  def compass
+    @compass ||= begin
+      data = if (config_file = Compass.detect_configuration_file) && (config_data = Compass.configuration_for(config_file))
+        config_data
+      else
+        Compass::Configuration::Data.new("rails_config")
+      end
+      data.project_type = :rails # Forcing this makes sure all the rails defaults will be loaded.
+      data.inherit_from!(Compass.configuration) #force this
+      Compass.add_project_configuration(data)
+      Compass.configuration.on_sprite_saved do |filename|
+        # This is a huge hack based on reading through the sprockets internals.
+        # Sprockets needs an API for adding assets during precompilation.
+        # At a minimum sprockets should provide this API:
+        #
+        #     #filename is a path in the asset source directory
+        #     Rails.application.assets.new_asset!(filename)
+        #
+        #     # logical_path is how devs refer to it, data is the contents of it.
+        #     Rails.application.assets.new_asset!(logical_path, data)
+        #
+        # I would also like to select one of the above calls based on whether
+        # the user is precompiling or not:
+        #
+        #     Rails.application.assets.precompiling? #=> true or false
+        #
+        # But even the above is not an ideal API. The issue is that compass sprites need to
+        # avoid generation if the sprite file is already generated (which can be quite time
+        # consuming). To do this, compass has it's own uniqueness hash based on the user's
+        # inputs instead of being based on the file contents. So if we could provide our own
+        # hash or some metadata that is opaque to sprockets that could be read from the
+        # asset's attributes, we could avoid cluttering the assets directory with generated
+        # sprites and always just use the logical_path + data version of the api.
+        if Rails.application.config.assets.digests.try(:any?)
+          asset         = Rails.application.assets.find_asset(filename)
+          pathname      = Pathname.new(filename)
+          logical_path  = filename[(Compass.configuration.generated_images_path.length+1)..-1]
+          # Force the asset into the cache so find_asset will find it.
+          cached_assets = Rails.application.assets.instance_variable_get("@assets")
+          cached_assets[logical_path] = cached_assets[filename] = asset
+
+          target = Pathname.new(File.join(Rails.public_path, Rails.application.config.assets.prefix))
+          asset = Rails.application.assets.find_asset(logical_path)
+          filename = target.join(asset.digest_path)
+          asset.write_to(filename)
+        end
+      end
+      data
+    end
+    @compass
+  end
+end
+
+module CompassRails
+  class Railtie < Rails::Railtie
+
+    initializer "compass.initialize_rails", :group => :all do |app|
+      # Configure compass for use within rails, and provide the project configuration
+      # that came via the rails boot process.
+      CompassRails.check_for_double_boot!
+      Compass.discover_extensions!
+      CompassRails.configure_rails!(app)
+    end
+  end
+end

data/lib/compass-rails/version.rb

@@ -0,0 +1,5 @@
+module CompassRails
+  unless defined?(::CompassRails::VERSION)
+    VERSION = "1.0.0.rc.1"
+  end
+end

data/lib/compass/app_integration/rails.rb

@@ -0,0 +1,10 @@
+module Compass
+  module AppIntegration
+    module Rails
+      extend self
+      def initialize!
+        Compass::Util.compass_warn("WARNING:  Please remove the call to Compass::AppIntegration::Rails.initialize! from #{caller[0].sub(/:.*$/,'')};\nWARNING:  This is done automatically now. If this is default compass initializer you can just remove the file.")
+      end
+    end
+  end
+end

data/test/helpers/command_helper.rb

@@ -0,0 +1,120 @@
+require 'appraisal'
+require 'appraisal/command'
+module Kernal
+  module Captures
+    def capture_output
+      buffer = []
+      real_stdout, $stdout = $stdout, StringIO.new
+      buffer << yield
+      buffer << $stdout.string
+      return buffer.join
+    ensure
+      $stdout = real_stdout
+    end
+
+    def capture_all_output
+      capture_output do
+        capture_warning do
+          yield
+        end
+      end
+    end
+
+
+    def capture_warning
+      buffer = []
+      real_stderr, $stderr = $stderr, StringIO.new
+      buffer << yield
+      buffer << $stderr.string
+      return buffer.join
+    ensure
+      $stderr = real_stderr
+    end
+  end
+end
+
+include Kernal::Captures
+
+module CompassRails
+  module Test
+    module CommandHelper
+      include DebugHelper
+      GEMFILES_DIR = Pathname.new(ROOT_PATH).join('gemfiles')
+      BUNDLER_COMMAND = 'bundle'
+
+      def run_command(command, gemfile=nil)
+        debug("Running: #{command} with gemfile: #{gemfile}".foreground(:cyan))
+        capture_all_output { CompassRails::Test::CommandRunner.new(command, gemfile).run }
+      end
+
+      def bundle(gemfile=nil)
+        run_command(BUNDLER_COMMAND, gemfile)
+      end
+
+    end
+  end
+end
+
+# Executes commands with a clean environment
+class CompassRails::Test::CommandRunner
+  BUNDLER_ENV_VARS = %w(RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE).freeze
+
+  def self.from_args(gemfile)
+    command = ([$0] + ARGV.slice(1, ARGV.size)).join(' ')
+    new(command, gemfile)
+  end
+
+  def initialize(command, gemfile = nil)
+    @original_env = {}
+    @gemfile = gemfile
+    if command =~ /^bundle/
+      @command = command
+    else
+      @command = "bundle exec #{command}"
+    end
+  end
+
+  def run
+    announce
+    with_clean_env do
+      %x{#{@command}}
+    end
+  end
+
+  def exec
+    announce
+    with_clean_env { Kernel.exec(@command) }
+  end
+
+  private
+
+  def with_clean_env
+    unset_bundler_env_vars
+    ENV['BUNDLE_GEMFILE'] = @gemfile
+    yield
+  ensure
+    restore_env
+  end
+
+  def announce
+    return
+    if @gemfile
+      puts ">> BUNDLE_GEMFILE=#{@gemfile} #{@command}"
+    else
+      puts ">> #{@command}"
+    end
+  end
+
+  def unset_bundler_env_vars
+    BUNDLER_ENV_VARS.each do |key|
+      @original_env[key] = ENV[key]
+      ENV[key] = nil
+    end
+  end
+
+  def restore_env
+    @original_env.each { |key, value| ENV[key] = value }
+  end
+end
+
+

data/test/helpers/debug_helper.rb

@@ -0,0 +1,12 @@
+module CompassRails
+  module Test
+    module DebugHelper
+
+      def debug(message)
+       puts "#{message}\n".bright #if ENV['DEBUG']
+       $stdout.flush
+      end
+
+    end
+  end
+end

data/test/helpers/file_helper.rb

@@ -0,0 +1,53 @@
+module CompassRails
+  module Test
+    module FileHelper
+      include DebugHelper
+
+      def mkdir_p(dir)
+        debug("Creating Directory: #{dir}".foreground(:green))
+        ::FileUtils.mkdir_p dir
+        assert File.directory?(dir), "mkdir_p: #{dir} failed"
+      end
+
+      def rm_rf(path)
+        debug("Removing: #{path}".foreground(:red))
+        ::FileUtils.rm_rf(path)
+        assert !File.directory?(path), "rm_rf: #{path} failed"
+      end
+
+      def cd(path, &block)
+        debug("Entered: #{path}".foreground(:yellow))
+        Dir.chdir(path, &block)
+      end
+
+      def inject_at_bottom(file_name, string)
+        content = File.read(file_name)
+        content = "#{content}#{string}"
+        File.open(file_name, 'w') { |file| file << content }
+      end
+
+      def touch(file)
+        debug("Touching File: #{file}".foreground(:green))
+        ::FileUtils.touch(file)
+      end
+      
+      def inject_into_file(file_name, replacment, position, anchor)
+        case position
+        when :after
+          replace(file_name, Regexp.escape(anchor), "#{anchor}#{replacment}")
+        when :before
+          replace(file_name, Regexp.escape(anchor), "#{replacment}#{anchor}")
+        else
+          raise Compass::FilesystemConflict.new("You need to specify :before or :after")
+        end
+      end
+      
+      def replace(destination, regexp, string)
+        content = File.read(destination)
+        content.gsub!(Regexp.new(regexp), string)
+        File.open(destination, 'wb') { |file| file.write(content) }
+      end
+
+    end
+  end
+end

data/test/helpers/rails_helper.rb

@@ -0,0 +1,65 @@
+
+module CompassRails
+  module Test
+    module RailsHelpers
+      include FileHelper
+      include DebugHelper
+      include CommandHelper
+        RAILS_3_2   = "3.2"
+        RAILS_3_1   = "3.1"
+        RAILS_3     = "3.0"
+        RAILS_2     = "2.3"
+
+        WORKING_DIR = File.join(ROOT_PATH, 'rails-temp')
+
+        GEMFILES = {
+          RAILS_3_2 => GEMFILES_DIR.join("rails32.gemfile").to_s,
+          RAILS_3_1 => GEMFILES_DIR.join("rails31.gemfile").to_s,
+          RAILS_3   => GEMFILES_DIR.join("rails3.gemfile").to_s,
+          RAILS_2   => GEMFILES_DIR.join("rails2.gemfile").to_s
+        }
+        
+        GENERTOR_OPTIONS = {
+          RAILS_3_2 => ['-q', '-G', '-O', '--skip-bundle'],
+          RAILS_3_1 => ['-q', '-G', '-O', '--skip-bundle'],
+          RAILS_3   => ['-q', '-G', '-O', '--skip-bundle'],
+          RAILS_2   => ['-q']
+        }
+        
+        GENERATOR_COMMAND = {
+          RAILS_3_2 => 'new',
+          RAILS_3_1 => 'new',
+          RAILS_3   => 'new',
+          RAILS_2   => ''
+        }
+
+    def rails_command(options, version)
+      debug("Running Rails command with: rails #{options.join(' ')}".foreground(:cyan))
+      run_command("rails #{options.join(' ')}", GEMFILES[version])
+    end
+
+    # Generate a rails application without polluting our current set of requires
+    # with the rails libraries. This will allow testing against multiple versions of rails
+    # by manipulating the load path.
+    def generate_rails_app(name, version, options=[])
+      options += GENERTOR_OPTIONS[version]
+      rails_command([GENERATOR_COMMAND[version], name, *options], version)
+    end
+
+    def within_rails_app(named, version, &block)
+      dir = "#{named}-#{version}"
+      rm_rf File.join(WORKING_DIR, dir)
+      mkdir_p WORKING_DIR
+      cd(WORKING_DIR) do
+        generate_rails_app(dir, version)
+        cd(dir) do
+          yield RailsProject.new(File.join(WORKING_DIR, dir), version)
+        end
+      end
+      rm_rf File.join(WORKING_DIR, dir)
+    end
+    
+
+    end
+  end
+end