escort 0.1.0 → 0.2.0

data/lib/escort/option_dependency_validator.rb

@@ -0,0 +1,83 @@
+module Escort
+  class OptionDependencyValidator
+    class << self
+      def for(parser)
+        self.new(parser)
+      end
+    end
+
+    attr_reader :parser
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def validate(options, dependencies)
+      dependencies.each_pair do |option_name, dependency_rules|
+        ensure_dependencies_satisfied_for(option_name, dependency_rules, options)
+      end
+      options
+    end
+
+    private
+
+    def option_exists?(option)
+      parser.specs.keys.include?(option)
+    end
+
+    def ensure_dependencies_satisfied_for(option_name, dependency_rules, options)
+      ensure_dependency_for_valid_option(option_name)
+      dependency_rules.each do |rule|
+        case rule
+        when Hash
+          handle_all_option_value_dependency_rules(option_name, rule, options)
+        else
+          ensure_option_depends_on_valid_option(option_name, rule)
+          handle_possible_presence_dependency_issue(option_name, rule, options)
+        end
+      end
+    end
+
+    def handle_all_option_value_dependency_rules(option_name, rule, options)
+      if option_was_specified?(option_name, options)
+        rule.each_pair do |rule_option, rule_option_value|
+          ensure_option_depends_on_valid_option(option_name, rule_option)
+          handle_possible_option_value_dependency_issue(option_name, rule_option, rule_option_value, options)
+        end
+      end
+    end
+
+    def handle_possible_option_value_dependency_issue(option_name, rule_option, rule_option_value, options)
+      unless options[rule_option] == rule_option_value
+        raise Escort::UserError.new("Option dependency unsatisfied, '#{option_name}' depends on '#{rule_option}' having value '#{rule_option_value}', '#{option_name}' specified with value '#{options[option_name]}', but '#{rule_option}' is '#{options[rule_option]}'")
+      end
+    end
+
+    def handle_possible_presence_dependency_issue(option_name, rule, options)
+      if option_was_specified?(option_name, options) && option_was_unspecified?(rule, options)
+        raise Escort::UserError.new("Option dependency unsatisfied, '#{option_name}' depends on '#{rule}', '#{option_name}' specified with value '#{options[option_name]}', but '#{rule}' is unspecified")
+      end
+    end
+
+    def option_was_unspecified?(option_name, options)
+      !option_was_specified?(option_name, options)
+    end
+
+
+    def option_was_specified?(option_name, options)
+      !options[option_name].nil? && !(options[option_name] == []) && !(options[option_name] == false)
+    end
+
+    def ensure_dependency_for_valid_option(option_name)
+      unless option_exists?(option_name)
+        raise Escort::ClientError.new("Dependency specified for option '#{option_name}', but no such option was defined, perhaps you misspelled it")
+      end
+    end
+
+    def ensure_option_depends_on_valid_option(option_name, rule)
+      unless option_exists?(rule)
+        raise Escort::ClientError.new("'#{option_name}' is set up to depend on '#{rule}', but '#{rule}' does not appear to be a valid option, perhaps it is a spelling error")
+      end
+    end
+  end
+end

data/lib/escort/option_parser.rb

@@ -54,6 +54,7 @@ module Escort
       parser.version(setup.version)                                   #set the version if it was provided
       parser.help_formatter(Escort::Formatter::DefaultHelpFormatter.new(setup, context))
       parsed_options = parse_options_string(parser, cli_options)
+      Escort::OptionDependencyValidator.for(parser).validate(parsed_options, setup.dependencies_for(context))
       Escort::Validator.for(parser).validate(parsed_options, setup.validations_for(context))
     end
 
@@ -66,12 +67,21 @@ module Escort
     end
 
     def add_option_conflicts_to(parser, context = [])
-      setup.conflicting_options_for(context).each do |conflict_list|
+      conflicting_options_for_context = setup.conflicting_options_for(context)
+      conflicting_options_for_context.keys.each do |option_name|
+        conflict_list = [option_name] + conflicting_options_for_context[option_name]
+        conflict_list.each do |option|
+          raise Escort::ClientError.new("Conflict defined with option '#{option}', but this option does not exist, perhaps it is a spelling error.") unless option_exists?(parser, option)
+        end
         parser.conflicts *conflict_list
       end
       parser
     end
 
+    def option_exists?(parser, option)
+      parser.specs.keys.include?(option)
+    end
+
     def default_option_values_from_config_for(parser, context)
       unless configuration.empty?
         parser.specs.each do |sym, opts|

data/lib/escort/setup/configuration/reader.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module Escort
   module Setup
     module Configuration

data/lib/escort/setup/configuration/writer.rb

@@ -1,5 +1,3 @@
-require 'json'
-
 module Escort
   module Setup
     module Configuration

data/lib/escort/setup/dsl/command.rb

@@ -21,11 +21,8 @@ module Escort
           Action.action(@name, @action, &block)
         end
 
