compass 0.12.4 → 1.0.0

data/lib/compass/frameworks.rb

@@ -1,133 +0,0 @@
-module Compass
-  module Frameworks
-    extend self
-
-    ALL = []
-    DEFAULT_FRAMEWORKS_PATH = File.join(Compass.base_directory, 'frameworks')
-
-    class Framework
-      attr_accessor :name
-      attr_accessor :path
-      attr_accessor :templates_directory, :stylesheets_directory
-      def initialize(name, *arguments)
-        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
-        self.path = path = options[:path] || arguments.shift
-        @name = name
-        @templates_directory = options[:templates_directory]
-        @templates_directory ||= File.join(path, 'templates') if path
-        @stylesheets_directory = options[:stylesheets_directory]
-        @stylesheets_directory ||= File.join(path, 'stylesheets') if path
-      end
-      def template_directories
-        if templates_directory
-          Dir.glob(File.join(templates_directory, "*")).map{|f| File.basename(f)}
-        else
-          []
-        end
-      end
-      def manifest_file(pattern)
-        File.join(templates_directory, pattern.to_s, "manifest.rb")
-      end
-      def manifest(pattern, options = {})
-        options[:pattern_name] ||= pattern
-        Compass::Installers::Manifest.new(manifest_file(pattern), options)
-      end
-    end
-
-    def detect_registration
-      @registered = nil
-      yield
-      @registered
-    ensure
-      @registered = nil
-    end
-
-    def register(name, *arguments)
-      @registered = Framework.new(name, *arguments)
-      if idx = ALL.index(self[name])
-        ALL[idx] = @registered
-      else
-        ALL << @registered
-      end
-    end
-
-    def [](name)
-      ALL.detect{|f| f.name.to_s == name.to_s}
-    end
-
-    def discover(frameworks_directory)
-      frameworks_directory = DEFAULT_FRAMEWORKS_PATH if frameworks_directory == :defaults
-      frameworks_directory = Dir.new(frameworks_directory) unless frameworks_directory.is_a?(Dir)
-      dirs = frameworks_directory.entries.reject{|e| e =~ /^\./}.sort_by{|n| n =~ /^_/ ? n[1..-1] : n}
-      dirs.each do |framework|
-        register_directory File.join(frameworks_directory.path, framework)
-      end
-    end
-
-    def register_directory(directory)
-      loaders = [
-        File.join(directory, "compass_init.rb"),
-        File.join(directory, 'lib', File.basename(directory)+".rb"),
-        File.join(directory, File.basename(directory)+".rb")
-      ]
-      loader = loaders.detect{|l| File.exists?(l)}
-      registered_framework = detect_registration do
-        require loader if loader
-      end
-      unless registered_framework
-        register File.basename(directory), directory
-      end
-    end
-
-    def template_exists?(template)
-      framework_name, template = template.split(%r{/}, 2)
-      template ||= "project"
-      if (framework = self[framework_name]) && framework.templates_directory
-        return File.directory?(File.join(framework.templates_directory, template))
-      end
-      false
-    end
-
-    def template_usage(template)
-      framework_name, template = template.split(%r{/}, 2)
-      framework = self[framework_name]
-      template ||= "project"
-      usage_file = File.join(framework.templates_directory, template, "USAGE.markdown")
-      if File.exists?(usage_file)
-        File.read(usage_file)
-      elsif help = framework.manifest(template).help
-        help
-      else
-        <<-END.gsub(/^ {8}/, '')
-          No Usage!
-        END
-      end
-    end
-
-    def pretty_print(skip_patterns = false)
-      result = ""
-      max = Compass::Frameworks::ALL.inject(0) do |gm, framework|
-        fm = framework.template_directories.inject(0) do |lm,pattern|
-          [lm, 7 + framework.name.size + pattern.size].max
-        end
-        [gm, fm].max
-      end
-      Compass::Frameworks::ALL.each do |framework|
-        next if framework.name =~ /^_/
-        result << "  * #{framework.name}\n"
-        unless skip_patterns
-          framework.template_directories.each do |pattern|
-            result << "    - #{framework.name}/#{pattern}".ljust(max)
-            if description = framework.manifest(pattern).description
-              result << " - #{description}"
-            end
-            result << "\n"
-          end
-        end
-      end
-      result
-    end
-  end
-end
-
-Compass::Frameworks.discover(:defaults)

