optionscrapper 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 55227d37e4e22dc9ff1625a0cc6257ed76326b6a
+  data.tar.gz: 714240abbc84f62c81e0f9e2178ba1b815709ed4
+SHA512:
+  metadata.gz: f22b3bdf77e3b01bda61d634d509aa0eec9a3e46bbe08c0010a00975293b4e47571f76e7ee84b762ec8f3a73cc6430db5d327e78cc50a73d0aaaab05e2e277a7
+  data.tar.gz: 7e54275583b4aeba65daeeba88cec9fd342192151ba29c9243292710cf132cd50389d0fd17286ab12dedb2157257b60c0d2c8134fff35c6829b2b6518e31b3d4

data/.gitignore

@@ -0,0 +1,42 @@
+#
+#   Author: Rohith
+#   Date: 2014-05-22 16:52:19 +0100 (Thu, 22 May 2014)
+#
+#  vim:ts=4:sw=4:et
+#
+
+*.swp
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/README.md

@@ -0,0 +1,63 @@
+Options Scrapper!
+----------------
+
+Is a wrapper for the OptionsParser (optparse) gem which makes using subcommand like cli easier to define. Note, all the options configuration is passed directly to optparse; so anything it supports, this will support; any methods missing is also passed down to optpasr i.e. banner, separator etc
+    
+    require 'optionscrapper'
+    require 'pp'
+    
+    @options = {
+      :config           => '../config/openstack.yaml',
+      :flavor           => '2cores-4096mem-10gb',
+      :image            => 'centos-base-6.5-min-stable',
+      :user_data        => '../config/user_data.erb',
+      :keypair          => 'default',
+      :networks         => [],
+      :security_group   => [ 'default' ],
+      :verbose          => true,
+      :force            => false
+    }
+    
+    begin
+    
+      Parser = OptionScrapper::new do |o|
+        o.on( '-S stack',       '--stack NAME',             'the name of the openstack you wish to connect' ) { |x|   @options[:stack]             =  x    }
+        o.on( '-c CONFIG',      '--config CONFIG',          'the configuration file to read credentials' )    { |x|   @options[:config]            =  x    }
+        o.on( '-H',             '--hostname HOSTNAME',      'switch on verbose mode' )                        {       @options[:verbose]           =  true }
+        o.on( '-v',             '--verbose',                'switch on verbose mode' )                        {       @options[:verbose]           =  true }
+        o.command :launch, 'launch a instance in to openstack cluster' do 
+          o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of instance you are creating' )     { |x|   @options[:hostname]          =  x    }
+          o.on( '-i IMAGE',       '--image IMAGE',            'the image you wish to boot from' )               { |x|   @options[:image]             =  x    }
+          o.on( '-f FLAVOR',      '--flavor FLAVOR',          'the flavor the instance should work from' )      { |x|   @options[:flavor]            =  x    }
+          o.on( '-k KEYPAIR',     '--keypair KEYPAIR',        'the keypair the instance should use' )           { |x|   @options[:keypair]           =  x    }
+          o.on( '-n NETWORK',     '--network NETWORK',        'the network the instance should be connected' )  { |x|   @options[:networks]          << x    }
+          o.on( '-s SECURITY',    '--secgroups SECURITY',     'the security group assigned to the instance' )   { |x|   @options[:security_group]    << x    } 
+          o.on( '-u USER_DATA',   '--user-data USER_DATA',    'the user data template' )                        { |x|   @options[:user_data]         =  x    }
+          o.on( nil,              '--hypervisor HOST',        'the compute node you want the instance to run' ) { |x|   @options[:availability_zone] =  x    }
+          o.on_command { @options[:action] = :launch   }
+        end
+        o.command :destroy, 'destroy and delete an instance in openstack' do 
+          o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of instance you are creating' )     { |x|   @options[:hostname]          =  x    }
+          o.on_command { @options[:action] = :destroy  }
+        end
+        o.command :snapshot, 'snapshot a instance within openstack' do 
+          o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of the instance being snapshot' )   { |x|   @options[:hostname]          =  x    }
+          o.on( '-s NAME',        '--snapshot NAME',          'the name of the snapshot you are creating' )     { |x|   @options[:snapshot]          =  x    }
+          o.on( nil,              '--wait'                    'wait on the snapshot to complete' )              { |x|   @options[:wait]              =  true }
+          o.on( '-f',             '--force',                  'if the snapshot image exists, delete it' )       { |x|   @options[:force]             =  true }
+          o.on_command { @options[:action] = :snapshot }
+        end  
+      end
+      Parser.parse!
+      PP.pp @options
+    rescue SystemExit => e 
+      exit e.status
+    end
+
+Global Options
+--------------
+
+Assuming you are using subcommands, global options may be intermixed amougst the subcommands - i.e. if you have an option --dry-run in global, it can be placed anywhere within the command line options. If however, the subcommand which it is seated has the same option, the subcommand takes priority. Using the above definition as an example
+
+    ./test launch -H hostname   ; -H exists in global and launch, but launch take priority and it's his to process
+

