new 0.1.1 → 1.0.9

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 49de7a525567990df4a73895129d9016fd6cb025
-  data.tar.gz: a7187f5f73de9b3ccc126306e8243c8ad3377cde
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjNlNjUyMWY0NjY3ZjBjZThkZTM0MjQwODU1YTllYTNhNjYwZDBlZA==
+  data.tar.gz: !binary |-
+    NmQ4NmQ4NTUwZWU3ZTAwNmFkZTJkMjUzOTYwN2Y0M2FjMDc2MzExZg==
 SHA512:
-  metadata.gz: d2ee8c15e70e71526ba0681e8d81686e06c80eab051470938e26d89d3dbe6d37ea64ed996bb3da5baf065a48df299aadfddd7b80af946726112b21358d9f8221
-  data.tar.gz: f2784493ad68df62dc988f31d98b5045c1fdebf39b8f1442f3d975903d1d9470e9de1ca43444bb335d9d25d1e3f870da53a7c07c75848e852a802fcc02a01f76
+  metadata.gz: !binary |-
+    NmE3NjBmODFiNDMxODkzNTFmYTAzMjA5YTlhMzEwZWQ4NDU4MmI0MzhiOTJm
+    NzczOGVjOWY2Yzk2NzQ5NTI5YThhMGJkZDBiN2U3MzJkNTA4MDFjYTQ1N2Fk
+    NjM2MzZkZDFhYTUwZDQ3MzFiY2RlZjZjMGQwZmZhZGE4MDlmM2Q=
+  data.tar.gz: !binary |-
+    MzlhMWQ4OWFjYmNhMTQ5YzYxMWNiM2I4OGVlNDA3ZmRkNzViMzM5ODU4ZTYz
+    MTU0NmIyMGU3YTgwNmFlOGVlNTQ0M2Y5YTA1ZGZlMmU2YmZkODcyMWQ4YzRl
+    MDI2NzE4ODRlZDJjZDFiNDI1NWY0NjIzMzcxZjZmMDc2ZDFjNDc=

data/bin/new

@@ -1,6 +1,4 @@
 #!/usr/bin/env ruby
 $: << File.dirname(__FILE__) + '/../lib'
-
 require 'new'
-
 New::Cli.start ARGV

data/lib/new.rb

@@ -1,71 +1,144 @@
+require 'active_support/core_ext/hash/deep_merge'
 require 'yaml'
 
+# Allow true/false to respond to Boolean class
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+
 class New
-  VERSION = '0.0.1'
-  DEFAULT_DIR = File.expand_path('../..', __FILE__)
-  CUSTOM_DIR = File.expand_path('~/.new')
-  TASKS_DIR_NAME = 'tasks'
-  TEMPLATES_DIR_NAME = 'templates'
-  CONFIG_FILE = '.new'
-
-  # List all the available tasks
-  #
-  def self.tasks
-    custom_tasks | default_tasks
-  end
+  require 'new/validation'
+
+  require 'new/cli'
+  require 'new/source'
+  require 'new/task'
+
+  HOME_DIRECTORY = ENV['HOME']
+  PROJECT_DIRECTORY = Dir.pwd
+  NEWFILE_NAME = 'Newfile'
 
-  # List all the available templates
   #
-  def self.templates
-    custom_templates | default_templates
-  end
+  # CLASS METHODS
+  #
+  class << self
+    @@cli = false
+    @@verbose = false
+    @@new_object = {
+      :sources => {
+        :default => 'brewster1134/new-tasks'
+      }
+    }
 
-  def self.default_templates
-    @default_templates ||= get_list TEMPLATES_DIR_NAME, :default
-  end
+    # access the current new object
+    def new_object; @@new_object; end
 
-  def self.custom_templates
-    @custom_templates ||= get_list TEMPLATES_DIR_NAME, :custom
-  end
+    # set cli to true when initialized via cli
+    def set_cli; @@cli = true; end
 
-  def self.default_tasks
-    @default_tasks ||= get_list TASKS_DIR_NAME, :default
-  end
+    # set verbose to true when set via cli
+    def set_verbose; @@verbose = true; end
+    def verbose; @@verbose; end
 