data/lib/compass/grid_builder.rb

@@ -1,102 +0,0 @@
-require 'zlib'
-
-module Compass
-
-  # A simple class to represent and create a PNG-File
-  # No drawing features given
-  # Just subclass and write [R,G,B]-Byte-Values into the <tt>@data</tt> matrix
-  # Build for compactness, so not much error checking!
-  #
-  # Code based on seattlerb's png, see http://seattlerb.rubyforge.org/png/
-  class PNG
-    CRC_TABLE = (0..255).map do |n|
-      (0...8).inject(n){|x,i| x = ((x & 1) == 1) ? 0xedb88320 ^ (x >> 1) : x >> 1}
-    end
-
-    class << self
-      def crc(chunkdata='')
-        chunkdata.unpack('C*').inject(0xffffffff){|crc, byte| CRC_TABLE[(crc ^ byte)  & 0xff] ^ (crc >> 8) } ^  0xffffffff
-      end
-
-      def chunk(type, data="")
-        [data.size, type, data, crc(type + data)].pack("Na*a*N")
-      end
-    end
-
-    # Initiates a new PNG-Object
-    # * <tt>width</tt>: Width of the image in pixels
-    # * <tt>height</tt>: Height of the image in pixels
-    # * <tt>background</tt>: Background-color represented as [R,G,B]-Byte-Array
-    def initialize(width, height, background = [255,255,255])
-      @height = height
-      @width = width
-      @data = Array.new(@height) { |x| Array.new(@width, background) }
-    end
-
-    BITS    = 8
-    RGB     = 2 # Color Types ( RGBA = 6)
-    NONE    = 0 # Filter
-
-    # binary representation of the PNG, write to file with binary mode
-    def to_blob
-      blob = []
-      blob <<  [137, 80, 78, 71, 13, 10, 26, 10].pack("C*")
-      blob << PNG.chunk('IHDR', [@width, @height, BITS, RGB, NONE, NONE, NONE].pack("N2C5"))
-      blob << PNG.chunk('IDAT', Zlib::Deflate.deflate(self.png_join))
-      blob << PNG.chunk('IEND', '')
-      blob.join
-    end
-
-    def png_join
-      @data.map { |row| "\0" + row.map { |p| "%c%c%c" % p}.join }.join
-    end
-  end
-
-  class GridBuilder < PNG
-    include Actions
-
-    attr_reader :column_width, :gutter_width, :filename, :able_to_generate, :options
-
-    # ==== Options
-    # * <tt>options</tt>
-    #   * <tt>:column_width</tt> -- Width (in pixels) of current grid column
-    #   * <tt>:gutter_width</tt> -- Width (in pixels) of current grid gutter
-    #   * <tt>:height</tt> -- Height (in pixels) of a row
-    #   * <tt>:filename</tt> -- Output path of grid.png file
-    def initialize(options={})
-      @column_width = options[:column_width] || 0
-      gutter_width = options[:gutter_width] || 0
-
-      height = options[:height] || 20
-      width = @column_width + gutter_width
-      width = 10 if width == 0
-
-      @filename = options[:filename]
-      @options = options
-
-      super(width, height, [0xe9,0xe9,0xe9])
-    end
-
-    def working_path
-      options[:working_path]
-    end
-
-    # generates (overwriting if necessary) grid.png image to be tiled in background
-    def generate!
-      (0...@height-1).each do |line|
-        @data[line] = Array.new(@width){|x| x < @column_width ? [0xe8, 0xef, 0xfb] : [0xff,0xff,0xff] }
-      end
-
-      if File.exists?(filename)
-        if options[:force]
-          overwrite = true
-        else
-          msg = "#{filename} already exists. Overwrite with --force."
-          raise Compass::FilesystemConflict.new(msg)
-        end
-      end
-      directory File.dirname(filename)
-      write_file(filename, self.to_blob, options, true)
-    end
-  end
-end

