middleman 0.11.5 → 0.12.0.pre

data/lib/middleman/vendor/gems/gems/configuration-1.1.0/samples/a.rb

@@ -0,0 +1,11 @@
+#
+# basic usage is quite, simple, load the config and use it's values.  the
+# config syntax is fairly obvious, i think, but note that it *is* ruby and any
+# ruby can be included.  also note that each config is named, allowing
+# multiple configs to be places in one file 
+#
+  require 'configuration'
+ 
+  c = Configuration.load 'a'
+
+  p c.a + c.b - c.c

data/lib/middleman/vendor/gems/gems/configuration-1.1.0/samples/b.rb

@@ -0,0 +1,11 @@
+#
+# configuration.rb supports a very natural nesting syntax.  note how values
+# are scoped in a POLS fashion
+#
+  require 'configuration'
+
+  c = Configuration.for 'b' 
+
+  p c.www.url
+  p c.db.url
+  p c.mail.url

data/lib/middleman/vendor/gems/gems/configuration-1.1.0/samples/c.rb

@@ -0,0 +1,11 @@
+#
+# configuration.rb let's you keep code very dry.
+#
+
+  require 'configuration'
+
+  Configuration.load 'c'
+
+  p Configuration.for('development').db
+  p Configuration.for('production').db
+  p Configuration.for('testing').db

data/lib/middleman/vendor/gems/gems/configuration-1.1.0/samples/d.rb

@@ -0,0 +1,14 @@
+#
+# configuration.rb makes use of an external blank slate dsl, this means that
+# you Configuration objects do, in fact, have all built-in ruby methods such
+# as #inspect, etc, *unless* you configure over the top of them.  the effect
+# is a configuration object that behaves like a nice ruby object, but which
+# allows *any* key to be configured
+#
+  require 'configuration'
+
+  c = Configuration.for 'd' 
+
+  p c.object_id
+  p c.inspect
+  p c.p

data/lib/middleman/vendor/gems/gems/configuration-1.1.0/samples/e.rb

@@ -0,0 +1,12 @@
+#
+# configuration.rb uses a totally clean slate dsl for the block.  if you need
+# to access base Object methods you can do this
+#
+
+  require 'configuration'
+
+  c = Configuration.for 'e'
+
+  p c.foo
+  p c.bar
+  p c.foobar

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/ChangeLog

@@ -0,0 +1,46 @@
+Revision history for Ruby library Diff::LCS. Unless explicitly noted otherwise,
+all changes are produced by Austin Ziegler <diff-lcs@halostatue.ca>.
+
+== Diff::LCS 1.1.2
+* Fixed a problem reported by Mauricio Fernandez in htmldiff. Future versions
+  of Diff::LCS will be removing this program.
+
+== Diff::LCS 1.1.1
+* Fixed bug #891:
+  http://rubyforge.org/tracker/?func=detail&atid=407&aid=891&group_id=84
+* Fixed a problem with callback initialisation code (it assumed that all
+  callbacks passed as classes can be initialised; now, it rescues
+  NoMethodError in the event of private :new being called).
+* Modified the non-initialisable callbacks to have a private #new method.
+* Moved ldiff core code to Diff::LCS::Ldiff (diff/lcs/ldiff.rb).
+
+== Diff::LCS 1.1.0
+* Eliminated the need for Diff::LCS::Event and removed it.
+* Added a contextual diff callback, Diff::LCS::ContextDiffCallback.
+* Implemented patching/unpatching for standard Diff callback output formats
+  with both #diff and #sdiff.
+* Extensive documentation changes.
+
+== Diff::LCS 1.0.4
+* Fixed a problem with bin/ldiff output, especially for unified format.
+  Newlines that should have been present weren't.
+* Changed the .tar.gz installer to generate Windows batch files if ones do not
+  exist already. Removed the existing batch files as they didn't work.
+
+== Diff::LCS 1.0.3
+* Fixed a problem with #traverse_sequences where the first difference from the
+  left sequence might not be appropriately captured.
+
+== Diff::LCS 1.0.2
+* Fixed an issue with ldiff not working because actions were changed from
+  symbols to strings.
+
+== Diff::LCS 1.0.1
+* Minor modifications to the gemspec, the README.
+* Renamed the diff program to ldiff (as well as the companion batch file) so as
+  to not collide with the standard diff program.
+* Fixed issues with RubyGEMs. Requires RubyGems > 0.6.1 or >= 0.6.1 with the
+  latest CVS version.
+
+== Diff::LCS 1.0
+* Initial release based mostly on Perl's Algorithm::Diff.

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/Install

