compass-rails 2.0.0 → 3.1.0

data/lib/compass-rails/patches/sass_importer.rb

@@ -7,18 +7,23 @@ end
 klass.class_eval do
   def evaluate(context, locals, &block)
     # Use custom importer that knows about Sprockets Caching
-    cache_store = Sprockets::SassCacheStore.new(context.environment)
-    paths  = context.environment.paths.map { |path| CompassRails::SpriteImporter.new(context, path) }
-    paths += context.environment.paths.map { |path| self.class.parent::SassImporter.new(context, path) }
-    paths += ::Rails.application.config.sass.load_paths
+    cache_store =
+      if defined?(Sprockets::SassProcessor::CacheStore)
+        Sprockets::SassProcessor::CacheStore.new(sprockets_cache_store, context.environment)
+      else
+        Sprockets::SassCacheStore.new(context.environment)
+      end
 
+    paths  = context.environment.paths.map { |path| CompassRails::SpriteImporter.new(path) }
+    paths += context.environment.paths.map { |path| sass_importer(context, path) }
+    paths += ::Rails.application.config.sass.load_paths
 
     options = CompassRails.sass_config.merge( {
       :filename => eval_file,
       :line => line,
       :syntax => syntax,
       :cache_store => cache_store,
-      :importer => self.class.parent::SassImporter.new(context, context.pathname),
+      :importer => sass_importer(context, context.pathname),
       :load_paths => paths,
       :sprockets => {
         :context => context,
@@ -26,11 +31,66 @@ klass.class_eval do
       }
     })
 
-    ::Sass::Engine.new(data, options).render
+    engine = ::Sass::Engine.new(data, options)
+
+    engine.dependencies.map do |dependency|
+      filename = dependency.options[:filename]
+      if filename.include?('*') # Handle sprite globs
+        image_path = Rails.root.join(Compass.configuration.images_dir).to_s
+        Dir[File.join(image_path, filename)].each do |f|
+          context.depend_on(f)
+        end
+      else
+        context.depend_on(filename) if File.exist?(filename)
+      end
+    end
+
+    engine.render
   rescue ::Sass::SyntaxError => e
     # Annotates exception message with parse line number
     context.__LINE__ = e.sass_backtrace.first[:line]
     raise e
   end
-end    
 
+  private
+
+  def sass_importer_artiy
+    @sass_importer_artiy ||= sass_importer_class.instance_method(:initialize).arity
+  end
+
+  def sass_importer(context, path)
+    case sass_importer_artiy.abs
+    when 1
+      sass_importer_class.new(path)
+    else
+      sass_importer_class.new(context, path)
+    end
+  end
+
+  # if using haml-rails, self.class.parent = Haml::Filters (which doesn't have an implementation)
+  def sass_importer_class
+    @sass_importer_class ||= if defined?(self.class.parent::SassImporter)
+                               self.class.parent::SassImporter
+                             elsif defined?(Sass::Rails::SassTemplate)
+                               Sass::Rails::SassImporter
+                             else
+                               Sprockets::SassImporter
+                             end
+  end
+
+  def sprockets_cache_store
+    cache =
+      case Rails.application.config.assets.cache_store
+      when :null_store
+        Sprockets::Cache::NullStore.new
+      when :memory_store, :mem_cache_store
+        Sprockets::Cache::MemoryStore.new
+      else
+        path = "#{Rails.application.config.root}/tmp/cache/assets/#{Rails.env}"
+
+        Sprockets::Cache::FileStore.new(path)
+      end
+
+    Sprockets::Cache.new(cache, Rails.logger)
+  end
+end

data/lib/compass-rails/patches/sprite_importer.rb

@@ -3,19 +3,19 @@ require 'compass/sprite_importer'
 
 module CompassRails
   class SpriteImporter < Compass::SpriteImporter
-    attr_reader :context, :root
+    attr_reader :root
 
-    def initialize(context, root)
-      @context = context
+    def initialize(root)
       @root = root
     end
 
     def find(uri, options)
       if old = super(uri, options)