data/lib/compass/sass_extensions/functions/colors.rb

@@ -1,67 +0,0 @@
-module Compass::SassExtensions::Functions::Colors
-
-  # a genericized version of lighten/darken so that negative values can be used.
-  def adjust_lightness(color, amount)
-    assert_type color, :Color
-    assert_type amount, :Number
-    color.with(:lightness => Compass::Util.restrict(color.lightness + amount.value, 0..100))
-  end
-
-  # Scales a color's lightness by some percentage.
-  # If the amount is negative, the color is scaled darker, if positive, it is scaled lighter.
-  # This will never return a pure light or dark color unless the amount is 100%.
-  def scale_lightness(color, amount)
-    assert_type color, :Color
-    assert_type amount, :Number
-    color.with(:lightness => scale_color_value(color.lightness, amount.value))
-  end
-
-  # a genericized version of saturation/desaturate so that negative values can be used.
-  def adjust_saturation(color, amount)
-    assert_type color, :Color
-    assert_type amount, :Number
-    color.with(:saturation => Compass::Util.restrict(color.saturation + amount.value, 0..100))
-  end
-
-  # Scales a color's saturation by some percentage.
-  # If the amount is negative, the color is desaturated, if positive, it is saturated.
-  # This will never return a pure saturated or desaturated color unless the amount is 100%.
-  def scale_saturation(color, amount)
-    assert_type color, :Color
-    assert_type amount, :Number
-    color.with(:saturation => scale_color_value(color.saturation, amount.value))
-  end
-
-  def shade(color, percentage)
-    assert_type color, :Color
-    assert_type percentage, :Number
-    black = Sass::Script::Color.new([0, 0, 0])
-    mix(black, color, percentage)
-  end
-
-  def tint(color, percentage)
-    assert_type color, :Color
-    assert_type percentage, :Number
-    white = Sass::Script::Color.new([255, 255, 255])
-    mix(white, color, percentage)
-  end
-
-  # returns an IE hex string for a color with an alpha channel
-  # suitable for passing to IE filters.
-  def ie_hex_str(color)
-    assert_type color, :Color
-    alpha = (color.alpha * 255).round
-    alphastr = alpha.to_s(16).rjust(2, '0')
-    Sass::Script::String.new("##{alphastr}#{color.send(:hex_str)[1..-1]}".upcase)
-  end
-  
-  private
-  def scale_color_value(value, amount)
-    if amount > 0
-      value += (100 - value) * (amount / 100.0)
-    elsif amount < 0
-      value += value * amount / 100.0
-    end
-    value
-  end
-end

data/lib/compass/sass_extensions/functions/constants.rb

