ivanvc-choice 0.1.3.1

data/examples/ftpd.rb

@@ -0,0 +1,87 @@
+$:.unshift "../lib"
+$:.unshift "lib"
+require 'choice'
+
+port = 21
+PROGRAM_VERSION = 4
+
+Choice.options do
+  #banner "Usage: ftpd.rb [options]"
+  
+  header ""
+  header "Specific options:" 
+  
+  option :host do
+    short '-h'
+    long '--host=HOST'
+    desc "The hostname or ip of the host to bind to"
+    desc "(default 127.0.0.1)"
+    default '127.0.0.1'
+  end
+
+  option :port do
+    short '-p'
+    long '--port=PORT'
+    desc "The port to listen on (default 21)"
+    cast Integer
+    default port
+  end
+
+  option :clients do
+    short '-c'
+    long '--clients=NUM'
+    cast Integer
+    desc "The number of connections to allow at once (default 5)"
+    default 5
+  end
+
+  option :protocol do
+    short '-l'
+    long '--protocol=PROTOCOL'
+    desc "The protocol to use (default ftp)"
+    valid %w[ftp sftp]
+    default 'ftp'
+  end
+      
+  option :yaml_cfg do
+    long '--config=FILE'
+    desc 'Load configuration from YAML file'
+  end
+  
+  option :sample do
+    long '--sample'
+    desc "See a sample YAML config file"
+    action do
+      puts "See!"
+      exit
+    end
+  end
+  
+  option :debug do
+    short '-d'
+    long '--debug[=LEVEL]'
+    desc 'Turn on debugging mode'
+  end  
+  
+   separator ''
+   separator 'Common options: '
+
+  option :help do
+    long '--help'
+    desc 'Show this message'
+  end
+
+  option :version do
+    short '-v'
+    long '--version'
+    desc 'Show version'
+    action do
+      puts "ftpd.rb FTP server v#{PROGRAM_VERSION}"
+      exit      
+    end
+  end
+  
+end
+
+print "Choices: "
+puts Choice.choices.inspect

data/examples/gamble.rb

@@ -0,0 +1,42 @@
+$:.unshift "../lib"
+$:.unshift "lib"
+require 'choice'
+
+suits = %w[clubs diamonds spades hearts]
+stringed_numerics = (1..13).to_a.map { |a| a.to_s }
+valid_cards = stringed_numerics + %w[jack queen king ace]
+cards = {}
+stringed_numerics.each { |n| cards[n] = n }
+cards.merge!('1' => 'ace', '11' => 'jack', '12' => 'queen', '13' => 'king')
+
+Choice.options do
+  header "Gambling is fun again!  Pick a card and a suit (or two), then see if you win!"
+  header ""
+  header "Options:" 
+  
+  option :suit, :required => true do
+    short '-s'
+    long '--suit *SUITS'
+    desc "The suit you wish to choose.  Required.  You can pass in more than one, even."
+    desc "  Valid suits: #{suits * ' '}"
+    valid suits
+  end
+
+  separator ''
+
+  option :card, :required => true do
+    short '-c'
+    long '--card CARD'
+    desc "The card you wish to gamble on.  Required.  Only one, please."
+    desc "  Valid cards: 1 - 13, jack, queen, king, ace"
+    valid valid_cards
+    cast String
+  end
+end
+
+suit = suits[rand(suits.size)]
+card = cards[(rand(13)+1).to_s]
+
+puts "I drew the #{card} of #{suit}."
+puts "You picked the #{Choice.choices.card} of #{Choice.choices.suit * ' or '}."
+puts "You " << (Choice.choices.suit.include?(suit) && card == cards[Choice.choices.card] ? 'win!' : 'lose :(')

data/lib/choice.rb

