compass-rails 1.0.3 → 1.1.3

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

@@ -0,0 +1,102 @@
+#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.
+      Compass.add_configuration(:rails)
+      Compass.add_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.digest && # if digesting is enabled
+            caller.grep(%r{/sprockets/rails/task.rb}).any? && #OMG HAX - check if we're being precompiled
+            Compass.configuration.generated_images_path[Compass.configuration.images_path.to_s] # if the generated images path is not in the assets images directory, we don't have to do these backflips
+
+          # 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))
+
+          pathname      = Pathname.new(filename)
+          logical_path  = pathname.relative_path_from(Pathname.new(Compass.configuration.images_path))
+          asset         = Rails.application.assets.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
+
+
+          # Adds the fingerprinted asset to the public directory
+          FileUtils.mkdir_p File.dirname(target)
+          asset.write_to target
+
+        end
+      end
+      data
+    end
+    @compass
+  end
+end
+
+module CompassRails
+  class Railtie < Rails::Railtie
+
+    initializer "compass.initialize_rails", :group => :all do |app|
+      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
+  end
+end

data/lib/compass-rails/railties.rb

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

data/lib/compass-rails/version.rb

@@ -1,5 +1,5 @@
 module CompassRails
   unless defined?(::CompassRails::VERSION)
-    VERSION = "1.0.3"
+    VERSION = "1.1.3"
   end
 end

data/lib/compass-rails.rb

@@ -4,14 +4,15 @@ require "compass-rails/configuration"
 
 module CompassRails
 
+    RAILS_4 = %r{^4.[0|1]}
     RAILS_32 = %r{^3.2}
     RAILS_31 = %r{^3.1}
-    RAILS_23 = %r{^2.3}
     RAILS_3 = %r{^3.0}
 
     extend self
 
     def load_rails
+      return true if rails_loaded?
       return if defined?(::Rails) && ::Rails.respond_to?(:application) && !::Rails.application.nil?
 
       rails_config_path = Dir.pwd
@@ -21,7 +22,7 @@ module CompassRails
       end
       #load the rails config
       require "#{rails_config_path}/config/application.rb"
-      if rails31? || rails32?
+      if rails31? || rails32? || rails4?
         require 'sass-rails'
         require 'sprockets/railtie'
         require 'rails/engine'
@@ -85,21 +86,30 @@ module CompassRails
 
     def rails3?
       return false unless defined?(::Rails)
-      rails_version =~ RAILS_3
+      version_match RAILS_3
     end
 
     def rails31?
       return false unless defined?(::Rails)
-      rails_version =~ RAILS_31
+      version_match RAILS_31
     end
 
     def rails32?
       return false unless defined?(::Rails)
-      rails_version =~ RAILS_32
+      version_match RAILS_32
     end
 
-    def rails2?
-      rails_version =~ RAILS_23
+    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!
@@ -111,14 +121,12 @@ module CompassRails
     end
 
     def configuration
-      load_rails unless rails2?
+      load_rails
       config = Compass::Configuration::Data.new('rails')
       config.extend(Configuration::Default)
-      if (rails31? || rails32?)
-        if asset_pipeline_enabled?
-          require "compass-rails/configuration/3_1"
-          config.extend(Configuration::Rails3_1)
-        end
+      if asset_pipeline_enabled?
+        require "compass-rails/configuration/asset_pipeline"
+        config.extend(Configuration::AssetPipeline)
       end
       config
     end
@@ -165,7 +173,7 @@ module CompassRails
       end
     end
 
-    # Rails 2.x projects use this in their compass initializer.
+    # 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)
@@ -210,7 +218,11 @@ module CompassRails
   def asset_pipeline_enabled?
     return false unless rails_loaded?
     rails_config = ::Rails.application.config
-    rails_config.respond_to?(:assets) && rails_config.assets.try(:enabled)
+    if rails_config.respond_to?(:assets)
+      rails_config.assets.enabled != false
+    else
+      false
+    end
   end
 
   private

data/test/helpers/file_helper.rb

@@ -30,18 +30,18 @@ module CompassRails
         debug("Touching File: #{file}".foreground(:green))
         ::FileUtils.touch(file)
       end
-      
-      def inject_into_file(file_name, replacment, position, anchor)
+
+      def inject_into_file(file_name, replacement, position, anchor)
         case position
         when :after
-          replace(file_name, Regexp.escape(anchor), "#{anchor}#{replacment}")
+          replace(file_name, Regexp.escape(anchor), "#{anchor}#{replacement}")
         when :before