@@ -1,74 +0,0 @@
-module Compass::SassExtensions::Functions::Constants
-  if defined?(Sass::Script::List)
-    POSITIONS = /top|bottom|left|right|center/
-    def is_position(position)
-      Sass::Script::Bool.new(position.is_a?(Sass::Script::String) && !!(position.value =~ POSITIONS))
-    end
-    def is_position_list(position_list)
-      Sass::Script::Bool.new(position_list.is_a?(Sass::Script::List) && position_list.value.all?{|p| is_position(p).to_bool})
-    end
-    # returns the opposite position of a side or corner.
-    def opposite_position(position)
-      position = unless position.is_a?(Sass::Script::List)
-        Sass::Script::List.new([position], :space)
-      else
-        Sass::Script::List.new(position.value.dup, position.separator)
-      end
-      position.value.map! do |pos|
-        if pos.is_a? Sass::Script::String
-          opposite = case pos.value
-          when "top" then "bottom"
-          when "bottom" then "top"
-          when "left" then "right"
-          when "right" then "left"
-          when "center" then "center"
-          else
-            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
-            pos.value
-          end
-          Sass::Script::String.new(opposite)
-        elsif pos.is_a? Sass::Script::Number
-          if pos.numerator_units == ["%"] && pos.denominator_units == []
-            Sass::Script::Number.new(100-pos.value, ["%"])
-          else
-            Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
-            pos
-          end
-        else
-          Compass::Util.compass_warn("Cannot determine the opposite position of: #{pos}")
-          pos
-        end
-      end
-      if position.value.size == 1
-        position.value.first
-      else
-        position
-      end
-    end
-
-    def is_url(string)
-      if string.is_a?(Sass::Script::String)
-        is_url = !!(string.value =~ /^url\(.*\)$/)
-        Sass::Script::Bool.new(is_url)
-      else
-        Sass::Script::Bool.new(false)
-      end
-    end
-  else
-    # returns the opposite position of a side or corner.
-    def opposite_position(position)
-      opposite = position.value.split(/ +/).map do |pos|
-        case pos
-        when "top" then "bottom"
-        when "bottom" then "top"
-        when "left" then "right"
-        when "right" then "left"
-        when "center" then "center"
-        else
-          pos
-        end
-      end
-      Sass::Script::String.new(opposite.join(" "), position.type)
-    end
-  end
-end

data/lib/compass/sass_extensions/functions/cross_browser_support.rb

@@ -1,70 +0,0 @@
-module Compass::SassExtensions::Functions::CrossBrowserSupport
-
-  class CSS2FallbackValue < Sass::Script::Literal
-    attr_accessor :value, :css2_value
-    def children
-      [value, css2_value]
-    end
-    def initialize(value, css2_value)
-      self.value = value
-      self.css2_value = css2_value
-    end
-    def inspect
-      to_s
-    end
-    def to_s(options = self.options)
-      value.to_s(options)
-    end
-    def supports?(aspect)
-      aspect == "css2"
-    end
-    def has_aspect?
-      true
-    end
-    def to_css2(options = self.options)
-      css2_value
-    end
-  end
-
-  # Check if any of the arguments passed require a vendor prefix.
-  def prefixed(prefix, *args)
-    aspect = prefix.value.sub(/^-/,"")
-    needed = args.any?{|a| a.respond_to?(:supports?) && a.supports?(aspect)}
-    Sass::Script::Bool.new(needed)
-  end
-
-  %w(webkit moz o ms svg pie css2 owg).each do |prefix|
-    class_eval <<-RUBY, __FILE__, __LINE__ + 1
-      # Syntactic sugar to apply the given prefix
-      # -moz($arg) is the same as calling prefix(-moz, $arg)
-      def _#{prefix}(*args)
-        prefix("#{prefix}", *args)
-      end
-    RUBY
-  end
-
-  def prefix(prefix, *objects)
-    prefix = prefix.value if prefix.is_a?(Sass::Script::String)
-    prefix = prefix[1..-1] if prefix[0] == ?-
-    if objects.size > 1
-      self.prefix(prefix, Sass::Script::List.new(objects, :comma))
-    else
-      object = objects.first
-      if object.is_a?(Sass::Script::List)
-        Sass::Script::List.new(object.value.map{|e|
-          self.prefix(prefix, e)
-        }, object.separator)
-      elsif object.respond_to?(:supports?) && object.supports?(prefix) && object.respond_to?(:"to_#{prefix}")
-        object.options = options
-        object.send(:"to_#{prefix}")
-      else
-        object
-      end
-    end
-  end
-
-  def css2_fallback(value, css2_value)
-    CSS2FallbackValue.new(value, css2_value)
-  end
-
-end