middleman 0.13.1 → 0.13.2.pre

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/lazy_module.rb

@@ -1,18 +0,0 @@
-class LazyModule < Module
-  def self.new(&blk)
-    # passing no-op block overrides &blk
-    m = super{ }
-    class << m
-      include ClassMethods
-    end
-    m.lazy_evaluated_body = blk
-    m
-  end
-
-  module ClassMethods
-    attr_accessor :lazy_evaluated_body
-    def included(host)
-      host.class_eval(&@lazy_evaluated_body)
-    end
-  end
-end

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/logger.rb

@@ -1,198 +0,0 @@
-require "time" # httpdate
-# ==== Public Extlib Logger API
-#
-# To replace an existing logger with a new one:
-#  Extlib::Logger.set_log(log{String, IO},level{Symbol, String})
-#
-# Available logging levels are
-#   Extlib::Logger::{ Fatal, Error, Warn, Info, Debug }
-#
-# Logging via:
-#   Extlib.logger.fatal(message<String>,&block)
-#   Extlib.logger.error(message<String>,&block)
-#   Extlib.logger.warn(message<String>,&block)
-#   Extlib.logger.info(message<String>,&block)
-#   Extlib.logger.debug(message<String>,&block)
-#
-# Logging with autoflush:
-#   Extlib.logger.fatal!(message<String>,&block)
-#   Extlib.logger.error!(message<String>,&block)
-#   Extlib.logger.warn!(message<String>,&block)
-#   Extlib.logger.info!(message<String>,&block)
-#   Extlib.logger.debug!(message<String>,&block)
-#
-# Flush the buffer to
-#   Extlib.logger.flush
-#
-# Remove the current log object
-#   Extlib.logger.close
-#
-# ==== Private Extlib Logger API
-#
-# To initialize the logger you create a new object, proxies to set_log.
-#   Extlib::Logger.new(log{String, IO},level{Symbol, String})
-module Extlib
-
-  class << self
-    attr_accessor :logger
-  end
-
-  class Logger
-
-    attr_accessor :level
-    attr_accessor :delimiter
-    attr_accessor :auto_flush
-    attr_reader   :buffer
-    attr_reader   :log
-    attr_reader   :init_args
-
-    # ==== Notes
-    # Ruby (standard) logger levels:
-    # :fatal:: An unhandleable error that results in a program crash
-    # :error:: A handleable error condition
-    # :warn:: A warning
-    # :info:: generic (useful) information about system operation
-    # :debug:: low-level information for developers
-    Levels =
-    {
-      :fatal => 7,
-      :error => 6,
-      :warn  => 4,
-      :info  => 3,
-      :debug => 0
-    }
-
-    private
-
-    # Readies a log for writing.
-    #
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    def initialize_log(log)
-      close if @log # be sure that we don't leave open files laying around.
-
-      if log.respond_to?(:write)
-        @log = log
-      elsif File.exist?(log)
-        @log = open(log, (File::WRONLY | File::APPEND))
-        @log.sync = true
-      else
-        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
-        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
-        @log.sync = true
-        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
-      end
-    end
-
-    public
-
-    # To initialize the logger you create a new object, proxies to set_log.
-    #
-    # ==== Parameters
-    # *args:: Arguments to create the log from. See set_logs for specifics.
-    def initialize(*args)
-      @init_args = args
-      set_log(*args)
-    end
-
-    # Replaces an existing logger with a new one.
-    #
-    # ==== Parameters
-    # log<IO, String>:: Either an IO object or a name of a logfile.
-    # log_level<~to_sym>::
-    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
-    #   production environment and :debug otherwise.
-    # delimiter<String>::
-    #   Delimiter to use between message sections. Defaults to " ~ ".
-    # auto_flush<Boolean>::
-    #   Whether the log should automatically flush after new messages are
-    #   added. Defaults to false.
-    def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
-      if log_level && Levels[log_level.to_sym]
-        @level = Levels[log_level.to_sym]
-      else
-        @level = Levels[:debug]
-      end
-      @buffer     = []
-      @delimiter  = delimiter
-      @auto_flush = auto_flush
-
-      initialize_log(log)
-    end
-
-    # Flush the entire buffer to the log object.
-    def flush
-      return unless @buffer.size > 0
-      @log.write(@buffer.slice!(0..-1).join)
-    end
-
-    # Close and remove the current log object.
-    def close
-      flush
-      @log.close if @log.respond_to?(:close) && !@log.tty?
-      @log = nil
-    end
-
-    # Appends a message to the log. The methods yield to an optional block and
-    # the output of this block will be appended to the message.
-    #
-    # ==== Parameters
-    # string<String>:: The message to be logged. Defaults to nil.
-    #
-    # ==== Returns
-    # String:: The resulting message added to the log file.
-    def <<(string = nil)
-      message = ""
-      message << delimiter
-      message << string if string
-      message << "\n" unless message[-1] == ?\n
-      @buffer << message
-      flush if @auto_flush
-
-      message
-    end
-    alias :push :<<
-
-    # Generate the logging methods for Extlib.logger for each log level.
-    Levels.each_pair do |name, number|
-      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}(message = nil)
-        self << message if #{number} >= level
-        self
-      end
-
-      # Appends a message to the log if the log level is at least as high as
-      # the log level of the logger. The bang! version of the method also auto
-      # flushes the log buffer to disk.
-      #
-      # ==== Parameters
-      # string<String>:: The message to be logged. Defaults to nil.
-      #
-      # ==== Returns
-      # self:: The logger object for chaining.
-      def #{name}!(message = nil)
-        self << message if #{number} >= level
-        flush if #{number} >= level
-        self
-      end
-
-      # ==== Returns
-      # Boolean:: True if this level will be logged by this logger.
-      def #{name}?
-        #{number} >= level
-      end
-      LEVELMETHODS
-    end
-
-  end
-
-end

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/mash.rb