@@ -0,0 +1,166 @@
+$:.unshift File.dirname(__FILE__)
+require 'choice/option'
+require 'choice/parser'
+require 'choice/writer'
+require 'choice/lazyhash'
+
+#
+# Usage of this module is lovingly detailed in the README file.
+#
+module Choice 
+  extend self
+
+  # The main method, which defines the options
+  def options(hash = {}, &block)
+    # if we are passing in a hash to define our options, use that straight
+    options_from_hash(hash) unless hash.empty?
+
+    # Setup all instance variables
+    reset! if hash.empty?
+    @@args ||= ARGV
+    
+    # Eval the passed block to define the options.
+    instance_eval(&block) if block_given?
+
+    # Parse what we've got.
+    parse unless parsed?
+  end
+
+  # Set options from a hash, shorthand style
+  def options_from_hash(options_hash)
+    options_hash.each do |name, definition|
+      option = Option.new
+      definition.each do |key, value| 
+        Array(value).each { |hit| option.send(key, hit) }
+      end
+      @@options << [name.to_s, option]
+    end
+  end
+  
+  # Return an array representing the rest of the command line arguments
+  def rest
+    @@rest
+  end
+
+  # Returns a hash representing options passed in via the command line.
+  def choices
+    @@choices
+  end
+
+  # Shortcut access to Choice.choices
+  def [](choice)
+    choices[choice]
+  end
+
+  # Defines an option.
+  def option(opt, options = {}, &block)
+    # Notice: options is maintained as an array of arrays, the first element
+    # the option name and the second the option object.
+    @@options << [opt.to_s, Option.new(options, &block)]
+  end
+
+  # Separators are text displayed by --help within the options block.
+  def separator(str)
+    # We store separators as simple strings in the options array to maintain
+    # order.  They are ignored by the parser.
+    @@options << str
+  end
+
+  # Define the banner, header, footer methods.  All are just getters/setters
+  # of class variables.
+  %w[banner header footer].each do |method|
+    define_method(method) do |string|
+      variable = "@@#{method}"
+      return class_variable_get(variable) if string.nil?
+      val = class_variable_get(variable) || ''
+      class_variable_set(variable, val << string)
+    end
+  end
+
+  
+  # Parse the provided args against the defined options.
+  def parse #:nodoc:
+    # Do nothing if options are not defined.
+    return unless @@options.size > 0
+
+    # Show help if it's anywhere in the argument list.
+    if @@args.include?('--help')
+      help
+    else
+      begin
+        # Delegate parsing to our parser class, passing it our defined 
+        # options and the passed arguments.
+        @@choices, @@rest = Parser.parse(@@options, @@args)
+        @@choices = LazyHash.new(@@choices)
+      rescue Choice::Parser::ParseError
+        # If we get an expected exception, show the help file.
+        help
+      end
+    end
+  end
+  
+  # Did we already parse the arguments?
+  def parsed? #:nodoc:
+    @@choices ||= false
+  end
+  
+  # Print the help screen by calling our Writer object
+  def help #:nodoc:
+    Writer.help( { :banner => @@banner, :header => @@header, 
+                   :options => @@options, :footer => @@footer }, 
+                   output_to, exit_on_help? )
+  end
+  
+  # Set the args, potentially to something other than ARGV.
+  def args=(args) #:nodoc:
+    @@args = args.dup.map { |a| a + '' }
+    parse if parsed?
+  end
+
+  # Return the args.
+  def args #:nodoc:
+    @@args
+  end
+  
+  # Returns the arguments that follow an argument
+  def args_of(opt)
+    args_of_opt = []
+    
+    # Return an array of the arguments between opt and the next option,
+    # which all start with "-"
+    @@args.slice(@@args.index(opt)+1, @@args.length).select do |arg|
+      if arg[0].chr != "-"
+        args_of_opt << arg
+      else
+        break
+      end
+    end
+    args_of_opt
+  end
+  
+  # You can choose to not kill the script after the help screen is printed.
+  def dont_exit_on_help=(val) #:nodoc:
+    @@exit = true
+  end
+  
+  # Do we want to exit on help?
+  def exit_on_help? #:nodoc:
+    @@exit rescue false
+  end
+  
+  # If we want to write to somewhere other than STDOUT.
+  def output_to(target = nil) #:nodoc:
+    @@output_to ||= STDOUT
+    return @@output_to if target.nil?
+    @@output_to = target
+  end
+  
+  # Reset all the class variables.
+  def reset! #:nodoc:
+    @@args    = false
+    @@banner  = false
+    @@header  = Array.new
+    @@options = Array.new
+    @@footer  = Array.new
+  end
+end

data/lib/choice/lazyhash.rb