@@ -0,0 +1,6 @@
+Installing this package is as simple as:
+
+% ruby install.rb
+
+Alternatively, you can use the RubyGem version of Diff::LCS available as
+diff-lcs-1.1.2.gem from the usual sources.

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/README

@@ -0,0 +1,76 @@
+Diff::LCS README
+================
+Diff::LCS is a port of Algorithm::Diff[1] that uses the McIlroy-Hunt
+longest common subsequence (LCS) algorithm to compute intelligent
+differences between two sequenced enumerable containers[2]. The
+implementation is based on Mario I. Wolczko's[3] Smalltalk version (1.2,
+1993)[4] and Ned Konz's[5] Perl version (Algorithm::Diff)[6].
+
+This release is version 1.1.2, fixing an htmldiff bug in 1.1.1. Version 1.1.0
+added new features, including the ability to #patch and #unpatch changes as
+well as a new contextual diff callback, Diff::LCS::ContextDiffCallbacks, that
+should improve the context sensitivity of patching.
+
+Using this module is quite simple. By default, Diff::LCS does not extend
+objects with the Diff::LCS interface, but will be called as if it were a
+function:
+
+  require 'diff/lcs'
+
+  seq1 = %w(a b c e h j l m n p)
+  seq2 = %w(b c d e f j k l m r s t)
+
+  lcs = Diff::LCS.LCS(seq1, seq2)
+  diffs = Diff::LCS.diff(seq1, seq2)
+  sdiff = Diff::LCS.sdiff(seq1, seq2)
+  seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
+  bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
+  seq2 == Diff::LCS.patch!(seq1, diffs)
+  seq1 == Diff::LCS.unpatch!(seq2, diffs)
+  seq2 == Diff::LCS.patch!(seq1, sdiff)
+  seq1 == Diff::LCS.unpatch!(seq2, sdiff)
+
+Objects can be extended with Diff::LCS:
+
+  seq1.extend(Diff::LCS)
+  lcs = seq1.lcs(seq2)
+  diffs = seq1.diff(seq2)
+  sdiff = seq1.sdiff(seq2)
+  seq = seq1.traverse_sequences(seq2, callback_obj)
+  bal = seq1.traverse_balanced(seq2, callback_obj)
+  seq2 == seq1.patch!(diffs)
+  seq1 == seq2.unpatch!(diffs)
+  seq2 == seq1.patch!(sdiff)
+  seq1 == seq2.unpatch!(sdiff)
+
+By requiring 'diff/lcs/array' or 'diff/lcs/string', Array or String will
+be extended for use this way.
+
+Copyright
+=========
+# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
+#   adapted from:
+#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
+#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
+#   implements McIlroy-Hunt diff algorithm
+#
+# This program is free software. It may be redistributed and/or modified
+# under the terms of the GPL version 2 (or later), the Perl Artistic
+# licence, or the Ruby licence.
+# 
+# $Id: README,v 1.7 2004/10/17 20:31:10 austin Exp $
+
+Footnotes
+=========
+[1] This library is called Diff::LCS because there are multiple
+    Ruby libraries called Algorithm::Diff maintained by other authors.
+[2] By sequenced enumerable, I mean that the order of enumeration is
+    predictable and consistent for the same set of data. While it is
+    theoretically possible to generate a diff for unordereded hash, it
+    will only be meaningful if the enumeration of the hashes is
+    consistent. In general, this will mean that containers that behave
+    like String or Array will perform best.
+[3] mario@wolczko.com
+[4] ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
+[5] perl@bike-nomad.com
+[6] http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/Rakefile