data/lib/optionscrapper/ext/optparse.rb

@@ -0,0 +1,10 @@
+#
+#
+#   Author: Rohith
+#   Date: 2014-07-22 23:30:04 +0100 (Tue, 22 Jul 2014)
+#
+#  vim:ts=4:sw=4:et
+#
+class OptionParser
+  attr_reader :stack
+end

data/lib/optionscrapper/optparser.rb

@@ -0,0 +1,95 @@
+#
+#   Author: Rohith
+#   Date: 2014-05-22 23:55:29 +0100 (Thu, 22 May 2014)
+#
+#  vim:ts=2:sw=2:et
+#
+$:.unshift File.join(File.dirname(__FILE__),'.')
+require 'parsing'
+require 'usage'
+
+module OptionScrapper
+  class OptParser
+    include OptionScrapper::Parsing
+    include OptionScrapper::Usage
+
+    alias_method :newline, :puts
+
+    def initialize &block
+      initialize_parsers
+      yield self if block_given?
+    end
+
+    def parse! arguments = ARGV
+      # step: we need to separate into subcommand arguments
+      batches  = batch_arguments arguments, parsers
+      # step: iterate the batches and fire off the parsers for each subcommand
+      batches.each_pair { |cmd,args| parsers[cmd][:parser].parse! args }
+    end
+
+    def command name, description, &block
+      # step: create a new command parser
+      command_name = name.to_sym
+      # step: create a new command parser
+      p = parser( command_name, description )
+      # step: add a spacer to the current one
+      @cursor[:parser].separator ""
+      # step: add the new parser to the @parsers
+      parsers[command_name] = p
+      # step: update the cursor to the new parser
+      @cursor = p
+      # step: create a useage for this command
+      @cursor[:parser].banner = "    %s : description: %s" % [ name, description ]
+      @cursor[:parser].separator "    %s" % [ horizontal_line( 72 ) ]
+      @cursor[:parser].separator ""
+      yield @cursor[:parser] if block_given?
+    end
+
+    def command_alias name
+      @cursor[:aliases] << name
+    end
+
+    def on_command &block
+      @cursor[:on_command] = block if block_given?
+    end
+
+    def on *args, &block
+      # step: we are creating an array of all the
+      parse_option_switches *args do |x|
+        @cursor[:switches][x] = true
+      end
+      @cursor[:parser].on *args do |x|
+        # step: build up a list of switches for this command
+        yield x if block_given?
+      end
+    end
+
+    private
+    def method_missing method, *args, &block
+      if @cursor[:parser].respond_to? method
+        case method
+        when :banner=
+          @cursor[:parser].send method, args.first, &block
+        else
+          @cursor[:parser].send method, args, &block if args and !args.empty?
+          @cursor[:parser].send method, &block if !args or args.empty?
+        end
+      else
+        super( method, args, block )
+      end
+    end
+
+    def initialize_parsers
+      # step: we create the global and inject the global parser into the parser hash
+      parsers[:global] = parser( 'global' )
+      parsers[:global][:parser].program_name = program_name
+      # step: set the cursor to global - i.e. all options are initially global
+      @cursor = parsers[:global]
+      # step: inject a default help options for global
+      @cursor[:parser].on( '-h', '--help', 'display this usage menu' ) do
+        puts print_usage
+        exit 0
+      end
+    end
+  end
+end

