climate 0.4.0 → 0.5.0

data/lib/climate.rb

@@ -1,30 +1,27 @@
 require 'trollop'
 
 module Climate
-  def self.with_standard_exception_handling(&block)
+
+  def self.with_standard_exception_handling(options={}, &block)
+    error_messages = {
+      UnexpectedArgumentError => 'Unknown argument',
+      UnknownCommandError => 'Unknown command',
+      MissingArgumentError => 'Missing argument',
+      ConflictingOptionError => 'Conflicting options given'
+    }
+
     begin
       yield
     rescue ExitException => e
-      $stderr.puts(e.message)
+      # exit silently if there is no error message to print out
+      $stderr.puts(e.message) if e.has_message?
       exit(e.exit_code)
     rescue HelpNeeded => e
-      print_usage(e.command_class)
+      print_usage(e.command_class, options)
       exit(0)
-    rescue UnexpectedArgumentError => e
-      $stderr.puts("Unknown argument: #{e.message}")
-      print_usage(e.command_class)
-      exit(1)
-    rescue UnknownCommandError => e
-      $stderr.puts("Unknown command: #{e.message}")
-      print_usage(e.command_class)
-      exit(1)
-    rescue MissingArgumentError => e
-      $stderr.puts("Missing argument: #{e.message}")
-      print_usage(e.command_class)
-      exit(1)
-    rescue CommandError => e
-      $stderr.puts(e.message)
-      print_usage(e.command_class)
+    rescue ParsingError => e
+      $stderr.puts(error_messages[e.class] + ": #{e.message}")
+      print_usage(e.command_class, options)
       exit(1)
     rescue => e
       $stderr.puts("Unexpected error: #{e.class.name} - #{e.message}")
@@ -36,7 +33,7 @@ module Climate
   def self.print_usage(command_class, options={})
     help = Help.new(command_class)
 
-    help.print
+    help.print(options)
   end
 
   def run(&block)

data/lib/climate/command.rb

@@ -1,5 +1,20 @@
 module Climate
 
+  # Create a new sub-class of Command with the given name.  You can either
+  # extend this class in the traditional `class MyCommand < Command('bob') way`
+  # or you can define the class using class_eval by passing a block.
+  def self.Command(name, &block)
+    Class.new(Command).tap do |clazz|
+      clazz.instance_eval """
+  def command_name
+    '#{name}'
+  end
+"""
+
+      clazz.class_eval(&block) if block_given?
+    end
+  end
+
   #
   # A {Command} is a unit of work, intended to be invoked from the command line.  It should be
   # extended to either do something itself by implementing run, or just be
@@ -41,26 +56,28 @@ module Climate
         parent.nil?? our_list : parent.ancestors + our_list
       end
 
-      # Supply a name for this command, or return the existing name
-      def name(name=nil)
-        @name = name if name
-        @name
+      # Set the name of this command, use if you don't want to use the class
+      # function to define your command
+      def set_name(command_name)
+        @name = command_name
       end
 
-      # because we've extended Class.name, we expose the original method
-      # under another name
-      # FIXME: surely there is a saner way of doing this?
-      def class_name
-        Class.method(:name).unbind.bind(self).call
+      # Return the name of the command
+      def command_name
+        @name
       end
 
       # Register this class as being a subcommand of another {Command} class
       # @param [Command] parent_class The parent we hang off of
       def subcommand_of(parent_class)
-        raise DefinitionError, 'can not set subcommand before name' unless @name
+        raise DefinitionError, 'can not set subcommand before name' unless command_name
         parent_class.add_subcommand(self)
       end
 
+      def subcommand_of?(parent_class)
+        parent_class.has_subcommand?(self)
+      end
+
       # Set the description for this command
       # @param [String] string Description/Banner/Help text
       def description(string=nil)
@@ -87,12 +104,16 @@ module Climate
         if cli_arguments.empty?
           subcommands << subcommand
           subcommand.parent = self
-          stop_on(subcommands.map(&:name))
+          stop_on(subcommands.map(&:command_name))
         else
           raise DefinitionError, 'can not mix subcommands with arguments'
         end
       end
 
+      def has_subcommand?(subcommand)
+        subcommands.include?(subcommand)
+      end
+
       def arg(*args)
         if subcommands.empty?
           super(*args)
@@ -110,11 +131,11 @@ module Climate
         command_name, *arguments = parent.leftovers
 
         if command_name.nil?
