shellissimo 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b74cb3f6faba944fab76670f0d5c9769c8b44387
+  data.tar.gz: 920d6f8e50bb5bd2b5cc1a65fc7bf45ddf195401
+SHA512:
+  metadata.gz: 3a40da683fcc53aa0fb493bad3ba0354cbb377bba037c127e5a9acf5fb7b897120921b5fd963bea814a69f514b6435075509361d3ae9acb6984fc8976c51440d
+  data.tar.gz: 2471579d9177cd250f21b9882c85ba0eb0fc24a1235b955d1654cab0937de6e14ae6ae472654f8f8e22f2d663b04b07f0fa871751acc1641e2e4b7ae196df903

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+branches:
+  only:
+    - master

data/README.md

@@ -1,8 +1,15 @@
-# Shellissimo
+Shellissimo
+===========
+
+[![Build Status](https://secure.travis-ci.org/v-yarotsky/shellissimo.png)](http://travis-ci.org/v-yarotsky/shellissimo)
+[![Coverage Status](https://coveralls.io/repos/v-yarotsky/shellissimo/badge.png?branch=master)](https://coveralls.io/r/v-yarotsky/shellissimo)
+[![Code Climate](https://codeclimate.com/github/v-yarotsky/shellissimo.png)](https://codeclimate.com/github/v-yarotsky/shellissimo)
+[![Gem Version](https://badge.fury.io/rb/shellissimo.png)](http://badge.fury.io/rb/shellissimo)
 
 Minimalistic framework for constructing shell-like applications.
 
-## Installation
+Installation
+---------------
 
 Add this line to your application's Gemfile:
 
@@ -16,11 +23,51 @@ Or install it yourself as:
 
     $ gem install shellissimo
 
-## Usage
+Usage
+-----
+
+Create your shell by sublcassing ``Shellissimo::Shell``
+
+```ruby
+require 'shellissimo'
+
+class Greeter; def say_hi(name, title); p "hi #{title} #{name}"; end; end
+
+class MyShell < Shellissimo::Shell
+  command :hi do |c|
+    c.description "Says hello to the user"
+    c.mandatory_param(:user) do |p|
+      p.description "User name"
+      p.validate { |v| !v.to_s.strip.empty? }
+    end
+    c.param(:title) do |p|
+      p.validate { |v| %w(Mr. Ms.).include?(v.to_s) }
+    end
+    c.run { |params| @greeter.say_hi(params[:user], params[:title]) }
+  end
+
+  def initialize
+    @greeter = Greeter.new
+    super
+  end
+end
+
+MyShell.new.run
+```
+
+In this example help message would look like:
+
+    Available commands:
+
+    hi                               - Says hello to the user
+      user                           - User name - mandatory
+      title                          - optional
 
-TODO: Write usage instructions here
+    help (aliases: h)                - Show available commands
+    quit (aliases: exit)             - Quit irb
 
-## Contributing
+Contributing
+------------
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/lib/shellissimo.rb

@@ -1,5 +1,4 @@
 require "shellissimo/version"
-require "shellissimo/dsl"
 require "shellissimo/shell"
 
 module Shellissimo

data/lib/shellissimo/command.rb

@@ -3,10 +3,11 @@ require 'shellissimo/command_name'
 module Shellissimo
 
   class Command
-    attr_reader :name, :aliases, :description, :params, :block
+    attr_reader :name, :aliases, :description, :param_definitions, :block
 
-    def initialize(name, description = "", aliases = [],  params = [], &block)
-      @name, @description, @params = CommandName.new(name, aliases), String(description), params
+    def initialize(name, description = "", aliases = [],  param_definitions = [], &block)
+      @name, @description = CommandName.new(name, aliases), String(description)
+      @param_definitions = Array(param_definitions)
       self.block = block
     end
 
@@ -15,6 +16,7 @@ module Shellissimo
     end
 
     def prepend_params(params)
+      params = filter_params(params)
       old_block = block # let's fool ruby
       dup.tap { |c| c.block = proc { instance_exec(params, &old_block) } }
     end
@@ -27,6 +29,17 @@ module Shellissimo
     def to_proc
       block
     end
+
+    private
+
+    def filter_params(params)
+      filtered = {}
+      @param_definitions.each do |p|
+        raise ArgumentError, "param '#{p.name}' is not valid!" unless p.valid?(params[p.name])
+        filtered[p.name] = params[p.name]
+      end
+      filtered.merge(params)
+    end
   end
 
 end

data/lib/shellissimo/command_name.rb

@@ -6,8 +6,8 @@ module Shellissimo
     attr_reader :name, :aliases
 
     def initialize(name, aliases = [])
-      @name, @aliases = String(name), Array(aliases).map(&:to_s)
-      raise ArgumentError, "command name can't be blank" if @name.empty?
+      raise ArgumentError, "command name can't be blank" if String(name).empty?
+      @name, @aliases = name.to_sym, Array(aliases).map(&:to_sym)
     end
 
     def hash
@@ -19,13 +19,16 @@ module Shellissimo
       when CommandName
         return true if other.equal? self
         return true if name == other.name && aliases == other.aliases
+        false
       when String, Symbol
-        return true if other.to_s == @name
-        return true if @aliases.include?(other.to_s)
+        return true if other.to_sym == @name
+        return true if @aliases.include?(other.to_sym)
+        false
       else
         false
       end
     end
+    alias :eql? :==
 
     def <=>(other)
       self == other or name <=> other.name
@@ -36,10 +39,6 @@ module Shellissimo
       result += " (aliases: #{aliases.join(", ")})" unless aliases.empty?
       result
     end
-
-    def inspect
-      "<CommandName:#{self.object_id} name: #{@name.inspect}, aliases: #{@aliases.inspect}"
-    end
   end
 
 end

data/lib/shellissimo/command_param.rb

@@ -0,0 +1,23 @@
+require 'shellissimo/command_param_validator'
+
+module Shellissimo
+
+  class CommandParam
+    attr_reader :description, :validator
+
+    def initialize(name, validator = nil, description = "")
+      @name, @description = String(name), String(description)
+      raise ArgumentError, "command param name can't be blank" if @name.empty?
+      @validator = validator || CommandParamValidator.noop
+    end
+
+    def name
+      @name.to_sym
+    end
+
+    def valid?(value)
+      !!@validator[value]
+    end
+  end
+
+end

data/lib/shellissimo/command_param_validator.rb

@@ -0,0 +1,42 @@
+module Shellissimo
+
+  class CommandParamValidator
+    attr_reader :description, :block
+
+    class << self
+      def noop
+        new { |v| true }
+      end
+
+      def optional
+        new("optional") { |v| v.nil? }
+      end
+
+      def mandatory
+        new("mandatory") { |v| !v.nil? }
+      end
+    end
+
+    def initialize(description = "", &block)
+      @description = description
+      @block = block or
+        raise ArgumentError, "command param validator block can't be blank"
+    end
+
+    def call(value)
+      @block.call(value)
+    end
+    alias :[] :call
+
+    def &(other)
+      CommandParamValidator.new(description) { |value| block[value] && other.block[value] }
+    end
+
+    def |(other)
+      CommandParamValidator.new(description) { |value| block[value] || other.block[value] }
+    end
+  end
+
+end
+
+

data/lib/shellissimo/commands_collection.rb

@@ -0,0 +1,36 @@
+require 'forwardable'
+
+module Shellissimo
+
+  class CommandsCollection
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@commands, :size
+
+    def initialize
+      @commands = []
+    end
+
+    def find_by_name_or_alias(name_or_alias)
+      @commands.detect { |c| c.name == name_or_alias } or
+        raise CommandNotFoundError, "Command #{name_or_alias} not found"
+    end
+    alias :[] :find_by_name_or_alias
+
+    def each(&block)
+      @commands.each(&block)
+    end
+
+    def <<(command)
+      @commands << command
+      self
+    end
+
+    def push(*commands)
+      @commands.push(*commands)
+      self
+    end
+  end
+
+end

data/lib/shellissimo/dsl.rb

@@ -1,4 +1,5 @@
 require 'shellissimo/dsl/command_builder'
+require 'shellissimo/commands_collection'
 
 module Shellissimo
   class CommandNotFoundError < StandardError; end
@@ -20,23 +21,22 @@ module Shellissimo
       def command(name)
         builder = CommandBuilder.new(name)
         yield builder
-        commands << builder.result
+        add_command(builder.result)
       end
-
     end
 
     module ClassMethods
       #
-      # @return [Array] a list of defined commands
+      # @return [CommandsCollection] a list of defined commands
       #
       def commands
-        @commands ||= begin
-          c = Array.new
-          def c.find_by_name_or_alias(name_or_alias)
-            detect { |c| c.name == name_or_alias } or
-              raise CommandNotFoundError, "Command #{command_name} not found"
-          end
-          c
+        CommandsCollection.new
+      end
+
+      def add_command(command)
+        new_commands = (commands << command)
+        define_singleton_method :commands do
+          new_commands
         end
       end
     end

data/lib/shellissimo/dsl/command_builder.rb

@@ -1,11 +1,14 @@
 require 'shellissimo/command'
+require 'shellissimo/dsl/command_param_builder'
 
 module Shellissimo
   module DSL
 
     class CommandBuilder
-      def initialize(name)
+      def initialize(name, param_builder_class = CommandParamBuilder)
         @name = name
+        @param_definitions = []
+        @param_builder_class = param_builder_class
       end
 
       def description(desc)
@@ -24,8 +27,42 @@ module Shellissimo
         @block = block
       end
 
+      #
+      # Defines a single command param (optional)
+      # @see CommandParamBuilder
+      # @param name [String] name for command param
+      # @yieldparam [CommandParamBuilder]
+      # @return [CommandParam]
+      #
+      def param(name)
+        build_param(name) do |p|
+          p.optional!
+          yield p if block_given?
+        end
+      end
+
+      #
+      # Defines mandatory command param
+      # @see #param
+      #
+      def mandatory_param(name)
+        build_param(name) do |p|
+          p.mandatory!
+          yield p if block_given?
+        end
+      end
+
       def result
-        Command.new(String(@name), @description, @aliases, &@block)
+        Command.new(String(@name), @description, @aliases, @param_definitions, &@block)
+      end
+
+      private
+
+      def build_param(name)
+        builder = @param_builder_class.new(name)
+        yield builder if block_given?
+        @param_definitions << builder.result
+        builder.result
       end
     end
 

data/lib/shellissimo/dsl/command_param_builder.rb

@@ -0,0 +1,55 @@
+require 'shellissimo/command_param'
+require 'shellissimo/command_param_validator'
+
+module Shellissimo
+  module DSL
+
+    class CommandParamBuilder
+      attr_reader :name, :description
+
+      def initialize(name)
+        @name = name
+        @validator = CommandParamValidator.noop
+        @kind = :optional
+      end
+
+      def description(desc)
+        @description = desc
+      end
+
+      def validate(description = "", &block)
+        @validator = @validator & CommandParamValidator.new(description, &block)
+      end
+
+      #
+      # @private
+      #
+      def mandatory!
+        @kind = :mandatory
+      end
+
+      #
+      # @private
+      #
+      def optional!
+        @kind = :optional
+      end
+
+      def result
+        CommandParam.new(@name, validator, @description)
+      end
+
+      private
+
+      def validator
+        case @kind
+        when :optional
+          CommandParamValidator.optional | @validator
+        when :mandatory
+          CommandParamValidator.mandatory & @validator
+        end
+      end
+    end
+
+  end
+end

data/lib/shellissimo/help.rb

@@ -0,0 +1,52 @@
+module Shellissimo
+
+  #
+  # Generates help secion based on commands defined for a shell
+  #
+  class Help
+    def initialize(commands)
+      @commands = commands
+      @rendered = ""
+      render
+    end
+
+    def rendered
+      @rendered.dup.chomp
+    end
+
+    private
+
+    def render
+      line "Available commands:"
+      line
+      @commands.partition { |c| !builtin_commands.include? c }.each do |cs|
+        cs.sort_by(&:name).each(&method(:render_command))
+        line
+      end
+    end
+
+    def line(str = "")
+      @rendered += "#{str}\n"
+    end
+
+    def builtin_commands
+      %w(help quit).map { |n| @commands[n] }
+    end
+
+    def render_command(cmd)
+      render_name_and_description(cmd.name, "%-40s", cmd.description)
+      cmd.param_definitions.each { |p| render_param(p) }
+    end
+
+    def render_param(param)
+      render_name_and_description(param.name, "  %-30s", param.description, param.validator.description)
+    end
+
+    def render_name_and_description(name, name_format, *details)
+      formatted_name = name_format % [name]
+      details.map! { |d| " - %s" % [d] unless d.empty? }
+      line String(formatted_name) + details.join
+    end
+  end
+
+end

data/lib/shellissimo/input_parser.rb

@@ -6,7 +6,7 @@ module Shellissimo
     COMMAND_PATTERN = /(\w+)(?:\s*(.*))/
 
     #
-    # @param commands [#find_by_name_or_alias] a list of commands
+    # @param commands [CommandsCollection] a list of commands
     #
     def initialize(commands)
       @commands = commands
@@ -18,7 +18,7 @@ module Shellissimo
     #
     def parse_command(line)
       command_name, command_params = line.match(COMMAND_PATTERN)[1..2]
-      command = @commands.find_by_name_or_alias(command_name)
+      command = @commands[command_name]
       command.prepend_params(parse_params(command_params))
     end
 

data/lib/shellissimo/shell.rb

@@ -2,6 +2,7 @@ require 'readline'
 require 'shellissimo/error_handling'
 require 'shellissimo/dsl'
 require 'shellissimo/input_parser'
+require 'shellissimo/help'
 
 module Shellissimo
 
@@ -39,18 +40,11 @@ module Shellissimo
     command :help do |c|
       c.shortcut :h
       c.description "Show available commands"
-      c.run do |*|
-        result = "Available commands:\n\n"
-        print_command = proc { |cmd| result += "%-40s - %s\n" % [cmd.name, cmd.description] }
-        commands.partition { |c| !%w(help quit).include? c.name.name }.each do |some_commands|
-          some_commands.sort_by(&:name).each(&print_command)
-          result += "\n"
-        end
-        result.chomp
-      end
+      c.run { |*| Help.new(self.class.commands).rendered }
     end
 
     command :quit do |c|
+      c.shortcut :exit
       c.description "Quit #$0"
       c.run { |*| exit 0 }
     end

data/lib/shellissimo/version.rb

@@ -1,3 +1,3 @@
 module Shellissimo
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/shellissimo.gemspec

@@ -18,7 +18,10 @@ Gem::Specification.new do |gem|
 
   gem.has_rdoc = "yard"
 
-  gem.add_dependency("yard")
-  gem.add_dependency("redcarpet")
+  gem.add_dependency("json")
+
+  gem.add_development_dependency("yard")
+  gem.add_development_dependency("redcarpet")
   gem.add_development_dependency("minitest")
+  gem.add_development_dependency("minitest-reporters")
 end

data/test/lib/shellissimo/dsl/test_command_builder.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'shellissimo/dsl/command_builder'
+
+include Shellissimo::DSL
+
+class TestCommandBuilder < ShellissimoTestCase
+  class FakeParamBuilder
+    attr_reader :mandatory, :optional
+    def initialize(*); @mandatory = false; end
+    def mandatory!;    @mandatory = true;  end
+    def optional!;     @optional = true;   end
+    def result;                            end
+  end
+
+  test "sets command name" do
+    assert_equal builder("foo").result.name, "foo"
+  end
+
+  test "#description sets command description" do
+    assert_equal "bar", builder("foo") { |c| c.description "bar" }.result.description
+  end
+
+  test "#shortcut sets command aliases" do
+    assert_equal builder("foo") { |c| c.shortcut :f }.result.name, "f"
+  end
+
+  test "#run sets command block" do
+    assert_equal :hi, builder("foo") { |c| c.run { :hi } }.result.call
+  end
+
+  test "#param creates a param" do
+    assert_includes builder("foo") { |c| c.param("bar") }.result.param_definitions.map(&:name), :bar
+  end
+
+  test "#param yields CommandParamBuilder" do
+    param_builder = nil
+    builder("foo") { |c| c.param("bar") { |p| param_builder = p } }
+    assert_instance_of CommandParamBuilder, param_builder
+  end
+
+  test "#param returns CommandParam" do
+    param = nil
+    builder("foo") { |c| param = c.param("bar") }
+    assert_instance_of Shellissimo::CommandParam, param
+  end
+
+  test "#param yields builder for optional param" do
+    param_builder = nil
+    builder("foo", FakeParamBuilder) { |c| c.param("bar") { |p| param_builder = p } }
+    assert param_builder.optional, "expected param to be built as optional"
+  end
+
+  test "#mandatory_param yields builder with presence validator" do
+    param_builder = nil
+    builder("foo", FakeParamBuilder) { |c| c.mandatory_param("bar") { |p| param_builder = p } }
+    assert param_builder.mandatory, "expected param to be built as mandatory"
+  end
+
+  private
+
+  def builder(name, *args)
+    c = CommandBuilder.new(name, *args)
+    c.run {}
+    yield c if block_given?
+    c
+  end
+end
+
+

data/test/lib/shellissimo/dsl/test_command_param_builder.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+require 'shellissimo/dsl/command_param_builder'
+
+include Shellissimo::DSL
+
+class TestCommandParamBuilder < ShellissimoTestCase
+  test "sets command param name" do
+    assert_equal builder("foo").result.name, :foo
+  end
+
+  test "#description sets command param description" do
+    assert_equal "bar", builder("foo") { |c| c.description "bar" }.result.description
+  end
+
+  test "#mandatory! sets stock validator to mandatory" do
+    refute builder("foo") { |c| c.mandatory! }.result.valid?(nil), "expected param to be mandatory"
+  end
+
+  test "#validate sets validator" do
+    called = false
+    param = builder("foo") { |c| c.validate { |v| called = true } }.result
+    param.valid?(:anything)
+    assert called, "expected validation block to be set"
+  end
+
+  test "#validate respects mandatory/optional" do
+    param = builder("foo") { |c| c.optional!; c.validate { |v| v == 1 } }.result
+    assert param.valid?(nil), "expected param to be optional"
+    refute param.valid?(2), "expected param to be checked by custom validator"
+  end
+
+  private
+
+  def builder(name)
+    c = CommandParamBuilder.new(name)
+    yield c if block_given?
+    c
+  end
+end
+
+

data/test/lib/shellissimo/test_command.rb

@@ -1,5 +1,6 @@
 require 'test_helper'
 require 'shellissimo/command'
+require 'ostruct'
 
 include Shellissimo
 
@@ -21,10 +22,33 @@ class TestCommand < ShellissimoTestCase
     assert called, "expected command block to be called"
   end
 
+  test "#prepend_params return command copy with curried block" do
+    received_params = {}
+    c = command("foo") { |params| received_params = params }
+    c = c.prepend_params(:foo => 1, :bar => 2)
+    c.call
+    assert_equal ({ :foo => 1, :bar => 2 }), received_params
+  end
+
+  test "#prepend_params runs validations over params" do
+    param_definition = sample_param_definition
+    def param_definition.valid?(*); false; end
+    c = command("foo", "", [], [param_definition]) { |params| received_params = params }
+    assert_raises ArgumentError do
+      c.prepend_params(:removed => 1, :bar => 2)
+    end
+  end
+
   private
 
   def command(*args, &block)
     Command.new(*args, &block)
   end
+
+  def sample_param_definition
+    param_definition = OpenStruct.new(:name => :bar)
+    def param_definition.valid?(*); true; end
+    param_definition
+  end
 end
 

data/test/lib/shellissimo/test_command_name.rb

@@ -10,37 +10,45 @@ class TestCommandName < ShellissimoTestCase
     end
   end
 
-  test "CommandName instance is equal to itself" do
+  test "is equal to itself" do
     n = command_name("foo")
     assert_equal n, n
   end
 
-  test "CommandName instances are equal if both name and aliases are equal" do
+  test "instances are equal if name and aliases are equal" do
     assert_equal command_name("foo"), command_name("foo")
     assert_equal command_name("foo", ["baz"]), command_name("foo", ["baz"])
   end
 
-  test "CommandName instances are not equal if names aren't equal" do
+  test "instances are not equal if names aren't equal" do
     refute_equal command_name("foo"), command_name("bar")
   end
 
-  test "CommandName instances are not equal if aliases aren't equal" do
+  test "instances are not equal if aliases aren't equal" do
     refute_equal command_name("foo", ["baz"]), command_name("foo", ["qux"])
   end
 
-  test "CommandName instance is equal to a string if the string is a command's name" do
+  test "is equal to a string if the string is a command's name" do
     assert_equal command_name("foo"), "foo"
   end
 
-  test "CommandName instance is equal to a string if the string is one of command's aliases" do
+  test "is equal to a string if it is one of command's aliases" do
     assert_equal command_name("foo", ["bar", "baz"]), "bar"
     assert_equal command_name("foo", ["bar", "baz"]), "baz"
   end
 
-  test "CommandName instance is not equal to a string if the string is neither command's name nor one of command's aliases" do
+  test "is not equal to a string that is neither name nor an alias" do
     refute_equal command_name("foo", ["bar", "baz"]), "qux"
   end
 
+  test "is not equal to crap" do
+    refute_equal command_name("foo"), 1
+  end
+
+  test "hashes of equal instances are equal" do
+    assert_equal command_name("foo").hash, command_name("foo").hash
+  end
+
   test "is sorted by name" do
     assert command_name("foo") > command_name("bar"), "expected 'foo' to be greater than 'bar'"
     assert command_name("bar") < command_name("baz"), "expected 'bar' to be less than 'baz'"

data/test/lib/shellissimo/test_command_param.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+require 'shellissimo/command_param'
+
+include Shellissimo
+
+class TestCommandParam < ShellissimoTestCase
+  test "can't be created without name" do
+    assert_raises ArgumentError, "command param name can't be blank" do
+      param(nil)
+    end
+  end
+
+  test "can have a description" do
+    assert_equal "foo desc", param("foo", :noop, "foo desc").description
+  end
+
+  test "is always valid by default" do
+    assert param("foo").valid?(:literally_anything), "expected param to be valid by default"
+  end
+
+  test "param name is a symbol" do
+    assert_equal :foo, param("foo").name
+  end
+
+  private
+
+  def param(*args)
+    CommandParam.new(*args)
+  end
+end
+

data/test/lib/shellissimo/test_command_param_validator.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'shellissimo/command_param_validator'
+
+include Shellissimo
+
+class TestCommandParamValidator < ShellissimoTestCase
+  test "can have a description" do
+    assert_equal "foo desc", (validator("foo desc") {}).description
+  end
+
+  test "noop is always valid" do
+    assert noop_validator[:literally_anything], "expected param to be valid by default"
+  end
+
+  test "mandatory is not valid if nil" do
+    refute mandatory_validator[nil], "expected mandatory param not to be valid by if nil"
+  end
+
+  test "mandatory is valid if non-nil" do
+    assert mandatory_validator[1], "expected mandatory param to be valid by if non-nil"
+  end
+
+  test "allows combining validator with logical &" do
+    v = mandatory_validator & validator("custom") { |v| v.nil? || v == 1 }
+    refute v[nil], "expected mandatory validator to work"
+    refute v[2], "expected custom validator to work"
+    assert v[1], "expected both validators to work"
+  end
+
+  test "allows combining validator with logical |" do
+    v = validator("v1") { |v| v == 1 } | validator("v2") { |v| v == 2 }
+    assert v[1], "expected first custom validator to work"
+    assert v[2], "expected second custom validator to work"
+    refute v[0], "expected not to do whats not expected :)"
+  end
+
+  private
+
+  def validator(description, &block)
+    CommandParamValidator.new(description, &block)
+  end
+
+  [:noop, :optioal, :mandatory].each do |kind|
+    define_method "#{kind}_validator" do
+      CommandParamValidator.public_send(kind)
+    end
+  end
+end
+

data/test/lib/shellissimo/test_commands_collection.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'shellissimo/commands_collection'
+require 'ostruct'
+
+include Shellissimo
+
+class TestCommandsCollection < ShellissimoTestCase
+  test "#find_by_name_or_alias returns command by name" do
+    assert_equal command("foo"), collection(command("foo")).find_by_name_or_alias("foo")
+  end
+
+  test "#[] returns command by name" do
+    assert_equal command("foo"), collection(command("foo"))["foo"]
+  end
+
+  test "is enumerable" do
+    c = collection(command("foo"), command("bar"))
+    assert_kind_of Enumerable, c
+    assert_equal [command("bar")], c.select { |c| c.name == "bar" }
+  end
+
+  private
+
+  def collection(*commands)
+    result = CommandsCollection.new
+    result.push *commands
+  end
+
+  def command(name)
+    OpenStruct.new(:name => name)
+  end
+end
+

data/test/lib/shellissimo/test_dsl.rb

@@ -5,34 +5,25 @@ include Shellissimo
 
 class TestDsl < ShellissimoTestCase
   test ".command creates a command" do
-    assert fake_with_command_foo.commands.find_by_name_or_alias("foo"), "expected command 'foo' to be defined"
-  end
-
-  test "#run inside .command sets command block" do
-    assert_equal :hello, fake_with_command_foo.commands.find_by_name_or_alias("foo").call
-  end
-
-  test "#shortcut inside .command sets command aliases" do
-    assert fake_with_command_foo.commands.find_by_name_or_alias("f"), "expected command 'foo' to be found by alias 'f'"
-  end
-
-  test "#description inside .command sets command description" do
-    assert_equal "foo description", fake_with_command_foo.commands.find_by_name_or_alias("foo").description
-  end
-
-  private
-
-  def fake_with_command_foo
-    fake do
+    f = dsl do
       command :foo do |c|
-        c.shortcut :f
-        c.description "foo description"
         c.run { :hello }
       end
     end
+    assert f.commands["foo"], "expected command 'foo' to be defined"
   end
 
-  def fake(*args, &block)
+  test ".command yields a builder" do
+    builder = nil
+    dsl do
+      command(:foo) { |c| c.run {}; builder = c }
+    end
+    assert_instance_of DSL::CommandBuilder, builder
+  end
+
+  private
+
+  def dsl(*args, &block)
     Class.new do
       include DSL
       instance_eval(&block)

data/test/lib/shellissimo/test_input_parser.rb

@@ -1,6 +1,7 @@
 require 'test_helper'
 require 'shellissimo/input_parser'
 require 'shellissimo/command'
+require 'shellissimo/command_param'
 
 include Shellissimo
 
@@ -24,9 +25,7 @@ class TestInputParser < ShellissimoTestCase
   private
 
   def commands
-    cmds = [Command.new("foo") { |*args| args }]
-    def cmds.find_by_name_or_alias(name); first; end
-    cmds
+    { "foo" => Command.new("foo") { |*args| args } }
   end
 
   def parser

data/test/test_helper.rb

@@ -1,17 +1,23 @@
 require 'rubygems'
+require 'bundler/setup'
 
-if ENV["COVERAGE"]
+lib = File.expand_path('../../lib', __FILE__)
+$:.unshift lib
+
+if ENV["TRAVIS"]
   require 'simplecov'
-  SimpleCov.start
-elsif ENV["TRAVIS"]
   require 'coveralls'
-  Coveralls.wear!
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+  Dir.glob(File.join(lib, "**", "*.rb")).each { |f| require f }
 end
 
 require 'minitest/unit'
-require 'minitest/pride'
+require 'minitest/reporters'
 
-$:.unshift File.expand_path('../../lib', __FILE__)
+MiniTest::Reporters.use! MiniTest::Reporters::SpecReporter.new
 
 class ShellissimoTestCase < MiniTest::Unit::TestCase
   def self.test(name, &block)

metadata

@@ -1,64 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: shellissimo
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Vladimir Yarotsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-08 00:00:00.000000000 Z
+date: 2013-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  prerelease: false
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  type: :development
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - vladimir.yarotsky@gmail.com
@@ -67,6 +88,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -74,51 +96,59 @@ files:
 - lib/shellissimo.rb
 - lib/shellissimo/command.rb
 - lib/shellissimo/command_name.rb
+- lib/shellissimo/command_param.rb
+- lib/shellissimo/command_param_validator.rb
+- lib/shellissimo/commands_collection.rb
 - lib/shellissimo/dsl.rb
 - lib/shellissimo/dsl/command_builder.rb
+- lib/shellissimo/dsl/command_param_builder.rb
 - lib/shellissimo/error_handling.rb
+- lib/shellissimo/help.rb
 - lib/shellissimo/input_parser.rb
 - lib/shellissimo/shell.rb
 - lib/shellissimo/version.rb
 - shellissimo.gemspec
+- test/lib/shellissimo/dsl/test_command_builder.rb
+- test/lib/shellissimo/dsl/test_command_param_builder.rb
 - test/lib/shellissimo/test_command.rb
 - test/lib/shellissimo/test_command_name.rb
+- test/lib/shellissimo/test_command_param.rb
+- test/lib/shellissimo/test_command_param_validator.rb
+- test/lib/shellissimo/test_commands_collection.rb
 - test/lib/shellissimo/test_dsl.rb
 - test/lib/shellissimo/test_input_parser.rb
 - test/test_helper.rb
 homepage: https://github.com/v-yarotsky/shellissimo
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 1124256564094815538
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 1124256564094815538
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Minimalistic framework for constructing shell-like applications
 test_files:
+- test/lib/shellissimo/dsl/test_command_builder.rb
+- test/lib/shellissimo/dsl/test_command_param_builder.rb
 - test/lib/shellissimo/test_command.rb
 - test/lib/shellissimo/test_command_name.rb
+- test/lib/shellissimo/test_command_param.rb
+- test/lib/shellissimo/test_command_param_validator.rb
+- test/lib/shellissimo/test_commands_collection.rb
 - test/lib/shellissimo/test_dsl.rb
 - test/lib/shellissimo/test_input_parser.rb
 - test/test_helper.rb