-          replace(file_name, Regexp.escape(anchor), "#{replacment}#{anchor}")
+          replace(file_name, Regexp.escape(anchor), "#{replacement}#{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)
@@ -50,4 +50,4 @@ module CompassRails
 
     end
   end
-end
+end

data/test/helpers/rails_helper.rb

@@ -5,32 +5,32 @@ module CompassRails
       include FileHelper
       include DebugHelper
       include CommandHelper
+        RAILS_4_0   = "4.0"
         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_4_0 => GEMFILES_DIR.join("rails40.gemfile").to_s,
           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
+          RAILS_3   => GEMFILES_DIR.join("rails3.gemfile").to_s
         }
-        
-        GENERTOR_OPTIONS = {
+
+        GENERATOR_OPTIONS = {
+          RAILS_4_0 => ['-q', '-G', '-O', '--skip-bundle'],
           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']
+          RAILS_3   => ['-q', '-G', '-O', '--skip-bundle']
         }
-        
+
         GENERATOR_COMMAND = {
+          RAILS_4_0 => 'new',
           RAILS_3_2 => 'new',
           RAILS_3_1 => 'new',
-          RAILS_3   => 'new',
-          RAILS_2   => ''
+          RAILS_3   => 'new'
         }
 
     def rails_command(options, version)
@@ -42,24 +42,23 @@ module CompassRails
     # 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]
+      options += GENERATOR_OPTIONS[version]
       rails_command([GENERATOR_COMMAND[version], name, *options], version)
     end
 
-    def within_rails_app(named, version, &block)
+    def within_rails_app(named, version, asset_pipeline_enabled = true, &block)
       dir = "#{named}-#{version}"
       rm_rf File.join(WORKING_DIR, dir)
       mkdir_p WORKING_DIR
       cd(WORKING_DIR) do
-        generate_rails_app(dir, version)
+        generate_rails_app(dir, version, asset_pipeline_enabled ? [] : ["-S"])
         cd(dir) do
-          yield RailsProject.new(File.join(WORKING_DIR, dir), version)
+          yield RailsProject.new(File.join(WORKING_DIR, dir), version, asset_pipeline_enabled)
         end
       end
       rm_rf File.join(WORKING_DIR, dir)
     end
-    
 
     end
   end
-end
+end

data/test/helpers/rails_project.rb

@@ -16,16 +16,16 @@ module CompassRails
       BOOT_FILE = 'config/boot.rb'
 
 
-      attr_reader :directory, :version
+      attr_reader :directory, :version, :asset_pipeline_enabled
 
-      def initialize(directory, version)
+      def initialize(directory, version, asset_pipeline_enabled = true)
         @directory = Pathname.new(directory)
         @version = version
-        configure_for_bundler!
+        @asset_pipeline_enabled = asset_pipeline_enabled
       end
 
       ## FILE METHODS
-        
+
       def to_s
         directory_name
       end
@@ -39,10 +39,9 @@ module CompassRails
       end
 
       def screen_file
-        case version
-        when RAILS_3_1, RAILS_3_2
+        if asset_pipeline_enabled
           return directory.join('app', 'assets', 'stylesheets', 'screen.css.scss')
-        when RAILS_2, RAILS_3
+        else
           return directory.join('app', 'assets', 'stylesheets','screen.scss')
         end
       end
@@ -65,10 +64,6 @@ module CompassRails
         directory.join(APPLICATION_FILE).exist?
       end
 
-      def rails2?
-        directory.join(BOOT_FILE).exist? && !directory.join(APPLICATION_FILE).exist?
-      end
-
       def boots?
         string = 'THIS IS MY RANDOM AWESOME TEST STRING'
         test_string = "puts \"#{string}\""
@@ -82,12 +77,7 @@ module CompassRails
       end
 
       def runner(string)
-        case version
-        when RAILS_3_1, RAILS_3, RAILS_3_2
-          rails_command(['runner', "'#{string}'"], version)
-        when RAILS_2
-          run_command("script/runner '#{string}'", GEMFILES[version])
-        end
+        rails_command(['runner', "'#{string}'"], version)
       end
 
       # COMPASS METHODS
@@ -110,61 +100,7 @@ module CompassRails
         else
           "\n    config.#{property} = '#{value}'\n"
         end
-        inject_into_file(directory.join(APPLICATION_FILE), value, :after, '# Enable the asset pipeline')
-      end
-
-      ## GEM METHODS
-
-      def configure_for_bundler!
-        return if [RAILS_3_1, RAILS_3, RAILS_3_2].include?(version)
-        bundle = <<-BUNDLER
-        class Rails::Boot
-          def run
-            load_initializer
-
-            Rails::Initializer.class_eval do
-              def load_gems
-                @bundler_loaded ||= Bundler.require :default, Rails.env
-              end
-            end
-
-            Rails::Initializer.run(:set_load_path)
-          end
-        end
-        BUNDLER
-        inject_into_file(directory.join('config/boot.rb'), bundle, :before, 'Rails.boot!')
-
-        touch directory.join('config/preinitializer.rb')
-        preinit = <<-PREINIT
-          begin
-            require "rubygems"
-            require "bundler"
-          rescue LoadError
-            raise "Could not load the bundler gem. Install it with `gem install bundler`."
-          end
-
-          if Gem::Version.new(Bundler::VERSION) <= Gem::Version.new("0.9.24")
-            raise RuntimeError, "Your bundler version is too old for Rails 2.3." +
-             "Run `gem install bundler` to upgrade."
-          end
-
-          begin
-            # Set up load paths for all bundled gems
-            ENV["BUNDLE_GEMFILE"] = File.expand_path("../../Gemfile", __FILE__)
-            Bundler.setup
-          rescue Bundler::GemNotFound
-            raise RuntimeError, "Bundler couldn't find some gems." +
-              "Did you run `bundle install`?"
-          end
-        PREINIT
-        inject_at_bottom(directory.join('config/preinitializer.rb'), preinit)
-
-        touch directory.join('Gemfile')
-
-      end
-
-      def bundle
-        raise "NO BUNDLE FOR U"
+        inject_into_file(directory.join(APPLICATION_FILE), value, :after, 'class Application < Rails::Application')
       end
 
     private
@@ -183,4 +119,4 @@ module CompassRails
       end
     end
   end
-end
+end

data/test/integrations/rails3_test.rb

@@ -4,13 +4,13 @@ class Rails3Test < Test::Unit::TestCase
   RAILS_VERSION = RAILS_3
 
   def test_rails_app_created
-    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
       assert project.boots?
     end
   end
 
   def test_installs_compass
-    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
       project.run_compass('init')
       assert project.has_config?
       assert project.has_screen_file?
@@ -19,7 +19,7 @@ class Rails3Test < Test::Unit::TestCase
   end
 
   def test_compass_compile
-    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
       project.run_compass('init')
       project.run_compass('compile')
       assert project.directory.join('public/stylesheets/screen.css').exist?
@@ -27,7 +27,7 @@ class Rails3Test < Test::Unit::TestCase
   end
 
   def test_install_blueprint
-    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
       project.run_compass('init')
       project.run_compass('install blueprint --force')
       assert project.directory.join('app/assets/stylesheets/partials').directory?

data/test/integrations/rails_32_without_pipeline_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+class Rails32WithoutPipelineTest < Test::Unit::TestCase
+  include CompassRails::Test::RailsHelpers
+  RAILS_VERSION = RAILS_3_2
+
+  def test_rails_app_created
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
+      assert project.boots?
+    end
+  end
+
+  def test_installs_compass
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
+      project.run_compass('init')
+      assert project.has_config?
+      assert project.has_screen_file?
+      assert project.has_compass_import?
+    end
+  end
+
+  def test_compass_compile
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
+      project.run_compass('init')
+      project.run_compass('compile')
+      assert project.directory.join('public/stylesheets/screen.css').exist?
+    end
+  end
+
+  def test_install_blueprint
+    within_rails_app('test_railtie', RAILS_VERSION, false) do |project|
+      project.run_compass('init')
+      project.run_compass('install blueprint --force')
+      assert project.directory.join('app/assets/stylesheets/partials').directory?
+    end
+  end
+
+end

data/test/integrations/{rails_23_test.rb → rails_40_test.rb}

@@ -1,7 +1,7 @@
 require 'test_helper'
-class Rails23Test < Test::Unit::TestCase
+class Rails40Test < Test::Unit::TestCase
   include CompassRails::Test::RailsHelpers
-  RAILS_VERSION = RAILS_2
+  RAILS_VERSION = RAILS_4_0
 
   def test_rails_app_created
     within_rails_app('test_railtie', RAILS_VERSION) do |project|
@@ -9,6 +9,7 @@ class Rails23Test < Test::Unit::TestCase
     end
   end
 
+
   def test_installs_compass
     within_rails_app('test_railtie', RAILS_VERSION) do |project|
       project.run_compass('init')
@@ -18,11 +19,28 @@ class Rails23Test < Test::Unit::TestCase
     end
   end
 
+  def test_compass_compile
+    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+      project.run_compass('init')
+      project.run_compass('compile')
+      assert project.directory.join('public/assets/screen.css').exist?
+    end
+  end
+
   def test_install_blueprint
     within_rails_app('test_railtie', RAILS_VERSION) do |project|
+      project.run_compass('init')
       project.run_compass('install blueprint --force')
       assert project.directory.join('app/assets/stylesheets/partials').directory?
     end
   end
 
-end
+  def test_compass_preferred_syntax
+    within_rails_app('test_railtie', RAILS_VERSION) do |project|
+      project.set_rails('sass.preferred_syntax', :sass)
+      project.run_compass('init')
+      assert project.directory.join('app/assets/stylesheets/screen.css.sass').exist?
+    end
+  end
+
+end