@@ -1,155 +0,0 @@
-# This class has dubious semantics and we only have it so that people can write
-# params[:key] instead of params['key'].
-class Mash < Hash
-
-  # @param constructor<Object>
-  #   The default value for the mash. Defaults to an empty hash.
-  #
-  # @details [Alternatives]
-  #   If constructor is a Hash, a new mash will be created based on the keys of
-  #   the hash and no default value will be set.
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash)
-      super()
-      update(constructor)
-    else
-      super(constructor)
-    end
-  end
-
-  # @param key<Object> The default value for the mash. Defaults to nil.
-  #
-  # @details [Alternatives]
-  #   If key is a Symbol and it is a key in the mash, then the default value will
-  #   be set to the value matching the key.
-  def default(key = nil)
-    if key.is_a?(Symbol) && include?(key = key.to_s)
-      self[key]
-    else
-      super
-    end
-  end
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # @param key<Object> The key to set.
-  # @param value<Object>
-  #   The value to set the key to.
-  #
-  # @see Mash#convert_key
-  # @see Mash#convert_value
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value))
-  end
-
-  # @param other_hash<Hash>
-  #   A hash to update values in the mash with. The keys and the values will be
-  #   converted to Mash format.
-  #
-  # @return [Mash] The updated mash.
-  def update(other_hash)
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-    self
-  end
-
-  alias_method :merge!, :update
-
-  # @param key<Object> The key to check for. This will be run through convert_key.
-  #
-  # @return [Boolean] True if the key exists in the mash.
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  # def include? def has_key? def member?
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # @param key<Object> The key to fetch. This will be run through convert_key.
-  # @param *extras<Array> Default value.
-  #
-  # @return [Object] The value at key or the default value.
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  # @param *indices<Array>
-  #   The keys to retrieve values for. These will be run through +convert_key+.
-  #
-  # @return [Array] The values at each of the provided keys
-  def values_at(*indices)
-    indices.collect {|key| self[convert_key(key)]}
-  end
-
-  # @param hash<Hash> The hash to merge with the mash.
-  #
-  # @return [Mash] A new mash with the hash values merged in.
-  def merge(hash)
-    self.dup.update(hash)
-  end
-
-  # @param key<Object>
-  #   The key to delete from the mash.\
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
-  #
-  # @return [Mash] A new mash without the selected keys.
-  #
-  # @example
-  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { "two" => 2, "three" => 3 }
-  def except(*keys)
-    super(*keys.map {|k| convert_key(k)})
-  end
-
-  # Used to provide the same interface as Hash.
-  #
-  # @return [Mash] This mash unchanged.
-  def stringify_keys!; self end
-
-  # @return [Hash] The mash as a Hash with symbolized keys.
-  def symbolize_keys
-    h = Hash.new(default)
-    each { |key, val| h[key.to_sym] = val }
-    h
-  end
-
-  # @return [Hash] The mash as a Hash with string keys.
-  def to_hash
-    Hash.new(default).merge(self)
-  end
-
-  protected
-  # @param key<Object> The key to convert.
-  #
-  # @param [Object]
-  #   The converted key. If the key was a symbol, it will be converted to a
-  #   string.
-  #
-  # @api private
-  def convert_key(key)
-    key.kind_of?(Symbol) ? key.to_s : key
-  end
-
-  # @param value<Object> The value to convert.
-  #
-  # @return [Object]
-  #   The converted value. A Hash or an Array of hashes, will be converted to
-  #   their Mash equivalents.
-  #
-  # @api private
-  def convert_value(value)
-    if value.class == Hash
-      value.to_mash
-    elsif value.is_a?(Array)
-      value.collect { |e| convert_value(e) }
-    else
-      value
-    end
-  end
-end

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/module.rb