-        def validations(&block)
-          Validations.validations(@name, @validations, &block)
-        end
-
         def command(name, options = {}, &block)
+          raise Escort::ClientError.new("Parameter to 'requires_arguments' must be a boolean") unless [true, false].include?(boolean)
           options[:requires_arguments] = @requires_arguments
           command = Command.new(name.to_sym, options, &block)
           aliases = [options[:aliases] || []].flatten + [name]
@@ -43,7 +40,7 @@ module Escort
         end
 
         def conflicting_options(*command_names)
-          @conflicts << command_names
+          raise Escort::ClientError.new("This interface for specifying conflicting options is no longer supported, please use 'opts.conflict' in the options block")
         end
 
         def summary(summary)
@@ -61,11 +58,9 @@ module Escort
           @commands = {}
           @options = Options.new(name)
           @action = Action.new(name)
-          @validations = Validations.new(name)
           @name = nil
           @description = nil
           @aliases = []
-          @conflicts = []
           @summary = nil
         end
       end

data/lib/escort/setup/dsl/global.rb

@@ -17,10 +17,6 @@ module Escort
           Action.action(:global, @action, &block)
         end
 
-        def validations(&block)
-          Validations.validations(:global, @validations, &block)
-        end
-
         def command(name, options = {}, &block)
           options[:requires_arguments] = @requires_arguments
           command = Command.new(name.to_sym, options, &block)
@@ -31,7 +27,7 @@ module Escort
         end
 
         def requires_arguments(boolean = true)
-          #TODO raise a client error if the value is anything besides true or false
+          raise Escort::ClientError.new("Parameter to 'requires_arguments' must be a boolean") unless [true, false].include?(boolean)
           @requires_arguments = boolean
           @commands.each do |command|
             command.requires_arguments(boolean)
@@ -54,9 +50,8 @@ module Escort
           @description = description
         end
 
-
         def conflicting_options(*command_names)
-          @conflicts << command_names
+          raise Escort::ClientError.new("This interface for specifying conflicting options is no longer supported, please use 'opts.conflict' in the options block")
         end
 
         private
@@ -69,9 +64,7 @@ module Escort
           @requires_arguments = false
           @options = Options.new
           @action = Action.new
-          @validations = Validations.new
           @config_file  = nil
-          @conflicts = []
         end
 
         def set_instance_variable_on(instance, instance_variable, value)

data/lib/escort/setup/dsl/options.rb

@@ -13,11 +13,67 @@ module Escort
         def initialize(command_name = :global)
           @command_name = command_name
           @options = {}
+          @dependencies = {}
+          @conflicts = {}
+          @validations = {}
         end
 
         def opt(name, desc="", opts={})
           opts[:desc] ||= desc
           @options[name] ||= opts
+          dependency(name, :on => opts[:depends_on]) if opts[:depends_on]
+          conflict(*[name, opts[:conflicts_with]].flatten) if opts[:conflicts_with]
+        end
+
+        def validate(name, description, &block)
+          @validations[name] ||= []
+          @validations[name] << {:desc => description, :block => block}
+        end
+
+        def dependency(option_name, opts = {})
+          ensure_dependency_specification_syntax(opts)
+          @dependencies[option_name] ||= []
+          rules_as_array(opts).each do |rule|
+            ensure_no_self_dependency(option_name, rule)
+            @dependencies[option_name] << rule
+          end
+        end
+
+        def conflict(*opts)
+          opts.each do |opt|
+            conflicts_for_opt = opts.reject{|value| value == opt}
+            @conflicts[opt] ||= []
+            @conflicts[opt] += conflicts_for_opt
+            @conflicts[opt].uniq!
+          end
+        end
+
+        private
+        def ensure_no_self_dependency(option_name, rule)
+          case rule
+          when Hash
+            rule.each_pair do |rule_option, rule_option_value|
+              handle_possible_self_dependency(option_name, rule_option)
+            end
+          else
+            handle_possible_self_dependency(option_name, rule)
+          end
+        end
+
+        def ensure_dependency_specification_syntax(opts)
+          unless opts[:on]
+            raise Escort::ClientError.new("Problem with syntax of dependency specification in #{@command_name} options block, #{option_name} missing ':on' condition")
+          end
+        end
+
+        def rules_as_array(opts)
+          [opts[:on]].flatten
+        end
+
+        def handle_possible_self_dependency(option_name, rule)
+          if option_name == rule
+            raise Escort::ClientError.new("Problem with syntax of dependency specification in #{@command_name} options block, #{option_name} is set to depend on itself")
+          end
         end
       end
     end

data/lib/escort/setup_accessor.rb

@@ -14,17 +14,22 @@ module Escort
 
     def conflicting_options_for(context = [])
       with_context(context) do |current_context|
-        conflict_lists_for(current_context)
+        conflicts_hash_for(current_context)
       end
     end
 
-
     def validations_for(context = [])
       with_context(context) do |current_context|
         validations_hash_from(current_context)
       end
     end
 
