middleman 0.12.0.pre → 0.12.0.pre2

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/dependencies.rb

@@ -1,10 +0,0 @@
-unless defined?(Sass)
-  require 'rubygems'
-  begin
-    gem 'haml-edge', '>= 2.3.0'
-    $stderr.puts "Loading haml-edge gem."
-  rescue Exception
-    #pass
-  end
-  require 'sass'
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/errors.rb

@@ -1,7 +0,0 @@
-module Compass
-  class Error < StandardError
-  end
-
-  class FilesystemConflict < Error
-  end
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/exec.rb

@@ -1,251 +0,0 @@
-require File.join(Compass.lib_directory, 'compass', 'dependencies')
-require 'optparse'
-require File.join(Compass.lib_directory, 'compass', 'logger')
-require File.join(Compass.lib_directory, 'compass', 'errors')
-require File.join(Compass.lib_directory, 'compass', 'actions')
-
-module Compass
-  module Exec
-
-    def report_error(e, options)
-      $stderr.puts "#{e.class} on line #{get_line e} of #{get_file e}: #{e.message}"
-      if options[:trace]
-        e.backtrace[1..-1].each { |t| $stderr.puts "  #{t}" }
-      else
-        $stderr.puts "Run with --trace to see the full backtrace"
-      end
-    end
-
-    def get_file(exception)
-      exception.backtrace[0].split(/:/, 2)[0]
-    end
-
-    def get_line(exception)
-      exception.backtrace[0].scan(/:(\d+)/)[0]
-    end
-    module_function :report_error, :get_file, :get_line
-
-    class Compass
-      
-      attr_accessor :args, :options, :opts
-
-      def initialize(args)
-        self.args = args
-        self.options = {}
-        parse!
-      end
-
-      def run!
-        begin
-          perform!
-        rescue Exception => e
-          raise e if e.is_a? SystemExit
-          if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
-            $stderr.puts e.message
-          else
-            ::Compass::Exec.report_error(e, @options)
-          end
-          return 1
-        end
-        return 0
-      end
-      
-      protected
-      
-      def perform!
-        if options[:command]
-          do_command(options[:command])
-        else
-          puts self.opts
-        end
-      end
-      
-      def parse!
-        self.opts = OptionParser.new(&method(:set_opts))
-        self.opts.parse!(self.args)    
-        if self.args.size > 0
-          self.options[:project_name] = trim_trailing_separator(self.args.shift)
-        end
-        self.options[:command] ||= self.options[:project_name] ? :create_project : :update_project
-        self.options[:framework] ||= :compass
-        self.options[:project_type] ||= :stand_alone
-      end
-
-      def trim_trailing_separator(path)
-        path[-1..-1] == File::SEPARATOR ? path[0..-2] : path
-      end
-
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: compass [options] [project]
-
-Description:
-  The compass command line tool will help you create and manage the stylesheets for your project.
-  
-  To get started on a stand-alone project based on blueprint:
-
-    compass -f blueprint my_compass_project
-
-  When you change any sass files, you must recompile your project using --update or --watch.
-END
-        opts.separator ''
-        opts.separator 'Mode Options(only specify one):'
-
-        opts.on('-i', '--install', :NONE, "Create a new compass project.",
-                                          "  The default mode when a project is provided.") do
-          self.options[:command] = :create_project
-        end
-
-        opts.on('-u', '--update', :NONE, 'Update the current project.',
-                                         '  This is the default when no project is provided.') do
-          self.options[:command] = :update_project
-        end
-
-        opts.on('-w', '--watch', :NONE, 'Monitor the current project for changes and update') do
-          self.options[:command] = :watch_project
-          self.options[:quiet] = true
-        end
-
-        opts.on('-p', '--pattern PATTERN', 'Stamp out a pattern into the current project.',
-                                           '  Must be used with -f.') do |pattern|
-          self.options[:command] = :stamp_pattern
-          self.options[:pattern] = pattern
-        end
-
-        opts.on('--write-configuration', "Write the current configuration to the configuration file.") do
-          self.options[:command] = :write_configuration
-        end
-
-        opts.on('--list-frameworks', "List compass frameworks available to use.") do
-          self.options[:command] = :list_frameworks
-        end
-
-        opts.on('--validate', :NONE, 'Validate your project\'s compiled css. Requires Java.') do
-          self.options[:command] = :validate_project
-        end
-
-        opts.on('--grid-img [DIMENSIONS]', 'Generate a background image to test grid alignment.',
-                                           '  Dimension is given as <column_width>+<gutter_width>.',
-                                           '  Defaults to 30+10.') do |dimensions|
-          self.options[:grid_dimensions] = dimensions || "30+10"
-          unless self.options[:grid_dimensions] =~ /^\d+\+\d+$/
-            puts "Please enter your dimensions as <column_width>+<gutter_width>. E.g. 20+5 or 30+10."
-            exit
-          end
-          self.options[:command] = :generate_grid_background
-        end
-
-        opts.separator ''
-        opts.separator 'Install/Pattern Options:'
-
-        opts.on('-f FRAMEWORK', '--framework FRAMEWORK', 'Use the specified framework. Only one may be specified.') do |framework|
-          self.options[:framework] = framework
-        end
-
-        opts.on('-n', '--pattern-name NAME', 'The name to use when stamping a pattern.',
-                                             '  Must be used in combination with -p.') do |name|
-          self.options[:pattern_name] = name
-        end
-
-        opts.on('--rails', "Sets the project type to a rails project.") do
-          self.options[:project_type] = :rails
-        end
-
-        opts.separator ''
-        opts.separator 'Configuration Options:'
-
-        opts.on('-c', '--config CONFIG_FILE', 'Specify the location of the configuration file explicitly.') do |configuration_file|
-          self.options[:configuration_file] = configuration_file
-        end
-
-        opts.on('--sass-dir SRC_DIR', "The source directory where you keep your sass stylesheets.") do |sass_dir|
-          self.options[:sass_dir] = sass_dir
-        end
-
-        opts.on('--css-dir CSS_DIR', "The target directory where you keep your css stylesheets.") do |css_dir|
-          self.options[:css_dir] = css_dir
-        end
-
-        opts.on('--images-dir IMAGES_DIR', "The directory where you keep your images.") do |images_dir|
-          self.options[:images_dir] = images_dir
-        end
-
-        opts.on('--javascripts-dir JS_DIR', "The directory where you keep your javascripts.") do |javascripts_dir|
-          self.options[:javascripts_dir] = javascripts_dir
-        end
-
-        opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment.',
-                '  One of: development, production (default)') do |env|
-          self.options[:environment] = env
-        end
-
-        opts.on('-s STYLE', '--output-style STYLE', [:nested, :expanded, :compact, :compressed], 'Select a CSS output mode.',
-                 '  One of: nested, expanded, compact, compressed') do |style|
-          self.options[:output_style] = style
-        end
-
-        opts.on('--relative-assets', :NONE, 'Make compass asset helpers generate relative urls to assets.') do
-          self.options[:relative_assets] = true
-        end
-
-        opts.separator ''
-        opts.separator 'General Options:'
-
-        opts.on('-r LIBRARY', '--require LIBRARY', "Require the given ruby LIBRARY before running commands.",
-                                                   "  This is used to access compass plugins without having a",
-                                                   "  project configuration file.") do |library|
-          ::Compass.configuration.require library
-        end
-        
-        opts.on('-q', '--quiet', :NONE, 'Quiet mode.') do
-          self.options[:quiet] = true
-        end
-
-        opts.on('--dry-run', :NONE, 'Dry Run. Tells you what it plans to do.') do
-          self.options[:dry_run] = true
-        end
-
-        opts.on('--trace', :NONE, 'Show a full stacktrace on error') do
-          self.options[:trace] = true
-        end
-        
-        opts.on('--force', :NONE, 'Force. Allows some failing commands to succeed instead.') do
-          self.options[:force] = true
-        end
-
-        opts.on('--imports', :NONE, 'Emit an imports suitable for passing to the sass command-line.',
-                                    '  Example: sass `compass --imports`',
-                                    '  Note: Compass\'s Sass extensions will not be available.') do
-          print ::Compass::Frameworks::ALL.map{|f| "-I #{f.stylesheets_directory}"}.join(' ')
-          exit
-        end
-
-        opts.on('--install-dir', :NONE, 'Emit the location where compass is installed.') do
-          puts ::Compass.base_directory
-          exit
-        end
-
-        opts.on_tail("-?", "-h", "--help", "Show this message") do
-          puts opts
-          exit
-        end
-
-        opts.on_tail("-v", "--version", "Print version") do
-          self.options[:command] = :print_version
-        end
-
-      end
-      
-      def do_command(command)
-        command_class_name = command.to_s.split(/_/).map{|p| p.capitalize}.join('')
-        command_class = eval("::Compass::Commands::#{command_class_name}")
-        command_class.new(Dir.getwd, options).execute
-      end
-
-    end
-  end
-end
-
-Dir.glob(File.join(File.dirname(__FILE__), 'commands', "*.rb")).each do |file|
-  require file
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/frameworks.rb

