clive 0.8.1 → 1.0.0

data/lib/clive/type/definitions.rb

@@ -0,0 +1,170 @@
+# can't autoload time as the constant is already defined
+require 'time'
+autoload :Pathname, 'pathname'
+
+class Clive
+  class Type
+
+    # Basic object, all arguments are valid and will simply return
+    # themselves.
+    class Object < Type
+
+      # Test the value to see if it is a valid value for this Tyoe.
+      # @param arg [String] The value to be tested
+      def valid?(arg)
+        true
+      end
+
+      # Cast the arg (String) to the correct type.
+      # @param arg [String] The value to be cast
+      def typecast(arg)
+        arg
+      end
+    end
+
+    # String will accept any argument which is not +nil+ and will
+    # return the argument with #to_s called on it.
+    class String < Object
+      refute :nil?
+      cast   :to_s
+    end
+
+    # Symbol will accept and argument which is not +nil+ and will
+    # return the argument with #to_sym called on it.
+    class Symbol < Object
+      refute :nil?
+      cast   :to_sym
+    end
+
+    # Integer will match anything that float matches, but will
+    # return an integer. If you need something that only matches
+    # integer values properly use {StrictInteger}.
+    class Integer < Object
+      match /^[-+]?\d*\.?\d+([eE][-+]?\d+)?$/
+      cast  :to_i
+    end
+
+    # StrictInteger only matches strings that look like integers,
+    # it returns Integers.
+    # @see Integer
+    class StrictInteger < Object
+      match /^[-+]?\d+([eE][-+]?\d+)?$/
+      cast  :to_i
+    end
+
+    # Binary matches any binary number which may or may not have a "0b" prefix
+    # and returns the number as an Integer.
+    class Binary < Object
+      match /^[-+]?(0b)?[01]*$/i
+      cast  :to_i, 2
+    end
+
+    # Octal matches any octal number which may (or may not) be prefixed with "0"
+    # or "0o" (or even "0O") so 25, 025, 0o25 and 0O25 are all valid and will
+    # give the same result, the Integer 21.
+    class Octal < Object
+      match /^[-+]?(0o?)?[0-7]*$/i
+      cast  :to_i, 8
+    end
+
+    # Hexadecimal matches any hexadecimal number which may or may not have a
+    # "0x" prefix, it returns the number as an Integer.
+    class Hexadecimal < Object
+      match /^[-+]?(0x)?[0-9a-f]*$/i
+      cast  :to_i, 16
+    end
+
+    class Float < Object
+      match /^[-+]?\d*\.?\d+([eE][-+]?\d+)?$/
+      cast  :to_f
+    end
+
+    # Boolean will accept 'true', 't', 'yes', 'y' or 'on' as +true+ and
+    # 'false', 'f', 'no', 'n' or 'off' as +false+.
+    class Boolean < Object
+      TRUE_VALUES  = %w(true t yes y on)
+      FALSE_VALUES = %w(false f no n off)
+
+      def valid?(arg)
+        (TRUE_VALUES + FALSE_VALUES).include? arg
+      end
+
+      def typecast(arg)
+        case arg
+          when *TRUE_VALUES  then true
+          when *FALSE_VALUES then false
+        end
+      end
+    end
+
+    class Pathname < Object
+      refute :nil?
+
+      def typecast(arg)
+        ::Pathname.new arg
+      end
+    end
+
+    # Range accepts 'a..b', 'a...b' which behave as in ruby and
+    # 'a-b' which behaves like 'a..b'. It returns the correct
+    # Range object.
+    class Range < Object
+      match /^(\w+\.\.\.?\w+|\w+\-\w+)$/
+
+      def typecast(arg)
+        if arg.include?('...')
+          a,b = arg.split('...')
+          ::Range.new a, b, true
+        elsif arg.include?('..')
+          a,b = arg.split('..')
+          ::Range.new a, b, false
+        else
+          a,b = arg.split('-')
+          ::Range.new a, b, false
+        end
+      end
+    end
+
+    # Array accepts a list of arguments separated by a comma, no
+    # spaces are allowed. It returns an array of the elements.
+    class Array < Object
+      match /^(.+,)*.+[^,]$/
+      cast  :split, ','
+    end
+
+    # Time accepts any value which can be parsed by {::Time.parse},
+    # it returns the correct {::Time} object.
+    class Time < Object
+      def valid?(arg)
+        ::Time.parse arg
+        true
+      rescue
+        false
+      end
+
+      def typecast(arg)
+        ::Time.parse arg
+      end
+    end
+
+    class Regexp < Object
+      match /^\/.*?\/[imxou]*$/
+
+      OPTS = {
+        'x' => ::Regexp::EXTENDED,
+        'i' => ::Regexp::IGNORECASE,
+        'm' => ::Regexp::MULTILINE
+      }
+
+      def typecast(arg)
+        parts = arg.split('/')
+        mods = parts.pop
+        arg = parts.join('')
+        mods = mods.split('').map {|a| OPTS[a] }.inject{|a,e| a | e }
+
+        ::Regexp.new arg, mods
+      end
+    end
+
+  end
+end