-          raise MissingArgumentError.new("command #{parent.class.name}" +
+          raise MissingArgumentError.new("command #{parent.class.command_name}" +
             " expects a subcommand as an argument", parent)
         end
 
-        found = subcommands.find {|c| c.name == command_name }
+        found = subcommands.find {|c| c.command_name == command_name }
 
         if found
           found.run(arguments, options.merge(:parent => parent))
@@ -186,5 +207,9 @@ module Climate
     def run
       raise NotImplementedError, "Leaf commands must implement a run method"
     end
+
+    def exit(status)
+      raise Climate::ExitException.new(nil, status)
+    end
   end
 end

data/lib/climate/command_compat.rb

@@ -0,0 +1,18 @@
+module Climate
+  # require this file to monkey patch Command to have old <= 0.4 Command.name
+  # method that was removed to fix https://github.com/playlouder/climate/issues/6
+  class Command
+    def self.name(name=nil)
+      set_name(name) if name
+      command_name
+    end
+
+    # because we've extended Class.name, we expose the original method
+    # under another name.  Can be removed once we move away from Command.name
+    # method
+    # FIXME: surely there is a saner way of doing this?
+    def self.class_name
+      Class.method(:name).unbind.bind(self).call
+    end
+  end
+end

data/lib/climate/errors.rb

@@ -18,6 +18,10 @@ module Climate
     end
   end
 
+  # Raised when there is some problem with parsing the command line, where the
+  # user is at fault
+  class ParsingError < CommandError ; end
+
   # Command instances can raise this error to exit
   class ExitException < CommandError
 
@@ -27,8 +31,14 @@ module Climate
 
     def initialize(msg, exit_code=1)
       @exit_code = exit_code
+      @message = msg
       super(msg)
     end
+
+    # Ruby will helpfully change a nil message to be the name of the exception
+    # class, so we have to have a special predicate method to tell us whether
+    # message was nil or not
+    def has_message? ; !!@message ;  end
   end
 
   class HelpNeeded < CommandError
@@ -36,12 +46,15 @@ module Climate
   end
 
   # Raised when a {Command} is run with too many arguments
-  class UnexpectedArgumentError < CommandError ; end
+  class UnexpectedArgumentError < ParsingError ; end
 
   # Raised when a {Command} is run with insufficient arguments
-  class MissingArgumentError < CommandError ; end
+  class MissingArgumentError < ParsingError ; end
+
+  # Raised when two or more options conflict
+  class ConflictingOptionError < ParsingError ; end
 
   # Raised when a parent {Command} is asked to run a sub command it does not
   # know about
-  class UnknownCommandError < CommandError ; end
+  class UnknownCommandError < ParsingError ; end
 end

data/lib/climate/help.rb

@@ -9,7 +9,8 @@ module Climate
       @output = options[:output] || $stdout
     end
 
-    def print
+    def print(options={})
+      run_pager if options[:pager]
       print_usage
       print_description
       print_options if command_class.has_options? || command_class.has_arguments?
@@ -17,7 +18,7 @@ module Climate
     end
 
     def print_usage
-      ancestor_list = command_class.ancestors.map(&:name).join(' ')
+      ancestor_list = command_class.ancestors.map(&:command_name).join(' ')
       opts_usage = command_class.cli_options.map {|opt| opt.usage }
       args_usage =
         if command_class.has_subcommands?
@@ -41,7 +42,7 @@ module Climate
       puts "Available subcommands:"
       indent do
         command_class.subcommands.each do |subcommand_class|
-          puts "#{subcommand_class.name}"
+          puts "#{subcommand_class.command_name}"
         end
       end
     end
@@ -143,6 +144,32 @@ module Climate
       }.join("\n\n")
     end
 
+    # taken from http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
+    def run_pager
+      return if PLATFORM =~ /win32/
+      return if PLATFORM == 'java'
+      return unless STDOUT.tty?
 
+      read, write = IO.pipe
+
+      unless Kernel.fork # Child process
+        STDOUT.reopen(write)
+        STDERR.reopen(write) if STDERR.tty?
+        read.close
+        write.close
+        return
+      end
+
+      # Parent process, become pager
+      STDIN.reopen(read)
+      read.close
+      write.close
+
+      ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+      Kernel.select [STDIN] # Wait until we have input before we start the pager
+      pager = ENV['PAGER'] || 'less'
+      exec pager rescue exec "/bin/sh", "-c", pager
+    end
   end
 end

data/lib/climate/help/man.rb

@@ -10,8 +10,7 @@ class Climate::Help
   class Man
 
     # Eat my own dog food