@@ -1,29 +0,0 @@
-module Compass
-  module Frameworks
-    ALL = []
-    class Framework
-      attr_accessor :name
-      attr_accessor :templates_directory, :stylesheets_directory
-      def initialize(name, *arguments)
-        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
-        path = options[:path] || arguments.shift
-        @name = name
-        @templates_directory = options[:templates_directory] || File.join(path, 'templates')
-        @stylesheets_directory = options[:stylesheets_directory] || File.join(path, 'stylesheets')
-      end
-    end
-    def register(name, *arguments)
-      ALL << Framework.new(name, *arguments)
-    end
-    def [](name)
-      ALL.detect{|f| f.name.to_s == name.to_s}
-    end
-    module_function :register, :[]
-  end
-end
-
-# Import all of the default frameworks.
-default_frameworks_directory = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'frameworks'))
-Dir.glob(File.join(default_frameworks_directory, "*.rb")).each do |framework|
-  require framework
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/grid_builder.rb

@@ -1,72 +0,0 @@
-# This file came from the Blueprint Project
-begin
-  require 'rubygems'
-  gem 'rmagick'
-  require 'rvg/rvg'
-rescue Exception => e
-end
-
-module Compass
-  # Uses ImageMagick and RMagick to generate grid.png file
-  class GridBuilder
-    include Actions
-
-    begin
-      include Magick
-    rescue Exception => e
-    end
-
-    attr_reader :column_width, :gutter_width, :output_path, :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>:output_path</tt> -- Output path of grid.png file
-    def initialize(options={})
-      @able_to_generate = Magick::Long_version rescue false
-      return unless @able_to_generate
-      @column_width = options[:column_width]
-      @gutter_width = options[:gutter_width]
-      @output_path  = options[:output_path]
-      @options = options
-    end
-
-    def working_path
-      options[:working_path]
-    end
-  
-    # generates (overwriting if necessary) grid.png image to be tiled in background
-    def generate!
-      return false unless self.able_to_generate
-      total_width = self.column_width + self.gutter_width
-      height = 20
-      RVG::dpi = 100
-
-      rvg = RVG.new((total_width.to_f/RVG::dpi).in, (height.to_f/RVG::dpi).in).viewbox(0, 0, total_width, height) do |canvas|
-        canvas.background_fill = 'white'
-
-        canvas.g do |column|
-          column.rect(self.column_width, height).styles(:fill => "#e8effb")
-        end
-
-        canvas.g do |baseline|
-          baseline.line(0, (height - 1), total_width, (height- 1)).styles(:fill => "#e9e9e9")
-        end
-      end
-
-      filename = File.join(self.output_path, "grid.png")
-      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 self.output_path
-      logger.record((overwrite ? :overwrite : :create), basename(filename))
-      rvg.draw.write(filename)
-    end
-  end
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/installers.rb