data/lib/clive/type/lookup.rb

@@ -0,0 +1,23 @@
+class Clive
+  class Type
+  
+    # Clive::Type::Lookup is an almost carbon copy of DataMapper::Property::Lookup
+    # @see https://github.com/datamapper/dm-core/blob/master/lib/dm-core/property/lookup.rb
+    module Lookup
+
+      protected
+
+      # Provides access to Types defined under {Type} as if accessed
+      # normally.
+      #
+      # @param name [#to_s] The name of the Type to lookup.
+      # @return [Type] The type with the given name.
+      # @raise [NameError] The property could not be found.
+      #
+      def const_missing(name)
+        Type.find_class(name.to_s) || super
+      end
+      
+    end
+  end
+end

data/lib/clive/version.rb

@@ -1,3 +1,3 @@
-module Clive
-  VERSION = '0.8.1'
-end
+class Clive
+  VERSION = '1.0.0'
+end

data/spec/clive/a_cli_spec.rb

@@ -0,0 +1,245 @@
+$: << File.dirname(__FILE__) + '/..'
+require 'helper'
+
+describe 'A CLI' do
+  subject {
+    Clive.new {
+
+      header 'Usage: clive_test.rb [command] [options]'
+
+      opt :version, :tail => true do
+        puts "Version 1"
+      end
+
+      set :something, []
+
+      bool :v, :verbose
+      bool :a, :auto
+
+      opt :s, :size, 'Size of thing', :arg => '<size>', :as => Float
+      opt :S, :super_size
+
+      opt :name, :args => '<name>'
+      opt :modify, :arg => '<key> <sym> [<args>]', :as => [Symbol, Symbol, Array] do
+        update key, sym, *args
+      end
+
+      desc 'Print <message> <n> times'
+      opt :print, :arg => '<message> <n>', :as => [String, Integer] do
+        n.times { puts message }
+      end
+
+      desc 'A super long description for a super stupid option, this should test the _extreme_ wrapping abilities as it should all be aligned. Maybe I should go for another couple of lines just for good measure. That\'s all'
+      opt :complex, :arg => '[<one>] <two> [<three>]', :match => [ /^\d$/, /^\d\d$/, /^\d\d\d$/ ] do |a,b,c|
+        puts "a: #{a}, b: #{b}, c: #{c}"
+      end
+
+      command :new, :create, 'Creates new things', :arg => '[<dir>]', :match => /\// do
+
+        set :something, []
+
+        # implicit arg as "<choice>", also added default
+        opt :T, :type, :in => %w(post page blog), :default => :page, :as => Symbol
+        opt :force, 'Force overwrite' do
+          require 'highline/import'
+          answer = ask("Are you sure, this could delete stuff? [y/n]\n")
+          set :force, true if answer == "y"
+        end
+
+        action do |dir|
+          puts "Creating #{get :type} in #{dir}" if dir
+        end
+      end
+    }
+  }
+
+  describe '--version' do
+    it 'prints version string' do
+      this {
+        subject.run s '--version'
+      }.must_output "Version 1\n"
+    end
+  end
+
+  describe 'set :something' do
+    it 'is set to an empty Array' do
+      r = subject.run []
+      r[:something].must_equal []
+    end
+  end
+
+  describe '-a, --[no-]auto' do
+    it 'sets to true' do
+      r = subject.run s '--auto'
+      r[:auto].must_be_true
+      r[:a].must_be_true
+    end
+
+    it 'sets to false if no passed' do
+      r = subject.run s '--no-auto'
+      r[:auto].must_be_false
+      r[:a].must_be_false
+    end
+
+    it 'allows the short version' do
+      r = subject.run s '-a'
+      r[:auto].must_be_true
+      r[:a].must_be_true
+    end
+  end
+
+  describe '-s, --size' do
+    it 'takes a Float as an argument' do
+      r = subject.run s '--size 50.56'
+      r[:size].must_equal 50.56
+      r[:s].must_equal 50.56
+    end
+
+    it 'raises an error if the argument is not passed' do
+      this {
+        subject.run s '--size'
+      }.must_raise Clive::Parser::MissingArgumentError
+    end
+
+    it 'raises an error if a Float is not given' do
+      this {
+        subject.run s '--size hello'
+      }.must_raise Clive::Parser::MissingArgumentError
+    end
+  end
+
+  describe '-S, --super-size' do
+    it 'can be called with dashes' do
+      r = subject.run s '--super-size'
+      r[:super_size].must_be_true
+      r[:S].must_be_true
+    end
+
+    it 'can be called with underscores' do
+      r = subject.run s '--super_size'
+      r[:super_size].must_be_true
+      r[:S].must_be_true
+    end
+  end
+
+  describe '--modify' do
+    it 'updates the key' do
+      r = subject.run s '--name "John Doe" --modify name count oe,e'
+      r[:name].must_equal 1
+    end
+  end
+
+  describe '--print' do
+    it 'prints a message n times' do
+      this {
+        subject.run s '--print "Hello World!" 5'
+      }.must_output "Hello World!\n" * 5
+    end
+  end
+
+  describe '--complex' do
+    it 'takes one argument' do
+      this {
+        subject.run s '--complex 55'
+      }.must_output "a: , b: 55, c: \n"
+
+      this {
+        subject.run s '--complex 4'
+      }.must_raise Clive::Parser::MissingArgumentError
+
+      this {
+        subject.run s '--complex 666'
+      }.must_raise Clive::Parser::MissingArgumentError
+    end
+
+    it 'takes two arguments' do
+      this {
+        subject.run s '--complex 4 55'
+      }.must_output "a: 4, b: 55, c: \n"
+
+      this {
+        subject.run s '--complex 55 666'
+      }.must_output "a: , b: 55, c: 666\n"
+
+      this {
+        subject.run s '--complex 4 666'
+      }.must_raise Clive::Parser::MissingArgumentError
+    end
+
+    it 'takes three arguments' do
+      this {
+        subject.run s '--complex 4 55 666'
+      }.must_output "a: 4, b: 55, c: 666\n"
+    end
+  end
+
+  describe 'new' do
+    describe 'set :something' do
+      it 'sets :something in :new to []' do
+        r = subject.run s 'new'
+        r[:new][:something].must_equal []
+      end
+    end
+
+    describe '-T, --type' do
+      it 'sets the type' do
+        r = subject.run s 'new --type blog'
+        r[:new][:type].must_equal :blog
+        r[:new][:T].must_equal :blog
+      end
+
+      it 'uses the default' do
+        r = subject.run s 'new --type'
+        r[:new][:type].must_equal :page
+        r[:new][:T].must_equal :page
+      end
+
+      it 'ignores non valid options' do
+        r = subject.run s 'new --type crazy'
+        r[:new][:type].must_equal :page
+        r[:new][:T].must_equal :page
+        r.args.must_equal ['crazy']
+      end
+    end
+
+    describe '--force' do
+      #it 'asks for conformation' do
+      #  r = subject.run s 'new --force'
+      #  r[:force].must_be_true
+      #end
+    end
+
+    describe 'action' do
+      it 'prints the type and dir' do
+        this {
+          subject.run s 'new --type ~/dir'
+        }.must_output "Creating page in ~/dir\n"
+      end
+
+      it 'only accepts directories' do
+        this {
+          subject.run s 'new not-a-dir'
+        }.must_output ""
+      end
+    end
+  end
+
+  it 'should be able to do this' do
+    this {
+      r = subject.run s('-v new --type post ~/my_site --no-auto arg arg2')
+      r.args.must_equal %w(arg arg2)
+      r.to_h.must_equal :something => [], :verbose => true,
+                   :new => {:something => [], :type => :post}, :auto => false
+    }.must_output "Creating post in ~/my_site\n"
+  end
+
+  it 'should be able to do combined short switches' do
+    r = subject.run s '-vas 2.45'
+
+    r.to_h.must_equal :something => [], :verbose => true, :auto => true, :size => 2.45
+
+    this {
+      subject.run %w(-vsa 2.45)
+    }.must_raise Clive::Parser::MissingArgumentError
+  end
+end