-  def self.custom_tasks
-    @custom_tasks ||= get_list TASKS_DIR_NAME, :custom
-  end
+    # Load Newfile in home & project directory
+    #
+    def load_newfiles
+      load_newfile File.join(HOME_DIRECTORY, NEWFILE_NAME)
+      load_newfile File.join(PROJECT_DIRECTORY, NEWFILE_NAME)
+    end
+
+    # Merge symbolized hash data into global new object
+    #
+    # @param hash [Hash] A hash to be merged into existing data
+    #
+    # @return [Hash] New merged data
+    #
+    def new_object= hash
+      @@new_object.deep_merge! hash.deep_symbolize_keys
+    end
+
+  private
+
+    # Load newfile contents into the global new object
+    #
+    # @param newfile_path [String] Path to a valid Newfile
+    #
+    # @return [Hash] Hash of Newfile yaml contents
+    #
+    def load_newfile newfile_path
+      # check file exists
+      return false unless File.file? newfile_path
 
-  def self.custom_config
-    @custom_config ||= YAML.load(File.open(File.join(CUSTOM_DIR, CONFIG_FILE))).deep_symbolize_keys! rescue {}
+      # load Newfile yaml into global new_object hash
+      self.new_object = YAML.load File.read newfile_path
+    end
   end
 
 private
 
-  def self.get_list dir, filter
-    case filter
-    when :default
-      Dir[File.join(DEFAULT_DIR, dir, '**')]
-    when :custom
-      Dir[File.join(CUSTOM_DIR, dir, '**')]
-    end.map{ |d| File.basename(d).to_sym }
-  end
-end
+  def initialize version, changelog, *skip_tasks
+    # load newfiles and sources
+    New.load_newfiles unless @@cli
+    New::Source.load_sources
 
-# core
-require 'new/core'
+    # update options with new attributes
+    @@new_object[:version] = version
+    @@new_object[:changelog] = changelog
 
-# modules
-require 'new/dsl'
-require 'new/interpolate'
-require 'new/version'
+    # create new options to pass to task
+    new_options = @@new_object.dup
+    new_options.delete(:sources)
+    new_options.delete(:tasks)
 
-# classes
-require 'new/cli'
-require 'new/project'
-require 'new/template'
-require 'new/task'
+    new_tasks = []
+    @@new_object[:tasks].each do |task_name, task_options|
+      # skip tasks
+      next if skip_tasks.include? task_name.to_s
 
-class New
-  extend New::Dsl
+      S.ay "Preparing `#{task_name}`", :header
+
+      # dupe task options
+      new_task_options = task_options ? task_options.dup : {}
+
+      # lookup and add task to array
+      task = New::Source.find_task task_name, new_task_options.delete(:source)
+      new_tasks << task
+
+      # add task options
+      new_options[:task_options] = new_task_options
+
+      # set options
+      task.options = new_options.dup
+
+      # validate task before running anything
+      S.ay 'Validating Options: ', :highlight_key
+      task.validate
+      S.ay 'OK', :highlight_value
+
+      # verify tasks
+      S.ay 'Verifying Task Dependencies: ', :highlight_key
+      task.verify
+      S.ay 'OK', :highlight_value
+      S.ay
+    end
+
+    # write new Newfile with new version
+    new_newfile = YAML.load(File.read(File.join(PROJECT_DIRECTORY, NEWFILE_NAME)))
+    new_newfile['version'] = version
+    File.open File.join(PROJECT_DIRECTORY, NEWFILE_NAME), 'w+' do |f|
+      f.write new_newfile.to_yaml
+    end
+
+    new_tasks.each do |task|
+      S.ay "Running `#{task.name}`", :header
+      task.run
+    end
+
+    # release summary
+    S.ay
+    S.ay 'Version ', :newline => false
+    S.ay "#{@@new_object[:version]}", :preset => :header, :newline => false
+    S.ay ' of ', :newline => false
+    S.ay "#{@@new_object[:name]}", :preset => :header, :newline => false
+    S.ay ' successfully released!'
+  end
 end

data/lib/new/cli.rb

@@ -1,94 +1,541 @@
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/keys'
+require 'cli_miami'
+require 'listen'
+require 'pp'
+require 'semantic'
 require 'thor'
 require 'yaml'
 
