compass-rails 2.0.1 → 4.0.0

data/lib/compass-rails.rb

@@ -4,63 +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?
-
-      rails_path = Dir.pwd
-      if File.exists?(File.join(rails_path, 'config', 'application.rb'))
-        raise 'Rails application not found' if rails_config_path == '/'
-        rails_config_path = File.join(rails_config_path, '..')
-        #load the rails config
-        require "#{rails_config_path}/config/application.rb"
-        require 'sass-rails'
-        require 'sprockets/railtie'
-        @app ||= ::Rails.application.initialize!
-        require 'rails/engine'
-        return true
-      end
-
-      false
-    end
-
-
     def setup_fake_rails_env_paths(sprockets_env)
       return unless rails_loaded?
+
+      if sprockets_env.respond_to?(:trail, true)
+        sprockets_trail = sprockets_env.send(:trail)
+      else
+        sprockets_trail = sprockets_env.index
+      end
+
       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)
@@ -70,10 +52,6 @@ module CompassRails
       end
     end
 
-    def installer(*args)
-      CompassRails::Installer.new(*args)
-    end
-
     def rails_loaded?
       defined?(::Rails)
     end
@@ -94,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
@@ -126,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
@@ -192,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
@@ -231,10 +122,6 @@ end
 
 if defined?(::Rails)
   Compass::AppIntegration.register(:rails, "::CompassRails")
-  Compass.add_configuration(CompassRails.boot_config)
-
   require "compass-rails/patches"
   require "compass-rails/railties"
-  require "compass-rails/installer"
 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

data/test/helpers/rails_helper.rb

@@ -1,59 +1,58 @@
-
 module CompassRails
   module Test
     module RailsHelpers
       include FileHelper
       include DebugHelper
       include CommandHelper
-        RAILS_4_0   = "4.0"
-        RAILS_3_2   = "3.2"
-        RAILS_3_1   = "3.1"
+        RAILS_6_1   = "6.1"
+        RAILS_6_0   = "6.0"
+        RAILS_5_2   = "5.2"
 
         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
+        VERSION_LOOKUP = {
+          RAILS_6_1 => %r{^6\.1\.},
+          RAILS_6_0 => %r{^6\.0\.},
+          RAILS_5_2 => %r{^5\.2\.},
         }
 
-        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']
+        GEMFILES = {
+          RAILS_6_1 => GEMFILES_DIR.join("rails_edge.gemfile").to_s,
+          RAILS_6_0 => GEMFILES_DIR.join("rails60.gemfile").to_s,
+          RAILS_5_2 => GEMFILES_DIR.join("rails52.gemfile").to_s,
         }
 
-        GENERATOR_COMMAND = {
-          RAILS_4_0 => 'new',
-          RAILS_3_2 => 'new',
-          RAILS_3_1 => 'new'
-        }
+        GENERATOR_OPTIONS = ['-q', '-G', '-O', '--skip-bundle']
 