+        context = options[:sprockets][:context]
         self.class.files(uri).each do |file|
           relative_path = Pathname.new(file).relative_path_from(Pathname.new(root))
           begin
-            pathname = context.resolve(relative_path)
+            pathname = context.resolve(relative_path.to_s)
             context.depend_on_asset(pathname)
           rescue Sprockets::FileNotFound
 

data/lib/compass-rails/patches.rb

@@ -1,6 +1,3 @@
 if CompassRails.rails31? || CompassRails.rails32?
-  CompassRails.load_rails
   require 'compass-rails/patches/importer'
-elsif CompassRails.rails4?
-  CompassRails.load_rails
 end

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

@@ -3,16 +3,9 @@ module CompassRails
 
     initializer "compass.initialize_rails", :group => :all do |app|
       require 'compass'
-      if CompassRails.asset_pipeline_enabled?
-        require 'compass-rails/patches/3_1'
-        # 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)
-      else
-        CompassRails.initialize!(app.config.compass)
-      end
+      require 'compass-rails/patches/3_1'
+      Compass.discover_extensions!
+      CompassRails.configure_rails!(app)
     end
 
     config.compass = begin
@@ -32,11 +25,11 @@ module CompassRails
 
             # Clear entries in Hike::Index for this sprite's directory.
             # This makes sure the asset can be found by find_assets
-            Rails.application.assets.send(:trail).instance_variable_get(:@entries).delete(File.dirname(filename))
+            CompassRails.sprockets.send(:trail).instance_variable_get(:@entries).delete(File.dirname(filename))
 
             pathname      = Pathname.new(filename)
             logical_path  = pathname.relative_path_from(Pathname.new(Compass.configuration.images_path))
-            asset         = Rails.application.assets.find_asset(logical_path)
+            asset         = CompassRails.sprockets.find_asset(logical_path)
             target        = File.join(Rails.public_path, Rails.application.config.assets.prefix, asset.digest_path)
 
             # Adds the asset to the manifest file.

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

@@ -4,9 +4,6 @@ module CompassRails
     initializer "compass.initialize_rails", :group => :all do |app|
       require 'compass'
       require 'compass-rails/patches/4_0'
-      # 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
@@ -28,19 +25,24 @@ module CompassRails
 
             # Clear entries in Hike::Index for this sprite's directory.
             # This makes sure the asset can be found by find_assets
-            trail = Rails.application.assets.send(:trail)
-            trail.instance_variable_get(:@entries).delete(File.dirname(filename))
-            trail.instance_variable_get(:@stats).delete(filename)
+            if CompassRails.sprockets.respond_to?(:trail, true)
+              index = CompassRails.sprockets.send(:trail).index
+            else
+              index = CompassRails.sprockets.index
+            end
+
+            index.instance_variable_get(:@entries).delete(File.dirname(filename))
+            index.instance_variable_get(:@stats).delete(filename)
 
             pathname      = Pathname.new(filename)
-            logical_path  = pathname.relative_path_from(Pathname.new(Compass.configuration.images_path))
-            asset         = Rails.application.assets.find_asset(logical_path)
+            logical_path  = pathname.relative_path_from(Pathname.new(Compass.configuration.images_path)).to_s
+            asset         = CompassRails.sprockets.find_asset(logical_path)
             target        = File.join(Rails.public_path, Rails.application.config.assets.prefix, asset.digest_path)
 
             # Adds the asset to the manifest file.
 
             manifest = ActionView::Base.assets_manifest
-            manifest.assets[logical_path.to_s] = asset.digest_path
+            manifest.assets[logical_path] = asset.digest_path
 
 
             # Adds the fingerprinted asset to the public directory

data/lib/compass-rails/railties.rb

@@ -1,9 +1,7 @@
 if defined?(::Rails)
   if CompassRails.rails31? || CompassRails.rails32?
     require "compass-rails/railties/3_1"
-  elsif CompassRails.rails4?
-    require "compass-rails/railties/4_0"
   else