@@ -0,0 +1,67 @@
+module Choice
+ 
+  # This class lets us get away with really bad, horrible, lazy hash accessing.
+  # Like so:
+  #   hash = LazyHash.new
+  #   hash[:someplace] = "somewhere"
+  #   puts hash[:someplace]
+  #   puts hash['someplace']
+  #   puts hash.someplace
+  #
+  # If you'd like, you can pass in a current hash when initializing to convert
+  # it into a lazyhash.  Or you can use the .to_lazyhash method attached to the 
+  # Hash object (evil!).
+  class LazyHash < Hash 
+    
+    # Keep the old methods around.
+    alias_method :old_store, :store
+    alias_method :old_fetch, :fetch
+    
+    # You can pass in a normal hash to convert it to a LazyHash.
+    def initialize(hash = nil)
+      hash.each { |key, value| self[key] = value } if !hash.nil? && hash.is_a?(Hash)
+    end
+
+    # Wrapper for []
+    def store(key, value)
+      self[key] = value
+    end
+    
+    # Wrapper for []=
+    def fetch(key)
+      self[key]
+    end
+
+    # Store every key as a string.
+    def []=(key, value)
+      key = key.to_s if key.is_a? Symbol
+      self.old_store(key, value)
+    end
+    
+    # Every key is stored as a string.  Like a normal hash, nil is returned if
+    # the key does not exist.
+    def [](key)
+      key = key.to_s if key.is_a? Symbol
+      self.old_fetch(key) rescue return nil
+    end
+
+    # You can use hash.something or hash.something = 'thing' since this is
+    # truly a lazy hash.
+    def method_missing(meth, *args)
+      meth = meth.to_s
+      if meth =~ /=/
+        self[meth.sub('=','')] = args.first
+      else
+        self[meth]
+      end
+    end
+    
+  end
+end
+
+# Really ugly, horrible, extremely fun hack.
+class Hash #:nodoc: 
+  def to_lazyhash
+    return Choice::LazyHash.new(self) 
+  end
+end

data/lib/choice/option.rb

@@ -0,0 +1,90 @@
+module Choice
+  
+  # The Option class parses and stores all the information about a specific
+  # option.
+  class Option #:nodoc: all
+
+    # Since we define getters/setters on the fly, we need a white list of
+    # which to accept.  Here's the list.
+    CHOICES = %w[short long desc default filter action cast validate valid]
+
+    # You can instantiate an option on its own or by passing it a name and
+    # a block.  If you give it a block, it will eval() the block and set itself
+    # up nicely.
+    def initialize(options = {}, &block)
+      # Here we store the definitions this option contains, to make to_a and
+      # to_h easier.
+      @choices = []      
+
+      # If we got a block, eval it and set everything up.
+      instance_eval(&block) if block_given?      
+
+      # Is this option required?
+      @required = options[:required] || false
+      @choices << 'required'
+    end
+       
+    # This is the catch all for the getter/setter choices defined in CHOICES.
+    # It also gives us choice? methods.
+    def method_missing(method, *args, &block)
+      # Get the name of the choice we want, as a class variable string.
+      var = "@#{method.to_s.sub('?','')}"
+
+      # To string, for regex purposes.
+      method = method.to_s
+      
+      # Don't let in any choices not defined in our white list array.
+      raise ParseError, "I don't know `#{method}'" unless CHOICES.include? method.sub('?','')
+      
+      # If we're asking a question, give an answer.  Like 'short?'.
+      return !!instance_variable_get(var) if method =~ /\?/ 
+      
+      # If we were called with no arguments, we want a get.
+      return instance_variable_get(var) unless args[0] || block_given?
+      
+      # If we were given a block or an argument, save it.
+      instance_variable_set(var, args[0]) if args[0]
+      instance_variable_set(var, block) if block_given?
+      
+      # Add the choice to the @choices array if we're setting it for the first
+      # time.
+      @choices << method if args[0] || block_given? unless @choices.index(method)
+    end
+    
+    # The desc method is slightly special: it stores itself as an array and
+    # each subsequent call adds to that array, rather than overwriting it.
+    # This is so we can do multi-line descriptions easily.
+    def desc(string = nil)
+      return @desc if string.nil?
+
+      @desc ||= []
+      @desc.push(string)
+
+      # Only add to @choices array if it's not already present.
+      @choices << 'desc' unless @choices.index('desc')
+    end
+    
+    # Simple, desc question method.
+    def desc?() !!@desc end
+
+    # Returns Option converted to an array.
+    def to_a
+      @choices.inject([]) do |array, choice|
+        return array unless @choices.include? choice
+        array + [instance_variable_get("@#{choice}")]
+      end
+    end
+    
+    # Returns Option converted to a hash.
+    def to_h
+      @choices.inject({}) do |hash, choice|
+        return hash unless @choices.include? choice
+        hash.merge choice => instance_variable_get("@#{choice}") 
+      end
+    end
+    
+    # In case someone tries to use a method we don't know about in their 
+    # option block.
+    class ParseError < Exception; end    
+  end
+end