commandeer 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+test.rb
+Gemfile.lock
+.rvmrc
+*.gem

data/Gemfile

@@ -0,0 +1 @@
+source "http://rubygems.org"

data/commandeer.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/commandeer', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["John E. Vincent"]
+  gem.email         = ["lusis.org+github.com@gmail.com"]
+  gem.description   = %q{Class-based CLI utility}
+  gem.summary       = "Commandeer allows you to make any class a git style command or subcommand"
+  gem.homepage      = "https://github.com/lusis/commandeer"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "commandeer"
+  gem.require_paths = ["lib"]
+  gem.version       = Commandeer::VERSION
+end

data/lib/commandeer.rb

@@ -0,0 +1,138 @@
+module Commandeer
+  VERSION = "0.0.1"
+
+  @commands = {}
+
+  def self.commands
+    @commands
+  end
+
+  def self.reset!
+    @commands = {}
+  end
+
+  def self.add_command(opts)
+    command = opts[:command].to_s
+    parent = opts[:parent].to_s
+    klass = opts[:klass].to_s
+    parser = opts[:parser].to_s
+    h = {}
+    case parent
+    when "top"
+      h = {:parser => parser, :klass => klass}
+      @commands[command] ||= {}
+      @commands[command].merge!(h)
+    else
+      h[command] = {:parser => parser, :klass => klass}
+      @commands[parent] ||= {}
+      @commands[parent]["subcommands"] ||= {}
+      @commands[parent]["subcommands"].merge!(h)
+    end
+  end
+
+  def self.parse!(args, script_name=__FILE__)
+    @script_name = script_name
+    # We haz no commands registered
+    if @commands.size == 0
+      puts "No known commands!"
+      exit(1)
+    end
+
+    # No args. Let's show what we have registered
+    if (args.size == 0) || (args[0] =~ /^-/)
+      puts "Usage: #{@script_name} [command options] or [command subcommand options]\n\n"
+      puts "Registered commands\n"
+      @commands.each do |command, options|
+        next if (command==:klass || command==:parser)
+        puts " #{command}"
+        unless options["subcommands"].nil?
+          puts "  subcommands:"
+          options["subcommands"].each do |sub, opts|
+            puts "   #{sub}"
+          end
+        end
+      end
+      exit
+    end
+
+    # Workflow
+    # Check if current scope is a valid command
+    scope = args.shift
+
+    # set the current command or return help
+    @commands.has_key?(scope) ? command=@commands[scope] : (puts "Unknown command: #{scope}\n"; self.parse!("-h"))
+
+    subcommands = command["subcommands"]
+
+    if subcommands
+      output = ''
+      output << "`#{scope}` has the following registered subcommands:\n"
+      subcommands.keys.each {|x| output << "\t#{x}" }
+      puts output
+    end if args.size == 0
+
+    if command.has_key?(:parser)
+      output = ''
+      output << "\n`#{scope}` also takes options"
+      output << "\ntry running '#{@script_name} #{scope} --help'"
+      puts output
+    end if args.size == 0
+
+    if args.size > 0 
+      if subcommands.has_key?(args[0])
+        # Okay so the next arg is a registered subcommand. Let's shift args
+        new_scope = args.shift
+        warning =<<-EOF
+        Warning! `#{new_scope}` is a registered subcommand for `#{scope}` but `#{scope}` also takes options.
+        This can cause unexpected results if `#{scope}` has an option named `#{new_scope}`
+        EOF
+        puts warning
+
+        parser = subcommands[new_scope][:parser]
+        klass = subcommands[new_scope][:klass]
+      else
+        parser = command[:parser]
+        klass = command[:klass]
+      end
+    else
+      parser = command[:parser]
+      klass = command[:klass]
+    end
+    begin
+      handler = constantize(klass)
+      handler.send parser.to_sym, args
+    rescue NoMethodError
+      if command[:parser]
+        puts "#{handler}##{parser} method does not exist"
+      end
+    rescue Exception => e
+      puts e.message
+    end
+  end
+
+  # Ripped from the ActiveSupport headlines!
+  def self.constantize(camel_cased_word)
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def command(command, opts={})
+      opts[:command] = command
+      opts[:parent] ||= :top
+      opts[:klass] ||= self.to_s
+      opts[:parser] ||= :parse
+      Commandeer.add_command(opts)
+    end
+  end
+end

data/test/helpers/all_override.rb

@@ -0,0 +1,11 @@
+class Foo
+  def self.zing(args)
+    puts args
+  end
+end
+
+class OverRideAll
+  include Commandeer
+
+  command "random", :parent => 'override', :klass => "Foo", :parser => "zing"
+end

data/test/helpers/command.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+class PrimaryCommand
+  include Commandeer
+
+  command "foo"
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "foo [options]"
+
+      opts.on("-f", "--foo FOOTHING", "The option for foo") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "foo help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end

data/test/helpers/namespaced.rb

@@ -0,0 +1,11 @@
+module Name
+  class Spaced
+    include Commandeer
+
+    command "namespaced"
+
+    def self.parse(args)
+      puts args
+    end
+  end
+end

data/test/helpers/sub_of_real_command.rb

@@ -0,0 +1,55 @@
+require 'optparse'
+
+class Parent
+  include Commandeer
+
+  command "parent"
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "parent [options]"
+
+      opts.on("-p", "--parent PARENTTHING", "The option for parent") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "parent help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end
+
+class Child
+  include Commandeer
+
+  command "child", :parent => 'parent'
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "child [options]"
+
+      opts.on("-c", "--child CHILDTHING", "The option for child") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "child help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end

data/test/helpers/subcommand.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+class SubCommand
+  include Commandeer
+
+  command "bar", :parent => 'fakeparent'
+
+  def self.parse(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      opts.banner = "bar [options]"
+
+      opts.on("-b", "--bar BARTHING", "The option for bar") do |f|
+        options[:f] = f
+      end
+      opts.on_tail("-h", "--help", "bar help") do
+        puts opts
+        exit(1)
+      end
+    end
+    begin
+      opts.parse!(args)
+    rescue OptionParser::InvalidOption => e
+      puts e
+      puts opts
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "test")))
+require 'commandeer'
+require 'minitest/autorun'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: commandeer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- John E. Vincent
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-28 00:00:00 Z
+dependencies: []
+
+description: Class-based CLI utility
+email: 
+- lusis.org+github.com@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- commandeer.gemspec
+- lib/commandeer.rb
+- test/helpers/all_override.rb
+- test/helpers/command.rb
+- test/helpers/namespaced.rb
+- test/helpers/sub_of_real_command.rb
+- test/helpers/subcommand.rb
+- test/test_commands.rb
+- test/test_helper.rb
+- test/test_output.rb
+homepage: https://github.com/lusis/commandeer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Commandeer allows you to make any class a git style command or subcommand
+test_files: []
+