+CliMiami.set_preset :error, :color => :red
+CliMiami.set_preset :fine_print, :color => :cyan
+CliMiami.set_preset :header, :color => :green
+CliMiami.set_preset :highlight_key, :indent => 2, :newline => false, :padding => 30, :justify => :rjust
+CliMiami.set_preset :highlight_value, :color => :blue, :style => :bright, :indent => 1
+CliMiami.set_preset :instruction, :color => :yellow, :indent => 2
+CliMiami.set_preset :list_item, :indent => 2
+CliMiami.set_preset :prompt, :color => :yellow, :style => :bold
+
+# create a horizontal line
+HR = -> {S.ay('-' * 32 , :header)}
+
 class New::Cli < Thor
-  desc '[TEMPLATE] [NAME]', "Create a new project with a given template (#{New.templates.join(' ')})"
-  # option :name, required: true
-  def method_missing method, *args
-    if New.templates.include? method.to_sym
-      # Split args that look like options (i.e start with - or --) into a separate array
-      positional_args, opts = Thor::Options.split args
-
-      # extract name from args
-      name = positional_args[0]
-      raise Thor::RequiredArgumentMissingError unless name
-
-      # Add all options here
-      # Make sure to include required options up above as well so they show in the help menu
-      parser = Thor::Options.new(
-      #   name: Thor::Option.new(:name, required: true, type: :string)
-      )
-
-      # The options hash is frozen in #initialize so you need to merge and re-assign
-      self.options = options.merge(parser.parse(opts)).freeze
-
-      # Dispatch the command
-      project method, name
-    else
-      super
+  desc 'init', 'Create a Newfile for your project'
+  option :name, :type => :string, :aliases => ['-n'], :default => '', :desc => 'Your project name'
+  option :version, :type => :string, :aliases => ['-v'], :default => '', :desc => 'Your project\'s current version'
+  option :tasks, :type => :array, :aliases => ['-t'], :default => [], :desc => 'Tasks to run when releasing your project'
+  def init
+    New.load_newfiles
+    New::Source.load_sources
+
+    # initialize empty newfile object
+    newfile_object = {
+      :tasks => {}
+    }
+
+    # get valid name
+    name = @options['name']
+    until !name.empty?
+      name = A.sk 'Project Name:', :prompt
+    end
+    newfile_object[:name] = name
+
+    # get valid version
+    version = Semantic::Version.new(@options['version']) rescue nil
+    until !version.to_s.empty?
+      begin
+        response = A.sk 'Current Project Version:', :prompt
+        version = Semantic::Version.new response
+      rescue
+        S.ay "`#{response}` is not a valid semantic version (e.g. 1.2.3)", :error
+      end
+    end
+    newfile_object[:version] = version.to_s
+
+    # get tasks
+    tasks_list = []
+    @options['tasks'].each do |task|
+      tasks_list << New::Source.find_task(task)
+    end
+
+    # remove any empty tasks in case the user specified an invalid task
+    tasks_list.compact!
+
+    # if no tasks are specified, show all available tasks
+    if tasks_list.empty?
+      S.ay
+      self.tasks :show_source => true, :load_newfiles => false, :load_sources => false
+
+      S.ay 'Add multiple tasks by pressing ENTER after each one', :instruction
+      S.ay 'Enter tasks in the order you want them to run', :instruction
+      S.ay 'Enter both the source and the task (e.g. source#task)', :instruction
+      S.ay 'Enter an empty value to finish', :instruction
+
+      added_task = nil
+      until added_task == '' && !tasks_list.empty?
+        S.ay
+        added_task = A.sk 'Add a task:', :prompt
+
+        # if a task is entered, verify it exists
+        unless added_task.empty?
+
+          # find task
+          task = New::Source.find_task added_task
+
+          # add task to array
+          if task
+            tasks_list << task
+          end
+        end
+      end
+
+      S.ay
+    end
+
+    # output the summary so far (no task options entered yet)
+    padding = 10
+    S.ay 'Name:', :preset => :highlight_key, :padding => padding
+    S.ay name, :preset => :highlight_value
+    S.ay 'Version:', :preset => :highlight_key, :padding => padding
+    S.ay version.to_s, :preset => :highlight_value
+    S.ay 'Tasks:', :preset => :highlight_key, :padding => padding
+
+    # output first task without a padding so it looks nicer
+    tasks_dup = tasks_list.dup
+    first_task = tasks_dup.shift
+    S.ay "#{first_task.source.name}##{first_task.name}", :highlight_value
+    tasks_dup.each do |task|
+      S.ay "#{task.source.name}##{task.name}", :preset => :highlight_value, :indent => padding + 3
+    end
+    S.ay
+
+    tasks_list.each do |task|
+      HR.call
+      S.ay 'OK, now lets set options for', :highlight_key
+      S.ay task.name.to_s.upcase, :highlight_value
+      HR.call
+      S.ay
+
+      newfile_object[:tasks][task.name] = {}
+      task.class_options.each do |option_name, option_settings|
+        S.ay option_name.to_s, :preset => :highlight_key, :padding => 0
+        S.ay option_settings[:description], :highlight_value
+
+        # show default
+        default = option_settings[:default]
+        if default && !option_settings[:required]
+          default = case default
+          when Array then default.join(', ')
+          when Hash then default.keys.join(', ')
+          else default.to_s
+          end
+
+          S.ay "default: #{default}", :preset => :fine_print, :indent => option_name.length + 3
+        end
+
+        # GET USER INPUT FOR ARRAY TYPE
+        #
+        option_type = option_settings[:type]
+        case
+
+        # collect array option type values
+        when option_type == Array
+          # cast type onto all user input values (default is String)
+          klass = option_settings[:validation] || String
+
+          # collect array elements from the user
+          option_value = nil
+          until option_value
+            begin
+              option_value = get_array_from_user(klass)
+              option_value = New::Task.validate_option(option_name, option_settings, option_value)
+            rescue
+              option_value = nil
+            end
+          end
+
+        # collect hash option type values
+        when option_type == Hash
+          # loop through the expected keys from the validation and get users input
+          option_value = nil
+          until option_value
+            begin
+              option_value = get_hash_from_user(option_settings[:validation])
+              option_value = New::Task.validate_option(option_name, option_settings, option_value)
+            rescue
+              option_value = nil
+            end
+          end
+
+        # collect non array/hash option type value
+        else
+          option_value = nil
+          until option_value
+            A.sk '', :newline => false, :preset => :prompt do |response|
+              option_value = New::Task.validate_option(option_name, option_settings, response) rescue nil
+            end
+          end
+        end
+
+        newfile_object[:tasks][task.name][option_name] = option_value
+        S.ay
+      end
+    end
+
+    # write project Newfile
+    project_newfile = File.join New::PROJECT_DIRECTORY, New::NEWFILE_NAME
+    File.open project_newfile, 'w+' do |f|
+      f.write newfile_object.deep_stringify_keys.to_yaml
     end