@@ -0,0 +1,116 @@
+#! /usr/bin/env rake
+$LOAD_PATH.unshift('lib')
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'diff/lcs'
+require 'archive/tar/minitar'
+require 'zlib'
+
+DISTDIR = "diff-lcs-#{Diff::LCS::VERSION}"
+TARDIST = "../#{DISTDIR}.tar.gz"
+
+DATE_RE = %r<(\d{4})[./-]?(\d{2})[./-]?(\d{2})(?:[\sT]?(\d{2})[:.]?(\d{2})[:.]?(\d{2})?)?>
+
+if ENV['RELEASE_DATE']
+  year, month, day, hour, minute, second = DATE_RE.match(ENV['RELEASE_DATE']).captures
+  year ||= 0
+  month ||= 0
+  day ||= 0
+  hour ||= 0
+  minute ||= 0
+  second ||= 0
+  ReleaseDate = Time.mktime(year, month, day, hour, minute, second)
+else
+  ReleaseDate = nil
+end
+
+task :test do |t|
+  require 'test/unit/testsuite'
+  require 'test/unit/ui/console/testrunner'
+
+  runner = Test::Unit::UI::Console::TestRunner
+
+  $LOAD_PATH.unshift('tests')
+  $stderr.puts "Checking for test cases:" if t.verbose
+  Dir['tests/*test*.rb'].each do |testcase|
+    $stderr.puts "\t#{testcase}" if t.verbose
+    load testcase
+  end
+
+  suite = Test::Unit::TestSuite.new
+
+  ObjectSpace.each_object(Class) do |testcase|
+    suite << testcase.suite if testcase < Test::Unit::TestCase
+  end
+
+  runner.run(suite)
+end
+
+spec = eval(File.read("diff-lcs.gemspec"))
+desc "Build the RubyGem for Diff::LCS."
+task :gem => [ :test ]
+Rake::GemPackageTask.new(spec) do |g|
+  g.need_tar    = false
+  g.need_zip    = false
+  g.package_dir = ".."
+end
+
+desc "Build an Diff::LCS .tar.gz distribution."
+task :tar => [ TARDIST ]
+file TARDIST => [ :test ] do |t|
+  current = File.basename(Dir.pwd)
+  Dir.chdir("..") do
+    begin
+      files = Dir["#{current}/**/*"].select { |dd| dd !~ %r{(?:/CVS/?|~$)} }
+      files.map! do |dd|
+        ddnew = dd.gsub(/^#{current}/, DISTDIR)
+        mtime = ReleaseDate || File.stat(dd).mtime
+        if File.directory?(dd)
+          { :name => ddnew, :mode => 0755, :dir => true, :mtime => mtime }
+        else
+          if dd =~ %r{bin/}
+            mode = 0755
+          else
+            mode = 0644
+          end
+          data = File.read(dd)
+          { :name => ddnew, :mode => mode, :data => data, :size => data.size,
+            :mtime => mtime }
+        end
+      end
+
+      ff = File.open(t.name.gsub(%r{^\.\./}o, ''), "wb")
+      gz = Zlib::GzipWriter.new(ff)
+      tw = Archive::Tar::Minitar::Writer.new(gz)
+
+      files.each do |entry|
+        if entry[:dir]
+          tw.mkdir(entry[:name], entry)
+        else
+          tw.add_file_simple(entry[:name], entry) { |os| os.write(entry[:data]) }
+        end
+      end
+    ensure
+      tw.close if tw
+      gz.close if gz
+    end
+  end
+end
+task TARDIST => [ :test ]
+
+def sign(file)
+  sh %("C:\\Program Files\\Windows Privacy Tools\\GnuPG\\Gpg.exe" -ba #{file}) rescue nil
+end
+
+task :signtar => [ :tar ] do
+  sign TARDIST
+end
+task :signgem => [ :gem ] do
+  sign "../#{DISTDIR}.gem"
+end
+
+desc "Build everything."
+task :default => [ :signtar, :signgem ] do
+end

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/bin/htmldiff

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
+#   adapted from:
+#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
+#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
+#   implements McIlroy-Hunt diff algorithm
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+# Ruby licence.
+# 
+# $Id: htmldiff,v 1.6 2004/10/17 19:33:21 austin Exp $
+#++
+
+begin
+  require 'rubygems'
+  require_gem 'diff-lcs', "1.1.1"
+  require 'diff/lcs/string'
+rescue LoadError
+  require 'diff/lcs'
+  require 'diff/lcs/string'
+end
+
+require 'text/format'
+
+class HTMLDiff #:nodoc:
+  attr_accessor :output
+
+  def initialize(output)
+    @output = output
+  end
+
+    # This will be called with both lines are the same
+  def match(event)
+    @output << %Q|<pre class="match">#{event.old_element}</pre>\n|
+  end
+
+    # This will be called when there is a line in A that isn't in B
+  def discard_a(event)
+    @output << %Q|<pre class="only_a">#{event.old_element}</pre>\n|
+  end
+
+    # This will be called when there is a line in B that isn't in A
+  def discard_b(event)
+    @output << %Q|<pre class="only_b">#{event.new_element}</pre>\n|
+  end
+end
+
+if ARGV.size != 2
+  puts "usage: #{File.basename($0)} old new > output.html"
+  exit 255
+end
+
+hd = HTMLDiff.new($stdout)
+tf = Text::Format.new
+tf.tabstop = 4
+
+preprocess = lambda { |line| tf.expand(line.chomp) }
+
+a = IO.readlines(ARGV[0]).map(&preprocess)
+b = IO.readlines(ARGV[1]).map(&preprocess)
+
+$stdout.write <<-START
+<html>
+  <head>
+    <title>diff #{ARGV[0]} #{ARGV[1]}</title>
+    <style>
+  body { margin: 0; }
+  .diff
+  {
+    border: 1px solid black;
+    margin: 1em 2em;
+  }
+  pre
+  {
+    padding-left: 1em;
+    margin: 0;
+    font-family: Lucida, Courier, monospaced;
+		white-space: pre;
+  }
+  .match { }
+  .only_a
+  {
+    background-color: #fdd;
+    color: red;
+    text-decoration: line-through;
+  }
+  .only_b
+  {
+    background-color: #ddf;
+    color: blue;
+    border-left: 3px solid blue
+  }
+  h1 { margin-left: 2em; }
+    </style>
+  </head>
+  <body>
+    <h1>diff&nbsp;
+        <span class="only_a">#{ARGV[0]}</span>&nbsp;
+        <span class="only_b">#{ARGV[1]}</span>
+    </h1>
+    <div class="diff">
+START
+
+Diff::LCS.traverse_sequences(a, b, hd)
+
+$stdout.write <<-END
+    </div>
+  </body>
+</html>
+END

data/lib/middleman/vendor/gems/gems/diff-lcs-1.1.2/bin/ldiff

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
+#   adapted from:
+#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
+#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
+#   implements McIlroy-Hunt diff algorithm
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+# Ruby licence.
+# 
+# $Id: ldiff,v 1.6 2004/09/26 01:35:57 austin Exp $
+#++
+
+  # 1) Try to load Ruwiki from the gem.
+  # 2) Try to load Ruwiki from $LOAD_PATH.
+  # 3) Modify $LOAD_PATH and try to load it from the modified $LOAD_PATH.
+  # 4) Fail hard.
+load_state = 1
+  begin
+    if 1 == load_state
+      require 'rubygems'
+      require_gem 'diff-lcs', '= 1.1.1'
+    else
+      require 'diff/lcs'
+    end
+  rescue LoadError
+    load_state += 1
+
+    case load_state
+    when 3
+      $LOAD_PATH.unshift "#{File.dirname($0)}/../lib"
+    when 4
+      $LOAD_PATH.shift
+      $LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+    when 5
+      raise
+    end
+    retry
+  end
+
+require 'diff/lcs/ldiff'
+
+exit Diff::LCS::Ldiff.run(ARGV)