+    def dependencies_for(context = [])
+      with_context(context) do |current_context|
+        dependencies_hash_from(current_context)
+      end
+    end
+
     def command_names_for(context = [])
       with_context(context) do |current_context|
         command_names_from(current_context)
@@ -169,13 +174,25 @@ module Escort
       end
     end
 
-    def conflict_lists_for(context_object)
-      fetch_instance_variable_from(context_object, :conflicts)
+    def conflicts_hash_for(context_object)
+      ensure_context_object(context_object, {}) do
+        options_object = options_object_from(context_object)
+        fetch_instance_variable_from(options_object, :conflicts)
+      end
     end
 
     def validations_hash_from(context_object)
-      validations_object = fetch_instance_variable_from(context_object, :validations)
-      fetch_instance_variable_from(validations_object, :validations)
+      ensure_context_object(context_object, {}) do
+        validations_object = fetch_instance_variable_from(context_object, :options)
+        fetch_instance_variable_from(validations_object, :validations)
+      end
+    end
+
+    def dependencies_hash_from(context_object)
+      ensure_context_object(context_object, {}) do
+        options_object = options_object_from(context_object)
+        fetch_instance_variable_from(options_object, :dependencies)
+      end
     end
 
     def fetch_instance_variable_from_setup(instance_variable)

data/lib/escort/trollop.rb

@@ -750,9 +750,10 @@ def with_standard_exception_handling(parser)
   begin
     yield
   rescue CommandlineError => e
-    $stderr.puts "Error: #{e.message}."
-    $stderr.puts "Try --help for help."
-    exit(1)
+    raise Escort::UserError.new(e.message, e)
+    #$stderr.puts "Error: #{e.message}."
+    #$stderr.puts "Try --help for help."
+    #exit(1)
   rescue HelpNeeded
     parser.current_help_formatter ? parser.current_help_formatter.print(parser) : parser.educate
     exit

data/lib/escort/validator.rb

@@ -31,7 +31,10 @@ module Escort
 
     def validate_option(option, options, validations_array)
       validations_array.each do |validation_data|
-        parser.die(option, validation_data[:desc]) if invalid?(option, options, validation_data)
+        if invalid?(option, options, validation_data)
+          raise Escort::UserError.new("#{option} #{validation_data[:desc]}")
+        end
+        #parser.die(option, validation_data[:desc]) if invalid?(option, options, validation_data)
       end
     end
 

data/lib/escort/version.rb

@@ -1,3 +1,3 @@
 module Escort
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/escort.rb

@@ -6,11 +6,17 @@ require 'escort/logger'
 
 require 'escort/error/error'
 
+require 'escort/formatter/option'
+require 'escort/formatter/options'
+require 'escort/formatter/command'
+require 'escort/formatter/commands'
+require 'escort/formatter/global_command'
+require 'escort/formatter/shell_command_executor'
 require 'escort/formatter/terminal'
 require 'escort/formatter/string_splitter'
 require 'escort/formatter/terminal_formatter'
 require 'escort/formatter/borderless_table'
-require 'escort/formatter/common'
+#require 'escort/formatter/common'
 require 'escort/formatter/default_help_formatter'
 
 require 'escort/setup/dsl/options'
@@ -31,6 +37,7 @@ require 'escort/setup/configuration/loader'
 
 require 'escort/setup_accessor'
 
+require 'escort/option_dependency_validator'
 require 'escort/validator'
 require 'escort/auto_options'
 require 'escort/global_pre_parser'

data/spec/integration/basic_conflicts_spec.rb

@@ -0,0 +1,47 @@
+describe "Escort basic app with conflicting options", :integration => true do
+  subject { Escort::App.create(option_string, &app_configuration) }
+
+  let(:app_configuration) do
+    lambda do |app|
+      app.options do |opts|
+        opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+        opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean
+
+        opts.conflict :flag1, :flag2
+      end
+
+      app.action do |options, arguments|
+        Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+      end
+    end
+  end
+
+  context "when conflicting options supplied" do
+    let(:option_string) { "--flag1 --flag2" }
+    it("should exit with code 2 or 3") { expect{ subject }.to exit_with_code(2, 3) }
+  end
+
+  context "when no conflicting options supplied" do
+    let(:option_string) { "--flag1" }
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+  end
+
+  context "when non-existant option in conflict list" do
+    let(:app_configuration) do
+      lambda do |app|
+        app.options do |opts|
+          opts.opt :flag1, "Flag 1", :short => '-f', :long => '--flag1', :type => :boolean
+          opts.opt :flag2, "Flag 2", :short => :none, :long => '--flag2', :type => :boolean
+
+          opts.conflict :flag1, :flag2, :flag3
+        end
+
+        app.action do |options, arguments|
+          Escort::IntegrationTestCommand.new(options, arguments).execute(result)
+        end
+      end
+    end
+    let(:option_string) { "--flag1" }
+    it("should exit with code 2") { expect{ subject }.to exit_with_code(2) }
+  end
+end