compass-rails-1.1.7/0000755000076400007640000000000012331165176013336 5ustar pravipravicompass-rails-1.1.7/sache.json0000644000076400007640000000016412331165176015315 0ustar pravipravi{ "name": "compass-rails", "description": "compass rails integration", "tags": ["ruby", "rails", "compass"] } compass-rails-1.1.7/LICENSE0000644000076400007640000000205312331165176014343 0ustar pravipraviCopyright (c) 2011 Scott Davis MIT License Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.compass-rails-1.1.7/.travis.yml0000644000076400007640000000012512331165176015445 0ustar pravipravirvm: - 1.9.3 - 2.0.0 - 2.1.0 script: "bundle exec rake appraisal:install test" compass-rails-1.1.7/compass-rails.gemspec0000644000076400007640000000166012331165176017463 0ustar pravipravi# -*- encoding: utf-8 -*- require File.expand_path('../lib/compass-rails/version', __FILE__) Gem::Specification.new do |gem| gem.authors = ["Scott Davis", "Chris Eppstein", "Craig McNamara"] gem.email = ["jetviper21@gmail.com", "chris@eppsteins.net", "craig.mcnamara@gmail.com"] gem.description = %q{Integrate Compass into Rails 3.0 and up.} gem.summary = %q{Integrate Compass into Rails 3.0 and up.} gem.homepage = "https://github.com/Compass/compass-rails" gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) } gem.files = `git ls-files`.split("\n") gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n") gem.name = "compass-rails" gem.require_paths = ["lib"] gem.version = CompassRails::VERSION gem.license = "MIT" gem.add_dependency 'compass', '>= 0.12.2' gem.add_dependency 'sprockets', '<= 2.11.0' end compass-rails-1.1.7/changelog.markdown0000644000076400007640000000032012331165176017024 0ustar pravipravi# Compass Rails ## 2.0.alpha.0 * Removed rails 2.x support * Added Alpha support for rails 4 ## 1.0.3 * StaticCompiler hack so sprite source files dont show up in manifest * Compass version bump to 0.12.2compass-rails-1.1.7/checksums.yaml.gz0000444000076400007640000000065212331165176016627 0ustar pravipravi‹ŽË'S…RM›0½çWн§'\VâÈ@Aš±H ÖøÆ&«5&îa)`õÇwµ·J{²=ïÍ{ãív»ùö6ý?×ä¥Oݺ¢xyÝ$Ix¿—ñ6~ÿˆ¯É¿’ß[Î$‰ª[gëÖSèöiQ²\@v9èë•" ƒºKÉØ«’‡hGîEÁÍOÈÛøù?XÒ§‰ô918ëç•ifŒC@C ߥËT郰5í 'ëˆýùãgâ«©I·™S€"ÆvBÓ¯6 3ÊÁ)Í1QfVgŠÇt/”éòMy ¿8Ðób=­šÔúaRÒ90 ¿OøÁ[yuàËc¿¢<‰&GΟܜ‘ïr2ƒƒ€x”ݦr (ÉÌ5òtÍΆæ+ÏPtlw¹SšŒ³OÄjÍöÇ.·¦ç³â¹p²²âuTL /d÷WÔ£ø䬜S(UòÂnœïä!úÙsqúȱ˜€uŸ)ÃÂ5,ÈbŸ6à|³G=ç$ÊÕ2 2-;Eif×.Xþ¼ÕEx³ÅæÄŠö3xcompass-rails-1.1.7/Appraisals0000644000076400007640000000040412331165176015356 0ustar pravipraviappraise "rails3" do gem "rails", "3.0.11" end appraise "rails31" do gem "rails", "3.1.3" gem "sass-rails" end appraise "rails32" do gem "rails", "~> 3.2" gem "sass-rails" end appraise "rails40" do gem "rails", "~> 4.0.0" gem "sass-rails" end compass-rails-1.1.7/README.md0000644000076400007640000000523012331165176014615 0ustar pravipravi# compass-rails **We Take Pull Requests!** [![Build Status](https://travis-ci.org/Compass/compass-rails.png?branch=stable)](https://travis-ci.org/Compass/compass-rails) [![Code Climate](https://codeclimate.com/github/Compass/compass-rails.png)](https://codeclimate.com/github/Compass/compass-rails) Compass rails is an adapter for the [Compass Stylesheet Authoring Framework](http://compass-style.org) for [Ruby on Rails](http://rubyonrails.org/). Since Compass v0.12.0, this is the only way to use compass with your rails application. Supports Rails 3.x, 4.x releases. ## Installation Add the `compass-rails` gem line to a group called `:assets` in your application's Gemfile (Rails 3.1+ users should already have the `:assets` group): ```ruby group :assets do gem 'sass-rails' # if running rails 3.1 or greater gem 'compass-rails' end ``` If you are using any Compass extensions, add them to this group in your Gemfile. And then execute: $ bundle ## Usage Change your `application.css` to `application.css.scss` or `application.css.sass` and use `@import` to your hearts content. Ex: ```scss @import "project/mixins"; @import "project/base"; ``` *or* Use `application.css` to require files that use compass features. Ex: ```css /* *= require styleguide_full_of_compass_stuff */ ``` *Don't* use `*= require something` within your SCSS or SASS files. You're gonna have a bad time. ### Configuration If you have a compass configuration file (recommended) then you can use the [Compass configuration reference](http://compass-style.org/help/tutorials/configuration-reference/) as is. If you choose to configure compass from your rails configuration files, then you should understand that the compass configuration options explained there will be methods and properties on the `config.compass` configuration object exposed to rails within any configuration block. ### Installing Compass extensions Step 1: Add it to your Gemfile in the `:assets` group and run the `bundle` command to install it. Step 2: Install the extension's assets: `bundle exec compass install ` For example, if you want to use susy. ```ruby # Gemfile group :assets do gem 'compass-rails' gem 'compass-susy-plugin' end ``` then run: $ bundle $ bundle exec compass install susy if you are using the rails configuration files you should add: ```ruby config.compass.require "susy" ``` to your application.rb configuration file. ## Contributing 1. Fork it 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Added some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create new Pull Request compass-rails-1.1.7/test/0000755000076400007640000000000012331165176014315 5ustar pravipravicompass-rails-1.1.7/test/fixtures/0000755000076400007640000000000012331165176016166 5ustar pravipravicompass-rails-1.1.7/test/fixtures/.gitkeep0000644000076400007640000000000012331165176017605 0ustar pravipravicompass-rails-1.1.7/test/test_helper.rb0000644000076400007640000000063412331165176017163 0ustar pravipravirequire 'test/unit' require 'compass-rails' require 'rainbow' module CompassRails module Test ROOT_PATH = File.expand_path('../../', __FILE__) TESTING_VERSION = '0.12.alpha' end end %w(debug file command rails).each do |helper| require File.join(File.expand_path('../', __FILE__), 'helpers', "#{helper}_helper") end require File.join(File.expand_path('../', __FILE__), 'helpers', "rails_project")compass-rails-1.1.7/test/integrations/0000755000076400007640000000000012331165176017023 5ustar pravipravicompass-rails-1.1.7/test/integrations/rails_40_test.rb0000644000076400007640000000250712331165176022030 0ustar pravipravirequire 'test_helper' class Rails40Test < Test::Unit::TestCase include CompassRails::Test::RailsHelpers RAILS_VERSION = RAILS_4_0 def test_rails_app_created within_rails_app('test_railtie', RAILS_VERSION) do |project| assert project.boots? end end def test_installs_compass within_rails_app('test_railtie', RAILS_VERSION) 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) 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 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 compass-rails-1.1.7/test/integrations/rails_32_test.rb0000644000076400007640000000251212331165176022025 0ustar pravipravirequire 'test_helper' class Rails32Test < Test::Unit::TestCase include CompassRails::Test::RailsHelpers RAILS_VERSION = RAILS_3_2 def test_rails_app_created within_rails_app('test_railtie', RAILS_VERSION) do |project| assert project.boots? end end def test_installs_compass within_rails_app('test_railtie', RAILS_VERSION) 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) 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 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 endcompass-rails-1.1.7/test/integrations/rails_32_without_pipeline_test.rb0000644000076400007640000000212212331165176025472 0ustar pravipravirequire '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 endcompass-rails-1.1.7/test/integrations/rails3_test.rb0000644000076400007640000000210012331165176021575 0ustar pravipravirequire 'test_helper' class Rails3Test < Test::Unit::TestCase include CompassRails::Test::RailsHelpers RAILS_VERSION = RAILS_3 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 endcompass-rails-1.1.7/test/integrations/.gitkeep0000644000076400007640000000000012331165176020442 0ustar pravipravicompass-rails-1.1.7/test/integrations/rails_31_test.rb0000644000076400007640000000251312331165176022025 0ustar pravipravirequire 'test_helper' class Rails31Test < Test::Unit::TestCase include CompassRails::Test::RailsHelpers RAILS_VERSION = RAILS_3_1 def test_rails_app_created within_rails_app('test_railtie', RAILS_VERSION) do |project| assert project.boots? end end def test_installs_compass within_rails_app('test_railtie', RAILS_VERSION) 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) 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 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 endcompass-rails-1.1.7/test/helpers/0000755000076400007640000000000012331165176015757 5ustar pravipravicompass-rails-1.1.7/test/helpers/command_helper.rb0000644000076400007640000000447312331165176021271 0ustar pravipravirequire '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(Rainbow("Running: #{command} with gemfile: #{gemfile}").foreground(:cyan)) 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 announce with_clean_env do %x{#{@command}} end end def exec announce 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 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] ENV[key] = nil end end def restore_env @original_env.each { |key, value| ENV[key] = value } end end compass-rails-1.1.7/test/helpers/debug_helper.rb0000644000076400007640000000030112331165176020723 0ustar pravipravimodule CompassRails module Test module DebugHelper def debug(message) puts Rainbow("#{message}\n").bright #if ENV['DEBUG'] $stdout.flush end end end end compass-rails-1.1.7/test/helpers/rails_helper.rb0000644000076400007640000000412612331165176020760 0ustar pravipravi 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_3 = "3.0" 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 } 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'] } GENERATOR_COMMAND = { RAILS_4_0 => 'new', RAILS_3_2 => 'new', RAILS_3_1 => 'new', RAILS_3 => 'new' } def rails_command(options, version) debug(Rainbow("Running Rails command with: rails #{options.join(' ')}").foreground(:cyan)) run_command("rails #{options.join(' ')}", GEMFILES[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 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) end end rm_rf File.join(WORKING_DIR, dir) end end end end compass-rails-1.1.7/test/helpers/rails_project.rb0000644000076400007640000000571012331165176021147 0ustar pravipravimodule CompassRails module Test class RailsProject include FileHelper include DebugHelper include CommandHelper 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 def initialize(directory, version, asset_pipeline_enabled = true) @directory = Pathname.new(directory) @version = version @asset_pipeline_enabled = asset_pipeline_enabled end ## FILE METHODS def to_s directory_name end def directory_name File.basename(directory) end def has_file?(file) File.exist? directory.join(file) 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 def has_screen_file? screen_file.exist? end def has_compass_import? File.read(screen_file).include?("compass/reset") end def has_config? directory.join('config', 'compass.rb').exist? end # RAILS METHODS def rails3? directory.join(APPLICATION_FILE).exist? 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 end end def runner(string) rails_command(['runner', "'#{string}'"], version) end # COMPASS METHODS def run_compass(command) run_command("compass #{command}", GEMFILES[version]) end def set_compass(property, value) file = directory.join(COMPASS_CONFIG) unless file.exist? touch file end inject_at_bottom(file, "#{property} = '#{value}'") end def set_rails(property, value) value = if value.is_a?(Symbol) "\n config.#{property} = :#{value}\n" else "\n config.#{property} = '#{value}'\n" end 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) end end end end compass-rails-1.1.7/test/helpers/file_helper.rb0000644000076400007640000000306112331165176020562 0ustar pravipravimodule CompassRails module Test 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 def cd(path, &block) debug(Rainbow("Entered: #{path}").foreground(:yellow)) Dir.chdir(path, &block) end def inject_at_bottom(file_name, string) content = File.read(file_name) content = "#{content}#{string}" 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 replace(file_name, Regexp.escape(anchor), "#{anchor}#{replacement}") when :before 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) File.open(destination, 'wb') { |file| file.write(content) } end end end end compass-rails-1.1.7/test/units/0000755000076400007640000000000012331165176015457 5ustar pravipravicompass-rails-1.1.7/test/units/.gitkeep0000644000076400007640000000000012331165176017076 0ustar pravipravicompass-rails-1.1.7/Gemfile0000644000076400007640000000072412331165176014634 0ustar pravipravisource 'https://rubygems.org' # Specify your gem's dependencies in compass-rails.gemspec gemspec group :assets do gem "compass", '~> 0.13.alpha.0' gem "compass-rails", :path=>"." gem 'compass-blueprint' end group :test do gem 'mocha' gem "appraisal", :git => 'https://github.com/scottdavis/appraisal.git' gem 'rainbow' end unless ENV["CI"] gem 'rb-fsevent', :require => false gem 'ruby_gntp', :require => false gem 'guard' gem 'guard-test' end compass-rails-1.1.7/metadata.yml0000644000076400007640000000703512331165176015646 0ustar pravipravi--- !ruby/object:Gem::Specification name: compass-rails version: !ruby/object:Gem::Version version: 1.1.7 platform: ruby authors: - Scott Davis - Chris Eppstein - Craig McNamara autorequire: bindir: bin cert_chain: [] date: 2014-03-18 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency requirement: !ruby/object:Gem::Requirement requirements: - - ! '>=' - !ruby/object:Gem::Version version: 0.12.2 prerelease: false name: compass version_requirements: !ruby/object:Gem::Requirement requirements: - - ! '>=' - !ruby/object:Gem::Version version: 0.12.2 type: :runtime - !ruby/object:Gem::Dependency requirement: !ruby/object:Gem::Requirement requirements: - - <= - !ruby/object:Gem::Version version: 2.11.0 prerelease: false name: sprockets version_requirements: !ruby/object:Gem::Requirement requirements: - - <= - !ruby/object:Gem::Version version: 2.11.0 type: :runtime description: Integrate Compass into Rails 3.0 and up. email: - jetviper21@gmail.com - chris@eppsteins.net - craig.mcnamara@gmail.com executables: [] extensions: [] extra_rdoc_files: [] files: - .gitignore - .travis.yml - Appraisals - Gemfile - Guardfile - LICENSE - README.md - Rakefile - changelog.markdown - compass-rails.gemspec - gemfiles/rails3.gemfile - gemfiles/rails31.gemfile - gemfiles/rails32.gemfile - gemfiles/rails40.gemfile - lib/compass-rails.rb - lib/compass-rails/configuration.rb - lib/compass-rails/configuration/asset_pipeline.rb - lib/compass-rails/configuration/default.rb - lib/compass-rails/installer.rb - lib/compass-rails/patches.rb - lib/compass-rails/patches/3_1.rb - lib/compass-rails/patches/4_0.rb - lib/compass-rails/patches/compass.rb - lib/compass-rails/patches/importer.rb - lib/compass-rails/patches/sass_importer.rb - lib/compass-rails/patches/sprite_importer.rb - lib/compass-rails/patches/static_compiler.rb - lib/compass-rails/railties.rb - lib/compass-rails/railties/3_0.rb - lib/compass-rails/railties/3_1.rb - lib/compass-rails/railties/4_0.rb - lib/compass-rails/version.rb - sache.json - test/fixtures/.gitkeep - test/helpers/command_helper.rb - test/helpers/debug_helper.rb - test/helpers/file_helper.rb - test/helpers/rails_helper.rb - test/helpers/rails_project.rb - test/integrations/.gitkeep - test/integrations/rails3_test.rb - test/integrations/rails_31_test.rb - test/integrations/rails_32_test.rb - test/integrations/rails_32_without_pipeline_test.rb - test/integrations/rails_40_test.rb - test/test_helper.rb - test/units/.gitkeep homepage: https://github.com/Compass/compass-rails licenses: - MIT metadata: {} post_install_message: rdoc_options: [] require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - ! '>=' - !ruby/object:Gem::Version version: '0' required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - ! '>=' - !ruby/object:Gem::Version version: '0' requirements: [] rubyforge_project: rubygems_version: 2.1.11 signing_key: specification_version: 4 summary: Integrate Compass into Rails 3.0 and up. test_files: - test/fixtures/.gitkeep - test/helpers/command_helper.rb - test/helpers/debug_helper.rb - test/helpers/file_helper.rb - test/helpers/rails_helper.rb - test/helpers/rails_project.rb - test/integrations/.gitkeep - test/integrations/rails3_test.rb - test/integrations/rails_31_test.rb - test/integrations/rails_32_test.rb - test/integrations/rails_32_without_pipeline_test.rb - test/integrations/rails_40_test.rb - test/test_helper.rb - test/units/.gitkeep compass-rails-1.1.7/lib/0000755000076400007640000000000012331165176014104 5ustar pravipravicompass-rails-1.1.7/lib/compass-rails/0000755000076400007640000000000012331165176016661 5ustar pravipravicompass-rails-1.1.7/lib/compass-rails/installer.rb0000644000076400007640000000142712331165176021207 0ustar pravipravimodule 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 compass-rails-1.1.7/lib/compass-rails/version.rb0000644000076400007640000000013712331165176020674 0ustar pravipravimodule CompassRails unless defined?(::CompassRails::VERSION) VERSION = "1.1.7" end end compass-rails-1.1.7/lib/compass-rails/patches/0000755000076400007640000000000012331165176020310 5ustar pravipravicompass-rails-1.1.7/lib/compass-rails/patches/sass_importer.rb0000644000076400007640000000207712331165176023535 0ustar pravipravimodule Sprockets class SassTemplate < Tilt::Template def evaluate(context, locals, &block) # Use custom importer that knows about Sprockets Caching cache_store = SassCacheStore.new(context.environment) paths = context.environment.paths.map { |path| CompassRails::SpriteImporter.new(context, path) } paths += context.environment.paths.map { |path| SassImporter.new(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 => SassImporter.new(context, context.pathname), :load_paths => paths, :sprockets => { :context => context, :environment => context.environment } }) ::Sass::Engine.new(data, options).render rescue ::Sass::SyntaxError => e # Annotates exception message with parse line number context.__LINE__ = e.sass_backtrace.first[:line] raise e end end end compass-rails-1.1.7/lib/compass-rails/patches/3_1.rb0000644000076400007640000000073312331165176021222 0ustar pravipravirequire 'compass-rails/patches/compass' require 'compass-rails/patches/static_compiler' module Sass::Script::Functions def generated_image_url(path, only_path = nil) asset_url(path, Sass::Script::String.new("image")) 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 compass-rails-1.1.7/lib/compass-rails/patches/importer.rb0000644000076400007640000000200512331165176022473 0ustar pravipravirequire '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 compass-rails-1.1.7/lib/compass-rails/patches/4_0.rb0000644000076400007640000000153212331165176021220 0ustar pravipravirequire 'compass-rails/patches/compass' require 'compass-rails/patches/sass_importer' require 'compass-rails/patches/sprite_importer' module Sass::Script::Functions def generated_image_url(path, only_path = nil) cachebust_generated_images asset_url(path) end def cachebust_generated_images generated_images_path = Rails.root.join(Compass.configuration.generated_images_dir).to_s sprockets_entries = options[:sprockets][:environment].send(:trail).instance_variable_get(:@entries) sprockets_entries.delete(generated_images_path) if sprockets_entries.has_key? generated_images_path 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 compass-rails-1.1.7/lib/compass-rails/patches/sprite_importer.rb0000644000076400007640000000122212331165176024061 0ustar pravipravirequire 'sprockets' require 'compass/sprite_importer' module CompassRails class SpriteImporter < Compass::SpriteImporter attr_reader :context, :root def initialize(context, root) @context = context @root = root end def find(uri, options) if old = super(uri, options) self.class.files(uri).each do |file| relative_path = Pathname.new(file).relative_path_from(Pathname.new(root)) begin pathname = context.resolve(relative_path) context.depend_on_asset(pathname) rescue Sprockets::FileNotFound end end end old end end end compass-rails-1.1.7/lib/compass-rails/patches/compass.rb0000644000076400007640000000041612331165176022303 0ustar pravipravimodule 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 compass-rails-1.1.7/lib/compass-rails/patches/static_compiler.rb0000644000076400007640000000052712331165176024022 0ustar pravipravirequire '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 compass-rails-1.1.7/lib/compass-rails/patches.rb0000644000076400007640000000026012331165176020633 0ustar pravipraviif CompassRails.rails31? || CompassRails.rails32? CompassRails.load_rails require 'compass-rails/patches/importer' elsif CompassRails.rails4? CompassRails.load_rails end compass-rails-1.1.7/lib/compass-rails/configuration/0000755000076400007640000000000012331165176021530 5ustar pravipravicompass-rails-1.1.7/lib/compass-rails/configuration/asset_pipeline.rb0000644000076400007640000000201412331165176025056 0ustar pravipravimodule CompassRails module Configuration module AssetPipeline 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 end end end compass-rails-1.1.7/lib/compass-rails/configuration/default.rb0000644000076400007640000000326412331165176023506 0ustar pravipravimodule 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 endcompass-rails-1.1.7/lib/compass-rails/railties/0000755000076400007640000000000012331165176020475 5ustar pravipravicompass-rails-1.1.7/lib/compass-rails/railties/3_1.rb0000644000076400007640000001075412331165176021413 0ustar pravipravi#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(/static_compiler/).any? && #OMG HAX - check if we're being precompiled Compass.configuration.generated_images_path[Compass.configuration.images_path] # 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. Sprockets::StaticCompiler.generated_sprites[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| 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 end end end compass-rails-1.1.7/lib/compass-rails/railties/4_0.rb0000644000076400007640000001062412331165176021407 0ustar pravipravi#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 compass-rails-1.1.7/lib/compass-rails/railties/3_0.rb0000644000076400007640000000277512331165176021416 0ustar pravipravi#3.0.11 require 'compass' require 'rails' 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("project") end data.project_type = :rails # Forcing this makes sure all the rails defaults will be loaded. data end end end module CompassRails class Railtie < Rails::Railtie initializer "compass.initialize_rails" do |app| # Configure compass for use within rails, and provide the project configuration # that came via the rails boot process. CompassRails.initialize!(app.config.compass) end end endcompass-rails-1.1.7/lib/compass-rails/railties.rb0000644000076400007640000000051412331165176021022 0ustar pravipraviif defined?(::Rails) 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 compass-rails-1.1.7/lib/compass-rails/configuration.rb0000644000076400007640000000005512331165176022055 0ustar pravipravirequire "compass-rails/configuration/default"compass-rails-1.1.7/lib/compass-rails.rb0000644000076400007640000001530412331165176017211 0ustar pravipravirequire 'compass' require "compass-rails/version" require "compass-rails/configuration" module CompassRails RAILS_4 = %r{^4.[0|1]} RAILS_32 = %r{^3.2} RAILS_31 = %r{^3.1} 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 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? || rails4? require 'sass-rails' require 'sprockets/railtie' require 'rails/engine' @app ||= ::Rails.application.initialize! 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 rails_spec = (Gem.loaded_specs["railties"] || Gem.loaded_specs["rails"]) raise "You have to require Rails before compass" unless rails_spec rails_spec.version.to_s end def rails3? return false unless defined?(::Rails) version_match RAILS_3 end def rails31? return false unless defined?(::Rails) version_match RAILS_31 end def rails32? return false unless defined?(::Rails) 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 end def configuration load_rails config = Compass::Configuration::Data.new('rails') config.extend(Configuration::Default) if asset_pipeline_enabled? require "compass-rails/configuration/asset_pipeline" config.extend(Configuration::AssetPipeline) 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 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 compass_config = app.config.compass sass_config.load_paths.concat(compass_config.sass_load_paths) { :output_style => :style, :line_comments => :line_comments, :cache => :cache, :disable_warnings => :quiet, :preferred_syntax => :preferred_syntax }.each do |compass_option, sass_option| set_maybe sass_config, compass_config, sass_option, compass_option end if compass_config.sass_options compass_config.sass_options.each do |config, value| sass_config.send("#{config}=", value) end 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.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 # has been explicitly set by the user. def set_maybe(sass_config, compass_config, sass_option, compass_option) if compass_value = compass_config.send(:"#{compass_option}_without_default") sass_config.send(:"#{sass_option}=", compass_value) end 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" compass-rails-1.1.7/gemfiles/0000755000076400007640000000000012331165176015131 5ustar pravipravicompass-rails-1.1.7/gemfiles/rails40.gemfile0000644000076400007640000000072312331165176017743 0ustar pravipravi# This file was generated by Appraisal source "https://rubygems.org" gem "rb-fsevent", :require=>false gem "ruby_gntp", :require=>false gem "guard" gem "guard-test" gem "rails", "~> 4.0.0" gem "sass-rails" group :assets do gem "compass", "~> 0.13.alpha.0" gem "compass-rails", :path=>".." gem "compass-blueprint" end group :test do gem "mocha" gem "appraisal", :git=>"https://github.com/scottdavis/appraisal.git" gem "rainbow" end gemspec :path=>"../"compass-rails-1.1.7/gemfiles/rails31.gemfile0000644000076400007640000000072012331165176017740 0ustar pravipravi# This file was generated by Appraisal source "https://rubygems.org" gem "rb-fsevent", :require=>false gem "ruby_gntp", :require=>false gem "guard" gem "guard-test" gem "rails", "3.1.3" gem "sass-rails" group :assets do gem "compass", "~> 0.13.alpha.0" gem "compass-rails", :path=>".." gem "compass-blueprint" end group :test do gem "mocha" gem "appraisal", :git=>"https://github.com/scottdavis/appraisal.git" gem "rainbow" end gemspec :path=>"../"compass-rails-1.1.7/gemfiles/rails3.gemfile0000644000076400007640000000070012331165176017655 0ustar pravipravi# This file was generated by Appraisal source "https://rubygems.org" gem "rb-fsevent", :require=>false gem "ruby_gntp", :require=>false gem "guard" gem "guard-test" gem "rails", "3.0.11" group :assets do gem "compass", "~> 0.13.alpha.0" gem "compass-rails", :path=>".." gem "compass-blueprint" end group :test do gem "mocha" gem "appraisal", :git=>"https://github.com/scottdavis/appraisal.git" gem "rainbow" end gemspec :path=>"../"compass-rails-1.1.7/gemfiles/rails32.gemfile0000644000076400007640000000072112331165176017742 0ustar pravipravi# This file was generated by Appraisal source "https://rubygems.org" gem "rb-fsevent", :require=>false gem "ruby_gntp", :require=>false gem "guard" gem "guard-test" gem "rails", "~> 3.2" gem "sass-rails" group :assets do gem "compass", "~> 0.13.alpha.0" gem "compass-rails", :path=>".." gem "compass-blueprint" end group :test do gem "mocha" gem "appraisal", :git=>"https://github.com/scottdavis/appraisal.git" gem "rainbow" end gemspec :path=>"../"compass-rails-1.1.7/Rakefile0000644000076400007640000000134012331165176015001 0ustar pravipravi#!/usr/bin/env rake require 'rubygems' require 'bundler' Bundler.setup require 'rake/dsl_definition' rescue nil require "bundler/gem_tasks" require 'appraisal' require 'compass' # ----- Default: Testing ------ task :default => [:test, :features] require 'rake/testtask' require 'fileutils' Rake::TestTask.new :test do |t| t.libs << 'lib' t.libs << 'test' test_files = FileList['test/**/*_test.rb'] test_files.exclude('test/rails/*', 'test/haml/*') t.test_files = test_files t.verbose = true end Rake::TestTask.new :units do |t| t.libs << 'lib' t.libs << 'test' test_files = FileList['test/units/**/*_test.rb'] test_files.exclude('test/rails/*', 'test/haml/*') t.test_files = test_files t.verbose = true endcompass-rails-1.1.7/Guardfile0000644000076400007640000000037112331165176015164 0ustar pravipravi# A sample Guardfile # More info at https://github.com/guard/guard#readme guard :test, :cli => '-v v' do watch(%r{^lib/(.+)\.rb$}) { |m| "test/#{m[1]}_test.rb" } watch(%r{^test/.+_test\.rb$}) watch('test/test_helper.rb') { "test" } end compass-rails-1.1.7/.gitignore0000644000076400007640000000027712331165176015334 0ustar pravipravi*.gem *.rbc .bundle .config .yardoc gemfiles/*.gemfile.lock Gemfile.lock InstalledFiles _yardoc coverage doc/ lib/bundler/man pkg rdoc spec/reports test/tmp test/version_tmp tmp rails-temp/*