clive 0.6.2 → 0.7.0

data/lib/clive/output.rb

@@ -6,7 +6,7 @@
 #
 #
 
-class Clive
+module Clive
   module Output
   
   end
@@ -68,23 +68,19 @@ class String
       colour("\e[4#{code}m")
     end
     
-    # Light white doesn't exist
-    unless name == "white"
-      # Change name to grey instead of l_black
-      _name = "l_#{name}"
-      if name == "black"
-        _name = "grey"
-      end
-      
-      define_method "#{_name}" do
-        colour("\e[9#{code}m")
-      end
-      
-      define_method "#{_name}_bg" do
-        colour("\e[10#{code}m")
-      end
+    # Change name to grey instead of l_black
+    l_name = "l_#{name}"
+    if name == "black"
+      l_name = "grey"
+    end
+    
+    define_method "#{l_name}" do
+      colour("\e[9#{code}m")
+    end
+    
+    define_method "#{l_name}_bg" do
+      colour("\e[10#{code}m")
     end
-  end
 
+  end
 end
-

data/lib/clive/parser.rb

@@ -8,7 +8,11 @@ require 'clive/switch'
 require 'clive/flag'
 require 'clive/bool'
 
-class Clive
+require 'clive/output'
+require 'clive/formatter'
+
+
+module Clive
 
   # A module wrapping the command line parsing of clive. In the future this
   # will be the only way of using clive.
@@ -19,11 +23,7 @@ class Clive
   # 
   #   class CLI
   #     include Clive::Parser
-  #   
-  #     @@opts ||= {}
-  #     def self.opts
-  #       @@opts
-  #     end
+  #     option_hash :opts
   #   
   #     switch :v, :verbose, "Run verbosely" do
   #       opts[:verbose] = true
@@ -34,32 +34,95 @@ class Clive
   #   p CLI.opts
   #
   module Parser
-  
+    
+    # When the module is included we need to keep track of the new class it
+    # is now in and we need to create a new base command. So here instance 
+    # variables are set directly in the new class, and the class is made to
+    # extend the methods in Parser so they are available as class methods.
+    # 
     def self.included(klass)
-      @@klass = klass
-      @@klass.extend(self)
-      @@base = Clive::Command.new(true)
+      klass.instance_variable_set("@klass", klass)
+      klass.extend(self)
+      klass.instance_variable_set "@base", Clive::Command.new(true)
     end
-  
+    
+    # @return [Clive::Command]
+    #   The base command to forward method calls to.
+    #
+    def base; @base; end
+    
+    # @see Clive::Command#run
     def parse(argv)
-      @@base.run(argv)
+      base.run(argv)
     end
     
+    # @see Clive::Command#flag
     def flag(*args, &block)
-      @@base.flag(*args, &block)
+      base.flag(*args, &block)
     end
     
+    # @see Clive::Command#switch
     def switch(*args, &block)
-      @@base.switch(*args, &block)
+      base.switch(*args, &block)
     end
     
+    # @see Clive::Command#command
     def command(*args, &block)
-      @@base.command(*args, &block)
+      base.command(*args, &block)
     end
     
+    # @see Clive::Command#bool
     def bool(*args, &block)
-      @@base.bool(*args, &block)
+      base.bool(*args, &block)
+    end
+    
+    # @see Clive::Command#desc
+    def desc(*args)
+      base.desc(*args)
+    end
+    
+    # @see Clive::Command#help_formatter
+    def help_formatter(*args, &block)
+      base.help_formatter(*args, &block)
+    end
+    
+    
+    # @see http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+    # or because that doesn't exist anymore from this mirror
+    # http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html
+    #
+    def meta_def(name, &blk)
+      (class << self; self; end).instance_eval { define_method(name, &blk) }
+    end
+    
+    def option_var(name, value=nil)
+      @klass.meta_def(name) do
+        instance_variable_get("@#{name}")
+      end
+      @klass.meta_def("#{name}=") do |val|
+        instance_variable_set("@#{name}", val)
+      end
+      instance_variable_set("@#{name}", value)
+    end
+    
+    # Create a new hash which is accessible to the options in the new class
+    # but can also be accessed from outside the class. Defines getters and 
+    # setters for the symbols given, and sets their initial value to +{}+.
+    #
+    # @param args [Symbol]
+    #
+    def option_hash(*args)
+      args.each do |arg|
+        option_var(arg, {})
+      end
+    end
+    
+    def option_array(*args)
+      args.each do |arg|
+        option_var(arg, [])
+      end
     end
+    alias_method :option_list, :option_array
 
   end
 end

data/lib/clive/switch.rb

