configurable 0.7.0 → 1.0.0

data/lib/config_parser/option.rb

@@ -1,108 +0,0 @@
-require 'config_parser/utils'
-
-class ConfigParser
-  
-  # Represents an option registered with ConfigParser.
-  class Option
-    
-    # A format string used by to_s
-    LINE_FORMAT = "%-36s %-43s"
-    
-    # The short switch mapping to self
-    attr_reader :short 
-    
-    # The long switch mapping to self
-    attr_reader :long
-    
-    # The argument name printed by to_s.  If arg_name
-    # is nil, no value will be parsed for self.
-    attr_reader :arg_name
-    
-    # The description printed by to_s
-    attr_reader :desc
-    
-    # The block called when one of the switches mapping
-    # to self is parse; block will receive the parsed
-    # argument if arg_name is specified.
-    attr_reader :block
-    
-    # Initializes a new Option using attribute values for :long, :short,
-    # :arg_name, and :desc.  The long and short values are transformed 
-    # using Utils.longify and Utils.shortify, meaning both bare strings
-    # (ex 'opt', 'o') and full switches ('--opt', '-o') are valid.
-    def initialize(attributes={}, &block)
-      @short = Utils.shortify(attributes[:short])
-      @long = Utils.longify(attributes[:long])
-      @arg_name = attributes[:arg_name]
-      @desc = attributes[:desc]
-      @block = block
-    end
-    
-    # Returns an array of non-nil switches mapping to self (ie [long, short]).
-    def switches
-      [long, short].compact
-    end
-    
-    # Parse determines how an option is actually parsed from an argv.  Parse 
-    # recieves the switch mapping to self for cases in which it affects the 
-    # outcome (see Switch).  By default parse has two modes of action:
-    #
-    # ==== Argument-style option (arg_name is specified)
-    #
-    # If arg_name is set, then parse passes value to the block. If no value
-    # is specified, the next argument in argv is used instead.  An error
-    # is raised if no value can be found.
-    #
-    # ==== Flag-style option (no arg_name is specified)
-    # 
-    # In this case, parse simply calls the block.  If a non-nil value is
-    # specified, parse raises an error.
-    #
-    def parse(switch, value, argv)
-      if arg_name
-        unless value
-          raise "no value provided for: #{switch}" if argv.empty?
-          value = argv.shift
-        end
-        block ? block.call(value) : value
-      else
-        raise "value specified for flag: #{switch}" if value
-        block ? block.call : nil
-      end
-    end
-    
-    # Formats self as a help string for use on the command line.
-    def to_s
-      lines = Lazydoc::Utils.wrap(desc.to_s, 43)
-      
-      header =  "    #{short_str}#{long_str} #{arg_name}"
-      header = header.length > 36 ? header.ljust(80) : (LINE_FORMAT % [header, lines.shift])
-      
-      if lines.empty?
-        header
-      else
-        lines.collect! {|line| LINE_FORMAT % [nil, line] }
-        "#{header}\n#{lines.join("\n")}"
-      end
-    end
-    
-    private
-    
-    # helper returning short formatted for to_s
-    def short_str # :nodoc:
-      case
-      when short && long
-        "#{short}, "
-      when short
-        "#{short}"
-      else 
-        '    '
-      end
-    end
-    
-    # helper returning long formatted for to_s
-    def long_str # :nodoc:
-      long
-    end
-  end
-end

data/lib/config_parser/switch.rb

@@ -1,44 +0,0 @@
-class ConfigParser
-  
-  # Switch represents a special type of Option where both a positive
-  # (--switch) and negative (--no-switch) version of long should
-  # map to self.  A short may be specified for Switch; it will always
-  # be treated like the positive switch.
-  class Switch < Option
-    
-    # The negative long switch, determined from long.
-    attr_reader :negative_long
-    
-    # Initializes a new Switch.  Raises an error if an arg_name is
-    # specified for self (as switches are intended to be boolean
-    # in nature), or if no long option is specified.
-    def initialize(options={})
-      super
-      raise ArgumentError, "arg_name specified for switch: #{arg_name}" if arg_name
-      raise ArgumentError, "no long specified" unless long
-      @negative_long = Utils.prefix_long(long, 'no-')
-    end
-    
-    # Returns an array of non-nil switches mapping to self (ie 
-    # [long, negative_long, short]).
-    def switches
-      [long, negative_long, short].compact
-    end
-    
-    # Calls the block with false if the negative long is specified,
-    # or calls the block with true in all other cases.  Raises an
-    # error if a value is specified.
-    def parse(switch, value, argv)
-      raise "value specified for switch: #{switch}" if value
-      value = (switch == negative_long ? false : true)
-      block ? block.call(value) : value
-    end
-
-    private
-    
-    # helper returning long formatted for to_s
-    def long_str # :nodoc:
-      long ? Utils.prefix_long(long, '[no-]') : ''
-    end
-  end
-end

