caty 0.0.1

data/lib/caty/option_array.rb

@@ -0,0 +1,30 @@
+#
+# Contains the OptionArray class.
+#
+
+require 'delegate'
+require 'ohash'
+
+#
+# Represents an array of options and adds some
+# useful methods.
+#
+class Caty::OptionArray < Array
+
+    include Caty::Helpers
+
+    #
+    # Forwards the ::grep!() to the different Options
+    # and collects the results into an OpenHash.
+    #
+    def grep!( args )
+        returning(OpenHash.new) do |hash|
+            self.each do |option|
+                grab = option.grep!(args)
+                hash[option.name.to_sym] = grab unless grab.nil?
+            end
+        end
+    end
+
+end
+

data/lib/caty/option_constructor.rb

@@ -0,0 +1,89 @@
+#
+# Contains the OptionConstructor class.
+#
+
+#
+# Constructs options using a DSL, e.g:
+#
+#   constructor.construct do
+#        desc('description')
+#        string  :option, 'default'
+#
+#        desc('desc2')
+#        integer :nother_one
+#   end
+#
+# Used by Caty when Caty::global_options() is
+# called.
+#
+class Caty::OptionConstructor
+
+    class << self
+
+        #
+        # Returns an array of all the option types
+        # registered.
+        #
+        def types
+            @types ||= Array.new
+        end
+
+        #
+        # Registers an option type (symbol) with the
+        # constructor.
+        #
+        def register( type )
+            @types ||= Array.new
+            @types <<  type
+        end
+
+    end
+
+    #
+    # Creates a new OptionConstructor that constructs
+    # the given options of the given class.
+    #
+    def initialize( option_klass )
+        @klass     = option_klass
+        @options   = Caty::OptionArray.new
+    end
+
+    #
+    # Constructs the actual options according to the
+    # given block.
+    #
+    def construct( &block )
+        self.instance_eval(&block)
+        @options
+    end
+
+    private
+
+    #
+    # Emulates the type methods, e.g:
+    #
+    #   string :name, 'default'
+    #
+    def method_missing( meth, *args, &block )
+        if self.class.types.include?(meth) and args.length.between?(1,2)
+            name    = args[0]
+            default = args.length == 2 ?
+                args[1] : meth
+            option = @klass.new(name, default)
+            option.description, @description =
+                @description, nil
+            @options << option
+        else
+            super
+        end
+    end
+
+    #
+    # Allows you to describe the constructed options.
+    #
+    def desc( description )
+        @description = description
+    end
+
+end
+

data/lib/caty/task.rb

@@ -0,0 +1,74 @@
+#
+# Contains the Task class.
+#
+
+#
+# Represents a single task.
+#
+# A Task object is created for every public method created
+# in the Caty subclass.
+#
+class Caty::Task
+
+    include Caty::Helpers
+    include Caty::HasDescription
+
+    attr_accessor :name, :usage
+
+    #
+    # Creates a new task with the given name for the
+    # given instance_method.
+    #
+    def initialize( name, instance_method, options )
+        @name, @instance_method, @options =
+            name, instance_method, options
+    end
+
+    #
+    # Tries to remove the options defined for this task
+    # from the args array.
+    #
+    # Returns an OpenHash containing the retrieved
+    # options.
+    #
+    def parse!( args )
+        @args = args
+        @options.grep!(args)
+    end
+
+    #
+    # Executes the associated instance_method by binding it
+    # to the given _context_.
+    #
+    def execute( context )
+        @instance_method.bind(context).call(*@args)
+    end
+
+    #
+    # Resolving end point.
+    # See Caty::Indirection#resolve() for more information.
+    #
+    def resolve( task_hash )
+        self
+    end
+
+    #
+    # Returns a string representation of the task and its
+    # options to be used by the help system.
+    #
+    def to_help
+        [ self.to_s , self.short_description, self.description ]
+    end
+
+    def to_s
+        returning(@name.to_s) do |output|
+            output << " #{@usage}" unless @usage.nil?
+
+            @options.each do |option|
+                output << " #{option}"
+            end
+        end
+    end
+
+end
+

data/lib/caty/task_hash.rb