@@ -1,4 +1,4 @@
-class Clive
+module Clive
   
   # A string that takes no argument, beginning with one or two dashes
   #   eg. ruby --version
@@ -8,26 +8,17 @@ class Clive
       
     # Create a new Switch instance.
     #
-    # +short+ _or_ +long+ may be omitted but not both.
+    # @param names [Array[Symbol]]
+    #   An array of names the option can be invoked by.
     #
-    # @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
+    # @param desc [String]
+    #   A description of what the option does.
     #
     # @yield A block to run if the switch is triggered
     #
-    def initialize(*args, &block)
-      @names = []
-      args.each do |i|
-        case i
-        when Symbol
-          @names << i.to_s
-        when String
-          @desc = i
-        end
-      end
+    def initialize(names, desc, &block)
+      @names = names.map(&:to_s)
+      @desc  = desc
       @block = block
     end
     

data/lib/clive/tokens.rb

@@ -1,4 +1,4 @@
-class Clive
+module Clive
 
   # A subclass of Array to allow the creation of arrays that look
   # like:

data/lib/clive/version.rb

@@ -1,3 +1,3 @@
-class Clive
-  VERSION = '0.6.2'
+module Clive
+  VERSION = '0.7.0'
 end

data/spec/clive/bool_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Clive::Bool do
+
+  subject { Clive::Bool.new([:n, :name], "A test", true) {|arg| puts arg } }
+  let(:falsey) { Clive::Bool.new([:n, :name], "A test", false) {|arg| puts arg } }
+
+  describe "#truth" do
+    it "returns the truth" do
+      subject.truth.should == true
+    end
+  end
+
+  it_behaves_like "an option"
+  
+  context "when no long name is given" do
+    it "raises an error" do
+      expect {
+        Clive::Bool.new([:n], "Short test", true) {}
+      }.should raise_error Clive::MissingLongName
+    end
+  end
+  
+  describe "#run" do
+    context "when truth is true" do
+      it "passes true to the block" do
+        $stdout.should_receive(:puts).with(true)
+        subject.run
+      end
+    end
+    
+    context "when truth is false" do
+      it "passes false to the block" do
+        $stdout.should_receive(:puts).with(false)
+        falsey.run
+      end
+    end
+  end
+  
+  describe "#to_h" do
+    context "when truth is true" do
+      it "returns hash for help formatter" do
+        hsh = {'names' => subject.names_to_strings(true),
+               'desc' => subject.desc}
+        subject.to_h.should == hsh
+      end
+    end
+    
+    context "when truth is false" do
+      specify { falsey.to_h.should be_nil }
+    end
+  end
+
+end

