optparse-plus 3.0.0

data/Rakefile

@@ -0,0 +1,94 @@
+require 'sdoc'
+require 'bundler'
+require 'rake/clean'
+require 'rake/testtask'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+desc 'run unit tests'
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "test/unit"
+  test_file = ENV["TEST"]
+  ENV.delete("TEST")
+  t.test_files = if test_file
+                   [test_file]
+                 else
+                   FileList['test/unit/test_*.rb'] +
+                     FileList['test/unit/execution_strategy/test_*.rb'] +
+                     FileList['test/unit/test/test_*.rb']
+                 end
+end
+
+desc 'run integration tests'
+Rake::TestTask.new("test:integration") do |t|
+  t.libs << "lib"
+  t.libs << "test/integration"
+  test_file = ENV["TEST"]
+  ENV.delete("TEST")
+  t.test_files = if test_file
+                   [test_file]
+                 else
+                   FileList['test/integration/test_*.rb']
+                 end
+end
+
+desc 'build rdoc'
+task :rdoc => [:build_rdoc, :hack_css]
+RDoc::Task.new(:build_rdoc) do |rd|
+  rd.main = "README.rdoc"
+  rd.options << '-f' << 'sdoc'
+  rd.template = 'direct'
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'optparse-plus - Power Up your Command Line Apps'
+end
+CLOBBER << 'html'
+
+FONT_FIX = {
+  "0.82em" => "16px",
+  "0.833em" => "16px",
+  "0.85em" => "16px",
+  "1.15em" => "20px",
+  "1.1em" => "20px",
+  "1.2em" => "20px",
+  "1.4em" => "24px",
+  "1.5em" => "24px",
+  "1.6em" => "32px",
+  "1em" => "16px",
+  "2.1em" => "38px",
+}
+
+
+task :hack_css do
+  maincss = File.open('html/css/main.css').readlines
+  File.open('html/css/main.css','w') do |file|
+    file.puts '@import url(https://fonts.googleapis.com/css?family=Lato:300italic,700italic,300,700);'
+    maincss.each do |line|
+      if line.strip == 'font-family: "Helvetica Neue", Arial, sans-serif;'
+        file.puts 'font-family: Lato, "Helvetica Neue", Arial, sans-serif;'
+      elsif line.strip == 'font-family: monospace;'
+        file.puts 'font-family: Monaco, monospace;'
+      elsif line =~ /^pre\s*$/
+        file.puts "pre {
+          font-family: Monaco, monospace;
+          margin-bottom: 1em;
+        }
+        pre.original"
+      elsif line =~ /^\s*font-size:\s*(.*)\s*;/
+        if FONT_FIX[$1]
+          file.puts "font-size: #{FONT_FIX[$1]};"
+        else
+          file.puts line.chomp
+        end
+      else
+        file.puts line.chomp
+      end
+    end
+  end
+end
+
+CLEAN << "coverage"
+CLOBBER << FileList['**/*.rbc']
+task :default => [:test, "test:integration"]