+
+    # Success Message
+    S.ay "A `#{'Newfile'.green}` was successfully created for your project `#{name.to_s.green}`"
+    S.ay 'Open the file to verify the values are correct, and make any neccessary modifications.'
+    S.ay "You are now ready to run `#{'new release'.green}` to release your software into the wild!"
+    S.ay
   end
 
-  desc 'init', 'Set up your home directory folder for storing custom templates and default configuration'
-  def init
-    if Dir.exists? New::CUSTOM_DIR
-      New.say 'Home folder already exists.', type: :warn
-    else
-      # create folders
-      New.say 'Creating home folder.', type: :success
-      FileUtils.mkdir_p File.join(New::CUSTOM_DIR, New::TASKS_DIR_NAME)
-      FileUtils.mkdir_p File.join(New::CUSTOM_DIR, New::TEMPLATES_DIR_NAME)
-
-      # create config file
-      New.say 'Creating default configuration file.', type: :success
-      File.open File.join(New::CUSTOM_DIR, New::CONFIG_FILE), 'w' do |f|
-        f.write New::Template::CUSTOM_CONFIG_TEMPLATE.deep_stringify_keys.to_yaml
+  desc 'tasks', 'List all available tasks'
+  option :sources, :type => :boolean, :aliases => ['-s'], :default => false, :desc => 'Show/Hide task sources'
+  def tasks args = {}
+    # merge into default options
+    options = {
+     :show_source => (@options['sources'] || false),
+     :load_newfiles => true,
+     :load_sources => true
+    }.merge(args)
+
+    New.load_newfiles if options[:load_newfiles]
+    if options[:load_sources]
+      S.ay
+      S.ay 'Fetching sources...', :header
+      S.ay "Use the #{'green'.green} value for defining task sources in your Newfile", :indent => 2 if options[:show_source]
+      S.ay
+      New::Source.load_sources
+    end
+
+    New::Source.sources.each do |source_name, source|
+      # determine the widest task & add some padding
+      longest_task_length = source.tasks.keys.map(&:length).max
+
+      S.ay source_name.to_s, :indent => 2, :newline => false, :style => :underline
+      S.ay source.path, :highlight_value
+
+      source.tasks.each do |task_name, task|
+        if options[:show_source]
+          padding = longest_task_length + source_name.to_s.length + 2
+          S.ay "#{source_name}##{task_name}", :preset => :header, :newline => false, :indent => 2, :padding => padding, :justify => :ljust
+        else
+          padding = longest_task_length + 2
+          S.ay task_name.to_s, :preset => :header, :newline => false, :indent => 2, :padding => padding, :justify => :ljust
+        end
+        S.ay task.description, :indent => 2
       end
 
