clive 0.8.1 → 1.0.0

data/lib/clive/switch.rb

@@ -1,31 +0,0 @@
-module Clive
-  
-  # A string that takes no argument, beginning with one or two dashes
-  #   eg. ruby --version
-  #       ruby -v
-  #
-  class Switch < Option
-      
-    # Create a new Switch instance.
-    #
-    # @param names [Array[Symbol]]
-    #   An array of names the option can be invoked by.
-    #
-    # @param desc [String]
-    #   A description of what the option does.
-    #
-    # @yield A block to run if the switch is triggered
-    #
-    def initialize(names, desc, &block)
-      @names = names.map(&:to_s)
-      @desc  = desc
-      @block = block
-    end
-    
-    # Runs the block that was given
-    def run
-      @block.call
-    end
-    
-  end
-end

data/lib/clive/tokens.rb

@@ -1,141 +0,0 @@
-module Clive
-
-  # A subclass of Array to allow the creation of arrays that look
-  # like:
-  #
-  #    [[:word, 'Value'], [:long, 'verbose'], [:short, 'r']]
-  #
-  # The tokens are not stored like that but as the string 
-  # representations:
-  #
-  #   ["Value", "--verbose", "-r"]
-  #
-  class Tokens < Array
-    
-    TOKEN_KEYS = [:word, :short, :long]
-    
-    # Create a new Tokens instance. Pass either an array of tokens
-    # or a plain array, they will be converted correctly.
-    #
-    # @param [Array] args 
-    #   pass either
-    #     ["command", "--flag"]
-    #     # or
-    #     [[:word, "command"], [:long, "flag"]]
-    # @return [Tokens]
-    #
-    def initialize(args=[])
-      if token?(args[0])
-        r = []
-        args.each {|i| r << token_to_string(i)}
-        args = r
-      end
-      super(args)
-    end
-    
-    # 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
-    
-    # Creates an array of tokens based on +self+.
-    # Strings beginning with a -, eg. -n become [:short, "n"].
-    # Strings beginning with --, eg. --verbose become [:long, "verbose"].
-    # Strings which begin with neither become [:word, "value"].
-    #
-    # @return [Array] the tokens that are held
-    def tokens
-      t = []
-      self.each do |i|
-        case i
-        when /\-\-.+/
-          if i.include?('=')
-            a, b = i[2..i.length].split('=')
-            t << [:long, a] << [:word, b]
-          else
-            t << [:long, i[2..i.length]]
-          end
-        when /\-.+/
-          i[1..i.length].split('').each do |j|
-            t << [:short, j]
-          end
-        else
-          t << [:word, i]
-        end
-      end
-      
-      t
-    end
-    
-    # @see #tokens
-    def self.to_tokens(arr)
-      Tokens.new(arr).tokens
-    end
-    
-    # @see #array
-    def self.to_array(tokens)
-      Tokens.new(tokens).array
-    end
-    
-    # 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
-    #  
-    #   t.token?([:word, "something"]) #=> true
-    #   t.token?(["a", "normal", "array"]) #=> false
-    #
-    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
-    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
-end