@@ -1,5 +0,0 @@
-require File.join(File.dirname(__FILE__), 'installers', 'manifest')
-require File.join(File.dirname(__FILE__), 'installers', 'base')
-require File.join(File.dirname(__FILE__), 'installers', 'stand_alone')
-require File.join(File.dirname(__FILE__), 'installers', 'rails')
-

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/installers/base.rb

@@ -1,158 +0,0 @@
-module Compass
-  module Installers
-
-    class Base
-
-      include Actions
-
-      attr_accessor :template_path, :target_path, :working_path
-      attr_accessor :options
-      attr_accessor :manifest
-
-      def initialize(template_path, target_path, options = {})
-        @template_path = template_path
-        @target_path = target_path
-        @working_path = Dir.getwd
-        @options = options
-        @manifest = Manifest.new(manifest_file) if template_path
-        self.logger = options[:logger]
-      end
-
-      def manifest_file
-        @manifest_file ||= File.join(template_path, "manifest.rb")
-      end
-
-      [:css_dir, :sass_dir, :images_dir, :javascripts_dir].each do |dir|
-        define_method dir do
-          Compass.configuration.send(dir)
-        end
-      end
-
-      # Initializes the project to work with compass
-      def init
-        dirs = manifest.map do |entry|
-          File.dirname(send("install_location_for_#{entry.type}", entry.to, entry.options))
-        end
-
-        if manifest.has_stylesheet?
-          dirs << sass_dir
-          dirs << css_dir
-        end
-
-        dirs.uniq.sort.each do |dir|
-          directory targetize(dir)
-        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(options = {})
-        prepare
-        install
-        finalize unless options[:skip_finalization]
-      end
-
-      # The default prepare method -- it is a no-op.
-      # Generally you would create required directories, etc.
-      def prepare
-      end
-
-      def configure_option_with_default(opt)
-        value = options[opt]
-        value ||= begin
-          default_method = "default_#{opt}".to_sym
-          send(default_method) if respond_to?(default_method)
-        end
-        send("#{opt}=", value)
-      end
-
-      # The default install method. Calls install_<type> methods in the order specified by the manifest.
-      def install
-        manifest.each do |entry|
-          send("install_#{entry.type}", entry.from, entry.to, entry.options)
-        end
-      end
-
-      # The default finalize method -- it is a no-op.
-      # This could print out a message or something.
-      def finalize
-      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))
-          copy from, to, nil, (installer_opts[:binary] || options[:binary])
-        end
-      end
-
-      installer :stylesheet do |to|
-        "#{sass_dir}/#{pattern_name_as_dir}#{to}"
-      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 :file do |to|
-        "#{pattern_name_as_dir}#{to}"
-      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
-
-      def stylesheet_links
-        html = "<head>\n"
-        manifest.each_stylesheet do |stylesheet|
-          # Skip partials.
-          next if File.basename(stylesheet.from)[0..0] == "_"
-          media = if stylesheet.options[:media]
-            %Q{ media="#{stylesheet.options[:media]}"}
-          end
-          ss_line = %Q{  <link href="/stylesheets/#{stylesheet.to.sub(/\.sass$/,'.css')}"#{media} rel="stylesheet" type="text/css" />}
-          if stylesheet.options[:condition]
-            ss_line = "  <!--[if #{stylesheet.options[:condition]}]>\n    #{ss_line}\n  <![endif]-->"
-          end
-          html << ss_line + "\n"
-        end
-        html << "</head>"
-      end
-    end
-  end
-end