@@ -1,47 +0,0 @@
-class Module
-  def find_const(const_name)
-    if const_name[0..1] == '::'
-      Object.full_const_get(const_name[2..-1])
-    else
-      nested_const_lookup(const_name)
-    end
-  end
-
-  def try_dup
-    self
-  end
-
-  private
-
-  # Doesn't do any caching since constants can change with remove_const
-  def nested_const_lookup(const_name)
-    unless equal?(Object)
-      constants = []
-
-      name.split('::').each do |part|
-        const = constants.last || Object
-        constants << const.const_get(part)
-      end
-
-      parts = const_name.split('::')
-
-      # from most to least specific constant, use each as a base and try
-      # to find a constant with the name const_name within them
-      constants.reverse_each do |const|
-        # return the nested constant if available
-        return const if parts.all? do |part|
-          const = if RUBY_VERSION >= '1.9.0'
-            const.const_defined?(part, false) ? const.const_get(part, false) : nil
-          else
-            const.const_defined?(part) ? const.const_get(part) : nil
-          end
-        end
-      end
-    end
-
-    # no relative constant found, fallback to an absolute lookup and
-    # use const_missing if not found
-    Object.full_const_get(const_name)
-  end
-
-end # class Module

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/nil.rb

@@ -1,5 +0,0 @@
-class NilClass
-  def try_dup
-    self
-  end
-end

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/numeric.rb

@@ -1,5 +0,0 @@
-class Numeric
-  def try_dup
-    self
-  end
-end

data/lib/middleman/vendor/gems/ruby/1.8/gems/extlib-0.9.14/lib/extlib/object.rb

