xass 0.1.0 → 0.1.1

data/Rakefile

@@ -1,349 +0,0 @@
-require 'rubygems/package'
-
-# ----- Utility Functions -----
-
-def scope(path)
-  File.join(File.dirname(__FILE__), path)
-end
-
-# ----- Default: Testing ------
-
-task :default => :test
-
-require 'rake/testtask'
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  test_files = FileList[scope('test/**/*_test.rb')]
-  test_files.exclude(scope('test/rails/*'))
-  test_files.exclude(scope('test/plugins/*'))
-  t.test_files = test_files
-  t.verbose = true
-end
-
-# ----- Packaging -----
-
-# Don't use Rake::GemPackageTast because we want prerequisites to run
-# before we load the gemspec.
-desc "Build all the packages."
-task :package => [:revision_file, :date_file, :submodules, :permissions] do
-  version = get_version
-  File.open(scope('VERSION'), 'w') {|f| f.puts(version)}
-  load scope('sass.gemspec')
-  Gem::Package.build(SASS_GEMSPEC)
-  sh %{git checkout VERSION}
-
-  pkg = "#{SASS_GEMSPEC.name}-#{SASS_GEMSPEC.version}"
-  mkdir_p "pkg"
-  verbose(true) {mv "#{pkg}.gem", "pkg/#{pkg}.gem"}
-
-  sh %{rm -f pkg/#{pkg}.tar.gz}
-  verbose(false) {SASS_GEMSPEC.files.each {|f| sh %{tar rf pkg/#{pkg}.tar #{f}}}}
-  sh %{gzip pkg/#{pkg}.tar}
-end
-
-task :permissions do
-  sh %{chmod -R a+rx bin}
-  sh %{chmod -R a+r .}
-  require 'shellwords'
-  Dir.glob('test/**/*_test.rb') do |file|
-    next if file =~ %r{^test/haml/spec/}
-    sh %{chmod a+rx #{file}}
-  end
-end
-
-task :revision_file do
-  require scope('lib/sass')
-
-  release = Rake.application.top_level_tasks.include?('release') || File.exist?(scope('EDGE_GEM_VERSION'))
-  if Sass.version[:rev] && !release
-    File.open(scope('REVISION'), 'w') { |f| f.puts Sass.version[:rev] }
-  elsif release
-    File.open(scope('REVISION'), 'w') { |f| f.puts "(release)" }
-  else
-    File.open(scope('REVISION'), 'w') { |f| f.puts "(unknown)" }
-  end
-end
-
-task :date_file do
-  File.open(scope('VERSION_DATE'), 'w') do |f|
-    f.puts Time.now.utc.strftime('%d %B %Y %T %Z')
-  end
-end
-
-# We also need to get rid of this file after packaging.
-at_exit do
-  File.delete(scope('REVISION')) rescue nil
-  File.delete(scope('VERSION_DATE')) rescue nil
-end
-
-desc "Install Sass as a gem. Use SUDO=1 to install with sudo."
-task :install => [:package] do
-  gem  = RUBY_PLATFORM =~ /java/  ? 'jgem' : 'gem' 
-  sh %{#{'sudo ' if ENV["SUDO"]}#{gem} install --no-ri pkg/sass-#{get_version}}
-end
-
-desc "Release a new Sass package to Rubyforge."
-task :release => [:check_release, :package] do
-  name = File.read(scope("VERSION_NAME")).strip
-  version = File.read(scope("VERSION")).strip
-  # sh %{rubyforge add_release sass sass "#{name} (v#{version})" pkg/sass-#{version}.gem}
-  # sh %{rubyforge add_file    sass sass "#{name} (v#{version})" pkg/sass-#{version}.tar.gz}
-  sh %{gem push pkg/sass-#{version}.gem}
-end
-
-# Ensures that the VERSION file has been updated for a new release.
-task :check_release do
-  version = File.read(scope("VERSION")).strip
-  raise "There have been changes since current version (#{version})" if changed_since?(version)
-  raise "VERSION_NAME must not be 'Bleeding Edge'" if File.read(scope("VERSION_NAME")) == "Bleeding Edge"
-end
-
-# Reads a password from the command line.
-#
-# @param name [String] The prompt to use to read the password
-def read_password(prompt)
-  require 'readline'
-  system "stty -echo"
-  Readline.readline("#{prompt}: ").strip
-ensure
-  system "stty echo"
-  puts
-end
-
-# Returns whether or not the repository, or specific files,
-# has/have changed since a given revision.
-#
-# @param rev [String] The revision to check against
-# @param files [Array<String>] The files to check.
-#   If this is empty, checks the entire repository
-def changed_since?(rev, *files)
-  IO.popen("git diff --exit-code #{rev} #{files.join(' ')}") {}
-  return !$?.success?
-end
-
-task :submodules do
-  if File.exist?(File.dirname(__FILE__) + "/.git")
-    sh %{git submodule sync}
-    sh %{git submodule update --init}
-  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/listen/lib")
-    warn <<WARN
-WARNING: vendor/listen doesn't exist, and this isn't a git repository so
-I can't get it automatically!
-WARN
-  end
-end
-
-task :release_edge do
-  ensure_git_cleanup do
-    puts "#{'=' * 50} Running rake release_edge"
-
-    sh %{git checkout master}
-    sh %{git reset --hard origin/master}
-    sh %{rake package}
-    version = get_version
-    # sh %{rubyforge add_release sass sass "Bleeding Edge (v#{version})" pkg/sass-#{version}.gem}
-    sh %{gem push pkg/sass-#{version}.gem}
-  end
-end
-
-# Get the version string. If this is being installed from Git,
-# this includes the proper prerelease version.
-def get_version
-  written_version = File.read(scope('VERSION').strip)
-  return written_version unless File.exist?(scope('.git'))
-
-  # Get the current master branch version
-  version = written_version.split('.')
-  version.map! {|n| n =~ /^[0-9]+$/ ? n.to_i : n}
-  return written_version unless version.size == 5 && version[3] == "alpha" # prerelease
-
-  return written_version if (commit_count = `git log --pretty=oneline HEAD ^stable | wc -l`).empty?
-  version[4] = commit_count.strip
-  version.join('.')
-end
-
-task :watch_for_update do
-  sh %{ruby extra/update_watch.rb}
-end
-
-# ----- Documentation -----
-
-task :rdoc do
-  puts '=' * 100, <<END, '=' * 100
-Sass uses the YARD documentation system (http://github.com/lsegal/yard).
-Install the yard gem and then run "rake doc".
-END
-end
-
-begin
-  require 'yard'
-
-  namespace :doc do
-    task :sass do
-      require scope('lib/sass')
-      Dir[scope("yard/default/**/*.sass")].each do |sass|
-        File.open(sass.gsub(/sass$/, 'css'), 'w') do |f|
-          f.write(Sass::Engine.new(File.read(sass)).render)
-        end
-      end
-    end
-
-    desc "List all undocumented methods and classes."
-    task :undocumented do
-      opts = ENV["YARD_OPTS"] || ""
-      ENV["YARD_OPTS"] = opts.dup + <<OPTS
- --list --query "
-  object.docstring.blank? &&
-  !(object.type == :method && object.is_alias?)"
-OPTS
-      Rake::Task['yard'].execute
-    end
-  end
-
-  YARD::Rake::YardocTask.new do |t|
-    t.files = FileList.new(scope('lib/**/*.rb')) do |list|
-      list.exclude('lib/sass/plugin/merb.rb')
-      list.exclude('lib/sass/plugin/rails.rb')
-    end.to_a
-    t.options << '--incremental' if Rake.application.top_level_tasks.include?('redoc')
-    t.options += FileList.new(scope('yard/*.rb')).to_a.map {|f| ['-e', f]}.flatten
-    files = FileList.new(scope('doc-src/*')).to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
-    t.options << '--files' << files.join(',')
-    t.options << '--template-path' << scope('yard')
-    t.options << '--title' << ENV["YARD_TITLE"] if ENV["YARD_TITLE"]
-
-    t.before = lambda do
-      if ENV["YARD_OPTS"]
-        require 'shellwords'
-        t.options.concat(Shellwords.shellwords(ENV["YARD_OPTS"]))
-      end
-    end
-  end
-  Rake::Task['yard'].prerequisites.insert(0, 'doc:sass')
-  Rake::Task['yard'].instance_variable_set('@comment', nil)
-
-  desc "Generate Documentation"
-  task :doc => :yard
-  task :redoc => :yard
-rescue LoadError
-  desc "Generate Documentation"
-  task :doc => :rdoc
-  task :yard => :rdoc
-end
-
-task :pages do
-  ensure_git_cleanup do
-    puts "#{'=' * 50} Running rake pages"
-    sh %{git checkout sass-pages}
-    sh %{git reset --hard origin/sass-pages}
-
-    Dir.chdir("/var/www/sass-pages") do
-      sh %{git fetch origin}
-
-      sh %{git checkout stable}
-      sh %{git reset --hard origin/stable}
-
-      sh %{git checkout sass-pages}
-      sh %{git reset --hard origin/sass-pages}
-      sh %{rake build --trace}
-      sh %{mkdir -p tmp}
-      sh %{touch tmp/restart.txt}
-    end
-  end
-end
-
-# ----- Coverage -----
-
-begin
-  require 'rcov/rcovtask'
-
-  Rcov::RcovTask.new do |t|
-    t.test_files = FileList[scope('test/**/*_test.rb')]
-    t.rcov_opts << '-x' << '"^\/"'
-    if ENV['NON_NATIVE']
-      t.rcov_opts << "--no-rcovrt"
-    end
-    t.verbose = true
-  end
-rescue LoadError; end
-
-# ----- Profiling -----
-
-begin
-  require 'ruby-prof'
-
-  desc <<END
-Run a profile of sass.
-  TIMES=n sets the number of runs. Defaults to 1000.
-  FILE=str sets the file to profile. Defaults to 'complex'.
-  OUTPUT=str sets the ruby-prof output format.
-    Can be Flat, CallInfo, or Graph. Defaults to Flat. Defaults to Flat.
-END
-  task :profile do
-    times  = (ENV['TIMES'] || '1000').to_i
-    file   = ENV['FILE']
-
-    require 'lib/sass'
-
-    file = File.read(scope("test/sass/templates/#{file || 'complex'}.sass"))
-    result = RubyProf.profile { times.times { Sass::Engine.new(file).render } }
-
-    RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
-  end
-rescue LoadError; end
-
-# ----- Handling Updates -----
-
-def email_on_error
-  yield
-rescue Exception => e
-  IO.popen("sendmail nex342@gmail.com", "w") do |sm|
-    sm << "From: nex3@nex-3.com\n" <<
-      "To: nex342@gmail.com\n" <<
-      "Subject: Exception when running rake #{Rake.application.top_level_tasks.join(', ')}\n" <<
-      e.message << "\n\n" <<
-      e.backtrace.join("\n")
-  end
-ensure
-  raise e if e
-end
-
-def ensure_git_cleanup
-  email_on_error {yield}
-ensure
-  sh %{git reset --hard HEAD}
-  sh %{git clean -xdf}
-  sh %{git checkout master}
-end
-
-task :handle_update do
-  email_on_error do
-    unless ENV["REF"] =~ %r{^refs/heads/(master|stable|sass-pages)$}
-      puts "#{'=' * 20} Ignoring rake handle_update REF=#{ENV["REF"].inspect}"
-      next
-    end
-    branch = $1
-
-    puts
-    puts
-    puts '=' * 150
-    puts "Running rake handle_update REF=#{ENV["REF"].inspect}"
-
-    sh %{git fetch origin}
-    sh %{git checkout stable}
-    sh %{git reset --hard origin/stable}
-    sh %{git checkout master}
-    sh %{git reset --hard origin/master}
-
-    case branch
-    when "master"
-      sh %{rake release_edge --trace}
-    when "stable", "sass-pages"
-      sh %{rake pages --trace}
-    end
-
-    puts 'Done running handle_update'
-    puts '=' * 150
-  end
-end

data/VERSION

@@ -1 +0,0 @@
-0.1.0

data/VERSION_NAME

@@ -1 +0,0 @@
-Media Mark

data/bin/push

@@ -1,13 +0,0 @@
-#! /bin/bash
-
-DIR=$(dirname $0)
-cd $DIR/..
-OLDVER=$(cat VERSION)
-NEWVER=3.4.$(expr $(cat VERSION | awk -F. '{ print $3 }') + 1)
-echo $NEWVER > VERSION
-gem build sass.gemspec
-gem push oreorenasass-$NEWVER.gem
-git add --all
-git commit -m "$NEWVER"
-git tag $NEWVER
-git push origin oreoremaster

data/bin/sass

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-# The command line Sass parser.
-
-THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
-begin
-  require File.dirname(THIS_FILE) + '/../lib/sass'
-rescue LoadError
-  require 'sass'
-end
-require 'sass/exec'
-
-opts = Sass::Exec::Sass.new(ARGV)
-opts.parse!

data/bin/sass-convert

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
-begin
-  require File.dirname(THIS_FILE) + '/../lib/sass'
-rescue LoadError
-  require 'sass'
-end
-require 'sass/exec'
-
-opts = Sass::Exec::SassConvert.new(ARGV)
-opts.parse!

data/bin/scss

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-# The command line Sass parser.
-
-THIS_FILE = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
-begin
-  require File.dirname(THIS_FILE) + '/../lib/sass'
-rescue LoadError
-  require 'sass'
-end
-require 'sass/exec'
-
-opts = Sass::Exec::Scss.new(ARGV)
-opts.parse!

data/extra/update_watch.rb

@@ -1,13 +0,0 @@
-require 'rubygems'
-require 'sinatra'
-require 'json'
-set :port, 3124
-set :environment, :production
-enable :lock
-Dir.chdir(File.dirname(__FILE__) + "/..")
-
-post "/" do
-  puts "Recieved payload!"
-  puts "Rev: #{`git name-rev HEAD`.strip}"
-  system %{rake handle_update --trace REF=#{JSON.parse(params["payload"])["ref"].inspect}}
-end

data/init.rb

@@ -1,18 +0,0 @@
-begin
-  require File.join(File.dirname(__FILE__), 'lib', 'sass') # From here
-rescue LoadError
-  begin
-    require 'sass' # From gem
-  rescue LoadError => e
-    # gems:install may be run to install Haml with the skeleton plugin
-    # but not the gem itself installed.
-    # Don't die if this is the case.
-    raise e unless defined?(Rake) &&
-      (Rake.application.top_level_tasks.include?('gems') ||
-        Rake.application.top_level_tasks.include?('gems:install'))
-  end
-end
-
-# Load Sass.
-# Sass may be undefined if we're running gems:install.
-require 'sass/plugin' if defined?(Sass)

data/lib/sass/cache_stores/base.rb

@@ -1,88 +0,0 @@
-module Sass
-  module CacheStores
-    # An abstract base class for backends for the Sass cache.
-    # Any key-value store can act as such a backend;
-    # it just needs to implement the
-    # \{#_store} and \{#_retrieve} methods.
-    #
-    # To use a cache store with Sass,
-    # use the {file:SASS_REFERENCE.md#cache_store-option `:cache_store` option}.
-    #
-    # @abstract
-    class Base
-      # Store cached contents for later retrieval
-      # Must be implemented by all CacheStore subclasses
-      #
-      # Note: cache contents contain binary data.
-      #
-      # @param key [String] The key to store the contents under
-      # @param version [String] The current sass version.
-      #                Cached contents must not be retrieved across different versions of sass.
-      # @param sha [String] The sha of the sass source.
-      #                Cached contents must not be retrieved if the sha has changed.
-      # @param contents [String] The contents to store.
-      def _store(key, version, sha, contents)
-        raise "#{self.class} must implement #_store."
-      end
-
-      # Retrieved cached contents.
-      # Must be implemented by all subclasses.
-      # 
-      # Note: if the key exists but the sha or version have changed,
-      # then the key may be deleted by the cache store, if it wants to do so.
-      #
-      # @param key [String] The key to retrieve
-      # @param version [String] The current sass version.
-      #                Cached contents must not be retrieved across different versions of sass.
-      # @param sha [String] The sha of the sass source.
-      #                Cached contents must not be retrieved if the sha has changed.
-      # @return [String] The contents that were previously stored.
-      # @return [NilClass] when the cache key is not found or the version or sha have changed.
-      def _retrieve(key, version, sha)
-        raise "#{self.class} must implement #_retrieve."
-      end
-
-      # Store a {Sass::Tree::RootNode}.
-      #
-      # @param key [String] The key to store it under.
-      # @param sha [String] The checksum for the contents that are being stored.
-      # @param obj [Object] The object to cache.
-      def store(key, sha, root)
-        _store(key, Sass::VERSION, sha, Marshal.dump(root))
-      rescue TypeError, LoadError => e
-        Sass::Util.sass_warn "Warning. Error encountered while saving cache #{path_to(key)}: #{e}"
-        nil
-      end
-
-      # Retrieve a {Sass::Tree::RootNode}.
-      #
-      # @param key [String] The key the root element was stored under.
-      # @param sha [String] The checksum of the root element's content.
-      # @return [Object] The cached object.
-      def retrieve(key, sha)
-        contents = _retrieve(key, Sass::VERSION, sha)
-        Marshal.load(contents) if contents
-      rescue EOFError, TypeError, ArgumentError, LoadError => e
-        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-        nil
-      end
-
-      # Return the key for the sass file.
-      #
-      # The `(sass_dirname, sass_basename)` pair
-      # should uniquely identify the Sass document,
-      # but otherwise there are no restrictions on their content.
-      #
-      # @param sass_dirname [String]
-      #   The fully-expanded location of the Sass file.
-      #   This corresponds to the directory name on a filesystem.
-      # @param sass_basename [String] The name of the Sass file that is being referenced.
-      #   This corresponds to the basename on a filesystem.
-      def key(sass_dirname, sass_basename)
-        dir = Digest::SHA1.hexdigest(sass_dirname)
-        filename = "#{sass_basename}c"
-        "#{dir}/#{filename}"
-      end
-    end
-  end
-end

data/lib/sass/cache_stores/chain.rb

@@ -1,33 +0,0 @@
-module Sass
-  module CacheStores
-    # A meta-cache that chains multiple caches together.
-    # Specifically:
-    #
-    # * All `#store`s are passed to all caches.
-    # * `#retrieve`s are passed to each cache until one has a hit.
-    # * When one cache has a hit, the value is `#store`d in all earlier caches.
-    class Chain < Base
-      # Create a new cache chaining the given caches.
-      #
-      # @param caches [Array<Sass::CacheStores::Base>] The caches to chain.
-      def initialize(*caches)
-        @caches = caches
-      end
-
-      # @see Base#store
-      def store(key, sha, obj)
-        @caches.each {|c| c.store(key, sha, obj)}
-      end
-
-      # @see Base#retrieve
-      def retrieve(key, sha)
-        @caches.each_with_index do |c, i|
-          next unless obj = c.retrieve(key, sha)
-          @caches[0...i].each {|prev| prev.store(key, sha, obj)}
-          return obj
-        end
-        nil
-      end
-    end
-  end
-end

data/lib/sass/cache_stores/filesystem.rb

@@ -1,64 +0,0 @@
-require 'fileutils'
-
-module Sass
-  module CacheStores
-    # A backend for the Sass cache using the filesystem.
-    class Filesystem < Base
-      # The directory where the cached files will be stored.
-      #
-      # @return [String]
-      attr_accessor :cache_location
-
-      # @param cache_location [String] see \{#cache\_location}
-      def initialize(cache_location)
-        @cache_location = cache_location
-      end
-
-      # @see Base#\_retrieve
-      def _retrieve(key, version, sha)
-        return unless File.readable?(path_to(key))
-        File.open(path_to(key), "rb") do |f|
-          if f.readline("\n").strip == version && f.readline("\n").strip == sha
-            return f.read
-          end
-        end
-        begin
-          File.unlink path_to(key)
-        rescue Errno::ENOENT
-          # Already deleted. Race condition?
-        end
-        nil
-      rescue EOFError, TypeError, ArgumentError => e
-        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-      end
-
-      # @see Base#\_store
-      def _store(key, version, sha, contents)
-        # return unless File.writable?(File.dirname(@cache_location))
-        # return if File.exists?(@cache_location) && !File.writable?(@cache_location)
-        compiled_filename = path_to(key)
-        # return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
-        # return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
-        FileUtils.mkdir_p(File.dirname(compiled_filename))
-        Sass::Util.atomic_create_and_write_file(compiled_filename, 0600) do |f|
-          f.puts(version)
-          f.puts(sha)
-          f.write(contents)
-        end
-      rescue Errno::EACCES
-        #pass
-      end
-
-      private
-
-      # Returns the path to a file for the given key.
-      #
-      # @param key [String]
-      # @return [String] The path to the cache file.
-      def path_to(key)
-        key = key.gsub(/[<>:\\|?*%]/) {|c| "%%%03d" % Sass::Util.ord(c)}
-        File.join(cache_location, key)
-      end
-    end
-  end
-end

data/lib/sass/cache_stores/memory.rb

@@ -1,47 +0,0 @@
-module Sass
-  module CacheStores
-    # A backend for the Sass cache using in-process memory.
-    class Memory < Base
-      # Since the {Memory} store is stored in the Sass tree's options hash,
-      # when the options get serialized as part of serializing the tree,
-      # you get crazy exponential growth in the size of the cached objects
-      # unless you don't dump the cache.
-      #
-      # @private
-      def _dump(depth)
-        ""
-      end
-
-      # If we deserialize this class, just make a new empty one.
-      #
-      # @private
-      def self._load(repr)
-        Memory.new
-      end
-
-      # Create a new, empty cache store.
-      def initialize
-        @contents = {}
-      end
-
-      # @see Base#retrieve
-      def retrieve(key, sha)
-        if @contents.has_key?(key)
-          return unless @contents[key][:sha] == sha
-          obj = @contents[key][:obj]
-          obj.respond_to?(:deep_copy) ? obj.deep_copy : obj.dup
-        end
-      end
-
-      # @see Base#store
-      def store(key, sha, obj)
-        @contents[key] = {:sha => sha, :obj => obj}
-      end
-      
-      # Destructively clear the cache.
-      def reset!
-        @contents = {}
-      end
-    end
-  end
-end