data/spec/clive/bool_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe Clive::Bool do
-
-  subject { Clive::Bool.new([:n, :name], "A test", true) {|arg| $stdout.puts arg } }
-  let(:falsey) { Clive::Bool.new([:n, :name], "A test", false) {|arg| $stdout.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/flag_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-
-describe Clive::Flag do
-
-  subject { Clive::Flag.new([:S, :say], "Say something", "WORD(S)") {|i| $stdout.puts i } }
-
-  it_behaves_like "an option"
-
-  describe "#run" do
-    it "calls the block with the argument" do
-      $stdout.should_receive(:puts).with("hey")
-      subject.run(["hey"])
-    end
-  end
-  
-  describe "#arg_size" do
-    context "when choice is available" do
-      it "returns 1" do
-        subject.args = 1..5
-        subject.arg_size.should == 1
-      end
-    end
-    
-    context "when arguments are required" do
-      subject { Clive::Flag.new([:n], "Description", "REQ [OPT] REQ2 [OPT2] [OPT3]") }
-    
-      it "returns the number of all arguments" do
-        subject.arg_size(:all).should == 5
-      end
-      
-      it "returns the number of optional arguments" do
-        subject.arg_size(:optional).should == 3
-      end
-      
-      it "returns the number of mandatory arguments" do
-        subject.arg_size(:mandatory).should == 2
-      end
-    end
-  end
-  
-  describe "#args_to_string" do
-  
-    context "when a list of options" do
-      it "returns the arguments as a string" do
-        subject.args = "first [second]"
-        subject.args_to_string.should == "<first> [second]"
-      end
-    end
-    
-    context "when a splat as option" do
-      it "returns the argument and ellipsis" do
-        subject.args = "arg..."
-        subject.args_to_string.should == "<arg1> ..."
-      end
-    end
-    
-    context "when a choice of options" do
-      it "returns an empty string" do
-        subject.args = %w(a b c)
-        subject.args_to_string.should == ""
-      end
-    end
-    
-    context "when a range of options" do
-      it "returns an empty string" do
-        subject.args = 1..5
-        subject.args_to_string.should == ""
-      end
-    end
-    
-  end
-  
-  describe "#options_to_string" do
-  
-    context "when a list of options" do
-      it "returns an empty string" do
-        subject.args = "first [second]"
-        subject.options_to_string.should == ""
-      end
-    end
-    
-    context "when a splat as option" do
-      it "returns an empty string" do
-        subject.args = "arg..."
-        subject.options_to_string.should == ""
-      end
-    end
-    
-    context "when a choice of options" do
-      it "returns the choices joined" do
-        subject.args = %w(a b c)
-        subject.options_to_string.should == "(a, b, c)"
-      end
-    end
-    
-    context "when a range of options" do
-      it "returns a string representation of the range" do
-        subject.args = 1..5
-        subject.options_to_string.should == "(1..5)"
-      end
-    end
-    
-  end
-  
-  describe "#to_h" do
-    it "returns a hash" do
-      hsh = {
-        "names" => %w(-S --say),
-        "desc"  => "Say something",
-        "args"  => "<WORD(S)>",
-        "options" => ""
-      }
-      subject.to_h.should == hsh
-    end
-  end
-  
-end

data/spec/clive/formatter_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-describe Clive::Formatter do
-
-  describe Clive::Formatter::Obj do
-    subject { Clive::Formatter::Obj.new({:test => 5}) }
-    
-    describe "#initialize" do
-      it "defines methods given by hash" do
-        subject.test.should == 5
-      end
-    end
-    
-    describe "#evaluate" do
-      it "evaluates code within the object" do
-        $stdout.should_receive(:puts).with(5)
-        subject.evaluate("$stdout.puts test")
-      end
-    end
-  end
-  
-  
-  subject { Clive::Formatter.new(30, 5) }
-  
-  
-  describe "#switch" do
-    it "sets format for switches" do
-      subject.switch("{desc}")
-      subject.instance_variable_get("@switch").should == "{desc}"
-    end
-  end
-  
-  describe "#bool" do
-    it "sets format for bools" do
-      subject.bool "{desc}"
-      subject.instance_variable_get("@bool").should == "{desc}"
-    end
-  end
-  
-  describe "#flag" do
-    it "sets format for flags" do
-      subject.flag "{desc}"
-      subject.instance_variable_get("@flag").should == "{desc}"
-    end
-  end
-  
-  describe "#command" do
-    it "sets format for commands" do
-      subject.command "{desc}"
-      subject.instance_variable_get("@command").should == "{desc}"
-    end
-  end
-  
-  
-  describe "#format" do
-    it "generates the help" do
-      formatter = Clive::Command.setup(Class.new).help_formatter(:white)
-      options = [
-        Clive::Switch.new([:t, :test], "A test switch"),
-        Clive::Bool.new([:boolean], "A bool", true),
-        Clive::Bool.new([:boolean], "A bool", false),
-        Clive::Flag.new([:args], "With args", "ARG [OPT]"),
-        Clive::Flag.new([:choose], "With options", ["a", "b", "c"])
-      ]
-      command = Clive::Command.new([:command], "A command", Class.new)
-      result = <<EOS
-head
-
-  Commands: 
-    command                   A command
-
-  Options: 
-    -t, --test                A test switch
-    --[no-]boolean            A bool
-    --args <ARG> [OPT]        With args \e[1m\e[0m
-    --choose                  With options \e[1m(a, b, c)\e[0m
-
-foot
-EOS
-      
-      formatter.format("head", "foot", [command], options).should == result
-    end
-  end
-  
-  
-  describe "#parse" do
-    it "parses before and after '{spaces}' separately" do
-      args = {"name" => "a", "desc" => "something"}
-      subject.should_receive(:parse_format).with("{name}", args).and_return("")
-      subject.should_receive(:parse_format).with("{desc}", args).and_return("")
-      subject.parse("{name}{spaces}{desc}", args)
-    end
-    
-    it "calculates the correct number of spaces" do
-      args = {"name" => "a long name", "desc" => "|a short desc"}
-      subject.parse("{name}{spaces}{desc}", args).split('|')[0].size.should == 30
-    end
-  end
-  
-  describe "#parse_format" do
-    it "inserts the arguments into the format" do
-      subject.parse_format(
-        "{desc}{name}", {'desc' => 'a', 'name' => 'b'}
-      ).should == "ab"
-    end
-  end
-
-end