data/bin/optparse_plus

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'optparse'
+require 'optparse_plus'
+require 'optparse_plus/cli'
+
+include FileUtils
+include OptparsePlus::Main
+include OptparsePlus::CLILogging
+include OptparsePlus::CLI
+include OptparsePlus::SH
+
+main do |app_name|
+  check_and_prepare_basedir!(app_name,options[:force])
+  using_readme = options[:readme]
+
+  gemname = File.basename(app_name)
+  module_name = gemname.split(/-/).map(&:capitalize).collect{ |segment| segment.split(/_/).map(&:capitalize).join('') }.join('::')
+
+  debug "Creating project for gem #{gemname}"
+
+  chdir File.dirname(app_name)
+
+  require_file = nil
+  sh! "bundle gem #{gemname} --no-color" do |stdout|
+    require_file = stdout.split(/\n/).select { |file|
+      file =~ /\.rb$/ && file !~ /version.rb$/
+    }.first
+  end
+  rm_rf "#{gemname}/spec"   # Don't want the default RSpec droppings
+  rm_rf "#{gemname}/.rspec"
+
+  require_file = gemname if require_file.nil?
+  require_file.gsub!(/^.*lib\//,'')
+
+  chdir gemname
+
+  template_dirs_in(:full).each  { |dir| mkdir_p dir }
+
+  rspec = options[:rspec]
+
+  ["Rakefile", ".gitignore", ].each do |file|
+    copy_file file, :binding => binding
+  end
+
+  if rspec
+    template_dirs_in(:rspec).each  { |dir| mkdir_p dir }
+    copy_file "spec/something_spec.rb", :from => :rspec, :binding => binding
+  else
+    template_dirs_in(:test_unit).each  { |dir| mkdir_p dir }
+    copy_file "test/unit/test_something.rb", :from => :test_unit, :binding => binding
+    copy_file "test/integration/test_cli.rb", :from => :test_unit, :binding => binding
+  end
+
+
+  gemspec = "#{gemname}.gemspec"
+  gem_variable = File.open(gemspec) { |x| x.read }.match(/(\w+)\.executables/)[1]
+
+  license = options[:license]
+  warn "warning: your app has no license" unless license
+  license = nil if license == 'NONE'
+  if license
+    copy_file "#{options[:license]}_LICENSE.txt", :as => "LICENSE.txt"
+  else
+    #Remove the MIT license generated by `bundle gem`
+    debug "Making sure no LICENSE.txt file exists at the root of the repo"
+    FileUtils.rm_f "LICENSE.txt"
+  end
+
+  #Ensure the gemspec file mentions the correct license
+  gemspec_content = File.read(gemspec)
+  if gemspec_content =~ /(^\s*#{gem_variable}\.license\s*=\s*).*/
+    gemspec_content.gsub!(/(^\s*#{gem_variable}\.license\s*=\s*).*/,"\\1#{license.to_s.inspect}")
+  else
+    gemspec_content.gsub!(/(^\s*#{gem_variable}\.name\s*=\s*.*)/,"\\1\n#{"  #{gem_variable}.license".ljust(20)} = #{license.to_s.inspect.upcase}")
+  end
+  # RubyGems won't deal with a gemspec in this state and so Bundler won't even
+  # work at all.  This is not helpful, so replace the magic keys its looking for
+  # with something else
+  gemspec_content.gsub!(/TODO/,"to-do")
+  gemspec_content.gsub!(/FIXME/,"fix me")
+  gemspec_content.gsub!(/^.*\.homepage.*$/,"")
+  File.open(gemspec,'w') {|f| f.write gemspec_content }
+
+
+  copy_file "README.rdoc", :binding => binding if using_readme
+
+  copy_file "bin/executable", :as => gemname, :executable => true, :binding => binding
+
+  add_to_file gemspec, [
+    "  #{gem_variable}.add_development_dependency('rdoc')",
+    "  #{gem_variable}.add_dependency('optparse_plus', '~> #{OptparsePlus::VERSION}')",
+  ], :before => /^end\s*$/
+  ruby_major,ruby_minor,ruby_patch = RUBY_VERSION.split(/\./).map(&:to_i)
+
+  if ruby_major >= 2 && ruby_minor >= 2
+    add_to_file gemspec, [
+      "  #{gem_variable}.add_development_dependency('test-unit')",
+    ], :before => /^end\s*$/
+  end
+
+  if rspec
+    add_to_file gemspec, [
+    "  #{gem_variable}.add_development_dependency('rspec', '~> 3')",
+    ], :before => /^end\s*$/
+  end
+  FileUtils.rm_f "README.md", verbose: true
+
+  sh! %q(git add --all .)
+end
+
+options[:readme] = true
+
+description "Kick the bash habit by bootstrapping your Ruby command-line apps"
+
+on("--force","Overwrite files if they exist")
+on("--[no-]readme","[Do not ]produce a README file")
+on("--rspec", "Generate RSpec unit tests instead of Test::Unit")
+
+licenses = %w(mit apache gplv2 gplv3 custom NONE)
+on("-l LICENSE","--license",licenses,"Specify the license for your project",'(' + licenses.join('|') + ')')
+
+use_log_level_option
+
+arg :app_name, :required, "Name of your app, which is used for the gem name and executable name"
+
+version OptparsePlus::VERSION, :compact => true
+
+go!

data/fix.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require "pathname"
+require "fileutils"
+
+
+ARGV.each do |filename|
+  filename = Pathname(filename)
+
+  contents = File.read(filename).split(/\n/)
+  File.open(filename,"w") do |file|
+    contents.each do |line|
+      file.puts line.gsub(/methadone/,"optparse_plus").gsub(/Methadone/,"OptparsePlus")
+    end
+  end
+
+  if filename.split.any? { |_| _ == "methadone" }
+    new_filename = filename.split.map { |_|
+      if _ == "methadone"
+        "optparse_plus"
+      else
+        _
+      end
+    }.join
+    FileUtils.mkdir_p new_filename.dirname
+    FileUtils.mv filename new_filename
+  end
+
+end

data/lib/optparse-plus.rb

@@ -0,0 +1 @@
+require_relative "optparse_plus"

data/lib/optparse_plus.rb

@@ -0,0 +1,15 @@
+require 'optparse_plus/version'
+require 'optparse_plus/cli_logger'
+require 'optparse_plus/cli_logging'
+require 'optparse_plus/exit_now'
+require 'optparse_plus/argv_parser'
+require 'optparse_plus/main'
+require 'optparse_plus/error'
+require 'optparse_plus/execution_strategy/base'
+require 'optparse_plus/execution_strategy/mri'
+require 'optparse_plus/execution_strategy/open_3'
+require 'optparse_plus/execution_strategy/open_4'
+require 'optparse_plus/execution_strategy/rbx_open_4'
+require 'optparse_plus/execution_strategy/jvm'
+require 'optparse_plus/sh'
+# Note: DO NOT require cli.rb, cucumber.rb, or anything in test/ here

data/lib/optparse_plus/argv_parser.rb

@@ -0,0 +1,50 @@
+module OptparsePlus #:nodoc:
+  # Assists with parsing strings in the same way that ARGV might.
+  # This is *not* used to parse the command-line, but used to 
+  # parse config files/environment variables so they can be placed into ARGV and properly interpretted by 
+  # OptionParser
+  module ARGVParser #:nodoc:
+
+  private
+
+    # Parses +string+, returning an array that can be placed into ARGV or given to OptionParser
+    def parse_string_for_argv(string) #:nodoc:
+      return [] if string.nil?
+
+      args = []               # return value we are building up
+      current = 0             # pointer to where we are in +string+
+      next_arg = ''           # the next arg we are building up to ultimatley put into args
+      inside_quote = nil      # quote character we are "inside" of
+      last_char = nil         # the last character we saw
+
+      while current < string.length
+        char = string.chars.to_a[current]
+        case char
+        when /["']/
+          if inside_quote.nil?         # eat the quote, but remember we are now "inside" one
+            inside_quote = char
+          elsif inside_quote == char   # we closed the quote we were "inside"
+            inside_quote = nil
+          else                         # we got a different quote, so it goes in literally
+            next_arg << char
+          end
+        when /\s/
+          if last_char == "\\"         # we have an escaped space, replace the escape char
+            next_arg[-1] = char
+          elsif inside_quote           # we are inside a quote so keep the space
+            next_arg << char
+          else                         # new argument
+            args << next_arg
+            next_arg = ''
+          end
+        else
+          next_arg << char
+        end
+        current += 1
+        last_char = char
+      end
+      args << next_arg unless next_arg == ''
+      args
+    end
+  end
+end

data/lib/optparse_plus/cli.rb

@@ -0,0 +1,116 @@
+require 'erb'
+
+module OptparsePlus
+  # <b>OptparsePlus Internal - treat as private</b>
+  #
+  # Stuff to implement optparse_plus's CLI app.  These
+  # stuff isn't generally for your use and it's not
+  # included when you require 'optparse_plus'
+  module CLI
+
+    # Checks that the basedir can be used, either by
+    # not existing, or by existing and force is true.
+    # In that case, we clean it out entirely
+    #
+    # +basedir+:: base directory where the user wants to create a new project
+    # +force+:: if true, and +basedir+ exists, delete it before proceeding
+    #
+    # This will exit the app if the dir exists and force is false
+    def check_and_prepare_basedir!(basedir,force)
+      if File.exists? basedir
+        if force
+          rm_rf basedir, :verbose => true, :secure => true
+        else
+          exit_now! 1,"error: #{basedir} exists, use --force to override"
+        end
+      end
+      mkdir_p basedir
+    end
+
+    # Add content to a file
+    #
+    # +file+:: path to the file
+    # +lines+:: Array of String representing the lines to add
+    # +options+:: Hash of options:
+    #             <tt>:before</tt>:: A regexp that will appear right after the new content. i.e.
+    #                                this is where to insert said content.
+    def add_to_file(file,lines,options = {})
+      new_lines = []
+      found_line = false
+      File.open(file).readlines.each do |line|
+        line.chomp!
+        if options[:before] && options[:before] === line
+          found_line = true
+          new_lines += lines
+        end
+        new_lines << line
+      end
+
+      raise "No line matched #{options[:before]}" if options[:before] && !found_line
+
+      new_lines += lines unless options[:before]
+      File.open(file,'w') do |fp|
+        new_lines.each { |line| fp.puts line }
+      end
+    end
+
+    # Copies a file, running it through ERB
+    #
+    # +relative_path+:: path to the file, relative to the project root, minus the .erb extension
+    #                   You should use forward slashes to separate paths; this method
+    #                   will handle making the ultimate path OS independent.
+    # +options+:: Options to affect how the copy is done:
+    #             <tt>:from</tt>:: The name of the profile from which to find the file, "full" by default
+    #             <tt>:as</tt>:: The name the file should get if not the one in relative_path
+    #             <tt>:executable</tt>:: true if this file should be set executable
+    #             <tt>:binding</tt>:: the binding to use for the template
+    def copy_file(relative_path,options = {})
+      options[:from] ||= :full
+
+      relative_path = File.join(relative_path.split(/\//))
+
+      template_path = File.join(template_dir(options[:from]),relative_path + ".erb")
+      template = ERB.new(File.open(template_path).readlines.join(''))
+
+      relative_path_parts = File.split(relative_path)
+      relative_path_parts[-1] = options[:as] if options[:as]
+
+      erb_binding = options[:binding] or binding
+
+      File.open(File.join(relative_path_parts),'w') do |file|
+        file.puts template.result(erb_binding)
+        file.chmod(0755) if options[:executable]
+      end
+    end
+
+    # Get the location of the templates for profile "from"
+    def template_dir(from)
+      File.join(File.dirname(__FILE__),'..','..','templates',from.to_s)
+    end
+
+    def template_dirs_in(profile)
+      template_dir = template_dir(profile)
+
+      Dir["#{template_dir}/**/*"].select { |x| 
+        File.directory? x 
+      }.map { |dir| 
+        dir.gsub(/^#{template_dir}\//,'')
+      }
+    end
+
+    def render_license_partial(partial)
+      ERB.new(File.read(template_dir('full/'+partial))).result(binding).strip 
+    end
+
+    def gemspec
+      @gemspec || @gemspec=_get_gemspec
+    end
+    private
+    def _get_gemspec
+      files=Dir.glob("*.gemspec")
+      raise "Multiple gemspec files" if files.size>1
+      raise "No gemspec file" if files.size < 1
+      Gem::Specification::load(files.first)
+    end
+  end
+end

data/lib/optparse_plus/cli_logger.rb

@@ -0,0 +1,133 @@
+require 'logger'
+
+module OptparsePlus
+  # A Logger instance that gives better control of messaging the user
+  # and logging app activity.  At it's most basic, you would use <tt>info</tt>
+  # as a replacement for +puts+ and <tt>error</tt> as a replacement
+  # for <tt>STDERR.puts</tt>.  Since this is a logger, however, you
+  # can also use #debug, #warn, and #fatal, and you can control
+  # the format and "logging level" as such.
+  #
+  # So, by default:
+  # * debug messages do not appear anywhere
+  # * info messages appear on the standard output
+  # * warn, error, and fatal messagse appear on the standard error
+  # * The default format of messages is simply the message, no logging cruft, however if your output
+  #   is redirected to a file, a better timestamped logging format is used
+  #
+  # You can customize this in several ways:
+  #
+  # * You can override the devices used by passing different devices to the constructor
+  # * You can adjust the level of message that goes to the error logger via error_level=
+  # * You can adjust the format for messages to the error logger separately via error_formatter=
+  #
+  # === Example
+  #
+  #     logger = CLILogger.new
+  #     logger.debug("Starting up") # => only the standard output gets this
+  #     logger.warn("careful!") # => only the standard error gets this
+  #     logger.error("Something went wrong!") # => only the standard error gets this
+  #
+  #     logger = CLILogger.new
+  #     logger.error_level = Logger::ERROR
+  #     logger.debug("Starting up") # => only the standard output gets this
+  #     logger.warn("careful!") # => only the standard OUTPUT gets this
+  #     logger.error("Something went wrong!") # => only the standard error gets this
+  #
+  #     logger = CLILogger.new('logfile.txt')
+  #     logger.debug("Starting up") # => logfile.txt gets this
+  #     logger.error("Something went wrong!") # => BOTH logfile.txt AND the standard error get this
+  class CLILogger < Logger
+    BLANK_FORMAT = proc { |severity,datetime,progname,msg|
+      msg + "\n"
+    }
+
+    # Helper to proxy methods to the super class AND to the internal error logger
+    #
+    # +symbol+:: Symbol for name of the method to proxy
+    def self.proxy_method(symbol) #:nodoc:
+      old_name = "old_#{symbol}".to_sym
+      alias_method old_name,symbol
+      define_method symbol do |*args,&block|
+        send(old_name,*args,&block)
+        @stderr_logger.send(symbol,*args,&block)
+      end
+    end
+
+    proxy_method :'formatter='
+    proxy_method :'datetime_format='
+
+    def add(severity, message = nil, progname = nil, &block) #:nodoc:
+      if @split_logs
+        unless severity >= @stderr_logger.level
+          super(severity,message,progname,&block)
+        end
+      else
+        super(severity,message,progname,&block)
+      end
+      @stderr_logger.add(severity,message,progname,&block)
+    end
+
+    DEFAULT_ERROR_LEVEL = Logger::Severity::WARN
+
+    # A logger that logs error-type messages to a second device; useful
+    # for ensuring that error messages go to standard error.  This should be
+    # pretty smart about doing the right thing.  If both log devices are
+    # ttys, e.g. one is going to standard error and the other to the standard output,
+    # messages only appear once in the overall output stream.  In other words,
+    # an ERROR logged will show up *only* in the standard error.  If either
+    # log device is NOT a tty, then all messages go to +log_device+ and only
+    # errors go to +error_device+
+    #
+    # +log_device+:: device where all log messages should go, based on level
+    # +error_device+:: device where all error messages should go.  By default, this is Logger::Severity::WARN
+    def initialize(log_device=$stdout,error_device=$stderr)
+      @stderr_logger = Logger.new(error_device)
+
+      super(log_device)
+
+      log_device_tty   = tty?(log_device)
+      error_device_tty = tty?(error_device)
+
+      @split_logs = log_device_tty && error_device_tty
+
+      self.level = Logger::Severity::INFO
+      @stderr_logger.level = DEFAULT_ERROR_LEVEL
+
+      self.formatter = BLANK_FORMAT if log_device_tty
+      @stderr_logger.formatter = BLANK_FORMAT if error_device_tty
+    end
+
+    def level=(level)
+      super(level)
+      if (level > DEFAULT_ERROR_LEVEL) && @split_logs
+        @stderr_logger.level = level
+      end
+    end
+
+    # Set the threshold for what messages go to the error device.  Note that calling
+    # #level= will *not* affect the error logger *unless* both devices are TTYs.
+    #
+    # +level+:: a constant from Logger::Severity for the level of messages that should go
+    #           to the error logger
+    def error_level=(level)
+      @stderr_logger.level = level
+    end
+
+    # Overrides the formatter for the error logger.  A future call to #formatter= will
+    # affect both, so the order of the calls matters.
+    #
+    # +formatter+:: Proc that handles the formatting, the same as for #formatter=
+    def error_formatter=(formatter)
+      @stderr_logger.formatter=formatter
+    end
+
+  private
+
+    def tty?(device_or_string)
+      return device_or_string.tty? if device_or_string.respond_to? :tty?
+      false
+    end
+
+  end
+end