murano-cli-commander 4.4.10

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+  t.rspec_opts = '--color --order random'
+end
+
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]

data/bin/murano-cli-commander

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'murano-cli-commander/import'
+
+program :name, 'murano-cli-commander'
+program :version, Commander::VERSION
+program :description, 'Commander utility program.'
+
+command :init do |c|
+  c.syntax = 'murano-cli-commander init [option] <file>'
+  c.summary = 'Initialize a commander template'
+  c.description = 'Initialize an empty <file> with a commander template,
+    allowing very quick creation of commander executables.'
+  c.example 'Create a new classic style template file.', 'murano-cli-commander init bin/my_executable'
+  c.example 'Create a new modular style template file.', 'murano-cli-commander init --modular bin/my_executable'
+  c.option '-m', '--modular', 'Initialize a modular style template'
+  c.action do |args, options|
+    file = args.shift || abort('file argument required.')
+    name = ask 'Machine name of program: '
+    description = ask 'Describe your program: '
+    commands = ask_for_array 'List the commands you wish to create: '
+    begin
+      if options.modular
+        File.open(file, 'w') do |f|
+          f.write <<-"...".gsub!(/^ {10}/, '')
+          #!/usr/bin/env ruby
+
+          require 'rubygems'
+          require 'murano-cli-commander'
+
+          class MyApplication
+            include Commander::Methods
+            # include whatever modules you need
+
+            def run
+              program :name, '#{name}'
+              program :version, '0.0.1'
+              program :description, '#{description}'
+
+          ...
+          commands.each do |command|
+            f.write <<-"...".gsub!(/^ {12}/, '')
+                command :#{command} do |c|
+                  c.syntax = '#{name} #{command} [options]'
+                  c.summary = ''
+                  c.description = ''
+                  c.example 'description', 'command example'
+                  c.option '--some-switch', 'Some switch that does something'
+                  c.action do |args, options|
+                    # Do something or c.when_called #{name.capitalize}::Commands::#{command.capitalize}
+                  end
+                end
+
+            ...
+          end
+          f.write <<-"...".gsub!(/^ {12}/, '')
+                run!
+              end
+            end
+
+            MyApplication.new.run if $0 == __FILE__
+          ...
+        end
+
+        File.chmod(0755, file)
+        say "Initialized modular template in #{file}"
+      else
+        File.open(file, 'w') do |f|
+          f.write <<-"...".gsub!(/^ {10}/, '')
+          #!/usr/bin/env ruby
+
+          require 'rubygems'
+          require 'murano-cli-commander/import'
+
+          program :name, '#{name}'
+          program :version, '0.0.1'
+          program :description, '#{description}'
+
+          ...
+          commands.each do |command|
+            f.write <<-"...".gsub!(/^ {12}/, '')
+            command :#{command} do |c|
+              c.syntax = '#{name} #{command} [options]'
+              c.summary = ''
+              c.description = ''
+              c.example 'description', 'command example'
+              c.option '--some-switch', 'Some switch that does something'
+              c.action do |args, options|
+                # Do something or c.when_called #{name.capitalize}::Commands::#{command.capitalize}
+              end
+            end
+
+            ...
+          end
+        end
+        File.chmod 0755, file
+        say "Initialized template in #{file}"
+      end
+    rescue => e
+      abort e
+    end
+  end
+end

data/lib/murano-cli-commander.rb

@@ -0,0 +1,35 @@
+#--
+# Copyright (c) 2008-2009 TJ Holowaychuk <tj@vision-media.ca>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'highline/import'
+require 'murano-cli-commander/version'
+require 'murano-cli-commander/blank'
+require 'murano-cli-commander/user_interaction'
+require 'murano-cli-commander/core_ext'
+require 'murano-cli-commander/runner'
+require 'murano-cli-commander/command'
+require 'murano-cli-commander/help_formatters'
+require 'murano-cli-commander/platform'
+require 'murano-cli-commander/delegates'
+require 'murano-cli-commander/methods'
+require 'murano-cli-commander/configure'

data/lib/murano-cli-commander/blank.rb

@@ -0,0 +1,7 @@
+module Blank
+  def self.included(base)
+    base.class_eval do
+      instance_methods.each { |m| undef_method m unless m =~ /^__|object_id/ }
+    end
+  end
+end