-      New.say "Edit `#{File.join(New::CUSTOM_DIR, New::CONFIG_FILE)}` with your custom configuration details.", type: :warn
+      S.ay
     end
   end
 
-  desc 'release', 'Release your new code (Run from within a project directory!)'
+  desc 'release', 'Release a new version of your project'
+  option :verbose, :type => :boolean, :aliases => ['-v'], :default => false, :desc => 'Verbose mode'
+  option :skip, :type => :array, :aliases => ['-s'], :default => [], :desc => 'Tasks to skip for this release'
   def release
-    project_config_file = File.join(Dir.pwd,  New::CONFIG_FILE)
-    raise unless File.exists? project_config_file
+    New.set_verbose if @options['verbose']
+    New.set_cli
+    New.load_newfiles
 
-    # get project config file
-    project_config = YAML.load(File.open(project_config_file)).deep_symbolize_keys!
+    # request the version to bump
+    S.ay
+    S.ay 'Releasing a new version of: ', :highlight_key
+    S.ay New.new_object[:name], :highlight_value
+    S.ay 'What do you want to bump: ', :highlight_key
+    S.ay "[#{'Mmp'.green}] (#{'M'.green}ajor / #{'m'.green}inor / #{'p'.green}atch)", :preset => :highlight_value, :color => :white
+    version = Semantic::Version.new New.new_object[:version]
+    version_bump_part = nil
+    until version_bump_part
+      S.ay 'Current Version:', :highlight_key
+      A.sk version.to_s, :highlight_value do |response|
+        version_bump_part = case response
+        when 'M'
+          version.major += 1
+          version.minor = 0
+          version.patch = 0
+        when 'm'
+          version.minor += 1
+          version.patch = 0
+        when 'p'
+          version.patch += 1
+        else
+          S.ay 'You must choose from [Mmp]', :error
+          nil
+        end
+      end
+    end
+    S.ay 'New Version: ', :highlight_key
+    S.ay version.to_s, :highlight_value
+    S.ay
 
-    # extract tasks from configuration
-    tasks = (project_config[:tasks] || {}).keys.map(&:to_sym)
+    # collect a list of changes in this version
+    changelog = get_changelog_from_user
+    S.ay
 