-    $stderr.puts "Unsupported rails environment for compass"
+    require "compass-rails/railties/4_0"
   end
 end

data/lib/compass-rails/version.rb

@@ -1,5 +1,3 @@
 module CompassRails
-  unless defined?(::CompassRails::VERSION)
-    VERSION = "2.0.0"
-  end
+  VERSION = '3.1.0' unless defined?(::CompassRails::VERSION)
 end

data/lib/compass-rails.rb

@@ -4,60 +4,45 @@ require "compass-rails/configuration"
 
 module CompassRails
 
-    RAILS_4 = %r{^4.[0|1|2]}
     RAILS_32 = %r{^3.2}
     RAILS_31 = %r{^3.1}
 
     extend self
 
-    def load_rails
-      return true if rails_loaded?
-      return if defined?(::Rails) && ::Rails.respond_to?(:application) && !::Rails.application.nil?
+    def setup_fake_rails_env_paths(sprockets_env)
+      return unless rails_loaded?
 
-      rails_config_path = Dir.pwd
-      until File.exists?(File.join(rails_config_path, 'config', 'application.rb')) do
-        raise 'Rails application not found' if rails_config_path == '/'
-        rails_config_path = File.join(rails_config_path, '..')
+      if sprockets_env.respond_to?(:trail, true)
+        sprockets_trail = sprockets_env.send(:trail)
+      else
+        sprockets_trail = sprockets_env.index
       end
-      #load the rails config
-      require "#{rails_config_path}/config/application.rb"
-      require 'sass-rails'
-      require 'sprockets/railtie'
-      require 'rails/engine'
-      @app ||= ::Rails.application.initialize!
-    end
-
 
-    def setup_fake_rails_env_paths(sprockets_env)
-      return unless rails_loaded?
       keys = ['app/assets', 'lib/assets', 'vendor/assets']
       local = keys.map {|path| ::Rails.root.join(path) }.map { |path| [File.join(path, 'images'), File.join(path, 'stylesheets')] }.flatten!
-      sprockets_env.send(:trail).paths.unshift(*local)
+      sprockets_trail.paths.unshift(*local)
       paths = []
       ::Rails::Engine.subclasses.each do |subclass|
         paths = subclass.paths
         keys.each do |key|
-          sprockets_env.send(:trail).paths.unshift(*paths[key].existent_directories)
+          sprockets_trail.paths.unshift(*paths[key].existent_directories)
         end
       end
     end
 
     def sass_config
-      load_rails
       ::Rails.application.config.sass
     end
 
     def sprockets
-      load_rails
-      @sprockets ||= ::Rails.application.assets
+      @sprockets ||= Rails.application.assets || ::Sprockets::Railtie.build_environment(Rails.application)
     end
 
     def context
-      load_rails
       @context ||= begin
         sprockets.version = ::Rails.env + "-#{sprockets.version}"
         setup_fake_rails_env_paths(sprockets)
-        context = ::Rails.application.assets.context_class
+        context = ::CompassRails.sprockets.context_class
         context.extend(::Sprockets::Helpers::IsolatedHelper)
         context.extend(::Sprockets::Helpers::RailsHelper)
         context.extend(::Sass::Rails::Railtie::SassContext)
@@ -67,10 +52,6 @@ module CompassRails
       end
     end
 
-    def installer(*args)
-      CompassRails::Installer.new(*args)
-    end
-
     def rails_loaded?
       defined?(::Rails)
     end
@@ -91,29 +72,11 @@ module CompassRails
       version_match RAILS_32
     end
 
-    def rails4?
-      return false unless defined?(::Rails)
-      version_match RAILS_4
-    end
-
     def version_match(version)
-      if (rails_version =~ version).nil?
-        return false
-      end
-
-      true
-    end
-
-    def booted!
-      CompassRails.const_set(:BOOTED, true)
-    end
-
-    def booted?
-      defined?(CompassRails::BOOTED) && CompassRails::BOOTED
+      !(rails_version =~ version).nil?
     end
 
     def configuration
-      load_rails
       config = Compass::Configuration::Data.new('rails')
       config.extend(CompassRails::Configuration)
       config