-    def rails_command(options, version)
-      debug(Rainbow("Running Rails command with: rails #{options.join(' ')}").foreground(:cyan))
-      run_command("rails #{options.join(' ')}", GEMFILES[version])
-    end
+      def rails_command(options)
+        debug cmd = "rails #{options.join(' ')}"
+        run_command(cmd, GEMFILES[rails_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 += GENERATOR_OPTIONS[version]
-      rails_command([GENERATOR_COMMAND[version], name, *options], version)
-    end
+      def rails_version
+        @rails_version ||= VERSION_LOOKUP.detect { |version, regex| CompassRails.version_match(regex) }.first
+      end
 
-    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, asset_pipeline_enabled ? [] : ["-S"])
-        cd(dir) do
-          yield RailsProject.new(File.join(WORKING_DIR, dir), version, asset_pipeline_enabled)
+      # 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, options = [])
+        options += GENERATOR_OPTIONS
+        rails_command(['new', name, *options])
+      end
+
+      def within_rails_app(named, &block)
+        dir = "#{named}-#{rails_version}"
+        rm_rf File.join(WORKING_DIR, dir)
+        mkdir_p WORKING_DIR
+        cd(WORKING_DIR) do
+          generate_rails_app(dir, [])
+          cd(dir) do
+            yield RailsProject.new(File.join(WORKING_DIR, dir), rails_version)
+          end
         end
+        rm_rf File.join(WORKING_DIR, dir) unless ENV['DEBUG_COMPILE']
       end
-      rm_rf File.join(WORKING_DIR, dir)
-    end
 
     end
   end

data/test/helpers/rails_project.rb

@@ -7,21 +7,14 @@ module CompassRails
       include RailsHelpers
       include Kernal::Captures
 
-
-      GEMFILE = 'Gemfile'
-      GEMFILE_LOCK = 'Gemfile.lock'
-      ENVIRONMENT = 'config/environment.rb'
-      COMPASS_CONFIG = 'config/compass.rb'
       APPLICATION_FILE = 'config/application.rb'
-      BOOT_FILE = 'config/boot.rb'
-
 
-      attr_reader :directory, :version, :asset_pipeline_enabled
+      attr_reader :directory, :version
 
-      def initialize(directory, version, asset_pipeline_enabled = true)
+      def initialize(directory, version)
         @directory = Pathname.new(directory)
         @version = version
-        @asset_pipeline_enabled = asset_pipeline_enabled
+        disable_cookies! if version == '3.1'
       end
 
       ## FILE METHODS
@@ -34,89 +27,56 @@ module CompassRails
         File.basename(directory)
       end
 
-      def has_file?(file)
-        File.exist? directory.join(file)
+      def file(path)
+        directory.join(path)
       end
 
-      def screen_file
-        if asset_pipeline_enabled
-          return directory.join('app', 'assets', 'stylesheets', 'screen.css.scss')
-        else
-          return directory.join('app', 'assets', 'stylesheets','screen.scss')
-        end
-      end
+      # RAILS METHODS
 
-      def has_screen_file?
-        screen_file.exist?
+      def boots?
+        rails_property("compass.project_type") == "rails"
       end
 
-      def has_compass_import?
-        File.read(screen_file).include?("compass/reset")
+      def precompile!
+        run_command("rake assets:precompile", GEMFILES[version])
       end
 
-      def has_config?
-        directory.join('config', 'compass.rb').exist?
+      def setup_asset_fixtures!
+        rm_rf file("app/assets")
+        cp_r CompassRails::Test.root.join('test', 'fixtures', 'assets'), file("app")
       end
 
-      # RAILS METHODS
-
-      def rails3?
-        directory.join(APPLICATION_FILE).exist?
+      def precompiled?(path)
+        !Dir[asset_path(path)].empty?
       end
 
-      def boots?
-        string = 'THIS IS MY RANDOM AWESOME TEST STRING'
-        test_string = "puts \"#{string}\""
-        matcher = %r{#{string}}
-        r = runner(test_string)
-        if r =~ matcher
-          return true
-        else
-          return false
+      def compiled_stylesheet(path, &block)
+        File.open(asset_path(path)).read.tap do |css|
+          debug(css)
+          yield css if block_given?
         end
       end
 
-      def runner(string)
-        rails_command(['runner', "'#{string}'"], version)
-      end
-
-      # COMPASS METHODS
-
-      def run_compass(command)
-        run_command("compass #{command}", GEMFILES[version])
+      def asset_path(path_pattern)
+        Dir[file(path_pattern)].first.tap do |asset|
+          raise 'Asset not found' if asset.nil?
+        end
       end
 
-      def set_compass(property, value)
-        file = directory.join(COMPASS_CONFIG)
-        unless file.exist?
-          touch file
-        end
-        inject_at_bottom(file, "#{property} = '#{value}'")
+      def rails_property(key)
+        rails_command(['runner', "'puts Rails.application.config.#{key}'"]).chomp
       end
 
       def set_rails(property, value)
-        value = if value.is_a?(Symbol)
-          "\n    config.#{property} = :#{value}\n"
-        else
-          "\n    config.#{property} = '#{value}'\n"
-        end
+        value = "\n    config.#{property} = #{value.inspect}\n"
         inject_into_file(directory.join(APPLICATION_FILE), value, :after, 'class Application < Rails::Application')
       end
 
-    private
-
-      ## GEM METHODS
-
-      def add_to_gemfile(name, requirements)
-        gemfile = directory.join(GEMFILE)
-        debug(Rainbow("Adding gem #{name} to file: #{gemfile}").foreground(:green))
-        if requirements
-          gem_string = "  gem '#{name}', #{requirements}\n"
-        else
-          gem_string = "  gem '#{name}'\n"
-        end
-        inject_at_bottom(gemfile, gem_string)
+      def disable_cookies!
+        value = "\n    config.middleware.delete 'ActionDispatch::Session::CookieStore'\n"
+        inject_into_file(directory.join(APPLICATION_FILE), value, :after, 'class Application < Rails::Application')
       end
+
     end
   end
 end

data/test/test_helper.rb

@@ -1,10 +1,14 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'compass-rails'
-require 'rainbow'
+require 'active_support/all'
 
 module CompassRails
   module Test
     ROOT_PATH = File.expand_path('../../', __FILE__)
+
+    def self.root
+      Pathname.new(ROOT_PATH)
+    end
   end
 end
 
@@ -12,4 +16,5 @@ end
   require File.join(File.expand_path('../', __FILE__), 'helpers', "#{helper}_helper")
 end
 
-require File.join(File.expand_path('../', __FILE__), 'helpers', "rails_project")
+require File.join(File.expand_path('../', __FILE__), 'helpers', "rails_project")
+