iisconfig 0.0.1.pre1

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

@@ -0,0 +1,181 @@
+require 'gli'
+require 'gli/command'
+require 'gli/terminal'
+
+module GLI
+  class DefaultHelpCommand < Command #:nodoc:
+    @@output = $stdout
+    @@skips_pre = true
+    @@skips_post = true
+
+    # Exposed for testing
+    def self.output_device=(o); @@output = o; end
+
+    # To override the default behavior of the help command, which is
+    # to NOT run the pre block, use this.
+    def self.skips_pre=(skips_pre)
+      @@skips_pre = skips_pre
+    end
+
+    # To override the default behavior of the help command, which is
+    # to NOT run the post block, use this.
+    def self.skips_post=(skips_post)
+      @@skips_post = skips_post
+    end
+
+    def initialize(version,*omit_from_list)
+      @omit_from_list = omit_from_list
+      @version = version
+      super(:help,
+            'Shows list of commands or help for one command',
+            '[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')
+      self.desc 'List all commands one line at a time, for use with shell completion ([command] argument is partial command to match)'
+      self.switch [:c,:completion]
+    end
+
+    def skips_pre; @@skips_pre; end
+    def skips_post; @@skips_post; end
+
+    def execute(global_options,options,arguments)
+      if options[:c]
+        names = commands_to_show.reduce([]) do |memo,obj|
+          memo << obj[0]
+          memo << obj[1].aliases
+          memo = memo.flatten
+        end
+        names.map! { |name| name.to_s } 
+        if arguments && arguments.size > 0
+          names = names.select { |name| name =~ /^#{arguments[0]}/ }
+        end
+        names.sort.each do |command|
+          next if command.empty?
+          @@output.puts command
+        end
+      else
+        if arguments.empty?
+          list_global_flags
+          list_commands
+        else
+          list_one_command_help(arguments[0])
+        end
+      end
+    end
+
+    private
+
+    def list_global_flags
+      if GLI.program_desc
+        @@output.puts wrap(GLI.program_desc,0)
+        @@output.puts
+      end
+      usage = "usage: #{GLI.program_name} "
+      all_options = GLI.switches.merge(GLI.flags)
+      if !all_options.empty?
+          usage += "[global options] "
+      end
+      usage += "command"
+      usage += ' [command options]'
+      @@output.puts usage
+      @@output.puts
+      if @version
+        @@output.puts "Version: #{@version}"
+        @@output.puts
+      end
+      @@output.puts 'Global Options:' if !all_options.empty?
+      output_command_tokens_for_help(all_options)
+      @@output.puts if !all_options.empty?
+    end
+
+    def list_commands
+      @@output.puts 'Commands:'
+      output_command_tokens_for_help(commands_to_show,:names)
+    end
+
+    def commands_to_show
+      GLI.commands.reject{ |name,c| @omit_from_list.include?(c) }
+    end
+
+    def list_one_command_help(command_name)
+      command = GLI.find_command(command_name)
+      if command
+        @@output.puts command.usage
+        description = wrap(command.description,4)
+        @@output.puts "    #{description}"
+        if command.long_description
+          @@output.puts
+          @@output.puts "    #{wrap(command.long_description,4)}"
+        end
+        all_options = command.switches.merge(command.flags)
+        if !all_options.empty?
+          @@output.puts
+          @@output.puts "Command Options:"
+          output_command_tokens_for_help(all_options)
+        end
+      else
+        @@output.puts "No such command #{command_name}"
+      end
+    end
+
+    def output_command_tokens_for_help(tokens,usage_name=:usage)
+      max = 0
+      tokens.values.each do |token| 
+        len = token.send(usage_name).length
+        if len > max 
+          max = len
+        end
+      end
+      names = tokens.keys.sort { |x,y| x.to_s <=> y.to_s }
+      names.each do |name|
+        token = tokens[name]
+        description = token.description || ''
+        if token.kind_of? Flag 
+          description += " (default: #{token.default_value})" if token.default_value
+        end
+        description = wrap(description,max+7)
+        string = sprintf "    %-#{max}s - %s",token.send(usage_name),description
+        @@output.puts string
+      end
+    end
+  end
+
+  private
+
+  # Wraps the line at the given column length, using the given line padding.
+  # Assumes that the first line doesn't need the padding, as its filled
+  # up with other stuff
+  def wrap(line,pad_length=0,line_length=nil)
+    line ||= ''
+    if line_length.nil?
+      line_length = Terminal.instance.size[0]
+    end
+    line_padding = sprintf("%#{pad_length}s",'')
+    words = line.split(/\s+/)
+    return line if !words || words.empty?
+    wrapped = ''
+    while wrapped.length + line_padding.length < line_length
+      wrapped += ' ' if wrapped.length > 0
+      word = words.shift
+      if (wrapped.length + line_padding.length + word.length > line_length)
+        words.unshift word
+        break;
+      end
+      wrapped += word
+      return wrapped if words.empty?
+    end
+    wrapped += "\n"
+    this_line = line_padding
+    words.each do |word|
+      if this_line.length + word.length >= line_length
+        wrapped += this_line
+        wrapped += "\n"
+        this_line = line_padding + word
+      else
+        this_line += ' ' if this_line.length > line_padding.length
+        this_line += word
+      end
+    end
+    wrapped.chomp!
+    wrapped + "\n" + this_line
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'gli'
+require 'gli/command'
+require 'yaml'
+
+module GLI
+  class InitConfig < Command # :nodoc:
+    COMMANDS_KEY = 'commands'
+
+    def initialize(config_file_name)
+      @filename = config_file_name
+      super(:initconfig,"Initialize the config file using current global options",nil,'Initializes a configuration file where you can set default options for command line flags, both globally and on a per-command basis.  These defaults override the built-in defaults and allow you to omit commonly-used command line flags when invoking this program')
+
+      self.desc 'force overwrite of existing config file'
+      self.switch :force
+    end
+
+    def execute(global_options,options,arguments)
+      if options[:force] || !File.exist?(@filename)
+        config = global_options
+        config[COMMANDS_KEY] = {}
+        GLI.commands.each do |name,command|
+          if (command != self) && (name != :rdoc) && (name != :help)
+            config[COMMANDS_KEY][name.to_sym] = {} if command != self
+          end
+        end
+        File.open(@filename,'w', 0600) do |file|
+          YAML.dump(config,file)
+        end
+      else
+        raise "Not overwriting existing config file #{@filename}, use --force to override"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+require 'gli'
+require 'fileutils'
+
+module GLI
+  class RDocCommand < Command # :nodoc:
+
+    def initialize
+      super(:rdoc,'Generates RDoc (and other types of documentation) for your command line interface')
+      self.desc 'Create a very basic scaffold for a cheat-style cheatsheet, in addition to rdoc'
+      self.switch 'cheatsheet'
+      self.desc 'Include a manapage suitable for gem man, in addition to rdoc'
+      self.switch 'manpage'
+      self.desc 'Do not create rdoc'
+      self.switch 'no-rdoc'
+    end
+
+    def execute(g,options,a)
+      create_rdoc unless options[:'no-rdoc']
+      create_manpage if options[:manpage]
+      create_cheatsheet if options[:cheatsheet]
+    end
+
+    def create_cheatsheet
+      File.open("#{GLI.program_name}.cheat",'w') do |file|
+        file << GLI.program_name
+        file << "\n"
+        file << GLI.program_name.length.times.inject("") { |a,x| a + "=" }
+        file << "\n"
+        file << "\n"
+        file << "Installation:\n"
+        file << "$ gem install #{GLI.program_name}\n\n"
+        GLI.commands.values.sort.each do |command|
+          next if command == self
+          file << command.description
+          file << "\n"
+          [command.name,command.aliases].flatten.each do |name|
+            next unless name
+            file << "$ #{GLI.program_name} #{name} #{command.arguments_description}\n"
+          end
+          file << "\n"
+        end
+      end
+    end
+
+    def create_manpage
+    end
+
+    def create_rdoc
+      File.open("#{GLI.program_name}.rdoc",'w') do |file|
+        file << "= <tt>#{GLI.program_name}</tt>\n\n"
+        if GLI.program_desc
+          file << GLI.program_desc
+          file << "\n\n"
+        end
+        file << "    "
+        file << GLI.program_name
+        file << " "
+        global_options = GLI.switches.merge(GLI.flags)
+        if (global_options && global_options.length > 0)
+          file << "[global options] "
+        end
+        file << "command_name"
+        file << " [command-specific options]"
+        file << " [--] arguments...\n\n"
+        file << "* Use the command +help+ to get a summary of commands\n"
+        file << "* Use the command <tt>help command_name</tt> to get a help for +command_name+\n"
+        file << "* Use <tt>--</tt> to stop command line argument processing; useful if your arguments have dashes in them\n"
+        file << "\n"
+        if (global_options && global_options.length > 0)
+          file << "== Global Options\n"
+          file << "These options are available for any command and are specified before the name of the command\n\n"
+          output_flags(file,global_options)
+        end
+        file << "== Commands\n"
+        GLI.commands.values.sort.each do |command|
+          next if command == self
+          file << "[<tt>#{command.name}</tt>] #{command.description}\n"
+        end
+        file << "\n"
+
+        GLI.commands.values.sort.each do |command|
+          next if command == self
+          file << "=== <tt>#{command.name} #{command.arguments_description}</tt>\n\n"
+          file << "#{command.description}\n\n"
+          if command.aliases
+            file << "*Aliases*\n"
+            command.aliases.each do |al|
+              file << "* <tt><b>#{al}</b></tt>\n"
+            end 
+            file << "\n"
+          end
+          all_options = command.switches.merge(command.flags)
+          file << "#{command.long_description}\n\n" if command.long_description
+          if (all_options && all_options.length > 0)
+            file << "==== Options\n"
+            file << "These options are specified *after* the command.\n\n"
+            output_flags(file,all_options)
+          end
+        end
+      end
+    end
+
+    def output_flags(file,flags)
+      flags.values.sort.each do |flag|
+        file << "[<tt>#{flag.usage}</tt>] #{flag.description}"
+        if flag.kind_of? Flag
+          file << " <i>( default: <tt>#{flag.default_value}</tt>)</i>" if flag.default_value
+        end
+        file << "\n"
+        if flag.long_description
+          file << "\n"
+          # 12 is: 4 for tt, 5 for /tt, 2 for the brackets and 1 for spacing
+          (flag.usage.length + 12).times { file << " " }
+          file << "#{flag.long_description}\n\n"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+require 'gli'
+require 'fileutils'
+
+module GLI
+  class Scaffold #:nodoc:
+
+    def self.create_scaffold(root_dir,create_test_dir,create_ext_dir,project_name,commands,force=false,dry_run=false)
+      dirs = [File.join(root_dir,project_name,'lib')]
+      dirs << File.join(root_dir,project_name,'bin')
+      dirs << File.join(root_dir,project_name,'test') if create_test_dir
+      dirs << File.join(root_dir,project_name,'ext') if create_ext_dir
+
+      if mkdirs(dirs,force,dry_run)
+        mk_binfile(root_dir,create_ext_dir,force,dry_run,project_name,commands)
+        mk_readme(root_dir,dry_run,project_name)
+        mk_gemspec(root_dir,dry_run,project_name)
+        mk_rakefile(root_dir,dry_run,project_name,create_test_dir)
+        mk_version(root_dir,dry_run,project_name)
+      end
+    end
+
+    def self.mk_readme(root_dir,dry_run,project_name)
+      return if dry_run
+      File.open("#{root_dir}/#{project_name}/README.rdoc",'w') do |file|
+        file << "= #{project_name}\n\n"
+        file << "Describe your project here\n\n"
+        file << ":include:#{project_name}.rdoc\n\n"
+      end
+      puts "Created #{root_dir}/#{project_name}/README.rdoc"
+      File.open("#{root_dir}/#{project_name}/#{project_name}.rdoc",'w') do |file|
+        file << "= #{project_name}\n\n"
+        file << "Generate this with\n    #{project_name} rdoc\nAfter you have described your command line interface"
+      end
+      puts "Created #{root_dir}/#{project_name}/#{project_name}.rdoc"
+    end
+
+    def self.mk_gemspec(root_dir,dry_run,project_name)
+      return if dry_run
+      File.open("#{root_dir}/#{project_name}/#{project_name}.gemspec",'w') do |file|
+        file.puts <<EOS
+# Ensure we require the local version and not one we might have installed already
+require File.join([File.dirname(__FILE__),'lib','#{project_name}_version.rb'])
+spec = Gem::Specification.new do |s| 
+  s.name = '#{project_name}'
+  s.version = #{project_name_as_module_name(project_name)}::VERSION
+  s.author = 'Your Name Here'
+  s.email = 'your@email.address.com'
+  s.homepage = 'http://your.website.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'A description of your project'
+# Add your other files here if you make them
+  s.files = %w(
+bin/#{project_name}
+  )
+  s.require_paths << 'lib'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc','#{project_name}.rdoc']
+  s.rdoc_options << '--title' << '#{project_name}' << '--main' << 'README.rdoc' << '-ri'
+  s.bindir = 'bin'
+  s.executables << '#{project_name}'
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rdoc')
+end
+EOS
+      end
+      puts "Created #{root_dir}/#{project_name}/#{project_name}.gemspec"
+    end
+
+    def self.project_name_as_module_name(project_name)
+      project_name.split(/_/).map { |part| part[0..0].upcase + part[1..-1] }.join('')
+    end
+
+    def self.mk_version(root_dir,dry_run,project_name)
+      return if dry_run
+      File.open("#{root_dir}/#{project_name}/lib/#{project_name}_version.rb",'w') do |file|
+        file.puts <<EOS
+module #{project_name_as_module_name(project_name)}
+  VERSION = '0.0.1'
+end
+EOS
+      end
+      puts "Created #{root_dir}/#{project_name}/lib/#{project_name}_version.rb"
+    end
+    def self.mk_rakefile(root_dir,dry_run,project_name,create_test_dir)
+      return if dry_run
+      File.open("#{root_dir}/#{project_name}/Rakefile",'w') do |file|
+        file.puts <<EOS
+require 'rake/clean'
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'Your application title'
+end
+
+spec = eval(File.read('#{project_name}.gemspec'))
+
+Rake::GemPackageTask.new(spec) do |pkg|
+end
+
+EOS
+        if create_test_dir
+          file.puts <<EOS
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/tc_*.rb']
+end
+
+task :default => :test
+EOS
+          File.open("#{root_dir}/#{project_name}/test/tc_nothing.rb",'w') do |test_file|
+            test_file.puts <<EOS
+require 'test/unit'
+
+class TC_testNothing < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_the_truth
+    assert true
+  end
+end
+EOS
+          end
+          puts "Created #{root_dir}/#{project_name}/test/tc_nothing.rb"
+        else
+          file.puts "task :default => :package\n"
+        end
+      end
+      puts "Created #{root_dir}/#{project_name}/Rakefile"
+      File.open("#{root_dir}/#{project_name}/Gemfile",'w') do |bundler_file|
+        bundler_file.puts "source :rubygems"
+        bundler_file.puts "gemspec"
+      end
+      puts "Created #{root_dir}/#{project_name}/Gemfile"
+    end
+
+    def self.mk_binfile(root_dir,create_ext_dir,force,dry_run,project_name,commands)
+      bin_file = File.join(root_dir,project_name,'bin',project_name)
+      if !File.exist?(bin_file) || force
+        if !dry_run
+          File.open(bin_file,'w') do |file|
+            file.chmod(0755)
+            file.puts '#!/usr/bin/env ruby'
+            file.puts <<EOS
+# 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
+EOS
+            file.puts '$: << File.expand_path(File.dirname(File.realpath(__FILE__)) + \'/../lib\')'
+            file.puts '$: << File.expand_path(File.dirname(File.realpath(__FILE__)) + \'/../ext\')' if create_ext_dir
+            file.puts <<EOS
+require 'rubygems'
+require 'gli'
+require '#{project_name}_version'
+
+include GLI
+
+program_desc 'Describe your application here'
+
+version #{project_name_as_module_name(project_name)}::VERSION
+
+desc 'Describe some switch here'
+switch [:s,:switch]
+
+desc 'Describe some flag here'
+default_value 'the default'
+arg_name 'The name of the argument'
+flag [:f,:flagname]
+EOS
+            first = true
+            commands.each do |command|
+              file.puts <<EOS
+
+desc 'Describe #{command} here'
+arg_name 'Describe arguments to #{command} here'
+EOS
+              if first
+                file.puts <<EOS
+command :#{command} do |c|
+  c.desc 'Describe a switch to #{command}'
+  c.switch :s
+
+  c.desc 'Describe a flag to #{command}'
+  c.default_value 'default'
+  c.flag :f
+  c.action do |global_options,options,args|
+
+    # Your command logic here
+     
+    # If you have any errors, just raise them
+    # raise "that command made no sense"
+  end
+end
+EOS
+              else
+                file.puts <<EOS
+command :#{command} do |c|
+  c.action do |global_options,options,args|
+  end
+end
+EOS
+              end
+              first = false
+            end
+            file.puts <<EOS
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abourt and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+exit GLI.run(ARGV)
+EOS
+            puts "Created #{bin_file}"
+          end
+        end
+      else
+        puts bin_file + " exists; use --force to override"
+        return false
+      end
+      true
+    end
+
+    def self.mkdirs(dirs,force,dry_run)
+      exists = false
+      if !force
+        dirs.each do |dir|
+          if File.exist? dir
+            raise "#{dir} exists; use --force to override"
+            exists = true
+          end
+        end
+      end
+      if !exists
+        dirs.each do |dir|
+          puts "Creating dir #{dir}..."
+          if dry_run
+            puts "dry-run; #{dir} not created"
+          else
+            FileUtils.mkdir_p dir
+          end
+        end
+      else
+        puts "Exiting..."
+        return false
+      end
+      true
+    end
+
+  end
+end