data/spec/clive/argument_spec.rb

@@ -0,0 +1,148 @@
+$: << File.dirname(__FILE__) + '/..'
+require 'helper'
+
+describe Clive::Argument::AlwaysTrue do
+  subject { Clive::Argument::AlwaysTrue } 
+  
+  it 'is always true for the method given' do
+    subject.for(:hey).hey.must_be_true
+  end
+  
+  it 'is always true for the methods given' do
+    a = subject.for(:one, :two, :three)
+    a.one.must_be_true
+    a.two.must_be_true
+    a.three.must_be_true
+  end
+end
+
+describe Clive::Argument do
+  subject { Clive::Argument }
+  
+  describe '#initialize' do
+    it 'converts name to Symbol' do
+      subject.new('arg').name.must_be_kind_of Symbol
+    end
+    
+    it 'calls #to_proc on a Symbol constraint' do
+      c = mock
+      c.expects(:respond_to?).with(:to_proc).returns(true)
+      c.expects(:to_proc)
+      
+      subject.new :a, :constraint => c
+    end
+    
+    it 'merges given options with DEFAULTS' do
+      opts = {:optional => true}
+      Clive::Argument::DEFAULTS.expects(:merge).with(opts).returns({})
+      subject.new('arg', opts)
+    end
+    
+    it 'finds the correct type class' do
+      subject.new(:a, :type => String).type.must_equal Clive::Type::String
+    end
+    
+    it 'uses the class passed if type cannot be found' do
+      type = Class.new
+      subject.new(:a, :type => type).type.must_equal type
+    end
+  end
+  
+  describe '#optional?' do
+    it 'is true if the argument is optional' do
+      subject.new(:arg, :optional => true).must_be :optional?
+    end
+    
+    it 'is false if the argument is not optional' do
+      subject.new(:arg, :optional => false).wont_be :optional?
+    end
+    
+    it 'is false by default' do
+      subject.new(:arg).wont_be :optional?
+    end
+  end
+  
+  describe '#to_s' do
+    it 'surrounds the name by < and >' do
+      subject.new(:a).to_s.must_equal '<a>'
+    end
+    
+    it 'surrounds optional arguments with [ and ]' do
+      subject.new(:a, :optional => true).to_s.must_equal '[<a>]'
+    end
+  end
+  
+  describe '#choice_str' do
+    it 'returns the array of values allowed' do
+      subject.new(:a, :within => %w(a b c)).choice_str.must_equal '(a, b, c)'
+    end
+    
+    it 'returns the range of values allowed' do
+      subject.new(:a, :within => 1..5).choice_str.must_equal '(1..5)'
+    end
+  end
+  
+  describe '#possible?' do
+    describe 'for @type' do
+      subject { Clive::Argument.new :a, :type => Clive::Type::Time }
+      
+      it 'is true for correct string values' do
+        subject.must_be :possible?, '12:34'
+      end
+      
+      it 'is true for objects of type' do
+        subject.must_be :possible?, Time.parse('12:34')
+      end
+      
+      unless RUBY_VERSION == '1.8.7' # No big problem so just ignore
+        it 'is false for incorrect values' do
+          subject.wont_be :possible?, 'not-a-time'
+        end
+      end
+    end
+    
+    describe 'for @match' do
+      subject { Clive::Argument.new :a, :match => /^[a-e]+![f-o]+\?.$/ }
+      
+      it 'is true for matching values' do
+        subject.must_be :possible?, 'abe!off?.'
+      end
+      
+      it 'is false for non-matching values' do
+        subject.wont_be :possible?, 'off?abe!.'
+      end
+    end
+    
+    describe 'for @within' do
+      subject { Clive::Argument.new :a, :within => %w(dog cat fish) }
+      
+      it 'is true for elements included in the collection' do
+        subject.must_be :possible?, 'dog'
+      end
+      
+      it 'is false for elements not in the collection' do
+        subject.wont_be :possible?, 'mouse'
+      end
+    end
+    
+    describe 'for @constraint' do
+      subject { Clive::Argument.new :a, :constraint => proc {|i| i.size == 5 } }
+      
+      it 'is true if the proc returns true' do
+        subject.must_be :possible?, 'abcde'
+      end
+      
+      it 'is false if the proc returns false' do
+        subject.wont_be :possible?, 'abcd'
+      end
+    end
+  end
+  
+  describe '#coerce' do
+    it 'uses @type to return the correct object' do
+      type = mock
+      type.expects(:typecast).with('str').returns(5)
+      subject.new(:a, :type => type).coerce("str").must_equal 5
+    end
+  end
+end