data/lib/optionscrapper/parsing.rb

@@ -0,0 +1,123 @@
+#
+#   Author: Rohith (gambol99@gmail.com)
+#   Date: 2014-07-11 14:26:25 +0100 (Fri, 11 Jul 2014)
+#
+#  vim:ts=4:sw=4:et
+#
+module OptionScrapper
+  module Parsing
+    OptionRegex = /^(-[-]?[[:alpha:]-]+)/
+
+    private
+    # [ -c config launch -H rohith -i djskdjs -n 2 -f dksldkslkdsldksl --stack hq --dry-run -f mine ]
+    # [ -c config launch -H rohith -i djskdjs -n 2 -f dksldkslkdsldksl --dry-run -S hq ]
+    def batch_arguments arguments = ARGV, commands = parsers
+      # step: create the batches
+      batches  = { :global => [] }
+      current  = :global
+      previous = nil
+
+      arguments.each do |argument|
+        # step: is the argument a subcommand?
+        subcommand = has_command argument
+        if subcommand
+          current  = subcommand
+          previous = nil
+          # step: create the new batch, reset the cursor and iterate
+          batches[current] = []
+          # step: call the block if the on_command block is set
+          parsers[current][:on_command].call if parsers[current].has_key? :on_command
+        else
+          unless option? argument
+            batches[current] << argument; next
+          end
+          # else we are processing a command line option and we are in global
+          if previous
+            current  = previous
+            previous = nil
+          end
+
+          if !parser_option?( current, argument ) and global_option? argument
+            previous = current
+            current  = :global
+            batches[current] << argument
+          else
+            # step: otherwise we inject into the current batch
+            batches[current] << argument
+          end
+        end
+      end
+      batches
+    end
+
+    def parser name, description = nil
+      p = {
+        :name     => name.to_sym,
+        :parser   => ::OptionParser::new,
+        :switches => {},
+        :aliases  => [],
+      }
+      p[:description] = description if description
+      p
+    end
+
+    def has_command argument
+      command_name = argument.to_sym
+      return command_name if command? command_name
+      alias?( command_name )
+    end
+
+    def command? argument
+      parsers.has_key? argument
+    end
+
+    def alias? argument
+      parsers.each_pair do |name,config|
+        next if name == :global
+        next if aliases( name ).empty?
+        return name if aliases( name ).include? argument
+      end
+      nil
+    end
+
+    def aliases parser_name
+      parsers[parser_name][:aliases]
+    end
+
+    def parsers
+      @parsers ||= {}
+    end
+
+    def option? argument
+      argument =~ OptionRegex
+    end
+
+    def parser_option? parser_name, option
+      parsers[parser_name][:switches].has_key? option
+    end
+
+    def global_parser
+      parsers[:global][:parser]
+    end
+
+    def global_switches
+      parsers[:global][:switches]
+    end
+
+    def global_option? option
+      global_switches.has_key? option
+    end
+
+    def parse_option_switches *args, &block
+      if args and args.size >= 2
+        args[0..1].each do |a|
+          yield $1 if a =~ OptionRegex and block_given?
+        end
+      end
+    end
+
+    def program_name
+      File.basename( $0 )
+    end
+  end
+end

data/lib/optionscrapper/usage.rb

