clive 0.2.3 → 0.3.0

data/test/test_command.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestCommand < Test::Unit::TestCase
+
+  context "A new command" do
+  
+    setup do
+      @c = Clive.new do
+        command(:add, "Add something") {puts "called!"}
+      end
+    end
+    
+    context "with multiple names" do
+      setup do
+        @c = Clive.new do
+          command(:add, :init, :new, "Add something") {puts "called!"}
+        end
+      end
+      
+      should "be called with first name" do
+        mock($stdout).puts("called!")
+        @c.parse ["add"]
+      end
+      
+      should "be called with second name" do
+        mock($stdout).puts("called!")
+        @c.parse ["init"]
+      end
+      
+      should "be called with third name" do
+        mock($stdout).puts("called!")
+        @c.parse ["new"]
+      end
+    end
+  
+  
+    should "only execute it's block when called" do
+      mock($stdout).puts("called!")
+      @c.parse(["a"])
+      @c.parse(["add"])
+    end
+  
+  end 
+end

data/test/test_flag.rb

@@ -6,7 +6,7 @@ class TestFlag < Test::Unit::TestCase
     
     setup do
       @c = Clive.new do
-        flag(:t, :type, "Choose type") {|i| $stdout.puts(i)}
+        flag(:t, :type, "TEXT", "Change type to TYPE") {|i| $stdout.puts(i)}
       end
     end
     
@@ -15,5 +15,44 @@ class TestFlag < Test::Unit::TestCase
       @c.parse(["--type", "text"])
     end
     
+    should "have an arg name" do
+      assert_equal "TEXT", @c.flags["t"].arg_name
+    end
+    
+    should "not be optional" do
+      assert_equal false, @c.flags["t"].optional
+    end
+    
   end
+  
+  context "A new flag with default" do
+  
+    setup do
+      @c = Clive.new do
+        flag(:t, :type, "[TEXT]", "Change type to TYPE") do |i| 
+          i ||= 'dog'
+          $stdout.puts(i)
+        end
+      end
+    end
+    
+    should "have an arg name" do
+      assert_equal "TEXT", @c.flags["t"].arg_name
+    end
+    
+    should "be optional" do
+      assert_equal true, @c.flags["t"].optional
+    end
+    
+    should "pass an argument to block" do
+      mock($stdout).puts("text")
+      @c.parse(["--type", "text"])
+    end
+    
+    should "pass nil to the block if no argument" do
+      mock($stdout).puts("dog")
+      @c.parse(["--type"])
+    end
+  end
+  
 end

data/test/test_token.rb

@@ -10,8 +10,7 @@ class TestToken < Test::Unit::TestCase
     end
   
     should "convert an array to tokens" do
-      t = Clive::Tokens.new(@array)
-      assert_equal @tokens, t.tokens
+      assert_equal @tokens, Clive::Tokens.to_tokens(@array)
     end
     
     should "convert tokens to an array" do