-    tasks.each do |task|
-      # require custom task and initialize it
-      begin
-        if New.custom_tasks.include? task
-          require "#{New::CUSTOM_DIR}/#{New::TASKS_DIR_NAME}/#{task}/#{task}"
-        else
-          require "#{New::DEFAULT_DIR}/#{New::TASKS_DIR_NAME}/#{task}/#{task}"
+    # show tasks
+    S.ay "#{'Running Tasks:'.green} (in order)"
+    skip_tasks = @options['skip'].map(&:to_sym)
+    New.new_object[:tasks].keys.each do |task|
+      if skip_tasks.include?(task)
+        S.ay "#{task.to_s} (skipped)", :preset => :fine_print, :indent => 4
+      else
+        S.ay task.to_s, :indent => 2
+      end
+    end
+    S.ay
+
+    New.new version.to_s, changelog, @options['skip']
+  end
+
+  desc 'version', 'Show the current version'
+  def version
+    New.load_newfiles
+    S.ay New.new_object[:name], :highlight_key
+    S.ay New.new_object[:version], :highlight_value
+  end
+
+  desc 'test', 'Run task tests from sources'
+  option :watch, :type => :boolean, :aliases => ['-w'], :desc => 'Watch local tasks for changes and run tests'
+  option :source, :type => :string, :aliases => ['-s'], :desc => 'Source name'
+  option :task, :type => :string, :aliases => ['-t'], :desc => 'Task name'
+  def test
+    spec_paths = []
+    watch_dirs = []
+
+    New.load_newfiles
+    New::Source.load_sources
+
+    # create a hash with a single source if one is passed
+    sources = if @options['source']
+      source_name = @options['source'].to_sym
+      source_hash = {}
+      source_hash[source_name] = New::Source.sources[source_name]
+      source_hash
+    else
+      New::Source.sources
+    end
+
+    # collect specs to run/watch
+    sources.each do |source_name, source|
+      next unless source
+
+      # create a hash with a single task if one is passed
+      tasks = @options['task'] ? [source.tasks[options['task'].to_sym]] : source.tasks
+      tasks = if @options['task']
+        task_name = @options['task'].to_sym
+        task_hash = {}
+        task_hash[task_name] = source.tasks[task_name]
+        task_hash
+      else
+        source.tasks
+      end
+
+      tasks.each do |task_name, task|
+        next unless task.path
+
+        spec_path = File.join(File.dirname(task.path), "#{task_name}_task_spec.rb")
+
+        # if the source/task has a spec file, and the source is local, watch the task directory for changes and run the spec whenever anything changes
+        if File.file?(spec_path) && File.directory?(source.path)
+          # find task directory in original path, not the sourcerer tmp directory
+          original_task_dir_path = File.dirname(Dir[File.join(source.path, '**', File.basename(task.path))][0])
+
+          watch_dirs << original_task_dir_path
+          spec_paths << spec_path
         end
-      rescue LoadError
-        New.say "No task '#{task}' found!", type: :fail
-        next
       end
-      New.say ">>> Initializing #{task.to_s.humanize} Task...", type: :warn
-      "New::Task::#{task.to_s.classify}".constantize.new project_config
+    end
+
+    # run tests
+    if !spec_paths.empty?
+      # S.ay "Running tests for `#{task_name}` task in `#{source_name}` source...", :warn
+      Kernel::system "bundle exec rspec #{spec_paths.join(' ')}"
+    end
+
+    # watch tests
+    # if watch files are found, start a listener to run the spec
+    if @options['watch'] && !watch_dirs.empty?
+      listener = Listen.to *watch_dirs do |modified, added, removed|
+        all = modified + added + removed
+
+        # find sibling spec file from modified file
+        spec_path = all.collect{ |file| Dir[File.join(File.dirname(file), '*_spec.rb')] }.flatten.first
+
+        Kernel::system "bundle exec rspec #{spec_path}"
+      end
+      listener.start
+      Kernel::sleep
     end
   end
 
-private
+  no_commands do
+    def get_changelog_from_user
+      S.ay 'Lets add some items to the changelog', :header
+      S.ay 'Add multiple entries by pressing ENTER after each one', :instruction
+      S.ay 'Enter an empty value to finish', :instruction
 
-  def project template, name
-    if Dir.exists? File.join(Dir.pwd, name)
-      New.say "A project named #{name} already exists...", type: :warn
-      New.say "                       Overwrite it? [Yn]", type: :warn
-      exit if STDIN.gets.chomp! != 'Y'
+      user_changelog = []
+      user_response = nil
 
