compass-sourcemaps 0.12.2.sourcemaps.57a186c

data/lib/compass/frameworks.rb

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,102 @@
+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/installers.rb

@@ -0,0 +1,3 @@
+%w(manifest template_context base manifest_installer bare_installer).each do |f|
+  require "compass/installers/#{f}"
+end

data/lib/compass/installers/bare_installer.rb

@@ -0,0 +1,58 @@
+module Compass
+  module Installers
+
+    class BareInstaller < Base
+      def completed_configuration
+        nil
+      end
+
+      def init
+        directory targetize("")
+        directory targetize(Compass.configuration.sass_dir)
+      end
+
+      def prepare
+      end
+
+      def install
+        config_file ||= targetize('config.rb')
+        write_file config_file, config_contents
+      end
+
+      def config_contents
+        project_path, Compass.configuration.project_path = Compass.configuration.project_path, nil
+        Compass.configuration.serialize
+      ensure
+        Compass.configuration.project_path = project_path
+      end
+
+      def finalize(options = {})
+        puts <<-NEXTSTEPS
+
+*********************************************************************
+Congratulations! Your compass project has been created.
+
+You may now add sass stylesheets to the #{Compass.configuration.sass_dir} subdirectory of your project.
+
+Sass files beginning with an underscore are called partials and won't be
+compiled to CSS, but they can be imported into other sass stylesheets.
+
+You can configure your project by editing the config.rb configuration file.
+
+You must compile your sass stylesheets into CSS when they change.
+This can be done in one of the following ways:
+  1. To compile on demand:
+     compass compile [path/to/project]
+  2. To monitor your project for changes and automatically recompile:
+     compass watch [path/to/project]
+
+More Resources:
+  * Website: http://compass-style.org/
+  * Sass: http://sass-lang.com
+  * Community: http://groups.google.com/group/compass-users/
+NEXTSTEPS
+      end
+
+    end
+  end
+end

data/lib/compass/installers/base.rb

@@ -0,0 +1,187 @@
+module Compass
+  module Installers
+
+    class Base
+
+      include Actions
+
+      attr_accessor :template_path, :target_path, :working_path
+      attr_accessor :options
+
+      def initialize(template_path, target_path, options = {})
+        @template_path = template_path
+        @target_path = target_path
+        @working_path = Dir.getwd
+        @options = options
+        self.logger = options[:logger]
+      end
+
+      [:css_dir, :sass_dir, :images_dir, :javascripts_dir, :http_stylesheets_path, :fonts_dir, :preferred_syntax].each do |dir|
+        define_method dir do
+          Compass.configuration.send(dir)
+        end
+        define_method "#{dir}_without_default" do
+          Compass.configuration.send("#{dir}_without_default")
+        end
+      end
+
+      # Runs the installer.
+      # Every installer must conform to the installation strategy of prepare, install, and then finalize.
+      # A default implementation is provided for each step.
+      def run(run_options = {})
+        prepare unless run_options[:skip_preparation]
+        install unless options[:prepare]
+        finalize(options.merge(run_options)) unless options[:prepare] || run_options[:skip_finalization]
+      end
+
+      # The default prepare method -- it is a no-op.
+      # Generally you would create required directories, etc.
+      def prepare
+      end
+
+      # The install method override this to install
+      def install
+        raise "Not Yet Implemented"
+      end
+
+      # The default finalize method -- it is a no-op.
+      # This could print out a message or something.
+      def finalize(options = {})
+      end
+
+      def compilation_required?
+        false
+      end
+
+      def pattern_name_as_dir
+        "#{options[:pattern_name]}/" if options[:pattern_name]
+      end
+
+      def self.installer(type, installer_opts = {}, &locator)
+        locator ||= lambda{|to| to}
+        loc_method = "install_location_for_#{type}".to_sym
+        define_method("simple_#{loc_method}", locator)
+        define_method(loc_method) do |to, options|
+          if options[:like] && options[:like] != type
+            send("install_location_for_#{options[:like]}", to, options)
+          else
+            send("simple_#{loc_method}", to)
+          end
+        end
+        define_method "install_#{type}" do |from, to, options|
+          from = templatize(from)
+          to = targetize(send(loc_method, to, options))
+          is_binary = installer_opts[:binary] || options[:binary]
+          if is_binary
+            copy from, to, nil, is_binary
+          else
+            contents = File.new(from).read
+            if options.delete(:erb)
+              ctx = TemplateContext.ctx(:to => to, :options => options)
+              contents = process_erb(contents, ctx)
+            end
+            write_file to, contents
+          end
+        end
+      end
+
+      installer :stylesheet do |to|
+        "#{sass_dir}/#{pattern_name_as_dir}#{to}"
+      end
+
+      def install_stylesheet(from, to, options)
+        from = templatize(from)
+        to = targetize(install_location_for_stylesheet(to, options))
+        contents = File.new(from).read
+        if options.delete(:erb)
+          ctx = TemplateContext.ctx(:to => to, :options => options)
+          contents = process_erb(contents, ctx)
+        end
+        if preferred_syntax.to_s != from[-4..-1]
+          # logger.record :convert, basename(from)
+          tree = Sass::Engine.new(contents, Compass.sass_engine_options.merge(:syntax => from[-4..-1].intern)).to_tree
+          contents = tree.send("to_#{preferred_syntax}")
+          to[-4..-1] = preferred_syntax.to_s
+        end
+        write_file to, contents
+      end
+
+      installer :css do |to|
+        "#{css_dir}/#{to}"
+      end
+
+      installer :image, :binary => true do |to|
+        "#{images_dir}/#{to}"
+      end
+
+      installer :javascript do |to|
+        "#{javascripts_dir}/#{to}"
+      end
+
+      installer :font do |to|
+        "#{fonts_dir}/#{to}"
+      end
+
+      installer :file do |to|
+        "#{pattern_name_as_dir}#{to}"
+      end
+
+      installer :html do |to|
+        "#{pattern_name_as_dir}#{to}"
+      end
+
+      def install_directory(from, to, options)
+        d = if within = options[:within]
+          if respond_to?(within)
+            targetize("#{send(within)}/#{to}")
+          else
+            raise Compass::Error, "Unrecognized location: #{within}"
+          end
+        else
+          targetize(to)
+        end
+        directory d
+      end
+
+      alias install_html_without_haml install_html
+      def install_html(from, to, options)
+        if to =~ /\.haml$/
+          require 'haml'
+          to = to[0..-(".haml".length+1)]
+          if respond_to?(:install_location_for_html)
+            to = install_location_for_html(to, options)
+          end
+          contents = File.read(templatize(from))
+          if options.delete(:erb)
+            ctx = TemplateContext.ctx(:to => to, :options => options)
+            contents = process_erb(contents, ctx)
+          end
+          Compass.configure_sass_plugin!
+          html = Haml::Engine.new(contents, :filename => templatize(from)).render
+          write_file(targetize(to), html, options)
+        else
+          install_html_without_haml(from, to, options)
+        end
+      end
+
+      # returns an absolute path given a path relative to the current installation target.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def targetize(path)
+        strip_trailing_separator File.join(target_path, separate(path))
+      end
+
+      # returns an absolute path given a path relative to the current template.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def templatize(path)
+        strip_trailing_separator File.join(template_path, separate(path))
+      end
+
+      # Emits an HTML fragment that can be used to link to the compiled css files
+      def stylesheet_links
+        ""
+      end
+    end
+  end
+end
+require 'compass/installers/bare_installer'
+require 'compass/installers/manifest_installer'