@@ -0,0 +1,75 @@
+#
+# Contains the TaskHash class.
+#
+
+require 'delegate'
+
+#
+# A hash that preserves the order of task insertion.
+#
+class Caty::TaskHash < DelegateClass(Hash)
+
+    #
+    # Works like Hash#initialize.
+    #
+    def initialize( *args )
+        @ary  = Array.new
+        @hash = Hash.new(*args)
+        super(@hash)
+    end
+
+    #
+    # Works like Hash#[].
+    #
+    def []( num_or_key )
+        case num_or_key
+        when Numeric, Range then @ary[num_or_key]
+        else @hash[num_or_key]
+        end
+    end
+
+    #
+    # Works like Hash#[]=.
+    #
+    def []=( key, value )
+        index = @ary.find { |item| item == @hash[key] }
+
+        if @hash[key].nil? or index.nil?
+            @ary << value
+        else
+            @ary[index] = value
+        end
+
+        @hash[key] = value
+    end
+
+    #
+    # Follows indirections until the task behind
+    # the given task name is discovered.
+    #
+    def resolve( task_name )
+        task = self[task_name]
+
+        if task.nil? then nil
+        else task.resolve(self)
+        end
+    end
+
+    #
+    # Returns a copy of the task hash as an array.
+    # The order of the items in the array is the same as in the
+    # task hash.
+    #
+    def to_a
+        @ary.dup
+    end
+
+    #
+    # Returns a copy of the task hash as a plain hash.
+    #
+    def to_h
+        @hash.dup
+    end
+
+end
+

data/test/kitty.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'caty'
+
+#
+# A Kitty.
+#
+class Kitty < Caty
+
+    global_options do
+
+        #
+        # It's trained not to meow if you tell it to be quiet...
+        #
+        desc('No meowing.')
+        boolean :quiet, false
+
+    end
+
+    #
+    # It needs to eat sometimes.
+    #
+    desc('SOMETHING', cut("
+        Eats SOMETHING.
+        You can give the kitty any -amount of food.
+    "))
+    task_options :amount => 1
+
+    def eat( something )
+        puts "The kitty eats #{task_options.amount} #{something}!"
+    end
+
+    #
+    # By default the kitty just meows at you.
+    #
+    def meow
+        puts 'meow!'
+    end
+
+    default :meow
+
+    #
+    # It likes to meow a lot.
+    #
+    before do |task|
+        puts 'meow!' unless global_options.quiet or task == :help
+    end
+
+    #
+    # And it tells you when it's done.
+    #
+    after do |task|
+        puts 'purrr...' unless task == :help
+    end
+
+    #
+    # If you ask it politely, it will tell you what it can do.
+    #
+    help_task
+
+end
+
+#
+# You could put this in a separate file and require it here
+# instead, thus separating any tasks from the others and
+# reducing interdependencies
+#
+Kitty.append do
+
+    #
+    # It can be sleepy...
+    # And doze away...
+    #
+    desc("Sleeps a bit.")
+    map :doze => :sleep
+
+    def sleep
+        puts 'The kitty sleeps...'
+    end
+
+end
+
+#
+# Pushes the kitty's on/off switch ;-)
+#
+Kitty.start!
+

data/test/test_caty.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'bacon'
+require 'facon'
+require 'caty'
+
+describe 'Caty' do
+
+    DEFAULT_TESTER = mock('default')
+
+    class CatyTest < Caty
+
+        default :beer
+        map 'lager' => :beer
+
+        def beer arg = DEFAULT_TESTER
+            arg.beer
+        end
+
+        def energy_drink
+            party(42) # raises an argument error
+        end
+
+        protected
+
+        def punch arg
+            arg.punch
+        end
+
+        private
+
+        def wine arg
+            arg.wine
+        end
+
+        def party
+        end
+
+    end
+
+    def suppress_output
+        output = $stdout = StringIO.new
+        yield
+        return output.string
+    ensure
+        $stdout = STDOUT
+    end
+
+    it 'should pass arguments' do
+        tester = mock('beer')
+        tester.should.receive(:beer)
+        CatyTest.start!(['beer', tester])
+    end
+
+    it 'should handle mappings' do
+        tester = mock('lager')
+        tester.should.receive(:beer)
+        CatyTest.start!(['lager', tester])
+    end
+
+    it 'should handle default task invocation' do
+        DEFAULT_TESTER.should.receive(:beer)
+        CatyTest.start!([])
+    end
+
+    it 'should not invoke private or protected methods' do
+        suppress_output do
+            tester = mock('punch')
+            tester.should.not.receive(:punch)
+            CatyTest.start!(['punch', tester])
+
+            tester = mock('wine')
+            tester.should.not.receive(:wine)
+            CatyTest.start!(['wine', tester])
+        end.should.not.be.empty
+    end
+
+    it 'should catch task argument errors' do
+        suppress_output do
+            lambda {
+                CatyTest.start!(%w{beer and lemonade})
+            }.should.not.raise ArgumentError
+        end.should.not.be.empty
+    end
+
+    it 'should not catch other argument errors' do
+        suppress_output do
+            lambda {
+                CatyTest.start!(%w{energy_drink})
+            }.should.raise ArgumentError
+        end.should.be.empty
+    end
+
+    it 'should handle unknown tasks' do
+        suppress_output do
+            CatyTest.start!(%w{salad})
+        end.should.not.be.empty
+    end
+
+end
+