@@ -123,50 +86,6 @@ module CompassRails
       ::Rails.application.config.assets.prefix
     end
 
-    def env_production?
-      if defined?(::Rails) && ::Rails.respond_to?(:env)
-        ::Rails.env.production?
-      elsif defined?(RAILS_ENV)
-        RAILS_ENV == "production"
-      end
-    end
-
-    def root
-      @root ||= begin
-        if defined?(::Rails) && ::Rails.respond_to?(:root)
-          ::Rails.root
-        elsif defined?(RAILS_ROOT)
-          Pathname.new(RAILS_ROOT)
-        else
-          Pathname.new(Dir.pwd)
-        end
-      end
-    end
-
-    def check_for_double_boot!
-      if booted?
-        Compass::Util.compass_warn("Warning: Compass was booted twice. Compass-rails has got your back; please remove your compass initializer.")
-      else
-        booted!
-      end
-    end
-
-    def sass_plugin_enabled?
-      unless rails31?
-        defined?(Sass::Plugin) && !Sass::Plugin.options[:never_update]
-      end
-    end
-
-    # Rails projects without asset pipeline use this in their compass initializer.
-    def initialize!(config = nil)
-      check_for_double_boot!
-      config ||= Compass.detect_configuration_file(root)
-      Compass.add_project_configuration(config, :project_type => :rails)
-      Compass.discover_extensions!
-      Compass.configure_sass_plugin!
-      Compass.handle_configuration_change! if sass_plugin_enabled?
-    end
-
     def configure_rails!(app)
       return unless app.config.respond_to?(:sass)
       sass_config = app.config.sass
@@ -189,31 +108,6 @@ module CompassRails
       end
     end
 
-    def boot_config
-      config = begin
-        if (config_file = Compass.detect_configuration_file) &&
-            (config_data = Compass.configuration_for(config_file))
-          config_data
-        else
-          Compass::Configuration::Data.new("compass_rails_boot")
-        end
-      end
-
-      config.tap do |c|
-        c.top_level.project_type = :rails
-      end
-    end
-
-  def asset_pipeline_enabled?
-    return false unless rails_loaded? && ::Rails.respond_to?(:application) && !::Rails.application.nil?
-    rails_config = ::Rails.application.config
-    if rails_config.respond_to?(:assets)
-      rails_config.assets.enabled != false
-    else
-      false
-    end
-  end
-
   private
 
     # sets the sass config value only if the corresponding compass-based setting
@@ -226,11 +120,8 @@ module CompassRails
 
 end
 
-Compass::AppIntegration.register(:rails, "::CompassRails")
-Compass.add_configuration(CompassRails.boot_config)
-
-require "compass-rails/patches"
-require "compass-rails/railties"
-require "compass-rails/installer"
-
-
+if defined?(::Rails)
+  Compass::AppIntegration.register(:rails, "::CompassRails")
+  require "compass-rails/patches"
+  require "compass-rails/railties"
+end

data/test/compass_rails_spec.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+describe CompassRails do
+  include CompassRails::Test::RailsHelpers
+
+  it "compiles a basic compass stylesheet" do
+    within_rails_app('test_railtie') do |project|
+      project.setup_asset_fixtures!
+
+      assert project.boots?
+
+      project.precompile!
+
+      project.compiled_stylesheet 'public/assets/application*.css' do |css|
+        refute css.empty?
+        assert_match 'body container', css
+        assert_match "-webkit-linear-gradient", css
+        assert_match "-moz-border-radius", css
+        assert_match '.numbers-sprite-1', css
+        assert_match '.numbers-sprite-2', css
+        assert_match '.letters-a', css
+        assert_match '.letters-a', css
+      end
+    end
+  end
+
+  it "supports rails config arguments" do
+    within_rails_app('test_railtie') do |project|
+      assert_equal "scss", project.rails_property("sass.preferred_syntax")
+      assert_equal "public/assets", project.rails_property("compass.css_dir")
+
+      project.set_rails('sass.preferred_syntax', :sass)
+      project.set_rails('compass.css_dir', "public/stylesheets")
+
+      assert_equal "sass", project.rails_property("sass.preferred_syntax")
+      assert_equal "public/stylesheets", project.rails_property("compass.css_dir")
+    end
+  end unless ENV['DEBUG_COMPILE']
+
+  it "compiles when in production mode" do
+    within_rails_app('test_railtie') do |project|
+      project.setup_asset_fixtures!
+
+      # Mimic Rails production mode
+      project.set_rails('assets.compile', false)
+
+      assert project.boots?
+
+      project.precompile!
+
+      project.compiled_stylesheet 'public/assets/application*.css' do |css|
+        refute css.empty?
+        assert_match 'body container', css
+        assert_match '.numbers-sprite-1', css
+      end
+    end
+  end
+end