@@ -0,0 +1,65 @@
+#
+#   Author: Rohith (gambol99@gmail.com)
+#   Date: 2014-07-11 14:39:16 +0100 (Fri, 11 Jul 2014)
+#
+#  vim:ts=4:sw=4:et
+#
+module OptionScrapper
+  module Usage
+    def usage message = nil, parser_name = :global
+      # step: if the parser is specified, print only that one
+      if !parser_name == :global
+        puts parsers[parser_name][:parser]
+      else
+        # step: else we generate the full parse usage menu
+        puts "\n%s" % [ parsers[:global][:parser] ]
+        # step: we don't need to do this if there are no sub commands
+        subcommand_usage
+      end
+      fail message if message
+      newline
+      exit 0
+    end
+    alias_method :print_usage, :usage
+    alias_method :to_s, :usage
+
+    def subcommand_usage
+      if parsers.size > 1
+        puts offset << "commands : %s" % [ horizontal_line( 61, "-" ) ]
+        parsers.each_pair do |name,par|
+          next if name == :global
+          subcommand_name = name.to_s
+          subcommand_name << " (%s)" % [ aliases( name ).join(',') ] unless par[:aliases].empty?
+          puts offset << "%-32s %s" % [ subcommand_name, par[:description] ]
+        end
+        puts offset << "%s" % [ horizontal_line( 72, "-" ) ]
+        newline
+        parsers.each_pair do |parser_name,p|
+          # step: skip the global, we have already displayed it
+          next if parser_name == :global
+          # step: we don't need to show this if the subcommand has no options / switches
+          next if p[:switches].empty?
+          # step: else we can show the parser usage
+          puts p[:parser]
+        end
+      end
+    end
+
+    def offset length = 4, spacer = ""
+      length.times.each { spacer << " " }
+      spacer
+    end
+
+    def fail message
+      puts "[error]: " << message
+      exit 1
+    end
+
+    def horizontal_line length, symbol = '-', line = ""
+      length.times.each { line << "#{symbol}" }
+      line
+    end
+  end
+end
+
+

data/lib/optionscrapper/version.rb

@@ -0,0 +1,9 @@
+#
+#   Author: Rohith
+#   Date: 2014-05-22 10:58:44 +0100 (Thu, 22 May 2014)
+#
+#  vim:ts=2:sw=2:et
+#
+module OptionScrapper
+  VERSION = "0.0.9"
+end

data/lib/optionscrapper.rb

@@ -0,0 +1,32 @@
+#
+#   Author: Rohith
+#   Date: 2014-05-22 23:55:29 +0100 (Thu, 22 May 2014)
+#
+#  vim:ts=2:sw=2:et
+#
+$:.unshift File.join(File.dirname(__FILE__),'.','./')
+require 'optparse'
+require 'optionscrapper/ext/optparse'
+require 'optionscrapper/version'
+require 'optionscrapper/optparser'
+
+module OptionScrapper
+  ROOT = File.expand_path File.dirname __FILE__
+
+  require "#{ROOT}/optionscrapper/version"
+
+  autoload :Version,    "#{ROOT}/optionscrapper/version"
+  autoload :Parser,     "#{ROOT}/optionscrapper/optparser"
+
+  @version = OptionScrapper::VERSION
+
+  def self.version
+    OptionScrapper::VERSION
+  end
+
+  def self.new &block
+    OptionScrapper::OptParser::new do |o|
+      yield o if block_given?
+    end
+  end
+end

data/optionscrapper.gemspec

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+#   Author: Rohith
+#   Date: 2014-06-06 16:48:00 +0100 (Thu, 06 Jun 2014)
+#
+#  vim:ts=2:sw=2:et
+#
+$:.unshift File.join(File.dirname(__FILE__),'.','lib/optionscrapper' )
+require 'version'
+
+Gem::Specification.new do |s|
+    s.name        = "optionscrapper"
+    s.version     = OptionScrapper::VERSION
+    s.platform    = Gem::Platform::RUBY
+    s.date        = '2014-05-22'
+    s.authors     = ["Rohith Jayawardene"]
+    s.email       = 'gambol99@gmail.com'
+    s.homepage    = 'https://github.com/gambol99/optionscrapper'
+    s.summary     = %q{Options Parser with subcommand supports}
+    s.description = %q{Is a wrapper for optparse which allows for using subcommand more easily}
+    s.license     = 'MIT'
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+end