data/lib/murano-cli-commander/command.rb

@@ -0,0 +1,214 @@
+require 'optparse'
+
+module Commander
+  class Command
+    attr_accessor :name, :examples, :syntax, :description
+    attr_accessor :summary, :proxy_options, :options
+
+    ##
+    # Options struct.
+
+    class Options
+      include Blank
+
+      def initialize
+        @table = {}
+      end
+
+      def __hash__
+        @table
+      end
+
+      def method_missing(meth, *args)
+        meth.to_s =~ /=$/ ? @table[meth.to_s.chop.to_sym] = args.first : @table[meth]
+      end
+
+      def default(defaults = {})
+        @table = defaults.merge! @table
+      end
+
+      def inspect
+        "<Commander::Command::Options #{ __hash__.map { |k, v| "#{k}=#{v.inspect}" }.join(', ') }>"
+      end
+    end
+
+    ##
+    # Initialize new command with specified _name_.
+
+    def initialize(name)
+      @name, @examples, @when_called = name.to_s, [], []
+      @options, @proxy_options = [], []
+    end
+
+    ##
+    # Add a usage example for this command.
+    #
+    # Usage examples are later displayed in help documentation
+    # created by the help formatters.
+    #
+    # === Examples
+    #
+    #   command :something do |c|
+    #     c.example "Should do something", "my_command something"
+    #   end
+    #
+
+    def example(description, command)
+      @examples << [description, command]
+    end
+
+    ##
+    # Add an option.
+    #
+    # Options are parsed via OptionParser so view it
+    # for additional usage documentation. A block may optionally be
+    # passed to handle the option, otherwise the _options_ struct seen below
+    # contains the results of this option. This handles common formats such as:
+    #
+    #   -h, --help          options.help           # => bool
+    #   --[no-]feature      options.feature        # => bool
+    #   --large-switch      options.large_switch   # => bool
+    #   --file FILE         options.file           # => file passed
+    #   --list WORDS        options.list           # => array
+    #   --date [DATE]       options.date           # => date or nil when optional argument not set
+    #
+    # === Examples
+    #
+    #   command :something do |c|
+    #     c.option '--recursive', 'Do something recursively'
+    #     c.option '--file FILE', 'Specify a file'
+    #     c.option('--info', 'Display info') { puts "handle with block" }
+    #     c.option '--[no-]feature', 'With or without feature'
+    #     c.option '--list FILES', Array, 'List the files specified'
+    #
+    #     c.when_called do |args, options|
+    #       do_something_recursively if options.recursive
+    #       do_something_with_file options.file if options.file
+    #     end
+    #   end
+    #
+    # === Help Formatters
+    #
+    # This method also parses the arguments passed in order to determine
+    # which were switches, and which were descriptions for the
+    # option which can later be used within help formatters
+    # using option[:switches] and option[:description].
+    #
+    # === Input Parsing
+    #
+    # Since Commander utilizes OptionParser you can pre-parse and evaluate
+    # option arguments. Simply require 'optparse/time', or 'optparse/date', as these
+    # objects must respond to #parse.
+    #
+    #   c.option '--time TIME', Time
+    #   c.option '--date [DATE]', Date
+    #
+
+    def option(*args, &block)
+      switches, description = Runner.separate_switches_from_description(*args)
+      proc = block || option_proc(switches)
+      @options << {
+        args: args,
+        proc: proc,
+        switches: switches,
+        description: description,
+      }
+    end
+
+    ##
+    # Handle execution of command. The handler may be a class,
+    # object, or block (see examples below).
+    #
+    # === Examples
+    #
+    #   # Simple block handling
+    #   c.when_called do |args, options|
+    #      # do something
+    #   end
+    #
+    #   # Create inst of Something and pass args / options
+    #   c.when_called MyLib::Command::Something
+    #
+    #   # Create inst of Something and use arbitrary method
+    #    c.when_called MyLib::Command::Something, :some_method
+    #
+    #   # Pass an object to handle callback (requires method symbol)
+    #   c.when_called SomeObject, :some_method
+    #
+
+    def when_called(*args, &block)
+      fail ArgumentError, 'must pass an object, class, or block.' if args.empty? && !block
+      @when_called = block ? [block] : args
+    end
+    alias action when_called
+
+    ##
+    # Run the command with _args_.
+    #
+    # * parses options, call option blocks
+    # * invokes when_called proc
+    #
+
+    def run(*args)
+      call parse_options_and_call_procs(*args)
+    end
+
+    #:stopdoc:
+
+    ##
+    # Parses options and calls associated procs,
+    # returning the arguments remaining.
+
+    def parse_options_and_call_procs(*args)
+      return args if args.empty?
+      # empty proxy_options before populating via OptionParser
+      # prevents duplication of options if the command is run twice
+      proxy_options.clear
+      @options.each_with_object(OptionParser.new) do |option, opts|
+        opts.on(*option[:args], &option[:proc])
+        opts
+      end.parse! args
+    end
+
+    ##
+    # Call the commands when_called block with _args_.
+
+    def call(args = [])
+      object, meth = @when_called[0, 2]
+      meth ||= :call
+      options = proxy_option_struct
+
+      case object
+      when Proc then object.call(args, options)
+      when Class then meth != :call ? object.new.send(meth, args, options) : object.new(args, options)
+      else object.send(meth, args, options) if object
+      end
+    end
+
+    ##
+    # Creates an Options instance populated with the option values
+    # collected by the #option_proc.
+
+    def proxy_option_struct
+      proxy_options.each_with_object(Options.new) do |(option, value), options|
+        # options that are present will evaluate to true
+        value = true if value.nil?
+        options.__send__ :"#{option}=", value
+        options
+      end
+    end
+
+    ##
+    # Option proxy proc used when a block is not explicitly passed
+    # via the #option method. This allows commander to auto-populate
+    # and work with option values.
+
+    def option_proc(switches)
+      ->(value) { proxy_options << [Runner.switch_to_sym(switches.last), value] }
+    end
+
+    def inspect
+      "<Commander::Command:#{name}>"
+    end
+  end
+end