data/test/fixtures/assets/stylesheets/application.css.scss

@@ -0,0 +1,23 @@
+// Import Compass
+@import "compass";
+
+// Glob import SCSS partials
+@import "partials/*";
+
+// Import Sprites
+@import "letters/*.png";
+@include all-letters-sprites;
+
+// Inline Sprites
+$numbers-inline: true;
+@import "numbers/sprite-*.png";
+@include all-numbers-sprites;
+
+// Try out some compass stuff
+body{
+  @include background-image(linear-gradient(white, #aaaaaa));
+
+  container{
+    @include border-radius(4px, 4px);
+  }
+}

data/test/fixtures/assets/stylesheets/partials/_partial_1.scss

@@ -0,0 +1,3 @@
+.partial1 {
+  display: none;
+}

data/test/fixtures/assets/stylesheets/partials/_partial_2.scss

@@ -0,0 +1,3 @@
+.partial2{
+  display: block;
+}

data/test/helpers/command_helper.rb

@@ -43,7 +43,7 @@ module CompassRails
       BUNDLER_COMMAND = 'bundle'
 
       def run_command(command, gemfile=nil)
-        debug(Rainbow("Running: #{command} with gemfile: #{gemfile}").foreground(:cyan))
+        debug "Running: #{command} with gemfile: #{gemfile}"
         capture_all_output { CompassRails::Test::CommandRunner.new(command, gemfile).run }
       end
 
@@ -75,14 +75,10 @@ class CompassRails::Test::CommandRunner
   end
 
   def run
-    announce
-    with_clean_env do
-      %x{#{@command}}
-    end
+    with_clean_env { %x{#{@command}} }
   end
 
   def exec
-    announce
     with_clean_env { Kernel.exec(@command) }
   end
 
@@ -96,15 +92,6 @@ class CompassRails::Test::CommandRunner
     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]

data/test/helpers/debug_helper.rb

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

data/test/helpers/file_helper.rb

@@ -3,20 +3,10 @@ module CompassRails
     module FileHelper
       include DebugHelper
 
-      def mkdir_p(dir)
-        debug(Rainbow("Creating Directory: #{dir}").foreground(:green))
-        ::FileUtils.mkdir_p dir
-        assert File.directory?(dir), "mkdir_p: #{dir} failed"
-      end
-
-      def rm_rf(path)
-        debug(Rainbow("Removing: #{path}").foreground(:red))
-        ::FileUtils.rm_rf(path)
-        assert !File.directory?(path), "rm_rf: #{path} failed"
-      end
+      delegate :mkdir_p, :rm, :rm_rf, :cp_r, :touch, to: ::FileUtils
 
       def cd(path, &block)
-        debug(Rainbow("Entered: #{path}").foreground(:yellow))
+        debug "Entering: #{path}"
         Dir.chdir(path, &block)
       end
 
@@ -26,11 +16,6 @@ module CompassRails
         File.open(file_name, 'w') { |file| file << content }
       end
 
-      def touch(file)
-        debug(Rainbow("Touching File: #{file}").foreground(:green))
-        ::FileUtils.touch(file)
-      end
-
       def inject_into_file(file_name, replacement, position, anchor)
         case position
         when :after