compass-rails 1.0.0.rc.1

data/lib/compass-rails.rb

@@ -0,0 +1,207 @@
+require 'compass'
+require "compass-rails/version"
+require "compass-rails/configuration"
+
+module CompassRails
+
+    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 if defined?(::Rails) && !::Rails.application.nil?
+      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, '..')
+      end
+      #load the rails config
+      require "#{rails_config_path}/config/application.rb"
+      if rails31? || rails32?
+        require 'sass-rails' 
+        require 'sprockets/railtie'
+        require 'rails/engine'
+        @app ||= ::Rails.application.initialize!(:assets)
+      end
+    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)
+      paths = []
+      ::Rails::Engine.subclasses.each do |subclass|
+        paths = subclass.paths
+        keys.each do |key|
+          sprockets_env.send(: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
+    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.extend(::Sprockets::Helpers::IsolatedHelper)
+        context.extend(::Sprockets::Helpers::RailsHelper)
+        context.extend(::Sass::Rails::Railtie::SassContext)
+        context.sass_config = sass_config
+
+        context
+      end
+    end
+
+    def installer(*args)
+      CompassRails::Installer.new(*args)
+    end
+
+    def rails_loaded?
+      defined?(::Rails)
+    end
+
+    def rails_version
+      Gem.loaded_specs["rails"].version.to_s
+    end
+
+    def rails3?
+      return false unless defined?(::Rails)
+      rails_version =~ RAILS_3
+    end
+
+    def rails31?
+      return false unless defined?(::Rails)
+      rails_version =~ RAILS_31
+    end
+
+    def rails32?
+      return false unless defined?(::Rails)
+      rails_version =~ RAILS_32
+    end
+
+    def rails2?
+      rails_version =~ RAILS_23
+    end
+
+    def booted!
+      CompassRails.const_set(:BOOTED, true)
+    end
+
+    def booted?
+      defined?(CompassRails::BOOTED) && CompassRails::BOOTED
+    end
+
+    def configuration
+      load_rails unless rails2?
+      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
+      end
+      config
+    end
+
+    def env
+      env_production? ? :production : :development
+    end
+
+    def prefix
+      ::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 2.x projects 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)
+      app.config.compass.to_sass_engine_options.each do |key, value|
+        app.config.sass.send(:"#{key}=", value)
+      end
+    end
+
+    def boot_config
+      config = 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
+      config.top_level.project_type = :rails
+      config
+    end
+
+  def asset_pipeline_enabled?
+    return false unless rails_loaded?
+    rails_config = ::Rails.application.config
+    rails_config.respond_to?(:assets) && rails_config.assets.try(:enabled)
+  end
+
+end
+
+Compass::AppIntegration.register(:rails, "::CompassRails")
+Compass.add_configuration(CompassRails.boot_config)
+
+require "compass-rails/patches"
+require "compass-rails/railties"
+require "compass-rails/installer"
+
+

data/lib/compass-rails/configuration.rb

@@ -0,0 +1 @@
+require "compass-rails/configuration/default"

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

@@ -0,0 +1,51 @@
+module CompassRails
+  module Configuration
+    module Rails3_1
+
+      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_generated_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
+
+    end
+  end
+end

data/lib/compass-rails/configuration/default.rb

@@ -0,0 +1,75 @@
+module CompassRails
+  module Configuration
+    module Default
+      
+      def project_type_without_default
+        :rails
+      end
+
+      def default_sass_dir
+        File.join("app", "assets", "stylesheets")
+      end
+
+      def default_css_dir
+        File.join("public", "stylesheets")
+      end
+
+      def default_images_dir
+        File.join("public", "images")
+      end
+
+      def default_fonts_dir
+        File.join("public", "fonts")
+      end
+
+      def default_javascripts_dir
+        File.join("public", "javascripts")
+      end
+
+      def default_http_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_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_http_javascripts_path
+        http_root_relative "javascripts"
+      end
+
+      def default_http_fonts_path
+        http_root_relative "fonts"
+      end
+
+      def default_http_stylesheets_path
+        http_root_relative "stylesheets"
+      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
+        project_path = CompassRails.root
+      end
+
+      def default_http_path
+        "/" # XXX Where is/was this stored in the Rails config?
+      end
+
+      def default_environment
+        CompassRails.env
+      end
+
+    end
+  end
+end

data/lib/compass-rails/installer.rb

@@ -0,0 +1,30 @@
+module CompassRails
+  class Installer < Compass::Installers::ManifestInstaller
+
+    SASS_FILE_REGEX = %r{(.*)(?:\.css)?\.(sass|scss)}
+
+    def completed_configuration
+      @completed_configuration ||= CompassRails.configuration
+    end
+
+    def install_stylesheet(from, to, options)
+      if CompassRails.rails_loaded? && CompassRails.asset_pipeline_enabled?
+        _, name, ext = SASS_FILE_REGEX.match(to).to_a
+        to = "#{name}.css.#{ext}"
+      end
+      super(from, to, options)
+    end
+
+    def write_configuration_files
+      config_file = CompassRails.root.join('config', 'compass.rb')
+      unless config_file.exist?
+        write_file config_file.to_s, CompassRails.configuration.serialize
+      end
+    end
+
+    def prepare
+      write_configuration_files
+    end
+
+  end
+end

data/lib/compass-rails/patches.rb

@@ -0,0 +1,6 @@
+if CompassRails.rails31? || CompassRails.rails32?
+  unless CompassRails.rails_loaded? 
+    CompassRails.load_rails
+  end
+  require 'compass-rails/patches/importer'
+end

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

@@ -0,0 +1,28 @@
+module Sass::Script::Functions
+  def generated_image_url(path, only_path = nil)
+    asset_url(path, Sass::Script::String.new("image"))
+  end
+end
+
+
+module Compass::RailsImageFunctionPatch
+  private
+  
+  def image_path_for_size(image_file)
+    begin
+      file = ::Rails.application.assets.find_asset(image_file)
+      return file
+    rescue ::Sprockets::FileOutsidePaths
+      return super(image_file)
+    end
+  end
+end
+
+module Sass::Script::Functions
+  include Compass::RailsImageFunctionPatch
+end
+
+# Wierd that this has to be re-included to pick up sub-modules. Ruby bug?
+class Sass::Script::Functions::EvaluationContext
+  include Sass::Script::Functions
+end

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

@@ -0,0 +1,26 @@
+require 'compass/compiler'
+module Compass
+  class Compiler
+    attr_accessor :sass_options
+    STYLESHEET = /stylesheet/
+    def sass_options
+      if CompassRails.asset_pipeline_enabled?
+        @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
+      end
+      @sass_options
+    end
+
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'sprockets'
+require 'compass/sprite_importer'
+
+module Compass
+  class SpriteImporter < Sass::Importers::Base
+
+    alias :old_find :find
+
+    def find(uri, options)
+
+      if old = old_find(uri, options)
+        @_options = options
+        self.class.files(uri).each do |file|
+          if pathname = resolve(file)
+            context.depend_on(pathname)
+          end
+        end
+      end
+      
+      old
+    end
+
+  private
+
+    def resolve(uri)
+      resolver.resolve(Pathname.new(uri))
+    end
+
+    def context
+     resolver.context
+    end
+
+    def resolver
+      @_options[:custom][:resolver]
+    end
+
+  end
+end