escort 0.0.1 → 0.1.0

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

@@ -0,0 +1,25 @@
+module Escort
+  module Setup
+    module Dsl
+      class Options
+        class << self
+          def options(command_name, instance, &block)
+            block.call(instance) if block_given?
+          rescue => e
+            raise Escort::ClientError.new("Problem with syntax of #{instance.instance_variable_get(:"@command_name")} options block", e)
+          end
+        end
+
+        def initialize(command_name = :global)
+          @command_name = command_name
+          @options = {}
+        end
+
+        def opt(name, desc="", opts={})
+          opts[:desc] ||= desc
+          @options[name] ||= opts
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Escort
+  module Setup
+    module Dsl
+      class Validations
+        class << self
+          def validations(command_name, instance, &block)
+            block.call(instance) if block_given?
+          rescue => e
+            raise Escort::ClientError.new("Problem with syntax of #{instance.instance_variable_get(:"@command_name")} validations block", e)
+          end
+        end
+
+        def initialize(command_name = :global)
+          @command_name = command_name
+          @validations = {}
+        end
+
+        def validate(name, description, &block)
+          @validations[name] ||= []
+          @validations[name] << {:desc => description, :block => block}
+        end
+      end
+    end
+  end
+end

data/lib/escort/setup_accessor.rb

@@ -0,0 +1,194 @@
+module Escort
+  class SetupAccessor
+    attr_reader :global_instance
+
+    def initialize(global_instance)
+      @global_instance = global_instance
+    end
+
+    def options_for(context = [])
+      with_context(context) do |current_context|
+        options_hash_from(current_context)
+      end
+    end
+
+    def conflicting_options_for(context = [])
+      with_context(context) do |current_context|
+        conflict_lists_for(current_context)
+      end
+    end
+
+
+    def validations_for(context = [])
+      with_context(context) do |current_context|
+        validations_hash_from(current_context)
+      end
+    end
+
+    def command_names_for(context = [])
+      with_context(context) do |current_context|
+        command_names_from(current_context)
+      end
+    end
+
+    def canonical_command_names_for(context = [])
+      with_context(context) do |current_context|
+        canonical_command_names_from(current_context)
+      end
+    end
+
+    def action_for(context = [])
+      with_context(context) do |current_context|
+        action_block_from(current_context)
+      end
+    end
+
+    def arguments_required_for(context = [])
+      with_context(context) do |current_context|
+        context_requires_arguments(current_context)
+      end
+    end
+
+    def has_config_file?
+      config_file_object != nil
+    end
+
+    def config_file_autocreatable?
+      autocreatable = fetch_instance_variable_from(config_file_object, :autocreate)
+    end
+
+    def config_file
+      name = fetch_instance_variable_from(config_file_object, :name)
+    end
+
+    def version
+      version_string = fetch_instance_variable_from(global_instance, :version)
+    end
+
+    def summary_for(context = [])
+      with_context(context) do |current_context|
+        fetch_instance_variable_from(current_context, :summary)
+      end
+    end
+
+    def description_for(context = [])
+      with_context(context) do |current_context|
+        fetch_instance_variable_from(current_context, :description)
+      end
+    end
+
+    def command_description_for(command_name, context = [])
+      with_context(context) do |current_context|
+        commands = fetch_instance_variable_from(current_context, :commands)
+        fetch_instance_variable_from(commands[command_name], :description)
+      end
+    end
+
+    def command_summary_for(command_name, context = [])
+      with_context(context) do |current_context|
+        commands = fetch_instance_variable_from(current_context, :commands)
+        fetch_instance_variable_from(commands[command_name], :summary)
+      end
+    end
+
+    def command_aliases_for(command_name, context = [])
+      with_context(context) do |current_context|
+        commands = fetch_instance_variable_from(current_context, :commands)
+        description = fetch_instance_variable_from(commands[command_name], :aliases)
+      end
+    end
+
+    def add_global_option(name, desc, options = {})
+      with_context([]) do |current_context|
+        options_object = options_object_from(current_context)
+        options_object.opt name, desc, options
+      end
+    end
+
+    def add_global_command(name, options = {}, &block)
+      global_instance.command(name, options, &block)
+
+      #with_context([]) do |current_context|
+        #commands = fetch_instance_variable_from(current_context, :commands)
+        #options_object.opt name, desc, options
+      #end
+    end
+
+    private
+
+    def config_file_object
+      config_file = fetch_instance_variable_from(global_instance, :config_file)
+    end
+
+    def with_context(context = [], &block)
+      context = [] if context.nil? || context.empty?
+      context = [context] unless context.kind_of?(Array)
+      current_context = global_instance
+      context.each do |command_name|
+        commands = fetch_instance_variable_from(current_context, :commands)
+        current_context = commands[command_name.to_sym]
+      end
+      block.call(current_context)
+    end
+
+    def context_requires_arguments(context_object)
+      requires_arguments = fetch_instance_variable_from(context_object, :requires_arguments)
+    end
+
+    def action_block_from(context_object)
+      action_object = fetch_instance_variable_from(context_object, :action)
+      block = fetch_instance_variable_from(action_object, :block)
+      #TODO make sure that if there is no block we exit with a client error
+    end
+
+    def command_names_from(context_object)
+      commands = fetch_instance_variable_from(context_object, :commands)
+      commands.keys
+      #TODO make sure there can be no errors here and at worst it is an empty array
+    end
+
+    def canonical_command_names_from(context_object)
+      commands = fetch_instance_variable_from(context_object, :commands)
+      commands.select do |key, command|
+        aliases = fetch_instance_variable_from(command, :aliases)
+        !aliases.include?(key)
+      end.keys
+      #TODO make sure there can be no errors here and at worst it is an empty array
+    end
+
+    def options_hash_from(context_object)
+      ensure_context_object(context_object, {}) do
+        options_object = options_object_from(context_object)
+        fetch_instance_variable_from(options_object, :options)
+      end
+    end
+
+    def options_object_from(context_object)
+      ensure_context_object(context_object, nil) do
+        fetch_instance_variable_from(context_object, :options)
+      end
+    end
+
+    def conflict_lists_for(context_object)
+      fetch_instance_variable_from(context_object, :conflicts)
+    end
+
+    def validations_hash_from(context_object)
+      validations_object = fetch_instance_variable_from(context_object, :validations)
+      fetch_instance_variable_from(validations_object, :validations)
+    end
+
+    def fetch_instance_variable_from_setup(instance_variable)
+      fetch_instance_variable_from(global_instance, instance_variable)
+    end
+
+    def fetch_instance_variable_from(instance, instance_variable)
+      instance_variable_symbol = :"@#{instance_variable.to_s}"
+      instance.instance_variable_get(instance_variable_symbol)
+    end
+
+    def ensure_context_object(context_object, default_value, &block)
+      context_object ? block.call : default_value
+    end
+  end
+end