@@ -25,9 +24,6 @@ class TestToken < Test::Unit::TestCase
       @array = ["add", "-al", "--verbose"]
       @array_split = ["add", "-a", "-l", "--verbose"]
       @tokens = [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
-      
-      @t = Clive::Tokens.new
-      @t << "add" << "-al" << "--verbose"
     end
     
     should "be created from an array" do
@@ -41,13 +37,30 @@ class TestToken < Test::Unit::TestCase
       assert_equal @tokens, t.tokens
       assert_equal @array_split, t.array
     end
-  
-    should "have tokens" do
-      
+    
+    should "tell whether an array is a token" do
+      t = Clive::Tokens.new
+      assert_equal false, t.token?(["a", "normal", "array"])
+      assert_equal true, t.token?([:word, "help"])
     end
     
-    should "have an array" do
+    should "turn token to string" do
+      t = Clive::Tokens.new
+      assert_equal "-v", t.token_to_string([:short, "v"])
+      assert_equal "--verbose", t.token_to_string([:long, "verbose"])
+      assert_equal "word", t.token_to_string([:word, "word"])
+    end
     
+    should "add new string values" do
+      t = Clive::Tokens.new
+      t << "add" << "-al" << "--verbose"
+      assert_equal @tokens, t.tokens
+    end
+    
+    should "add new token values" do
+      t = Clive::Tokens.new
+      t << [:word, "add"] << [:short, "a"] << [:short, "l"] << [:long, "verbose"]
+      assert_equal @array_split, t.array
     end
   
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clive
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Joshua Hawxwell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-17 00:00:00 +01:00
+date: 2010-08-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,16 +64,19 @@ files:
 - VERSION
 - clive.gemspec
 - lib/clive.rb
-- lib/clive/booleans.rb
-- lib/clive/commands.rb
+- lib/clive/bool.rb
+- lib/clive/command.rb
+- lib/clive/exceptions.rb
 - lib/clive/ext.rb
-- lib/clive/flags.rb
-- lib/clive/switches.rb
+- lib/clive/flag.rb
+- lib/clive/option.rb
+- lib/clive/switch.rb
 - lib/clive/tokens.rb
 - test/bin_test
 - test/helper.rb
 - test/test_boolean.rb
 - test/test_clive.rb
+- test/test_command.rb
 - test/test_exceptions.rb
 - test/test_flag.rb
 - test/test_switch.rb
@@ -116,6 +119,7 @@ test_files:
 - test/helper.rb
 - test/test_boolean.rb
 - test/test_clive.rb
+- test/test_command.rb
 - test/test_exceptions.rb
 - test/test_flag.rb
 - test/test_switch.rb

data/lib/clive/booleans.rb

@@ -1,37 +0,0 @@
-class Clive
-  
-  # A switch which can be triggered with either --no-verbose or --verbose
-  # for example.
-  class Boolean < Switch
-    attr_accessor :truth
-    
-    def initialize(short, long, desc, truth, &block)
-      @short = short
-      @long = long
-      @desc = desc
-      @truth = truth
-      @block = block
-    end
-    
-    def run
-      @block.call(@truth)
-    end
-    
-    # @return [String] summary for help or nil if +@truth = false+
-    def summary(width=30, prepend=5)
-      return nil unless @truth
-      a = ""
-      a << "-#{@short}" if @short
-      a << ", " if @short && @long
-      a << "--[no-]#{@long}" if @long
-      b = @desc
-      s, p = '', ''
-      # want at least one space between name and desc
-      spaces = width-a.length < 0 ? 1 : width-a.length
-      (0...spaces).each {s << ' '}
-      (0...prepend).each {p << ' '}
-      "#{p}#{a}#{s}#{b}"
-    end
-  
-  end
-end

data/lib/clive/commands.rb

@@ -1,317 +0,0 @@
-class Clive
-  
-  # A string which describes the command to execute
-  #   eg. git add
-  #       git pull
-  #
-  class Command
-    
-    attr_accessor :switches, :flags, :commands
-    attr_accessor :name, :desc, :block, :argv
-    attr_accessor :base
-    attr_accessor :banner
-    
-    # Create a new Command instance
-    #
-    # @overload initialize(base, &block)
-    #   Creates a new base Command to house everything else
-    #   @param [Boolean] base whether the command is the base
-    #
-    # @overload initialize(name, desc, &block)
-    #   Creates a new Command as part of the base Command
-    #   @param [Symbol] name the name of the command
-    #   @param [String] desc the description of the command
-    #
-    # @yield A block to run, containing switches, flags and commands
-    #
-    def initialize(*args, &block)
-      @argv     = []
-      @switches = Clive::Array.new
-      @flags    = Clive::Array.new
-      @commands = Clive::Array.new
-    
-      if args.length == 1 && args[0] == true
-        @base = true
-        self.instance_eval(&block)
-      else
-        @base = false
-        args.each do |i|
-          case i
-          when Symbol
-            @name = i.to_s
-          when String
-            @desc = i
-          end
-        end
-        @block = block
-      end
-      
-      @banner = "Usage: #{File.basename($0, '.*')} "
-      @banner << (@base ? "[commands]" : @name)
-      @banner << " [options]"
-      
-      self.build_help
-    end
-    
-    # Getter to find booleans
-    def booleans
-      @switches.find_all {|i| i.is_a?(Boolean)}
-    end
-    
-    # Run the block that was passed to find switches, flags, etc.
-    #
-    # This should only be called if the command has been called
-    # as the block could contain other actions to perform only 
-    # when called.
-    #
-    def find
-      return nil if @base
-      self.instance_eval(&@block)
-    end
-    
-    # Parse the ARGV passed from the command line, and run
-    #
-    # @param [Array] argv the command line input, usually just ARGV
-    # @return [Array] any arguments that were present in the input but not used
-    #
-    def run(argv=[])
-      tokens = argv
-      tokens = tokenize(argv) if @base
-      
-      r = []
-      tokens.each do |i|
-        k, v = i[0], i[1]
-        case k
-        when :command
-          v.run(i[2])
-        when :switch
-          v.run
-        when :flag
-          raise MissingArgument.new(v.long||v.short) unless i[2]
-          v.run(i[2])
-        when :argument
-          r << v
-        end
-      end
-      r
-    end
-    
-    # Turns the command line input into a series of tokens.
-    # It will only raise errors if this is the base command instance.
-    #
-    # @param [Array] argv the command line input
-    # @return [Array] a series of tokens
-    #
-    # @example
-    #
-    #   c.tokenize(["add", "-al", "--verbose"])
-    #   #=> [[:command, #<Clive::Command>, ...args...], [:switch, "a", 
-    #        #<Clive::Switch>], [:switch, "l", #<Clive::Switch>], [:switch, 
-    #        "verbose", #<Clive::Switch>]]
-    #
-    def tokenize(argv)
-      tokens = []
-      pre = Tokens.to_tokens(argv)
-      command = nil
-      @argv = argv unless @base
-      
-      pre.each do |i|
-        k, v = i[0], i[1]
-        case k
-        when :word
-          if @commands[v]
-            command = @commands[v]
-            pre -= [[:word, v]]
-          end
-        end
-      end
-      
-      if command
-        command.find
-        # tokenify the command
-        tokens << [:command, command, command.tokenize(Tokens.to_array(pre))]
-        pre = Tokens.to_tokens(command.argv)
-      end 
-      
-      pre.each do |i|
-        k, v = i[0], i[1]
-        case k
-        when :short, :long
-          if switch = @switches[v]
-            tokens << [:switch, switch]
-            pre -= [[k, v]] unless @base
-          elsif flag = @flags[v]
-            tokens << [:flag, flag]
-            pre -= [[k, v]] unless @base
-          else
-            raise InvalidOption.new(v) if @base
-          end
-        when :word
-          if tokens.last
-            case tokens.last[0]
-            when :flag
-              tokens.last[2] = v
-            else
-              tokens << [:argument, v] if @base
-            end
-          end
-        end
-      end
-      @argv = Tokens.to_array(pre)
-      
-      tokens
-    end
-    
-  #### CREATION HELPERS #### 
-    
-    # Add a new switch to +@switches+
-    #
-    # @overload switch(short, long, desc, &block)
-    #   Creates a new switch
-    #   @param [Symbol] short single character for short switch, eg. +:v+ => +-v+
-    #   @param [Symbol] long longer switch to be used, eg. +:verbose+ => +--verbose+
-    #   @param [String] desc the description for the switch
-    #
-    # @yield A block to run if the switch is triggered
-    #
-    def switch(*args, &block)
-      short, long, desc = nil
-      args.each do |i|
-        if i.is_a? String
-          desc = i
-        elsif i.length == 1
-          short = i.to_s
-        else
-          long = i.to_s
-        end
-      end
-      @switches << Switch.new(short, long, desc, &block)
-    end
-    
-    # Add a new command to +@commands+
-    #
-    # @overload command(name, desc, &block)
-    #   Creates a new command
-    #   @param [Symbol] name the name of the command, eg. +:add+ for +git add+
-    #   @param [String] desc description of the command
-    # 
-    # @yield A block to run when the command is called, can contain switches
-    #   and flags
-    #
-    def command(*args, &block)
-      name, desc = nil
-      args.each do |i|
-        if i.is_a? String
-          desc = i
-        else
-          name = i
-        end
-      end
-      @commands << Command.new(name, desc, &block)
-    end
-    
-    # Add a new flag to +@flags+
-    #
-    # @overload flag(short, long, desc, &block)
-    #   Creates a new flag
-    #   @param [Symbol] short single character for short flag, eg. +:t+ => +-t 10+
-    #   @param [Symbol] long longer switch to be used, eg. +:tries+ => +--tries=10+
-    #   @param [String] desc the description for the flag
-    #
-    # @yield [String] A block to be run if switch is triggered
-    def flag(*args, &block)
-      short, long, desc = nil
-      args.each do |i|
-        if i.is_a? String
-          desc = i
-        elsif i.length == 1
-          short = i.to_s
-        else
-          long = i.to_s
-        end
-      end
-      @flags << Flag.new(short, long, desc, &block)
-    end
-    
-    # Creates a boolean switch. This is done by adding two switches of
-    # Boolean type to +@switches+, one is created normally the other has
-    # "no-" appended to the long name and has no short name.
-    #
-    # @overload boolean(short, long, desc, &block)
-    #   Creates a new boolean switch
-    #   @param [Symbol] short single character for short label
-    #   @param [Symbol] long longer name to be used
-    #   @param [String] desc the description of the boolean
-    #
-    # @yield [Boolean] A block to be run if switch is triggered
-    def boolean(*args, &block)
-      short, long, desc = nil
-      args.each do |i|
-        if i.is_a? String
-          desc = i
-        elsif i.length == 1
-          short = i.to_s
-        else
-          long = i.to_s
-        end
-      end
-      raise "Boolean switch must have long name" unless long
-      @switches << Boolean.new(short, long, desc, true, &block)
-      @switches << Boolean.new(nil, "no-#{long}", desc, false, &block)
-    end
-    
-  #### HELP STUFF ####
-    
-    # This actually creates a switch with "-h" and "--help" that control
-    # the help on this command. If this is the base class it will also 
-    # creates a "help [command]" command.
-    def build_help
-      @switches << Switch.new("h", "help", "Display help") do
-        puts self.help
-        exit 0
-      end
-    end
-    
-    # Set the banner
-    def banner(val)
-      @banner = val
-    end
-    
-    def summary(width=30, prepend=5)
-      a = @name
-      b = @desc
-      s, p = '', ''
-      (0..width-a.length).each {s << ' '}
-      (0..prepend).each {p << ' '}
-      "#{p}#{a}#{s}#{b}"
-    end
-    
-    # Generate the summary for help, show all flags and switches, but do not
-    # show the flags and switches within each command. Should also prepend the
-    # banner.
-    def help(width=30, prepend=5)
-      summary = "#{@banner}\n"
-      
-      if @switches.length > 0 || @flags.length > 0
-        summary << "\n Options:\n"
-        @switches.each do |i|
-          summary << i.summary(width, prepend) << "\n" if i.summary
-        end
-        @flags.each do |i|
-          summary << i.summary(width, prepend) << "\n"
-        end
-      end
-      
-      if @commands.length > 0
-        summary << "\nCommands:\n"
-        @commands.each do |i|
-          summary << i.summary(width, prepend) << "\n"
-        end
-      end
-     
-      summary
-    end
-    
-    
-  end
-end