-      # Delete existing project
-      FileUtils.rm_rf File.join(Dir.pwd, name)
+      # add entries to the changelog until an empty string is entered
+      until user_response == '' && !user_changelog.empty?
+        A.sk user_changelog.compact.join("\n"), :prompt do |response|
+          if response.empty?
+            user_response = ''
+            next
+          end
+
+          user_changelog << user_response = response
+        end
+      end
+
+      user_changelog
     end
 
-    New::Project.new template, name
+    def get_array_from_user validation = String
+      # start to build the array of user values
+      user_array = []
+
+      # convert array to hash of Strings
+      if validation.is_a? Array
+        validation_hash = {}
+        validation.each do |v|
+          validation_hash[v.to_sym] = String
+        end
+        validation = validation_hash
+      end
+
+      if validation.is_a? Hash
+        S.ay 'We need to collect a list of complex objects', :header
+
+        user_response = nil
+        until user_response == 'n'
+          S.ay "#{user_array.length} objects created: ", :indent => 2, :newline => false
+          S.ay user_array.join(', '), :highlight_value
+          A.sk 'Press ENTER to create another object.  Enter `n` to stop.', :prompt do |response|
+            if response == 'n'
+              user_response = 'n'
+              next
+            end
+
+            user_response = get_hash_from_user(validation, false)
+            user_array << user_response
+          end
+        end
+
+      else
+        S.ay "We need to collect a list of #{validation}s", :header
+        S.ay 'Add multiple values by pressing ENTER after each one', :instruction
+        S.ay 'Enter an empty value to finish', :instruction
+
+        # add to the array until an empty string is entered
+        user_response = nil
+        until user_response == ''
+          A.sk user_array.compact.join(', '), :prompt do |response|
+
+            # if the option is valid, pass through the empty string to end entering values
+            if response.empty?
+              user_response = ''
+              next
+            end
+
+            user_response = New::Task.validate_class(response, validation) rescue nil
+            user_array << user_response
+          end
+        end
+      end
+
+      return user_array.compact
+    end
+
+    def get_hash_from_user validation = {}, allow_custom_keys = true
+      # start to build the hash of user values
+      user_hash = {}
+
+      # convert array to hash of Strings
+      if validation.is_a? Array
+        validation_hash = {}
+        validation.each do |v|
+          validation_hash[v.to_sym] = String
+        end
+        validation = validation_hash
+      end
+
+      # get user values for required validation keys
+      validation.each do |key, klass|
+        S.ay 'We need to collect some required values', :header
+
+        user_response = nil
+        until user_response
+
+          # do not allow nested arrays/hashes
+          # these should be declared as their own option
+          if klass == Array || klass == Hash
+            S.ay 'Hash options cannot have nested Arrays or Hashes. They should be declared as their own option.', :error
+            exit
+          end
+
+          A.sk "Enter a VALUE for `#{key}`", :prompt do |response|
+            # make sure validation keys have a value
+            if response == ''
+              user_response = nil
+              next
+            end
+
+            begin
+              user_response = New::Task.validate_class(response, klass)
+              user_hash[key] = user_response
+              S.ay user_hash
+            rescue
+              user_response = nil
+            end
+          end
+        end
+      end
+
+      if allow_custom_keys
+        # Allow users to enter custom keys AND values
+        S.ay 'You can add custom keys & values if you want', :header
+        S.ay 'Add multiple key/value pairs by pressing ENTER after each one', :instruction
+        S.ay 'Enter an empty key to finish', :instruction
+
+        user_key_response = nil
+        until user_key_response == ''
+          A.sk 'Enter a KEY name', :prompt do |key_response|
+            # exit loop if user is done entering info
+            if key_response == ''
+              user_key_response = ''
+              next
+            end
+
+            user_value_response = nil
+            until user_value_response
+              A.sk "Enter a VALUE for `#{key_response}`", :prompt do |value_response|
+                # make sure value exists for user created key
+                if value_response == ''
+                  user_value_response = nil
+                  next
+                end
+
+                # create key/value pair
+                user_hash[key_response.to_sym] = user_value_response = value_response
+                S.ay user_hash
+              end
+            end
+          end
+        end
+      end
+
+      return user_hash
+    end
   end
+
+  default_task :release
 end