@@ -1,175 +0,0 @@
-class Object
-  # Extracts the singleton class, so that metaprogramming can be done on it.
-  #
-  # @return [Class] The meta class.
-  #
-  # @example [Setup]
-  #   class MyString < String; end
-  #
-  #   MyString.instance_eval do
-  #     define_method :foo do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   MyString.meta_class.instance_eval do
-  #     define_method :bar do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   def String.add_meta_var(var)
-  #     self.meta_class.instance_eval do
-  #       define_method var do
-  #         puts "HELLO"
-  #       end
-  #     end
-  #   end
-  #
-  # @example
-  #   MyString.new("Hello").foo #=> "Hello"
-  # @example
-  #   MyString.new("Hello").bar
-  #     #=> NoMethodError: undefined method `bar' for "Hello":MyString
-  # @example
-  #   MyString.foo
-  #     #=> NoMethodError: undefined method `foo' for MyString:Class
-  # @example
-  #   MyString.bar
-  #     #=> MyString
-  # @example
-  #   String.bar
-  #     #=> NoMethodError: undefined method `bar' for String:Class
-  # @example
-  #   MyString.add_meta_var(:x)
-  #   MyString.x #=> HELLO
-  #
-  # @details [Description of Examples]
-  #   As you can see, using #meta_class allows you to execute code (and here,
-  #   define a method) on the metaclass itself. It also allows you to define
-  #   class methods that can be run on subclasses, and then be able to execute
-  #   code on the metaclass of the subclass (here MyString).
-  #
-  #   In this case, we were able to define a class method (add_meta_var) on
-  #   String that was executable by the MyString subclass. It was then able to
-  #   define a method on the subclass by adding it to the MyString metaclass.
-  #
-  #   For more information, you can check out _why's excellent article at:
-  #   http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-  def meta_class() class << self; self end end
-
-  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
-  #
-  # @return [Object] The constant corresponding to the name.
-  def full_const_get(name)
-    list = name.split("::")
-    list.shift if list.first.blank?
-    obj = self
-    list.each do |x|
-      # This is required because const_get tries to look for constants in the
-      # ancestor chain, but we only want constants that are HERE
-      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
-    end
-    obj
-  end
-
-  # @param name<String> The name of the constant to get, e.g. "Merb::Router".
-  # @param value<Object> The value to assign to the constant.
-  #
-  # @return [Object] The constant corresponding to the name.
-  def full_const_set(name, value)
-    list = name.split("::")
-    toplevel = list.first.blank?
-    list.shift if toplevel
-    last = list.pop
-    obj = list.empty? ? Object : Object.full_const_get(list.join("::"))
-    obj.const_set(last, value) if obj && !obj.const_defined?(last)
-  end
-
-  # Defines module from a string name (e.g. Foo::Bar::Baz)
-  # If module already exists, no exception raised.
-  #
-  # @param name<String> The name of the full module name to make
-  #
-  # @return [nil]
-  def make_module(str)
-    mod = str.split("::")
-    current_module = self
-    mod.each do |x|
-      unless current_module.const_defined?(x)
-        current_module.class_eval "module #{x}; end", __FILE__, __LINE__
-      end
-      current_module = current_module.const_get(x)
-    end
-    current_module
-  end
-
-  # @param duck<Symbol, Class, Array> The thing to compare the object to.
-  #
-  # @note
-  #   The behavior of the method depends on the type of duck as follows:
-  #   Symbol:: Check whether the object respond_to?(duck).
-  #   Class:: Check whether the object is_a?(duck).
-  #   Array::
-  #     Check whether the object quacks_like? at least one of the options in the
-  #     array.
-  #
-  # @return [Boolean]
-  #   True if the object quacks like duck.
-  def quacks_like?(duck)
-    case duck
-    when Symbol
-      self.respond_to?(duck)
-    when Class
-      self.is_a?(duck)
-    when Array
-      duck.any? {|d| self.quacks_like?(d) }
-    else
-      false
-    end
-  end
-
-  # Override this in a child if it cannot be dup'ed
-  #
-  # @return [Object]
-  def try_dup
-    self.dup
-  end
-
-  # If receiver is callable, calls it and
-  # returns result. If not, just returns receiver
-  # itself
-  #
-  # @return [Object]
-  def try_call(*args)
-    if self.respond_to?(:call)
-      self.call(*args)
-    else
-      self
-    end
-  end
-
-  # @param arrayish<#include?> Container to check, to see if it includes the object.
-  # @param *more<Array>:: additional args, will be flattened into arrayish
-  #
-  # @return [Boolean]
-  #   True if the object is included in arrayish (+ more)
-  #
-  # @example 1.in?([1,2,3]) #=> true
-  # @example 1.in?(1,2,3) #=> true
-  def in?(arrayish,*more)
-    arrayish = more.unshift(arrayish) unless more.empty?
-    arrayish.include?(self)
-  end
-
-  # Add instance_variable_defined? for backward compatibility
-  # @param variable<Symbol, String>
-  #
-  # @return [Boolean]
-  #   True if the object has the given instance variable defined
-  unless respond_to?(:instance_variable_defined?)
-    def instance_variable_defined?(variable)
-      instance_variables.include?(variable.to_s)
-    end
-  end
-end