clive 0.2.2 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/clive.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{clive}
-  s.version = "0.2.2"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Hawxwell"]
-  s.date = %q{2010-08-15}
+  s.date = %q{2010-08-17}
   s.description = %q{Clive is a DSL for creating a command line interface. It is for people who, like me, love OptionParser's syntax and love GLI's commands.}
   s.email = %q{m@hawx.me}
   s.extra_rdoc_files = [
@@ -33,8 +33,12 @@ Gem::Specification.new do |s|
      "lib/clive/tokens.rb",
      "test/bin_test",
      "test/helper.rb",
+     "test/test_boolean.rb",
      "test/test_clive.rb",
-     "test/test_exceptions.rb"
+     "test/test_exceptions.rb",
+     "test/test_flag.rb",
+     "test/test_switch.rb",
+     "test/test_token.rb"
   ]
   s.homepage = %q{http://github.com/hawx/clive}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -43,8 +47,12 @@ Gem::Specification.new do |s|
   s.summary = %q{Imagine if optparse and gli had a son called clive.}
   s.test_files = [
     "test/helper.rb",
+     "test/test_boolean.rb",
      "test/test_clive.rb",
-     "test/test_exceptions.rb"
+     "test/test_exceptions.rb",
+     "test/test_flag.rb",
+     "test/test_switch.rb",
+     "test/test_token.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/clive.rb

@@ -86,5 +86,9 @@ class Clive
     @base.flags
   end
   
+  def booleans
+    @base.booleans
+  end
+  
 end
 

data/lib/clive/booleans.rb

@@ -26,8 +26,10 @@ class Clive
       a << "--[no-]#{@long}" if @long
       b = @desc
       s, p = '', ''
-      (0..width-a.length).each {s << ' '}
-      (0..prepend).each {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
   

data/lib/clive/commands.rb

@@ -53,6 +53,11 @@ class Clive
       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

data/lib/clive/switches.rb

@@ -27,8 +27,10 @@ class Clive
       a << "--#{@long}" if @long
       b = @desc
       s, p = '', ''
-      (0..width-a.length).each {s << ' '}
-      (0..prepend).each {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
     

data/lib/clive/tokens.rb

@@ -5,75 +5,128 @@ class Clive
   #
   #    [[:word, 'Value'], [:long, 'verbose'], [:short, 'r']]
   #
-  # And converting between these and ordinary arrays.
+  # The tokens are not stored like that but as the string 
+  # representations:
+  #
+  #   ["Value", "--verbose", "-r"]
   #
   class Tokens < Array
-    attr_accessor :tokens, :array
+      
+    TOKEN_KEYS = [:word, :short, :long]
     
-    def self.to_tokens(tokens)
-      Tokens.new.to_tokens(tokens)
+    # Create a new Tokens instance. Pass either an array of tokens
+    # or a plain array, they will be converted correctly.
+    #
+    # @param [Array]
+    # @return [Tokens]
+    #
+    def initialize(args=[])
+      if token?(args[0])
+        r = []
+        args.each {|i| r << token_to_string(i)}
+        args = r
+      end
+      super(args)
     end
     
-    def self.to_array(arr)
-      Tokens.new.to_array(arr)
+    # Turn +@tokens+ into an array, this ensures that shorts are split
+    # as is expected
+    #
+    # @return [Array] array representation of tokens held
+    def array
+      return [] unless self.tokens
+      arr = []
+      self.tokens.each do |i|
+        k, v = i[0], i[1]
+        case k
+        when :long
+          arr << "--#{v}"
+        when :short
+          arr << "-#{v}"
+        when :word
+          arr << v
+        end
+      end
+      
+      arr
     end
     
-    # Turn into simple tokens that have been split up into logical parts
+    # Creates an array of tokens based on +self+
     #
-    # @example
-    #   
-    #   a = Tokens.new
-    #   a.to_tokens(["add", "-al", "--verbose"])
-    #   #=> [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
-    #
-    def to_tokens(arr=@array)
-      @tokens = []
-      arr.each do |i|
+    # @return [Array] the tokens that are held
+    def tokens
+      t = []
+      self.each do |i|
         if i[0..1] == "--"
           if i.include?('=')
             a, b = i[2..i.length].split('=')
-            @tokens << [:long, a] << [:word, b]
+            t << [:long, a] << [:word, b]
           else
-            @tokens << [:long, i[2..i.length]]
+            t << [:long, i[2..i.length]]
           end
-        
+          
         elsif i[0] == "-"
           i[1..i.length].split('').each do |j|
-            tokens << [:short, j]
+            t << [:short, j]
           end
         
         else
-          @tokens << [:word, i]
+          t << [:word, i]
         end
       end
       
-      @tokens
+      t
+    end
+    
+    def self.to_tokens(arr)
+      Tokens.new(arr).tokens
+    end
+    
+    def self.to_array(tokens)
+      Tokens.new(tokens).array
     end
     
-    # Turn tokens back to a normal array
+    # Checks to see if it is a token being added and changes it back
+    def <<(val)
+      if token?(val)
+        super(token_to_string(val))
+      else
+        super
+      end
+    end
+    
+    # Test whether an array is a token
+    #
+    # @param [Array]
+    # @return [Boolean]
     #
     # @example
-    #   
-    #   a = Tokens.new
-    #   a.to_array([[:word, "add"], [:short, "a"], [:short, "l"],
-    #              [:long, "verbose"]])
-    #   #=> ["add", "-al", "--verbose"]
+    #  
+    #   t.token?([:word, "something"]) #=> true
+    #   t.token?(["a", "normal", "array"]) #=> false
     #
-    def to_array(tokens=@tokens)
-      @array = []
-      tokens.each do |i|
-        k, v = i[0], i[1]
-        case k
-        when :long
-          @array << "--#{v}"
-        when :short
-          @array << "-#{v}"
-        when :word
-          @array << v
-        end
+    def token?(arr)
+      return false if arr.nil?
+      TOKEN_KEYS.include?(arr[0])
+    end
+    
+    # Convert a tokens to its string representation
+    def token_to_string(token)
+      k, v = token[0], token[1]
+      case k
+      when :long
+        "--#{v}"
+      when :short
+        "-#{v}"
+      when :word
+        v
       end
-      
-      @array
+    end
+    
+    # This is here to force the use of #tokens and #array when 
+    # accessing the contents
+    def inspect
+      "#<Clive::Tokens:0x#{'%x' % (self.object_id << 1)} #{self.tokens}>"
     end
     
   end

data/test/test_boolean.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+class TestBoolean < Test::Unit::TestCase
+  
+  context "A new boolean switch" do
+  
+    setup do
+      @c = Clive.new do
+        boolean(:v, :verbose, "Run verbosely") {|i| $stdout.puts(i)}
+      end
+    end
+  
+    should "create two switches" do
+      assert_equal 2, @c.booleans.length
+    end
+    
+    context "the true switch" do
+      should "have a short name" do
+        assert_equal "v", @c.switches["verbose"].short
+      end
+      
+      should "pass true to the block" do
+        mock($stdout).puts(true)
+        @c.parse(["--verbose"])
+      end
+      
+      should "create summary" do
+        assert_equal "-v, --[no-]verbose Run verbosely", @c.switches["verbose"].summary(0, 0)
+      end
+    end
+    
+    context "the false switch" do
+      should "not have short name" do
+        assert_equal nil, @c.switches["no-verbose"].short
+      end
+      
+      should "pass false to the block" do
+        mock($stdout).puts(false)
+        @c.parse(["--no-verbose"])
+      end
+      
+      should "not create summary" do
+        assert_equal nil, @c.switches["no-verbose"].summary
+      end
+    end
+  
+  end
+end

data/test/test_flag.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestFlag < Test::Unit::TestCase
+  
+  context "A new flag" do
+    
+    setup do
+      @c = Clive.new do
+        flag(:t, :type, "Choose type") {|i| $stdout.puts(i)}
+      end
+    end
+    
+    should "pass an argument to block" do
+      mock($stdout).puts("text")
+      @c.parse(["--type", "text"])
+    end
+    
+  end
+end

data/test/test_switch.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestSwitch < Test::Unit::TestCase
+  
+  context "A new switch" do
+  
+    setup do
+      @c = Clive.new do
+        switch(:d, :debug, "Use debug mode") {}
+      end
+    end
+    
+    should "create summary" do
+      assert_equal "-d, --debug Use debug mode", @c.switches["d"].summary(0, 0)
+    end
+  
+  end
+end

data/test/test_token.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestToken < Test::Unit::TestCase
+
+  context "When converting" do
+    setup do
+      @array = ["add", "-al", "--verbose"]
+      @array_split = ["add", "-a", "-l", "--verbose"]
+      @tokens = [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
+    end
+  
+    should "convert an array to tokens" do
+      t = Clive::Tokens.new(@array)
+      assert_equal @tokens, t.tokens
+    end
+    
+    should "convert tokens to an array" do
+      assert_equal @array_split, Clive::Tokens.to_array(@tokens)
+    end  
+  end
+  
+  context "A new tokens instance" do
+  
+    setup do
+      @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
+      t = Clive::Tokens.new(@tokens)
+      assert_equal @tokens, t.tokens
+      assert_equal @array_split, t.array
+    end
+    
+    should "be created from tokens" do
+      t = Clive::Tokens.new(@array)
+      assert_equal @tokens, t.tokens
+      assert_equal @array_split, t.array
+    end
+  
+    should "have tokens" do
+      
+    end
+    
+    should "have an array" do
+    
+    end
+  
+  end
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: clive
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Joshua Hawxwell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-15 00:00:00 +01:00
+date: 2010-08-17 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,8 +72,12 @@ files:
 - lib/clive/tokens.rb
 - test/bin_test
 - test/helper.rb
+- test/test_boolean.rb
 - test/test_clive.rb
 - test/test_exceptions.rb
+- test/test_flag.rb
+- test/test_switch.rb
+- test/test_token.rb
 has_rdoc: true
 homepage: http://github.com/hawx/clive
 licenses: []
@@ -110,5 +114,9 @@ specification_version: 3
 summary: Imagine if optparse and gli had a son called clive.
 test_files: 
 - test/helper.rb
+- test/test_boolean.rb
 - test/test_clive.rb
 - test/test_exceptions.rb
+- test/test_flag.rb
+- test/test_switch.rb
+- test/test_token.rb