data/lib/config_parser/utils.rb

@@ -1,177 +0,0 @@
-class ConfigParser
-  
-  # A medly of methods used throughout the ConfigParser classes.
-  module Utils
-    module_function
-    
-    # The option break argument
-    OPTION_BREAK = "--"
-
-    # Matches a nested long option, with or without a value
-    # (ex: '--opt', '--nested:opt', '--opt=value').  After 
-    # the match:
-    #
-    #   $1:: the switch
-    #   $2:: the value
-    #
-    LONG_OPTION = /^(--[A-z].*?)(?:=(.*))?$/
-
-    # Matches a nested short option, with or without a value
-    # (ex: '-o', '-n:o', '-o=value').  After the match:
-    #
-    #   $1:: the switch
-    #   $2:: the value
-    #
-    SHORT_OPTION = /^(-[A-z](?::[A-z])*)(?:=(.*))?$/
-
-    # Matches the alternate syntax for short options
-    # (ex: '-n:ovalue', '-ovalue').  After the match:
-    #
-    #   $1:: the switch
-    #   $2:: the value
-    #
-    ALT_SHORT_OPTION = /^(-[A-z](?::[A-z])*)(.+)$/
-    
-    # Turns the input string into a short-format option.  Raises
-    # an error if the option does not match SHORT_OPTION.  Nils
-    # are returned directly.
-    #
-    #   shortify("-o")         # => '-o'
-    #   shortify(:o)           # => '-o'
-    #
-    def shortify(str)
-      return nil if str == nil
-  
-      str = str.to_s
-      str = "-#{str}" unless str[0] == ?-
-      unless str =~ SHORT_OPTION && $2 == nil
-        raise ArgumentError, "invalid short option: #{str}"
-      end
-      str
-    end
-
-    # Turns the input string into a long-format option.  Underscores
-    # are converted to hyphens. Raises an error if the option does
-    # not match LONG_OPTION.  Nils are returned directly.
-    #
-    #   longify("--opt")       # => '--opt'
-    #   longify(:opt)          # => '--opt'
-    #   longify(:opt_ion)      # => '--opt-ion'
-    #
-    def longify(str)
-      return nil if str == nil
-  
-      str = str.to_s
-      str = "--#{str}" unless str =~ /^--/
-      str.gsub!(/_/, '-')
-      unless str =~ LONG_OPTION && $2 == nil
-        raise ArgumentError, "invalid long option: #{str}"
-      end
-      str
-    end
-    
-    # Adds a prefix onto the last nested segment of a long option.
-    #
-    #   prefix_long("--opt", 'no-')         # => '--no-opt'
-    #   prefix_long("--nested:opt", 'no-')  # => '--nested:no-opt'
-    #
-    def prefix_long(switch, prefix, split_char=':')
-      switch = switch[2,switch.length-2] if switch =~ /^--/
-      switch = switch.split(split_char)
-      switch[-1] = "#{prefix}#{switch[-1]}"
-      "--#{switch.join(':')}"
-    end
-    
-    # Infers the default long using key and adds it to attributes.  Returns
-    # attributes.
-    #
-    #   infer_long(:key, {})                      # => {:long => '--key'}
-    #
-    def infer_long(key, attributes)
-      unless attributes.has_key?(:long)
-        attributes[:long] = "--#{key}"
-      end
-      
-      attributes
-    end
-    
-    # Infers the default argname from attributes[:long] and sets it in
-    # attributes.  Returns attributes.
-    #
-    #   infer_arg_name(:key, {:long => '--opt'})  # => {:long => '--opt', :arg_name => 'OPT'}
-    #   infer_arg_name(:key, {})                  # => {:arg_name => 'KEY'}
-    #
-    def infer_arg_name(key, attributes)
-      if attributes.has_key?(:arg_name)
-        return attributes
-      end
-      
-      if long = attributes[:long]
-        long.to_s =~ /^(?:--)?(.*)$/
-        attributes[:arg_name] = $1.upcase
-      else
-        attributes[:arg_name] = key.to_s.upcase
-      end
-      
-      attributes
-    end
-    
-    # Attributes:
-    #
-    #   :long      the long key ("--key") 
-    #   :arg_name  the argument name ("KEY") 
-    #
-    def setup_option(key, attributes={})
-      infer_long(key, attributes)
-      infer_arg_name(key, attributes)
-      
-      lambda {|value| config[key] = value }
-    end
-    
-    # Attributes:
-    #
-    #   :long      the long key ("--key") 
-    #
-    def setup_flag(key, default=true, attributes={})
-      infer_long(key, attributes)
-      
-      lambda {config[key] = !default }
-    end
-    
-    # Attributes:
-    #
-    #   :long      the long key ("--[no-]key") 
-    #
-    def setup_switch(key, default=true, attributes={})
-      infer_long(key, attributes)
-      
-      if attributes[:long].to_s =~ /^(?:--)?(\[no-\])?(.*)$/ 
-        attributes[:long] = "--[no-]#{$2}" unless $1
-      end
-      
-      lambda {|value| config[key] = value }
-    end
-    
-    # Attributes:
-    #
-    #   :long      the long key ("--key")
-    #   :arg_name  the argument name ("KEY")
-    #   :split     the split character
-    #
-    def setup_list(key, attributes={})
-      infer_long(key, attributes)
-      infer_arg_name(key, attributes)
-      
-      split = attributes[:split]
-      n = attributes[:n]
-      
-      lambda do |value|
-        array = (config[key] ||= [])
-        array.concat(split ? value.split(split) : [value])
-        if n && array.length > n
-          raise "too many assignments: #{key.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/configurable/config.rb

