iisconfig 0.0.1.pre1

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/test/test-users-guide.rb

@@ -0,0 +1,73 @@
+###
+### $Release: 2.7.0 $
+### copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
+###
+
+require  "#{File.dirname(__FILE__)}/test.rb"
+
+
+class KwarkUsersGuideTest < Test::Unit::TestCase
+
+  DIR = File.expand_path(File.dirname(__FILE__) + '/data/users-guide')
+  CWD = Dir.pwd()
+
+
+  def setup
+    Dir.chdir DIR
+  end
+
+
+  def teardown
+    Dir.chdir CWD
+  end
+
+
+  def _test
+    @name = (caller()[0] =~ /`(.*?)'/) && $1
+    s = File.read(@filename)
+    s =~ /\A\$ (.*?)\n/
+    command = $1
+    expected = $'
+    if ruby19?
+      case @name
+      when 'test_main_program1_result'
+        expected.sub!('["eruby", "items", "x", "_buf"]', '[:_buf, :eruby, :items, :x]')
+      when 'test_main_program2_result'
+        expected.sub!('["_context", "x", "_buf"]', '[:_buf, :x, :_context]')
+      end
+    elsif rubinius?
+      command.sub!(/^ruby\b/, 'rbx')
+      case @name
+      when 'test_main_program1_result'
+        expected.sub!('["eruby", "items", "x", "_buf"]', '["_buf", "eruby", "items", "x"]')
+      when 'test_main_program2_result'
+        expected.sub!('["_context", "x", "_buf"]', '["_buf", "x", "_context"]')
+      end
+    end
+    result = `#{command}`
+    assert_text_equal(expected, result)
+  end
+
+
+  Dir.chdir DIR do
+    filenames = []
+    filenames += Dir.glob('*.result')
+    filenames += Dir.glob('*.source')
+    filenames.each do |filename|
+      name = filename.gsub(/[^\w]/, '_')
+      s = <<-END
+        def test_#{name}
+          # $stderr.puts "*** debug: test_#{name}"
+          @name = '#{name}'
+          @filename = '#{filename}'
+          _test()
+        end
+      END
+      eval s
+    end
+  end
+
+
+  self.post_definition()
+
+end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/test/test.rb

@@ -0,0 +1,45 @@
+##
+## $Release: 2.7.0 $
+## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
+##
+
+
+unless defined?(TESTDIR)
+  TESTDIR = File.dirname(__FILE__)
+  LIBDIR  = TESTDIR == '.' ? '../lib' : File.dirname(TESTDIR) + '/lib'
+  $: << TESTDIR
+  $: << LIBDIR
+end
+
+
+require 'test/unit'
+#require 'test/unit/ui/console/testrunner'
+require 'assert-text-equal'
+require 'yaml'
+require 'testutil'
+require 'erubis'
+
+
+Test::Unit::TestCase.class_eval do
+  if RUBY_VERSION >= "1.9"
+    ## minitest doesn't have 'name()' method
+    def name
+      @name || @__name__
+    end
+    def ruby19
+      yield
+    end
+  else
+    def ruby19
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  require "#{TESTDIR}/test-erubis.rb"
+  require "#{TESTDIR}/test-engines.rb"
+  require "#{TESTDIR}/test-enhancers.rb"
+  require "#{TESTDIR}/test-main.rb"
+  require "#{TESTDIR}/test-users-guide.rb"
+end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/test/testutil.rb

@@ -0,0 +1,111 @@
+###
+### $Release: 2.7.0 $
+### copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
+###
+
+require 'yaml'
+
+require 'test/unit/testcase'
+
+
+
+def ruby18?  # :nodoc:
+  RUBY_VERSION =~ /\A1.8/
+end
+
+def ruby19?  # :nodoc:
+  RUBY_VERSION =~ /\A1.9/
+end
+
+def rubinius?  # :nodoc:
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+end
+
+
+
+class Test::Unit::TestCase
+
+
+  def self.load_yaml_datafile(filename, options={}, &block)  # :nodoc:
+    # read datafile
+    s = File.read(filename)
+    if filename =~ /\.rb$/
+      s =~ /^__END__$/   or raise "*** error: __END__ is not found in '#{filename}'."
+      s = $'
+    end
+    # untabify
+    s = _untabify(s) unless options[:tabify] == false
+    # load yaml document
+    testdata_list = []
+    YAML.load_documents(s) do |ydoc|
+      if ydoc.is_a?(Hash)
+        testdata_list << ydoc
+      elsif ydoc.is_a?(Array)
+        ydoc.each do |hash|
+          raise "testdata should be a mapping." unless hash.is_a?(Hash)
+          testdata_list << hash
+        end
+      else
+        raise "testdata should be a mapping."
+      end
+    end
+    # data check
+    identkey = options[:identkey] || 'name'
+    table = {}
+    testdata_list.each do |hash|
+      ident = hash[identkey]
+      ident          or  raise "*** key '#{identkey}' is required but not found."
+      table[ident]   and raise "*** #{identkey} '#{ident}' is duplicated."
+      table[ident] = hash
+      yield(hash) if block
+    end
+    #
+    return testdata_list
+  end
+
+
+  def self.define_testmethods(testdata_list, options={}, &block)
+    identkey   = options[:identkey]   || 'name'
+    testmethod = options[:testmethod] || '_test'
+    testdata_list.each do |hash|
+      yield(hash) if block
+      ident = hash[identkey]
+      s  =   "def test_#{ident}\n"
+      hash.each do |key, val|
+        s << "  @#{key} = #{val.inspect}\n"
+      end
+      s  <<  "  #{testmethod}\n"
+      s  <<  "end\n"
+      $stderr.puts "*** load_yaml_testdata(): eval_str=<<'END'\n#{s}END" if $DEBUG
+      self.module_eval s
+    end
+  end
+
+
+  def self.post_definition
+    if ENV['TEST']
+      target = "test_#{ENV['TEST']}"
+      self.instance_methods.each do |method_name|
+        m = method_name.to_s
+        private m if m =~ /\Atest_/ && m != target
+      end
+    end
+  end
+
+
+  def self._untabify(str, width=8)
+      return str if str.nil?
+      list = str.split(/\t/, -1)   # if 2nd arg is negative then split() doesn't remove tailing empty strings
+      last = list.pop
+      sb = ''
+      list.each do |s|
+        column = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
+        n = width - (column % width)
+        sb << s << (' ' * n)
+      end
+      sb << last if last
+      return sb
+  end
+
+
+end

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/README.rdoc

@@ -0,0 +1,55 @@
+= Git-Like Interface Command Line Parser
+
+Author::  Dave Copeland (mailto:davetron5000 at g mail dot com)
+Copyright:: Copyright (c) 2010 by Dave Copeland
+License:: Distributes under the Apache License, see LICENSE.txt in the source distro
+
+This is a DSL you can use to create a command line interface like git, gem or svn, in that the first argument is a command, and there are global and command specific flags.
+
+* {Source on Github}[http://github.com/davetron5000/gli]
+* RDoc[http://davetron5000.github.com/gli]
+
+== Use
+
+Install if you need to:
+
+    gem install gli
+
+The simplest way to get started is to create a scaffold project
+
+    gli init my_proj command_name other_command_name
+
+This will create a basic scaffold project in <tt>./my_proj</tt> with:
+
+* executable in <tt>./my_proj/bin/my_proj</tt>.  This file demonstrates most of what you need to describe your command line interface.
+* an empty test in <tt>./my_proj/test/tc_nothing.rb</tt> that can bootstrap your tests
+* a gemspec shell
+* a README shell
+* Rakefile that can generate RDoc, package your Gem and run tests
+* A <tt>Gemfile</tt> suitable for use with Bundler to manage development-time dependencies
+
+== Supported Platforms
+
+Known to work on
+
+* 1.8.7
+* 1.9.2
+* 1.9.3
+* Ruby Enterprise Edition 1.8.7
+* Rubinius 1.0.1
+* JRuby 1.6.4 
+
+If you're interested in other versions of Ruby, let me know, and I'll add them to my test suite
+
+== Documentation
+
+Extensive documentation is {available at the wiki}[https://github.com/davetron5000/gli/wiki].  For API Documentation, start with the GLI module.
+
+== Links
+
+* [http://davetron5000.github.com/gli] - RubyDoc
+* [http://www.github.com/davetron5000/gli] - Source on GitHub
+* [http://www.github.com/davetron5000/gli/wiki] - Documentation Wiki
+* [http://www.github.com/davetron5000/gli/wiki/Changelog] - Changelog
+
+:include:gli.rdoc

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/bin/gli

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# 1.9 adds realpath to resolve symlinks; 1.8 doesn't
+# have this method, so we add it so we get resolved symlinks
+# and compatibility
+unless File.respond_to? :realpath
+  class File #:nodoc:
+    def self.realpath path
+      return realpath(File.readlink(path)) if symlink?(path)
+      path
+    end
+  end
+end
+
+$: << File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../lib') 
+
+require 'gli'
+require 'support/scaffold'
+require 'gli_version'
+
+include GLI
+
+program_desc 'gli allows you to create the scaffolding for a GLI-powered application'
+
+version GLI::VERSION
+desc 'Be verbose'
+switch :v
+
+desc 'Dry run; don''t change the disk'
+switch :n
+
+desc 'Root dir of project'
+long_desc 'This is the directory where the project''s directory will be made, so if you specify a project name ''foo'' and the root dir of ''.'', the directory ''./foo'' will be created'
+default_value '.'
+flag [:r,:root]
+
+desc 'Create a new GLI-based project'
+long_desc <<EOS
+This will create a scaffold command line project that uses GLI
+for command line processing.  Specifically, this will create
+an executable ready to go, as well as a lib and test directory, all
+inside the directory named for your project
+EOS
+arg_name 'project_name [command[ command]*]'
+command [:init,:scaffold] do |c|
+
+  c.desc 'Create an ext dir'
+  c.switch [:e,:ext]
+
+  c.desc 'Do not create a test dir'
+  c.switch [:notest]
+
+  c.desc 'Overwrite/ignore existing files and directories'
+  c.switch [:force]
+
+  c.action do |g,o,args|
+    if args.length < 1
+      raise 'You must specify the name of your project'
+    end
+    Scaffold.create_scaffold(g[:r],!o[:notest],o[:e],args[0],args[1..-1],o[:force],g[:n])
+  end
+end
+
+pre do |global,command,options,args|
+  puts "Executing #{command.name}" if global[:v]
+  true
+end
+
+post do |global,command,options,args|
+  puts "Executed #{command.name}" if global[:v]
+end
+
+exit run(ARGV)

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/gli.rdoc

@@ -0,0 +1,51 @@
+= <tt>gli</tt>
+
+gli allows you to create the scaffolding for a GLI-powered application
+    gli [global options] command_name [command-specific options] [--] arguments...
+
+* Use the command +help+ to get a summary of commands
+* Use the command <tt>help command_name</tt> to get a help for +command_name+
+* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them
+
+== Global Options
+These options are available for any command and are specified before the name of the command
+
+[<tt>-n</tt>] Dry run; dont change the disk
+[<tt>-r, --root=arg</tt>] Root dir of project <i>( default: <tt>.</tt>)</i>
+
+                          This is the directory where the projects directory will be made, so if you specify a project name foo and the root dir of ., the directory ./foo will be created
+
+[<tt>-v</tt>] Be verbose
+== Commands
+[<tt>help</tt>] Shows list of commands or help for one command
+[<tt>init</tt>] Create a new GLI-based project
+
+=== <tt>help [command]</tt>
+
+Shows list of commands or help for one command
+
+Gets help for the application or its commands.  Can also list the commands in a way helpful to creating a bash-style completion function
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-c, --completion</tt>] List all commands one line at a time, for use with shell completion ([command] argument is partial command to match)
+=== <tt>init project_name [command[ command]*]</tt>
+
+Create a new GLI-based project
+
+*Aliases*
+* <tt><b>scaffold</b></tt>
+
+This will create a scaffold command line project that uses GLI
+for command line processing.  Specifically, this will create
+an executable ready to go, as well as a lib and test directory, all
+inside the directory named for your project
+
+
+==== Options
+These options are specified *after* the command.
+
+[<tt>-e, --ext</tt>] Create an ext dir
+[<tt>--force</tt>] Overwrite/ignore existing files and directories
+[<tt>--notest</tt>] Do not create a test dir

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/lib/gli/command.rb

@@ -0,0 +1,124 @@
+require 'gli/command_line_token.rb'
+require 'gli/copy_options_to_aliases.rb'
+
+module GLI
+  # A command to be run, in context of global flags and switches.  You are given an instance of this class
+  # to the block you use for GLI#command.  You then use the methods described here to describe the 
+  # command-specific command-line arguments, much as you use the methods in GLI to describe the global
+  # command-line interface
+  class Command < CommandLineToken
+    include CopyOptionsToAliases
+
+    # Create a new command
+    #
+    # +names+:: A String, Symbol, or Array of String or Symbol that represents the name(s) of this command.
+    # +description+:: short description of this command as a Strign
+    # +arguments_name+:: description of the arguments as a String, or nil if this command doesn't take arguments
+    # +long_desc+:: a longer description of the command, possibly with multiple lines and text formatting
+    # +skips_pre+:: if true, this command advertises that it doesn't want the pre block called first
+    # +skips_post+:: if true, this command advertises that it doesn't want the post block called after it
+    def initialize(names,description,arguments_name=nil,long_desc=nil,skips_pre=false,skips_post=false) # :nodoc:
+      super(names,description,long_desc)
+      @arguments_description = arguments_name || ''
+      @skips_pre = skips_pre
+      @skips_post = skips_post
+      clear_nexts
+    end
+
+    # Return the arguments description
+    def arguments_description #:nodoc:
+      @arguments_description
+    end
+
+    # If true, this command doesn't want the pre block run before it executes
+    def skips_pre #:nodoc:
+      @skips_pre
+    end
+
+    # If true, this command doesn't want the post block run before it executes
+    def skips_post #:nodoc:
+      @skips_post
+    end
+
+    # Return the Array of the command's names
+    def names #:nodoc:
+      all_forms
+    end
+
+    # Get the usage string
+    # CR: This should probably not be here
+    def usage #:nodoc:
+      usage = name.to_s
+      usage += ' [command options]' if !flags.empty? || !switches.empty?
+      usage += ' ' + @arguments_description if @arguments_description
+      usage
+    end
+
+    # Return the flags as a Hash
+    def flags #:nodoc:
+      @flags ||= {}
+    end
+    # Return the switches as a Hash
+    def switches #:nodoc:
+      @switches ||= {}
+    end
+
+    # describe the next switch or flag just as GLI#desc does.
+    def desc(description); @next_desc = description; end
+    # set the long description of this flag/switch, just as GLI#long_desc does.
+    def long_desc(long_desc); @next_long_desc = long_desc; end
+    # describe the argument name of the next flag, just as GLI#arg_name does.
+    def arg_name(name); @next_arg_name = name; end
+    # set the default value of the next flag, just as GLI#default_value does.
+    def default_value(val); @next_default_value = val; end
+
+    # Create a command-specific flag, similar to GLI#flag
+    def flag(*names)
+      names = [names].flatten
+      GLI.verify_unused(names,flags,switches,"in command #{name}")
+      flag = Flag.new(names,@next_desc,@next_arg_name,@next_default_value,@next_long_desc)
+      flags[flag.name] = flag
+      clear_nexts
+    end
+
+    # Create a command-specific switch, similar to GLI#switch
+    def switch(*names)
+      names = [names].flatten
+      GLI.verify_unused(names,flags,switches,"in command #{name}")
+      switch = Switch.new(names,@next_desc,@next_long_desc)
+      switches[switch.name] = switch
+      clear_nexts
+    end
+
+    # Define the action to take when the user executes this command
+    #
+    # +block+:: A block of code to execute.  The block will be given 3 arguments:
+    #           +global_options+:: A Hash (or Options, see GLI#use_openstruct) of the _global_ options specified
+    #                              by the user, with defaults set and config file values used (if using a config file, see
+    #                              GLI#config_file)
+    #           +options+:: A Hash (or Options, see GLI#use_openstruct) of the command-specific options specified by the 
+    #                       user, with defaults set and config file values used (if using a config file, see GLI#config_file)
+    #           +arguments+:: An Array of Strings representing the unparsed command line arguments
+    #           The block's result value is not used; raise an exception or use GLI#exit_now! if you need an early exit based
+    #           on an error condition
+    def action(&block)
+      @action = block
+    end
+
+    def self.name_as_string(name) #:nodoc:
+      name.to_s
+    end
+
+    def clear_nexts #:nodoc:
+      @next_desc = nil
+      @next_arg_name = nil
+      @next_default_value = nil
+      @next_long_desc = nil
+    end
+
+    # Executes the command
+    def execute(global_options,options,arguments) #:nodoc:
+      @action.call(global_options,options,arguments)
+    end
+  end
+end

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/lib/gli/command_line_token.rb

@@ -0,0 +1,58 @@
+module GLI
+  # Abstract base class for a logical element of a command line, mostly so that subclasses can have similar
+  # initialization and interface
+  class CommandLineToken
+    attr_reader :name #:ndoc:
+    attr_reader :aliases #:ndoc:
+    attr_reader :description #:ndoc:
+    attr_reader :long_description #:ndoc:
+
+    def initialize(names,description,long_description=nil) #:ndoc:
+      @description = description
+      @long_description = long_description
+      @name,@aliases,@names = parse_names(names)
+    end
+
+    def usage #:nodoc:
+      all_forms
+    end
+
+    # Sort based on name
+    def <=>(other)
+      self.name.to_s <=> other.name.to_s
+    end
+
+    private
+    # Returns a string of all possible forms
+    # of this flag.  Mostly intended for printing
+    # to the user.
+    def all_forms(joiner=', ')
+      forms = all_forms_a
+      forms.join(joiner)
+    end
+
+
+    # Handles dealing with the "names" param, parsing
+    # it into the primary name and aliases list
+    def parse_names(names)
+      # Allow strings; convert to symbols
+      names = [names].flatten.map { |name| name.to_sym } 
+      names_hash = Hash.new
+      names.each do |name| 
+        raise ArgumentError.new("#{name} has spaces; they are not allowed") if name.to_s =~ /\s/
+        names_hash[self.class.name_as_string(name)] = true
+      end
+      name = names.shift
+      aliases = names.length > 0 ? names : nil
+      [name,aliases,names_hash]
+    end
+
+    def all_forms_a
+      forms = [self.class.name_as_string(name)]
+      if aliases
+        forms |= aliases.collect { |one_alias| self.class.name_as_string(one_alias) }.sort { |one,two| two.length <=> one.length }
+      end
+      forms
+    end
+  end
+end

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/lib/gli/copy_options_to_aliases.rb

@@ -0,0 +1,33 @@
+module GLI
+
+  # Mixin that both GLI and Command can use to copy command-line options to the aliased versions
+  # of flags and switches
+  #
+  # includers must provide the methods +flags+ and +switches+ that return an Array of Flag or Switch, 
+  # respectively
+  module CopyOptionsToAliases # :nodoc:
+    # For each option in options, copies its value to keys for the aliases of the flags or
+    # switches in gli_like
+    #
+    # options - Hash of options parsed from command line; this is an I/O param
+    def copy_options_to_aliases(options) # :nodoc:
+      new_options = {}
+      options.each do |key,value|
+        if flags[key] && flags[key].aliases
+          copy_aliases(flags[key].aliases,new_options,value)
+        elsif switches[key] && switches[key].aliases
+          copy_aliases(switches[key].aliases,new_options,value)
+        end
+      end
+      options.merge!(new_options)
+    end
+
+    private 
+
+    def copy_aliases(aliases,new_options,value)
+      aliases.each do |alias_name|
+        new_options[alias_name] = value
+      end
+    end
+  end
+end

data/build/bundler/ruby/1.9.1/gems/gli-1.4.0/lib/gli/exceptions.rb

@@ -0,0 +1,45 @@
+module GLI
+  # Indicates that the command line invocation was bad
+  class BadCommandLine < Exception
+    def exit_code; -1; end
+  end
+
+  # Indicates the bad command line was an unknown command
+  class UnknownCommand < BadCommandLine
+  end
+
+  # Indicates the bad command line was an unknown global argument
+  class UnknownGlobalArgument < BadCommandLine
+  end
+
+  # Indicates the bad command line was an unknown command argument
+  class UnknownCommandArgument < BadCommandLine
+    attr_reader :command
+    # +message+:: the error message to show the user
+    # +command+:: the command we were using to parse command-specific options
+    def initialize(message,command)
+      super(message)
+      @command = command
+    end
+  end
+
+  # Raise this if you want to use an exit status that isn't the default
+  # provided by GLI.  Note that GLI#exit_now! might be a bit more to your liking.
+  #
+  # Example:
+  #
+  #     raise CustomExit.new("Not connected to DB",-5) unless connected?
+  #     raise CustomExit.new("Bad SQL",-6) unless valid_sql?(args[0])
+  #
+  class CustomExit < Exception
+    attr_reader :exit_code #:nodoc:
+    # Create a custom exit exception
+    #
+    # +message+:: String containing error message to show the user
+    # +exit_code+:: the exit code to use (as an Int), overridding GLI's default
+    def initialize(message,exit_code)
+      super(message)
+      @exit_code = exit_code
+    end
+  end
+end