-    class Script < Climate::Command
-      name 'man'
+    class Script < Climate::Command('man')
       description 'Creates man/nroff output for a command'
 
       arg :command_class, "name of class that defines the command, i.e. Foo::Bar::Command",
@@ -58,7 +57,7 @@ class Climate::Help
         stack = []
         command_ptr = command_class
         while command_ptr
-          stack.unshift(command_ptr.name)
+          stack.unshift(command_ptr.command_name)
           command_ptr = command_ptr.parent
         end
 
@@ -66,7 +65,7 @@ class Climate::Help
       end
 
       def short_name
-        command_class.name
+        command_class.command_name
       end
 
       def date         ; Date.today.strftime('%b, %Y') ; end

data/lib/climate/parser.rb

@@ -41,7 +41,7 @@ module Climate
     end
 
     def long_usage
-      type == :flag ? "--#{long}" : "--#{long}=<#{type}>"
+      type == :flag ? "--[no-]#{long}" : "--#{long}=<#{type}>"
     end
 
     def short_usage
@@ -114,6 +114,14 @@ module Climate
       @stop_on = args
     end
 
+    def conflicts(*args)
+      conflicting_options << args
+    end
+
+    def depends(*args)
+      dependent_options << args
+    end
+
     def trollop_parser
       Trollop::Parser.new.tap do |parser|
         parser.stop_on @stop_on
@@ -121,6 +129,14 @@ module Climate
         cli_options.each do |option|
           option.add_to(parser)
         end
+
+        conflicting_options.each do |conflicting|
+          parser.conflicts(*conflicting)
+        end
+
+        dependent_options.each do |dependent|
+          parser.depends(*dependent)
+        end
       end
     end
 
@@ -165,6 +181,7 @@ module Climate
 
     def parse(arguments, command=self)
       parser = self.trollop_parser
+
       begin
         options = parser.parse(arguments)
       rescue Trollop::CommandlineError => e
@@ -172,6 +189,10 @@ module Climate
           raise UnexpectedArgumentError.new(m[1], command)
         elsif (m = /option (.+) must be specified/.match(e.message))
           raise MissingArgumentError.new(m[1], command)
+        elsif  /.+ conflicts with .+/.match(e.message)
+          raise ConflictingOptionError.new(e.message, command)
+        elsif /.+ requires .+/.match(e.message)
+          raise MissingArgumentError.new(e.message, command)
         else
           raise CommandError.new(e.message, command)
         end
@@ -189,12 +210,26 @@ module Climate
       [arguments, options, leftovers]
     end
 
-    def cli_options   ; @cli_options ||= []   ; end
-    def cli_arguments ; @cli_arguments ||= [] ; end
+    def cli_options         ; @cli_options ||= []         ; end
+    def cli_arguments       ; @cli_arguments ||= []       ; end
+    def conflicting_options ; @conflicting_options ||= [] ; end
+    def dependent_options   ; @dependent_options ||= []   ; end
 
     def has_options? ;     not cli_options.empty?   ; end
     def has_arguments? ;   not cli_arguments.empty? ; end
 
+    def has_argument?(name)
+      cli_arguments.map(&:name).include?(name)
+    end
+
+    def has_required_argument?(name)
+      cli_arguments.select(&:required?).map(&:name).include?(name)
+    end
+
+    def has_multi_argument?(name)
+      cli_arguments.select(&:multi?).map(&:name).include?(name)
+    end
+
   end
 
   class Parser

data/lib/climate/version.rb

@@ -1,3 +1,3 @@
 module Climate
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: climate
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Nick Griffiths
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-29 00:00:00 Z
+date: 2012-10-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: trollop
@@ -23,12 +23,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         hash: 3
         segments: 
+        - 2
         - 0
-        version: "0"
+        version: "2.0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -83,14 +84,15 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/climate.rb
+- lib/climate/help.rb
+- lib/climate/command_compat.rb
 - lib/climate/version.rb
-- lib/climate/help/man.rb
-- lib/climate/command.rb
-- lib/climate/parser.rb
-- lib/climate/errors.rb
 - lib/climate/script.rb
-- lib/climate/help.rb
-- lib/climate.rb
+- lib/climate/errors.rb
+- lib/climate/parser.rb
+- lib/climate/command.rb
+- lib/climate/help/man.rb
 - README.md
 - bin/climate
 homepage: 
@@ -122,10 +124,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Library for building command line interfaces
 test_files: []
 
-has_rdoc: