cliutils 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63361eba2c187fdc7bd5dbff677bf976fbd97559
-  data.tar.gz: 7e191c796aee68c3fa9a80641bbea6385bd05520
+  metadata.gz: 6f244aff7b8639cf70d06eee8bef9f69d1ccaced
+  data.tar.gz: 16845634a0d353037b7c60f200bc76788abc73b7
 SHA512:
-  metadata.gz: c07545c990b26e7fb5635e60e919ef886dbdb0bf291cae0425cad9d7aba057da4084076e0e1ac645502ff50cf74a19100140f035c337451f3df21b76e7eb18fe
-  data.tar.gz: c8bf5139e9b1c610e4ff05961ca794c164ed59d2955b04e6ad212e146b6c2c73f9841c2287e9d6c5174276295868e048105cb43aa8dcfef765fe336407542cc1
+  metadata.gz: 78b54b0002d6c07b1189983782b46462c2db1225b573d5924af0d53059f2a01925421c0cc2160b4410021c04d6985f739d2f695c02b6f744d5a1044c2f693807
+  data.tar.gz: 769aaa4b4026175ef9c4bcce2aa373639472759f5fcad62df3a90d4169316e6cdccf3f3ddbcde9b41b8d1b923942365716535aefb1edc521c0d19984fe49590f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cliutils (1.1.1)
+    cliutils (1.2.0)
 
 GEM
   remote: https://rubygems.org/

data/HISTORY.md

@@ -1,3 +1,9 @@
+# 1.1.0 (2014-04-03)
+
+* Changed Requirements => Prerequisites in Prefs
+* Added Validators to Prefs
+* Added Behaviors to Prefs
+
 # 1.1.0 (2014-04-01)
 
 * Added notice of valid options in Prefs

data/README.md

@@ -169,6 +169,8 @@ messenger.info("You answered: #{ p }")
 ```
 ![alt text](https://raw.githubusercontent.com/bachya/cli-utils/master/res/readme-images/prompting.png "Prompting")
 
+When you pass a default to `messenging.prompt`, hitting `Enter` (i.e., leaving the prompt blank) will return the value of the default.
+
 ### Logging
 
 Often, it's desirable to log messages as they appear to your user. `messenging` makes this a breeze by allowing you to attach and detach Logger instances at will.
@@ -180,7 +182,7 @@ messenger.info('This should only appear in STDOUT.')
 
 # messenger.attach takes a Hash of string/symbol keys
 # and Logger values (so you can refer to them later on).
-messenger.attach(MY\_FILE\_LOGGER: Logger.new('file.txt'))
+messenger.attach(MY_FILE_LOGGER: Logger.new('file.txt'))
 
 messenger.warn('This warning should appear in STDOUT and file.txt')
 messenger.error('This error should appear in STDOUT and file.txt')
@@ -188,7 +190,7 @@ messenger.debug('This debug message should only appear in file.txt')
 
 # messenger.detach takes the string/symbol key
 # defined earlier.
-messenger.detach(:MY\_FILE\_LOGGER)
+messenger.detach(:MY_FILE_LOGGER)
 
 messenger.section('This section message should appear only in STDOUT')
 ```
@@ -209,7 +211,7 @@ Since you can attach Logger objects, each can have it's own format and severity
 
 ## Configuration
 
-CLIUtils offers two "things" -- a `Configurator` class and a `Configuration` module that provides access to a shared instance of `Configurator` -- that make managing a user's configuration parameters easy. Mix it in!
+CLIUtils offers a `Configurator` class and a `Configuration` module (which provides access to a shared instance of `Configurator`) that make managing a user's configuration parameters easy. Mix it in!
 
 ```Ruby
 include CLIUtils::Configuration
@@ -263,49 +265,31 @@ user_data:
 
 Many times, CLI apps need to ask their users some questions, collect the feedback, validate it, and store it. CLIUtils makes this a breeze via the `Prefs` class.
 
+### Basic Schema
+
 `Prefs` can load preferences information from either a YAML file (via a filepath) or from an array of preferences. In either case, the schema is the same; each prompt includes the following:
 
-* prompt (**required**): the string to prompt your user with
-* default (*optional*): an optional default to offer
-* key (**required**): the key that refers to this preference
-* section (**required**): the Configuration section that this preference applies to
-* options (*optional*): an optional array of values; the user's choice must be in this array
-* requirements (*optional*): an optional list of key/value pairs that must exist for this preference to be displayed
+* `prompt` (**required**): the string to prompt your user with
+* `default` (*optional*): an optional default to offer
+* `config_key` (**required**): the Configurator key that this preference will use
+* `config_section` (**required**): the Configurator section that this preference applies to
 
 Here's an example YAML preferences file.
 
 ```YAML
 prompts:
-  - prompt: What is the hostname of your DD-WRT router?
-    default: 192.168.1.1
-    key: hostname
-    section: ssh_info
-  - prompt: What is the SSH username of your DD-WRT router?
-    default: root
-    key: username
-    section: ssh_info
-  - prompt: What SSH port does your DD-WRT router use?
-    default: 22
-    key: port
-    section: ssh_info
-  - prompt: Do you use password or key authentication?
-    default: password
-    key: auth_method
-    section: ssh_info
-    options: ['password', 'key']
-  - prompt: Where is your key located?
-    default: ~/.ssh
-    key: key_location
-    section: ssh_info
-    requirements:
-      - key: auth_method
-        value: key
-  - prompt: What is your password?
-    key: password
-    section: ssh_info
-    requirements:
-      - key: auth_method
-        value: password
+  - prompt: What is your name?
+    default: Bob Cobb
+    config_key: name
+    config_section: personal_info
+  - prompt: What is your age?
+    default: 45
+    config_key: age
+    config_section: personal_info
+  - prompt: Batman or Superman?
+    default: Batman
+    config_key: superhero
+    config_section: personal_info
 ```
 
 Assuming the above, `Prefs` is instantiated like so:
@@ -321,13 +305,137 @@ prefs.ask
 ```
 ![alt text](https://raw.githubusercontent.com/bachya/cli-utils/master/res/readme-images/prefs-ask.png "Prefs.ask")
 
+### Prerequisites
+
+Sometimes, you need to answer certain prompts before others become relevant. `Prefs` allows this via a `prereqs` key, which can contain multiple already-answered key/value pairs to check for. For instance, imagine we want to drill into a user's superhero preference a bit further:
+
+```YAML
+prompts:
+  - prompt: Batman or Superman?
+    default: Batman
+    config_key: superhero
+    config_section: personal_info
+  - prompt: Do you feel smart for preferring Batman?
+    default: Y
+    config_key: batman_answer
+    config_section: personal_info
+    prereqs:
+      - config_key: superhero
+        config_value: Batman
+  - prompt: Why do you prefer Superman?!
+    default: No clue
+    config_key: superman_answer
+    config_section: personal_info
+    prereqs:
+      - config_key: superhero
+        config_value: Superman
+```
+
+`prereqs` checks for already-answered preferences (based on a Configurator key and value); assuming everything checks out, the subsequent preferences are collected:
+
+```Ruby
+prefs.ask
+```
+![alt text](https://raw.githubusercontent.com/bachya/cli-utils/master/res/readme-images/prefs-ask-prereqs.png "Prerequisities")
+
+Be careful tht you don't define any circular prerequisities (e.g., A requires B and B requires A). In that case, neither preference will be collected.
+
+### Options
+
+What if you want to limit a preference to a certain set of options? Easy! Imagine we want to expand the previous example and force the user to choose either "Batman" or "Superman":
+
+```YAML
+prompts:
+  - prompt: Batman or Superman?
+    default: Batman
+    config_key: superhero
+    config_section: personal_info
+    options: ['Batman', 'Superman']
+  - prompt: Do you feel smart for preferring Batman?
+    default: Y
+    config_key: batman_answer
+    config_section: personal_info
+    prereqs:
+      - config_key: superhero
+        config_value: Batman
+  - prompt: Why do you prefer Superman?!
+    default: No clue
+    config_key: superman_answer
+    config_section: personal_info
+    prereqs:
+      - config_key: superhero
+        config_value: Superman
+```
+
+Once in place:
+
+```Ruby
+prefs.ask
+```
+![alt text](https://raw.githubusercontent.com/bachya/cli-utils/master/res/readme-images/prefs-ask-options.png "Options")
+
+### Validators
+
+"But," you say, "I want to ensure that my user gives answers that conform to certain specifications!" Not a problem, dear user, `Prefs` has you covered:
+
+```YAML
+prompts:
+  - prompt: What is your name?
+    config_key: name
+    config_section: personal_info
+    validators:
+      - alphabetic
+  - prompt: How old are you?
+    config_key: age
+    config_section: personal_info
+    validators:
+      - numeric
+```
+
+```Ruby
+prefs.ask
+```
+![alt text](https://raw.githubusercontent.com/bachya/cli-utils/master/res/readme-images/prefs-ask-validators.png "Validators")
+
+`Prefs` currently supports these validators:
+
+* `alphabetic`: must be made up of letters and spaces
+* `alphanumeric`: must be made up of letters, numbers, and spaces
+* `date`: must be a parsable date (e.g., 2014-04-03)
+* `non_nil`: must be a non-nil value
+* `numeric`: must be made up of numbers
+* `url`: must be a fully-qualified URL
+
+### Behaviors
+
+Finally, a common desire might be to modify the user's answer in some way:
+
+```YAML
+prompts:
+  - prompt: Where is your SSH public key located?
+    config_key: pub_key
+    config_section: personal_info
+    behaviors:
+      - local_filepath
+```
+
+This will expand the user's answer as a filepath (e.g., `~/.ssh` will get saved as `/Users/bachya/.ssh/`).
+
+`Prefs` currently supports these behaviors:
+
+* `local_filepath`: runs File.expand_path on the answer
+
+### Adding Pref Responses to a Configurator
+
 Once the user has answered all the preference prompts, you can fold those answers back into a Configurator using the `ingest` method:
 
 ```Ruby
-configuration.ingest(prefs)
+configuration.ingest_prefs(prefs)
 configuration.save
 ```
 
+### Using Configurator Values as Defaults
+
 Note that you can also initialize a `Prefs` object with a Configurator:
 
 ```Ruby
@@ -336,10 +444,6 @@ prefs = CLIUtils::Prefs.new('path/to/yaml/file', my_configurator)
 
 In this case, `Prefs` will look to see if any values already exist for a specific prompt; if so, that value will be used as the default, rather than the default specified in the YAML.
 
-### Why a Prefs Class?
-
-I've written apps that need to request user input at various times for multiple different things; as such, I thought it'd be easier to have those scenarios chunked up. You can always wrap `Prefs` into a module singleton if you wish.
-
 # Known Issues
 
 * LoggerDelegator doesn't currently know what to do with `messenger.prompt`, so you'll have to manually log a `debug` message if you want that information logged.
@@ -348,6 +452,8 @@ I've written apps that need to request user input at various times for multiple
 
 To report bugs with or suggest features/changes for CLIUtils, please use the [Issues Page](http://github.com/bachya/cli-utils/issues).
 
+* Trello Board: [https://trello.com/b/qXs7Yeir/cliutils](https://trello.com/b/qXs7Yeir/cliutils "CLIUtils on Trello")
+
 # Contributing
 
 Contributions are welcome and encouraged. To contribute:

data/lib/cliutils/prefs/pref-behavior.rb

@@ -0,0 +1,14 @@
+module CLIUtils
+  # PrefBehavior Module
+  # Behaviors that should be applied to a Pref's
+  # final value
+  module PrefBehavior
+    # Expands the passed text (assumes it
+    # is a filepath).
+    # @param [String] text The text to evaluate
+    # @return [String]
+    def self.local_filepath(text)
+      File.expand_path(text)
+    end
+  end
+end

data/lib/cliutils/prefs/pref-validation.rb

@@ -0,0 +1,64 @@
+require 'uri'
+
+module CLIUtils
+  # PrefValidation Module
+  # Validation rules that can be applied to a Pref.
+  module PrefValidation
+    Validator = Struct.new(:code, :message)
+
+    # Validates that a value is only letters.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.alphabetic(text)
+      m = "Response is not alphabetic: #{ text }"
+      c = text.to_s =~ /\A[A-Za-z\s]+\z/
+      Validator.new(c, m)
+    end
+
+    # Validates that a value is only letters and numbers.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.alphanumeric(text)
+      m = "Response is not alphanumeric: #{ text }"
+      c = text.to_s =~ /\A[A-Za-z0-9\s]+\z/
+      Validator.new(c, m)
+    end
+    
+    # Validates that a value is a date.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.date(text)
+      m = "Response is not a date: #{ text }"
+      c = !(Date.parse(text) rescue nil).nil?
+      Validator.new(c, m)
+    end
+
+    # Validates that a value is passed and is not
+    # empty.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.non_nil(text)
+      m = "Nil text not allowed"
+      c = !text.nil? && !text.empty?
+      Validator.new(c, m)
+    end
+
+    # Validates that a value is some sort of number.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.numeric(text)
+      m = "Response is not a number: #{ text }"
+      c = text.to_s =~ /\A[-+]?\d*\.?\d+\z/
+      Validator.new(c, m)
+    end
+
+    # Validates that passed value is a URL.
+    # @param [String] text The text to inspect
+    # @return [Boolean]
+    def self.url(text)
+      m = "Response is not a url: #{ text }"
+      c = text.to_s =~ URI::DEFAULT_PARSER.regexp[:ABS_URI]
+      Validator.new(c, m)
+    end
+  end
+end

data/lib/cliutils/prefs/pref.rb

@@ -0,0 +1,142 @@
+require 'cliutils/messenging'
+require 'cliutils/prefs/pref-behavior'
+require 'cliutils/prefs/pref-validation'
+
+module CLIUtils
+  # Pref Class
+  # An individual preference
+  class Pref
+    include Messenging
+
+    # Stores the answer to this Pref.
+    # @return [String, Symbol]
+    attr_accessor :answer
+
+    # Stores the behaviors that this Pref conforms to.
+    # @return [Array]
+    attr_accessor :behaviors
+
+    # Stores a key to reference this pref in a Configurator.
+    # @return [String, Symbol]
+    attr_accessor :config_key
+
+    # Stores a Configurator section to stick this Pref under.
+    # @return [String, Symbol]
+    attr_accessor :config_section
+
+    # Stores the default text.
+    # @return [String]
+    attr_accessor :default
+
+    # Stores the last error message.
+    # @return [String]
+    attr_accessor :last_error_message
+
+    # Stores the valid options the user can pick from.
+    # @return [Array]
+    attr_accessor :options
+
+    # Stores the prereqs information.
+    # @return [Array]
+    attr_accessor :prereqs
+
+    # Stores the prompt text.
+    # @return [String]
+    attr_accessor :prompt
+    
+    # Stores key/value combinations required to show this Pref.
+    # @return [Hash]
+    attr_accessor :validators
+
+    # Initializes a new Pref via passed-in parameters.
+    # @param [Hash] params Parameters to initialize
+    # @return [void]
+    def initialize(params = {})
+      params.each { |key, value| send("#{ key }=", value) }
+    end
+
+    # Custom equality operator for this class.
+    # @param [Pref] other
+    # @return [Boolean]
+    def ==(other)
+      return self.answer == other.answer &&
+             self.behaviors == other.behaviors &&
+             self.config_key == other.config_key &&
+             self.config_section == other.config_section &&
+             self.default == other.default &&
+             self.last_error_message == other.last_error_message &&
+             self.options == other.options &&
+             self.prereqs == other.prereqs &&
+             self.prompt == other.prompt &&
+             self.validators == other.validators
+    end
+
+    # Runs the passed text through this Pref's behaviors.
+    # @param [String] text The text to evaluate
+    # @return [String]
+    def evaluate_behaviors(text)
+      if @behaviors
+        modified_text = text
+        @behaviors.each do |b|
+          if PrefBehavior.respond_to?(b)
+            modified_text = PrefBehavior.send(b, modified_text)
+          else
+            messenger.warn("Skipping undefined Pref behavior: #{ b }")
+          end
+        end
+        
+        modified_text
+      else
+        text
+      end
+    end
+
+    # Validates a text against this pref's options and
+    # validators.
+    # @param [String] text The text to validate
+    # @return [Boolean]
+    def validate(text)
+      _confirm_options(text) &&
+      _confirm_validators(text)
+    end
+    
+    private
+
+    # Validates a text against the options for this Pref
+    # @param [String] text The text to validate
+    # @return [Boolean]
+    def _confirm_options(text)
+      ret = true
+      if @options
+        unless @options.include?(text)
+          @last_error_message = "Invalid option chosen (\"#{ text }\"); valid options are: #{ options }"
+          ret = false
+        end
+      end
+
+      ret
+    end
+
+    # Validates a text against the validators for this Pref
+    # @param [String] text The text to validate
+    # @return [Boolean]
+    def _confirm_validators(text)
+      ret = true
+      if @validators
+        @validators.each do |v|
+          if PrefValidation.respond_to?(v)
+            validator = PrefValidation.send(v, text)
+            unless validator.code
+              @last_error_message = validator.message
+              ret = false
+            end
+          else
+            messenger.warn("Skipping undefined Pref validator: #{ v }")
+          end
+        end
+      end
+      
+      ret
+    end
+  end
+end

data/lib/cliutils/prefs.rb

@@ -1,14 +1,11 @@
+require 'cliutils/prefs/pref'
 require 'cliutils/pretty-io'
 
 module CLIUtils
   # Engine to derive preferences from a YAML file, deliver
   # those to a user via a prompt, and collect the results.
   class Prefs
-    include PrettyIO
-    # Stores answers to prompt questions.
-    # @return [Array]
-    attr_reader :answers
-    
+    include Messenging
     # Stores the filepath (if it exists) to the prefs file.
     # @return [String]
     attr_reader :config_path
@@ -18,8 +15,8 @@ module CLIUtils
     attr_reader :configurator
     
     # Stores answers to prompt questions.
-    # @return [Hash]
-    attr_reader :prompts
+    # @return [Array]
+    attr_reader :prefs
 
     # Reads prompt data from and stores it.
     # @param [<String, Hash, Array>] data Filepath to YAML, Hash, or Array
@@ -28,28 +25,26 @@ module CLIUtils
     def initialize(data, configurator = nil)
       @answers = []
       @configurator = configurator
-      @prompts = {}
+      @prefs = []
 
       case data
       when String
         if File.exists?(data)
           @config_path = data
-
-          prompts = YAML::load_file(data)
-          @prompts.deep_merge!(prompts).deep_symbolize_keys!
+          data = YAML::load_file(data).deep_symbolize_keys
+          @prefs = _generate_prefs(data)
         else
-          fail "Invalid configuration file: #{ data }"
+          fail "Invalid configuration file: #{ data }" 
         end
       when Hash
         @config_path = nil
-        
         data = {:prompts => data} unless data.keys[0] == :prompts
-        @prompts.deep_merge!(data).deep_symbolize_keys!
+        data.deep_symbolize_keys!
+        @prefs = _generate_prefs(data)
       when Array
         @config_path = nil
-
-        prompts = {:prompts => data}
-        @prompts.deep_merge!(prompts).deep_symbolize_keys!
+        data = {:prompts => data}.deep_symbolize_keys
+        @prefs = _generate_prefs(data)
       else
         fail 'Invalid configuration data'
       end
@@ -57,16 +52,16 @@ module CLIUtils
 
     # Runs through all of the prompt questions and collects
     # answers from the user. Note that all questions w/o
-    # requirements are examined first; once those are
-    # complete, questions w/ requirements are examined.
+    # prerequisites are examined first; once those are
+    # complete, questions w/ prerequisites are examined.
     # @return [void]
     def ask
-      @prompts[:prompts].reject { |p| p[:requirements] }.each do |p|
+      @prefs.reject { |p| p.prereqs }.each do |p|
         _deliver_prompt(p)
       end
-
-      @prompts[:prompts].find_all { |p| p[:requirements] }.each do |p|
-        _deliver_prompt(p) if _requirements_fulfilled?(p)
+      
+      @prefs.find_all { |p| p.prereqs }.each do |p|
+        _deliver_prompt(p) if _prereqs_fulfilled?(p)
       end
     end
 
@@ -77,42 +72,46 @@ module CLIUtils
     # @param [Hash] p The prompt
     # @return [void]
     def _deliver_prompt(p)
-      default = p[:default]
+      default = p.default
       
       unless @configurator.nil?
-        unless @configurator.data[p[:section].to_sym].nil?
-          config_val = @configurator.data[p[:section].to_sym][p[:key].to_sym]
+        unless @configurator.data[p.section.to_sym].nil?
+          config_val = @configurator.data[p.config_section.to_sym][p.config_key.to_sym]
           default = config_val unless config_val.nil?
         end
       end
-      
-      if p[:options].nil?
-        pref = prompt(p[:prompt], default)
-      else
-        valid_option_chosen = false
-        until valid_option_chosen
-          pref = prompt(p[:prompt], default)
-          if p[:options].include?(pref)
-            valid_option_chosen = true
-          else
-            error("Invalid option chosen (\"#{ pref }\"); valid options are: #{ p[:options] }")
-          end
+
+      valid_option_chosen = false
+      until valid_option_chosen
+        response = prompt(p.prompt, default)
+
+        if p.validate(response)
+          valid_option_chosen = true
+          p.answer = p.evaluate_behaviors(response)
+        else
+          messenger.error(p.last_error_message)
         end
       end
-      p[:answer] = pref
-      @answers << p
+    end
+
+    # Generates an Array of Prefs based on passed
+    # in data.
+    # @param [Hash] pref_data Loaded pref data
+    # @return [Array]
+    def _generate_prefs(pref_data_hash)
+      pref_data_hash[:prompts].map { |p| CLIUtils::Pref.new(p) }
     end
 
     # Utility method for determining whether a prompt's
-    # requirements have already been fulfilled.
+    # prerequisites have already been fulfilled.
     # @param [Hash] p The prompt
     # @return [void]
-    def _requirements_fulfilled?(p)
+    def _prereqs_fulfilled?(p)
       ret = true
-      p[:requirements].each do |req|
-        a = @answers.detect do |answer|
-          answer[:key] == req[:key] &&
-          answer[:answer] == req[:value]
+      p.prereqs.each do |req|
+        a = @prefs.detect do |answer|
+          answer.config_key == req[:config_key] &&
+          answer.answer == req[:config_value]
         end
         ret = false if a.nil?
       end

data/lib/cliutils/version.rb

@@ -1,4 +1,4 @@
 module CLIUtils
   # The current version of the gem
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/lib/cliutils.rb

@@ -8,6 +8,7 @@ require 'cliutils/configuration'
 require 'cliutils/logger-delegator'
 require 'cliutils/messenging'
 require 'cliutils/prefs'
+require 'cliutils/prefs/pref'
 require 'cliutils/version'
 
 # The CLIUtils module, which wraps everything

data/test/prefs_test.rb

@@ -1,13 +1,13 @@
-require 'fileutils'
+require 'cliutils/ext/hash+extensions'
+require 'cliutils/prefs'
+require 'cliutils/prefs/pref'
 require 'test/unit'
 require 'yaml'
 
-require File.join(File.dirname(__FILE__), '..', 'lib/cliutils/ext/Hash+Extensions')
-require File.join(File.dirname(__FILE__), '..', 'lib/cliutils/prefs')
-
 class TestPrefs < Test::Unit::TestCase
   def setup
-    @prefs_arr = [{:prompt=>"What is the hostname of your DD-WRT router?", :default=>"192.168.1.1", :key=>"hostname", :section=>"ssh_info"}, {:prompt=>"What is the SSH username of your DD-WRT router?", :default=>"root", :key=>"username", :section=>"ssh_info"}, {:prompt=>"What SSH port does your DD-WRT router use?", :default=>22, :key=>"port", :section=>"ssh_info"}, {:prompt=>"How do you use password or key authentication?", :default=>"password", :key=>"auth_method", :section=>"ssh_info", :options=>["password", "key"]}, {:prompt=>"Where is your key located?", :default=>"~/.ssh", :key=>"key_location", :section=>"ssh_info", :requirements=>[{:key=>"auth_method", :value=>"key"}]}, {:prompt=>"What is your password?", :key=>"password", :section=>"ssh_info", :requirements=>[{:key=>"auth_method", :value=>"password"}]}]
+    @prefs_arr = [{:prompt=>"Where is your SSH public key located?", :config_key=>"pub_key", :config_section=>"personal_info", :behaviors=>["local_filepath"]}]
+    @prefs_hash = {:prompts=>@prefs_arr}
     
     @prefs_filepath = '/tmp/prefstest.yaml'
     FileUtils.cp(File.join(File.dirname(__FILE__), '..', 'test/test_files/prefstest.yaml'), @prefs_filepath)
@@ -19,11 +19,22 @@ class TestPrefs < Test::Unit::TestCase
 
   def test_file_creation
     p = CLIUtils::Prefs.new(@prefs_filepath)
-    assert_equal(YAML::load_file(@prefs_filepath).deep_symbolize_keys!, p.prompts)
+    prefs = YAML::load_file(@prefs_filepath).deep_symbolize_keys
+
+    assert_equal(prefs[:prompts].map { |p| CLIUtils::Pref.new(p) }, p.prefs)
   end
 
-  def test_hash_creation
+  def test_array_creation
     p = CLIUtils::Prefs.new(@prefs_arr)
-    assert_equal({:prompts => @prefs_arr}.deep_symbolize_keys!, p.prompts)
+    prefs = @prefs_hash.deep_symbolize_keys
+  
+    assert_equal(prefs[:prompts].map { |p| CLIUtils::Pref.new(p) }, p.prefs)    
+  end
+
+  def test_hash_creation
+    p = CLIUtils::Prefs.new(@prefs_hash)
+    prefs = @prefs_hash.deep_symbolize_keys
+  
+    assert_equal(prefs[:prompts].map { |p| CLIUtils::Pref.new(p) }, p.prefs)
   end
 end

data/test/test_files/prefstest.yaml

@@ -1,36 +1,6 @@
 prompts:
-  - prompt: What is the local hostname of your DD-WRT router?
-    default: 192.168.1.1
-    key: local_hostname
-    section: ssh_info
-  - prompt: What is the remote hostname of your DD-WRT router?
-    key: remote_hostname
-    section: ssh_info
-  - prompt: What is the SSH username of your DD-WRT router?
-    default: root
-    key: username
-    section: ssh_info
-  - prompt: What SSH port does your DD-WRT router use?
-    default: 22
-    key: port
-    section: ssh_info
-  - prompt: Do you use password or key authentication?
-    default: password
-    key: auth_method
-    section: ssh_info
-    options: ['password', 'key']
-  - prompt: Where is your key located?
-    default: ~/.ssh
-    key: key_location
-    section: ssh_info
-    requirements:
-      - key: auth_method
-        value: key
-  - prompt: What is your password?
-    key: password
-    section: ssh_info
-    requirements:
-      - key: auth_method
-        value: password
-      
-    
+  - prompt: Where is your SSH public key located?
+    config_key: pub_key
+    config_section: personal_info
+    behaviors:
+      - local_filepath

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cliutils
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Aaron Bach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,11 +93,18 @@ files:
 - lib/cliutils/logger-delegator.rb
 - lib/cliutils/messenging.rb
 - lib/cliutils/prefs.rb
+- lib/cliutils/prefs/pref-behavior.rb
+- lib/cliutils/prefs/pref-validation.rb
+- lib/cliutils/prefs/pref.rb
 - lib/cliutils/pretty-io.rb
 - lib/cliutils/version.rb
 - res/readme-images/messenger-types-1.png
 - res/readme-images/messenger-warn.png
 - res/readme-images/multi-logger.png
+- res/readme-images/prefs-ask-behaviors.png
+- res/readme-images/prefs-ask-options.png
+- res/readme-images/prefs-ask-prereqs.png
+- res/readme-images/prefs-ask-validators.png
 - res/readme-images/prefs-ask.png
 - res/readme-images/prettyio-color-chart.png
 - res/readme-images/prettyio-gnarly-text.png