data/lib/escort/trollop.rb

@@ -66,6 +66,8 @@ class Parser
   ## for testing.)
   attr_reader :specs
 
+  attr_reader :order
+
   ## Initializes the parser, and instance-evaluates any block given.
   def initialize *a, &b
     @version = nil
@@ -77,6 +79,7 @@ class Parser
     @constraints = []
     @stop_words = []
     @stop_on_unknown = false
+    @help_formatter = nil
 
     #instance_eval(&b) if b # can't take arguments
     cloaker(&b).bind(self).call(*a) if b
@@ -238,6 +241,14 @@ class Parser
   def banner s; @order << [:text, s] end
   alias :text :banner
 
+  def help_formatter(formatter)
+    @help_formatter = formatter
+  end
+
+  def current_help_formatter
+    @help_formatter
+  end
+
   ## Marks two (or more!) options as requiring each other. Only handles
   ## undirected (i.e., mutual) dependencies. Directed dependencies are
   ## better modeled with Trollop::die.
@@ -518,7 +529,7 @@ class Parser
       $stderr.puts "Error: #{arg}."
     end
     $stderr.puts "Try --help for help."
-    exit(-1)
+    exit(1)
   end
 
 private
@@ -735,15 +746,15 @@ end
 ##
 ## Requires passing in the parser object.
 
-def with_standard_exception_handling parser
+def with_standard_exception_handling(parser)
   begin
     yield
   rescue CommandlineError => e
     $stderr.puts "Error: #{e.message}."
     $stderr.puts "Try --help for help."
-    exit(-1)
+    exit(1)
   rescue HelpNeeded
-    parser.educate
+    parser.current_help_formatter ? parser.current_help_formatter.print(parser) : parser.educate
     exit
   rescue VersionNeeded
     puts parser.version

data/lib/escort/utils.rb

@@ -0,0 +1,21 @@
+require 'shellwords'
+
+module Escort
+  class Utils
+    class << self
+      def symbolize_keys(hash)
+        hash.inject({}) do |result, (key, value)|
+          new_key = (key.kind_of?(String) ? key.to_sym : key)
+          new_value = (value.kind_of?(Hash) ? symbolize_keys(value) : value)
+          result[new_key] = new_value
+          result
+        end
+      end
+
+      def tokenize_option_string(option_string)
+        option_string ||= ''
+        Shellwords.shellwords(option_string)
+      end
+    end
+  end
+end

