glebtv-compass-rails 2.0.4

data/lib/compass-rails/configuration.rb

@@ -0,0 +1,77 @@
+module CompassRails
+  module Configuration
+    def default_images_dir
+      File.join("app", "assets", "images")
+    end
+
+    def default_fonts_dir
+      File.join("app", "assets", "fonts")
+    end
+
+    def default_javascripts_dir
+      File.join("app", "assets", "javascripts")
+    end
+
+    def default_css_dir
+      File.join('public', CompassRails.prefix)
+    end
+
+    def default_http_path
+      File.join(CompassRails.prefix)
+    end
+
+    def default_http_images_path
+      "#{top_level.http_path}"
+    end
+
+    def default_http_javascripts_path
+      "#{top_level.http_path}"
+    end
+
+    def default_http_fonts_path
+      "#{top_level.http_path}"
+    end
+
+    def default_http_stylesheets_path
+      "#{top_level.http_path}"
+    end
+
+    def default_preferred_syntax
+      ::Rails.application.config.sass.preferred_syntax rescue nil
+    end
+
+    def default_sprite_load_path
+      CompassRails.sprockets.paths
+    end
+
+    def project_type_without_default
+      :rails
+    end
+
+    def default_sass_dir
+      File.join("app", "assets", "stylesheets")
+    end
+
+    def default_http_generated_images_path
+      # Relies on the fact that this will be loaded after the "normal"
+      # defaults, so that method_missing finds http_root_relative
+      http_root_relative "images"
+    end
+
+    def default_extensions_dir
+      File.join("vendor", "plugins", "compass_extensions")
+    end
+
+    def default_cache_dir
+      File.join("tmp", "sass-cache")
+    end
+
+    def default_project_path
+      Rails.root
+    end
+
+    def default_environment
+      Rails.env
+    end
+  end
+end

data/lib/compass-rails/patches.rb

@@ -0,0 +1,33 @@
+require 'compass-rails/patches/compass'
+require 'compass-rails/patches/sass_importer'
+require 'compass-rails/patches/sprite_importer'
+
+Compass::Core::SassExtensions::Functions::Urls::GeneratedImageUrl.module_eval do
+  def generated_image_url(path, cache_buster = Sass::Script::Bool.new(false))
+    cachebust_generated_images(path)
+    asset_url(path)
+  end
+
+  def cachebust_generated_images(path)
+    generated_images_dir = Compass.configuration.generated_images_dir
+    generated_images_dir = Rails.root.join(generated_images_dir)
+
+    sprockets_env     = options[:sprockets][:environment]
+    sprockets_entries = sprockets_env.instance_variable_get(:@entries) || {}
+    sprockets_stats   = sprockets_env.instance_variable_get(:@stats) || {}
+
+    if sprockets_entries.key?(generated_images_dir.to_s)
+      path = path.value
+      dir  = File.dirname(path)
+
+      # Delete the entries (directories) which cache the files/dirs in a directory
+      entry = generated_images_dir.join(dir).to_s
+      sprockets_entries.delete(entry)
+
+      # Delete the stats (file/dir info) which cache the what kind of file/dir each image is
+      stat = generated_images_dir.join(path).to_s
+      sprockets_stats.delete(stat)
+    end
+  end
+end
+

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

@@ -0,0 +1,12 @@
+Compass::Core::SassExtensions::Functions::ImageSize.class_eval do
+  private
+
+  def image_path_for_size(image_file)
+    begin
+      file = ::Rails.application.assets.find_asset(image_file)
+      return file.filename
+    rescue ::Sprockets::FileOutsidePaths
+      return super(image_file)
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'compass/compiler'
+module Compass
+  class Compiler
+    attr_accessor :sass_options
+    STYLESHEET = /stylesheet/
+    def sass_options
+      @sass_options[:custom] ||= {}
+      @sass_options[:custom] = {:resolver => ::Sass::Rails::Resolver.new(CompassRails.context)}
+      @sass_options[:load_paths] ||= []
+      unless @sass_options[:load_paths].any? {|k| k.is_a?(::Sass::Rails::Importer) }
+        ::Rails.application.assets.paths.each do |path|
+          next unless path.to_s =~ STYLESHEET
+          Dir["#{path}/**/*"].each do |pathname|
+            # args are: sprockets environment, the logical_path ex. 'stylesheets', and the full path name for the render
+            context = ::CompassRails.context.new(::Rails.application.assets, File.basename(path), Pathname.new(pathname))
+            @sass_options[:load_paths] << ::Sass::Rails::Importer.new(context)
+          end
+        end
+      end
+      @sass_options
+    end
+
+  end
+end

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

@@ -0,0 +1,90 @@
+klass = if defined?(Sass::Rails::SassTemplate)
+  Sass::Rails::SassTemplate
+else
+  Sprockets::SassTemplate
+end
+
+klass.class_eval do
+  def evaluate(context, locals, &block)
+    # Use custom importer that knows about Sprockets Caching
+    cache_store =  Sprockets::SassProcessor::CacheStore.new(sprockets_cache_store, context.environment)
+
+    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 => sass_importer(context, context.pathname),
+      :load_paths => paths,
+      :sprockets => {
+        :context => context,
+        :environment => context.environment
+      }
+    })
+
+    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)
+      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
+
+  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
+      tmpd = Rails.root.join("tmp/compass").to_s
+      FileUtils.mkdir(tmpd) unless File.directory?(tmpd)
+      Sprockets::Cache::FileStore.new(tmpd)
+    end
+
+    Sprockets::Cache.new(cache, Rails.logger)
+  end
+end

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

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

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

@@ -0,0 +1,12 @@
+require 'sprockets/static_compiler'
+module Sprockets
+  class StaticCompiler
+    cattr_accessor :generated_sprites
+    self.generated_sprites = {}
+    def write_manifest_with_sprites(manifest)
+      write_manifest_without_sprites(manifest.merge(self.class.generated_sprites))
+    end
+    alias_method_chain :write_manifest, :sprites
+  end
+end
+

data/lib/compass-rails/railtie.rb

@@ -0,0 +1,51 @@
+module CompassRails
+  class Railtie < Rails::Railtie
+
+    initializer "compass.initialize_rails", :group => :all do |app|
+      require 'compass'
+      Compass.discover_extensions!
+      CompassRails.configure_rails!(app)
+    end
+
+    config.compass = begin
+      @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|
+          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
+            index = Rails.application.assets.index
+            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)
+            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
+    end
+  end
+end
+

data/lib/compass-rails/version.rb

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

data/lib/glebtv-compass-rails.rb

@@ -0,0 +1 @@
+require 'compass-rails'

data/test/compass_rails_spec.rb

@@ -0,0 +1,39 @@
+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']
+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

@@ -0,0 +1,105 @@
+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}"
+        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
+    with_clean_env { %x{#{@command}} }
+  end
+
+  def exec
+    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 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