iisconfig 0.0.1.pre2 → 0.0.1.pre3

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

@@ -1,73 +0,0 @@
-###
-### $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

@@ -1,45 +0,0 @@
-##
-## $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

@@ -1,111 +0,0 @@
-###
-### $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

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

@@ -1,72 +0,0 @@
-#!/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

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

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

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

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

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