data/lib/murano-cli-commander/configure.rb

@@ -0,0 +1,14 @@
+module Commander
+  def configure(*configuration_opts, &configuration_block)
+    configuration_module = Module.new
+    configuration_module.extend Commander::Methods
+
+    configuration_module.class_exec(*configuration_opts, &configuration_block)
+
+    configuration_module.class_exec do
+      run!
+    end
+  end
+
+  module_function :configure
+end

data/lib/murano-cli-commander/core_ext.rb

@@ -0,0 +1,2 @@
+require 'murano-cli-commander/core_ext/array'
+require 'murano-cli-commander/core_ext/object'

data/lib/murano-cli-commander/core_ext/array.rb

@@ -0,0 +1,24 @@
+class Array
+  ##
+  # Split _string_ into an array. Used in
+  # conjunction with Highline's #ask, or #ask_for_array
+  # methods, which must respond to #parse.
+  #
+  # This method allows escaping of whitespace. For example
+  # the arguments foo bar\ baz will become ['foo', 'bar baz']
+  #
+  # === Example
+  #
+  #   # ask invokes Array#parse
+  #   list = ask 'Favorite cookies:', Array
+  #
+  #   # or use ask_for_CLASS
+  #   list = ask_for_array 'Favorite cookies: '
+  #
+
+  def self.parse(string)
+    # Using reverse + lookahead to work around Ruby 1.8's lack of lookbehind
+    # TODO: simplify now that we don't support Ruby 1.8
+    string.reverse.split(/\s(?!\\)/).reverse.map { |s| s.reverse.gsub('\\ ', ' ') }
+  end
+end

data/lib/murano-cli-commander/core_ext/object.rb

@@ -0,0 +1,8 @@
+class Object
+  ##
+  # Return the current binding.
+
+  def get_binding
+    binding
+  end
+end

data/lib/murano-cli-commander/delegates.rb

@@ -0,0 +1,25 @@
+module Commander
+  module Delegates
+    %w(
+      add_command
+      command
+      program
+      run!
+      global_option
+      alias_command
+      default_command
+      always_trace!
+      never_trace!
+    ).each do |meth|
+      eval <<-END, binding, __FILE__, __LINE__
+        def #{meth}(*args, &block)
+          ::Commander::Runner.instance.#{meth}(*args, &block)
+        end
+      END
+    end
+
+    def defined_commands(*args, &block)
+      ::Commander::Runner.instance.commands(*args, &block)
+    end
+  end
+end