data/spec/clive/command_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+describe Clive::Command do
+
+  context "when creating a base command" do
+    subject { Clive::Command.new(true) {} }
+  end
+  
+  subject { 
+    Clive::Command.new(:co, :comm, "A command") do
+      bool(:boo) {}
+      switch(:swi) {}
+      flag(:fla) {}
+      command(:com) {}
+    end
+  }
+  
+  it_behaves_like "an option"
+  
+  describe "#initialize" do
+    subject { 
+      Clive::Command.new(:com, "A command") do
+        flag(:test)
+      end
+    }
+  
+    it "generates a help header" do
+      File.stub!(:basename).and_return("test")
+      subject.instance_variable_get("@header").should == "Usage: test com [options]"
+    end
+    
+    it "generates an option missing proc" do
+      proc = subject.instance_variable_get("@option_missing")
+      expect {
+        proc.call("hey")
+      }.should raise_error Clive::NoOptionError
+    end
+    
+    it "sets the help formatter to :default" do
+      formatter = subject.instance_variable_get("@help_formatter")
+      formatter.should == subject.help_formatter(:default)
+    end
+    
+    it "doesn't run the block given" do
+      subject.flags.size.should == 0
+    end
+    
+    it "generates a help switch" do
+      subject.switches.map {|i| i.names}.should include ["h", "help"]
+    end
+  end
+  
+  describe "#bools" do
+    it "returns an array of bools" do
+      subject.find
+      subject.bools.each do |i|
+        i.should be_kind_of Clive::Bool
+      end
+    end
+  end
+  
+  describe "#switches" do
+    it "returns an array of switches" do
+      subject.find
+      subject.switches.each do |i|
+        i.should be_kind_of Clive::Switch
+      end
+    end
+  end
+  
+  describe "#flags" do
+    it "returns an array of flags" do
+      subject.find
+      subject.flags.each do |i|
+        i.should be_kind_of Clive::Flag
+      end
+    end
+  end
+  
+  describe "#find" do
+    it "runs the block for the command" do
+      subject.flags.size.should == 0
+      subject.find
+      subject.flags.size.should == 1
+    end
+    
+    it "sets the block to nil" do
+      subject.find
+      subject.block.should be_nil
+    end
+  end
+  
+  describe "#run" do
+    it "returns an array of unused arguments" do
+      subject.find
+      subject.run(%w(--swi what)).should == ['what']
+    end
+  end
+  
+  describe "#tokenize" do
+    it "returns an array of tokens" do
+      subject.find
+      res = [
+        [:switch, subject.bools.find {|i| i.names == ["boo"] }],
+        [:argument, "what"]
+      ]
+      subject.tokenize(%w(--boo what)).should == res
+    end
+  end
+  
+  describe "#parse" do
+    it "returns an array of tokens"
+  end
+  
+  describe "#to_h" do
+    it "returns a hash of data for help formatting" do
+      hsh = {'names' => subject.names, 'desc' => subject.desc}
+      subject.to_h.should == hsh
+    end
+  end
+  
+  describe "#command" do
+    it "creates a new command" do
+      expect {
+        subject.command(:comm)
+      }.should change {subject.commands.size}.by(1)
+    end
+    
+    it "resets the current description" do
+      subject.desc 'A command'
+      subject.command(:comm)
+      subject.current_desc.should == ""
+    end
+  end
+  
+  describe "#switch" do
+    it "creates a new switch" do
+      expect {
+        subject.switch(:s, :switch)
+      }.should change {subject.switches.size}.by(1)
+    end
+    
+    it "resets the current description" do
+      subject.desc 'A switch'
+      subject.switch(:s, :switch)
+      subject.current_desc.should == ""
+    end
+  end
+  
+  describe "#flag" do
+    it "creates a new flag" do
+      expect {
+        subject.flag(:f, :flag)
+      }.should change {subject.flags.size}.by(1)
+    end
+    
+    it "resets the current description" do
+      subject.desc 'A flag'
+      subject.flag(:f, :flag)
+      subject.current_desc.should == ""
+    end
+  end
+  
+  describe "#bool" do
+    it "creates two bool switches" do
+      expect {
+        subject.bool(:b, :bool)
+      }.should change {subject.bools.size}.by(2)
+    end
+    
+    it "resets the current description" do
+      subject.desc 'A bool'
+      subject.bool(:b, :bool)
+      subject.current_desc.should == ""
+    end
+  end
+  
+  describe "#desc" do
+    context "when called with no arguments" do
+      it "returns the description for the command" do
+        subject.desc.should == "A command"
+      end
+    end
+    
+    context "when called with an argument" do
+      it "sets the current description" do
+        subject.desc "A new desc"
+        subject.instance_variable_get("@current_desc").should == "A new desc"
+      end
+    end
+  end
+  
+  describe "#option_missing" do
+    it "sets the option missing proc" do
+      proc = lambda {|n| puts "What? #{name} doesn't exist" }
+      subject.option_missing(&proc)
+      subject.instance_variable_get("@option_missing").should == proc
+    end
+  end
+  
+  describe "#header" do
+    it "sets the header" do
+      subject.header "A header"
+      subject.instance_variable_get("@header").should == "A header"
+    end
+  end
+  
+  describe "#footer" do
+    it "sets the footer" do
+      subject.footer "A footer"
+      subject.instance_variable_get("@footer").should == "A footer"
+    end
+  end
+  
+  describe "#build_help" do
+    it "adds a switch for help" do
+      subject.options = Clive::Array.new
+      subject.options.should be_empty
+      subject.build_help
+      subject.options.map(&:names).should include ['h', 'help']
+    end
+  end
+  
+  describe "#help" do
+    it "returns a string of help" do
+      help = <<EOS
+Usage: rspec co, comm [options]
+
+  Options: 
+     -h, --help               \e[90mDisplay help\e[0m
+EOS
+    
+      subject.help.should == help
+    end
+  end
+  
+  describe "#help_formatter" do
+    context "when called with a symbol" do
+      it "uses the named formatter" do
+        before = subject.instance_variable_get("@formatter")
+        subject.help_formatter(:white)
+        subject.instance_variable_get("@formatter").should_not == before
+      end
+    end
+    
+    context "when called with argumentss and a block" do
+      it "creates a new help formatter" do
+        subject.help_formatter :width => 40, :prepend => 5 do |h|
+          h.switch  "switch"
+          h.bool    "bool"
+          h.flag    "flag"
+          h.command "command"
+        end
+        formatter = subject.instance_variable_get("@formatter")
+        formatter.width.should == 40
+      end
+    end
+  end
+
+end