data/lib/escort/validator.rb

@@ -0,0 +1,42 @@
+module Escort
+  class Validator
+    class << self
+      def for(parser)
+        self.new(parser)
+      end
+    end
+
+    attr_reader :parser
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def validate(options, validations)
+      validations.each do |option, validations_array|
+        if option_exists?(option)
+          validate_option(option, options, validations_array)
+        else
+          raise Escort::ClientError.new("Unable to create validation for '#{option}' as no such option was defined, maybe you misspelled it")
+        end
+      end
+      options
+    end
+
+    private
+
+    def option_exists?(option)
+      parser.specs.keys.include?(option)
+    end
+
+    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)
+      end
+    end
+
+    def invalid?(option, options, validation_data)
+      options[option] && !validation_data[:block].call(options[option])
+    end
+  end
+end

data/lib/escort/version.rb

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

data/spec/helpers/execute_action_matcher.rb

@@ -0,0 +1,21 @@
+RSpec::Matchers.define :execute_action do |command_name, result|
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+    end
+    result.first == command_name
+  end
+
+  failure_message_for_should do |block|
+    "'#{command_name}' action should have been executed as a result of block, but instead '#{result.first}' was executed"
+  end
+
+  failure_message_for_should_not do |block|
+    "'#{command_name}' action should not have been executed as a result of block"
+  end
+
+  description do
+    "'#{command_name}' action should have been executed as a result of block"
+  end
+end

data/spec/helpers/exit_with_code_matcher.rb

@@ -0,0 +1,21 @@
+RSpec::Matchers.define :exit_with_code do |exp_code|
+  actual = nil
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == exp_code
+  end
+  failure_message_for_should do |block|
+    "expected block to call exit(#{exp_code}) but exit" +
+      (actual.nil? ? " not called" : "(#{actual}) was called")
+  end
+  failure_message_for_should_not do |block|
+    "expected block not to call exit(#{exp_code})"
+  end
+  description do
+    "expect block to call exit(#{exp_code})"
+  end
+end

data/spec/helpers/give_option_to_action_with_value_matcher.rb

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :give_option_to_action_with_value do |option_name, expected_value, result|
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+    end
+    options = result[1] || {}
+    options.keys.include?(option_name) && options[option_name] == expected_value
+  end
+
+  failure_message_for_should do |block|
+    "'#{option_name}' should have been passed to action with value '#{expected_value}', but instead we got '#{(result[1] || {})[option_name]}'"
+  end
+
+  failure_message_for_should_not do |block|
+    "'#{option_name}' should not have been passed to action with value '#{expected_value}'"
+  end
+
+  description do
+    "'#{option_name}' should have been passed to action with value '#{expected_value}'"
+  end
+end

data/spec/integration/basic_options_spec.rb

@@ -0,0 +1,53 @@
+describe "Escort basic app with options defined" do
+  subject { Escort::App.create(option_string, &app_configuration) }
+  let(:result) { [] }
+
+  before do
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+  end
+
+  after do
+    $stderr = STDERR
+    $stdout = STDOUT
+  end
+
+  let(:app_configuration) do
+    ->(app) do
+      app.options do |opts|
+        opts.opt :option1, "Option1", :short => '-o', :long => '--option1', :type => :string, :default => "option 1"
+      end
+
+      app.action do |options, arguments|
+        result << :global
+        result << {:option1 => options[:global][:options][:option1]}
+      end
+    end
+  end
+
+  context "when called with empty option string" do
+    let(:option_string) { "" }
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
+    it("option1 have its default value in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'option 1', result) }
+  end
+
+  context "when called with option string with short code option" do
+    let(:option_string) { "-o blah" }
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
+    it("option1 have the value 'blah' in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'blah', result) }
+  end
+
+  context "when called with option string with long code option" do
+    let(:option_string) { "--option1=blah" }
+    it("should exit with code 0") { expect{ subject }.to exit_with_code(0) }
+    it("should execute the global action") { expect{subject}.to execute_action(:global, result) }
+    it("option1 have the value 'blah' in action") { expect{subject}.to give_option_to_action_with_value(:option1, 'blah', result) }
+  end
+
+  context "when called with option string with unknown option" do
+    let(:option_string) { "-k" }
+    it("should not exit with code 0") { expect{ subject }.not_to exit_with_code(0) }
+  end
+end