data/tests/test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__),'.','../lib')
+
+require 'optionscrapper'
+require 'pp'
+
+@options = {
+  :verbose    => true,
+  :networks   => [],
+  :security   => []
+}
+
+def parser
+  @parser ||= OptionScrapper::new do |o|
+    o.on( '-S stack',       '--stack NAME',             'the name of the openstack you wish to connect' ) { |x|   @options[:stack]             = x    }
+    o.on( '-c CONFIG',      '--config CONFIG',          'the configuration file to read credentials' )    { |x|   @options[:config]            = x    }
+    o.on( nil,              '--dry-run',                'perform a dry run' )                             {       @options[:dry_run]           = true }
+    o.on( '-v',             '--verbose',                'switch on verbose mode' )                        {       @options[:verbose]           = true }
+    o.command :launch, 'launch a instance in to openstack cluster' do
+      o.command_alias :ln
+      o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of instance you are creating' )     { |x|   @options[:hostname]          =  x  }
+      o.on( '-i IMAGE',       '--image IMAGE',            'the image you wish to boot from' )               { |x|   @options[:image]             =  x  }
+      o.on( '-f FLAVOR',      '--flavor FLAVOR',          'the flavor the instance should work from' )      { |x|   @options[:flavor]            =  x  }
+      o.on( '-k KEYPAIR',     '--keypair KEYPAIR',        'the keypair the instance should use' )           { |x|   @options[:keypair]           =  x  }
+      o.on( '-n NETWORK',     '--network NETWORK',        'the network the instance should be connected' )  { |x|   @options[:networks]          << x  }
+      o.on( '-s SECURITY',    '--secgroups SECURITY',     'the security group assigned to the instance' )   { |x|   @options[:security_group]    << x  }
+      o.on( '-u USER_DATA',   '--user-data USER_DATA',    'the user data template' )                        { |x|   @options[:user_data]         =  x  }
+      o.on( nil,              '--hypervisor HOST',        'the compute node you want the instance to run' ) { |x|   @options[:availability_zone] =  x  }
+      o.on( '-e',             '--error',                  'cause an error' )                                { o.usage                                  }
+      o.on_command { @options[:action] = :launch   }
+    end
+    o.command :destroy, 'destroy and delete an instance in openstack' do
+      o.command_alias :des
+      o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of instance you are creating' )     { |x|   @options[:hostname]          =  x    }
+      o.on_command { @options[:action] = :destroy  }
+    end
+    o.command :snapshot, 'snapshot a instance within openstack' do
+      o.command_alias :sp
+      o.on( '-H HOSTNAME',    '--hostname HOSTNAME',      'the hostname of the instance being snapshot' )   { |x|   @options[:hostname]          =  x    }
+      o.on( '-s NAME',        '--snapshot NAME',          'the name of the snapshot you are creating' )     { |x|   @options[:snapshot]          =  x    }
+      o.on( nil,              '--wait',                   'wait on the snapshot to complete' )              { |x|   @options[:wait]              =  true }
+      o.on( '-f',             '--force',                  'if the snapshot image exists, delete it' )       { |x|   @options[:force]             =  true }
+      o.on_command { @options[:action] = :snapshot }
+    end
+  end
+end
+
+begin
+  parser.parse!
+  PP.pp @options
+rescue SystemExit => e
+  exit e.status
+rescue Exception => e
+  parser.usage e.message
+end
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: optionscrapper
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- Rohith Jayawardene
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-22 00:00:00.000000000 Z
+dependencies: []
+description: Is a wrapper for optparse which allows for using subcommand more easily
+email: gambol99@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- lib/optionscrapper.rb
+- lib/optionscrapper/ext/optparse.rb
+- lib/optionscrapper/optparser.rb
+- lib/optionscrapper/parsing.rb
+- lib/optionscrapper/usage.rb
+- lib/optionscrapper/version.rb
+- optionscrapper.gemspec
+- tests/test.rb
+homepage: https://github.com/gambol99/optionscrapper
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Options Parser with subcommand supports
+test_files: []