@@ -1,97 +0,0 @@
-module Configurable
-  
-  # Configs are used by ConfigHash to determine how to delegate read/write
-  # operations to a receiver.  Configs also track metadata related to their
-  # presentation in various contexts.
-  class Config
-    class << self
-      
-      # Determines if the value is duplicable.  Non-duplicable values 
-      # include nil, true, false, Symbol, Numeric, Method, Module, and 
-      # any object that does not respond to dup.
-      def duplicable_value?(value)
-        case value
-        when nil, true, false, Symbol, Numeric, Method, Module then false
-        else value.respond_to?(:dup)
-        end
-      end
-    end
-      
-    # The reader method called on a receiver during get
-    attr_reader :reader
-
-    # The writer method called on a receiver during set
-    attr_reader :writer
-    
-    # An hash of metadata for self, often used to indicate how a config is
-    # presented in different contexts (ex on the command line, in a web form,
-    # or a desktop app).
-    attr_reader :attributes
-
-    # Initializes a new Config.
-    def initialize(reader, writer="#{reader}=", default=nil, attributes={}, init=true, dup=nil)
-      self.reader = reader
-      self.writer = writer
-      @default = default
-      @attributes = attributes
-      @init = init
-      @dup = dup.nil? ? Config.duplicable_value?(default) : dup
-    end
-    
-    # Returns the default value.  If duplicate is specified and the default
-    # may be duplicated (see Config.duplicable_value?) then a duplicate
-    # of the default is returned.
-    def default(duplicate=true)
-      duplicate && @dup ? @default.dup : @default
-    end
-    
-    # Returns the value for the specified attribute, or default if the
-    # attribute is unspecified.
-    def [](key, default=nil)
-      attributes.has_key?(key) ? attributes[key] : default
-    end
-    
-    # Calls reader on the receiver and returns the result.
-    def get(receiver)
-      receiver.send(reader)
-    end
-    
-    # Calls writer on the receiver with the value.
-    def set(receiver, value)
-      receiver.send(writer, value)
-    end
-    
-    # Sets the default value on the receiver.  Normally this method is only
-    # called during Configurable#initialize_config, and only then when init?
-    # returns true.
-    def init(receiver)
-      receiver.send(writer, default)
-    end
-    
-    # Returns true or false as specified in new.  True indicates that this
-    # delegate is allowed to initialize values on the receiver during
-    # Configurable#initialize_config.
-    def init?
-      @init
-    end
-    
-    # Returns an inspection string.
-    def inspect
-      "#<#{self.class}:#{object_id} reader=#{reader} writer=#{writer} default=#{default.inspect} >"
-    end
-    
-    protected
-    
-    # Sets the reader for self, assuring the reader is not nil.
-    def reader=(value) # :nodoc:
-      raise ArgumentError, "reader may not be nil" if value.nil?
-      @reader = value.to_sym
-    end
-
-    # Sets the writer for self, assuring the writer is not nil.
-    def writer=(value) # :nodoc:
-      raise ArgumentError, "writer may not be nil" if value.nil?
-      @writer = value.to_sym
-    end
-  end
-end

data/lib/configurable/indifferent_access.rb

@@ -1,35 +0,0 @@
-module Configurable
-  
-  # Implements AGET and ASET methods that symbolize string keys, in effect 
-  # producing indifferent access.  IndifferentAccess is intended to extend
-  # a Hash.
-  #
-  # Note that the indifference produced by this module is very thin indeed.
-  # Strings may still be used as keys through store/fetch, and
-  # existing string keys are not changed in any way.  Nonetheless,
-  # these methods are sufficient for Configurable and ConfigHash.
-  module IndifferentAccess
-    
-    # Symbolizes string keys and calls super.
-    def [](key)
-      super(convert(key))
-    end
-    
-    # Symbolizes string keys and calls super.
-    def []=(key, value)
-      super(convert(key), value)
-    end
-    
-    # Ensures duplicates use indifferent access.
-    def dup
-      super().extend IndifferentAccess
-    end
-    
-    private
-    
-    # a helper to convert strings to symbols
-    def convert(key) # :nodoc:
-      key.kind_of?(String) ? key.to_sym : key
-    end
-  end
-end