Merge pull request #1 from devnote-dev/dev

feat: push v2

Author: devnote-dev

README.md

@@ -1,29 +1,44 @@
 # CLI.cr
-Yet another Crystal command line interface library.
+
+Yet another command line interface library for Crystal. Based on [spf13/cobra](https://github.com/spf13/cobra), CLI.cr is built to be almost entirely modular, giving you absolute control over almost everything without the need for embedded macros - there isn't even a default help command or flag!
 
 ## Installation
+
 1. Add the dependency to your `shard.yml`:
 ```yaml
 dependencies:
   cli:
     github: devnote-dev/cli.cr
+    branch: stable
 ```
 
 2. Run `shards install`
 
 ## Usage
+
 ```crystal
 require "cli"
 
 class MainCmd < CLI::Command
-  def setup
+  def setup : Nil
     @name = "greet"
-    @description = "Greets a person"
+    description = "Greets a person"
     add_argument "name", desc: "the name of person to greet", required: true
-    add_option "caps", short: "c", desc: "greet with capitals"
+    add_option 'c', "caps", desc: "greet with capitals"
+    add_option 'h', "help", desc: "sends help information"
+  end
+
+  def pre_run(args, options)
+    if options.has? "help"
+      puts help_template # generated using CLI::Formatter
+
+      false
+    else
+      true
+    end
   end
 
-  def execute(args, options) : Nil
+  def run(args, options) : Nil
     msg = "Hello, #{args.get("name")}!"
 
     if options.has? "caps"
@@ -34,23 +49,21 @@ class MainCmd < CLI::Command
   end
 end
 
-app = CLI::Application.new
-app.add_command MainCmd, default: true
+main = MainCmd.new
+main.execute ARGV
+```
 
-app.run ARGV
 ```
-```shell
 $ crystal greet.cr -h
-Greets a person
-
 Usage:
         greet <arguments> [options]
 
 Arguments:
-        person    the person to greet
+        name    the name of person to greet (required)
 
 Options:
         -c, --caps  greet with capitals
+        -h, --help  sends help information
 
 $ crystal greet.cr Dev
 Hello, Dev!

shard.yml

@@ -1,6 +1,6 @@
 name: cli
-description: expandable command line interface library
-version: 1.0.0
+description: a modular, non-macro-based command line interface library
+version: 2.0.0
 crystal: 1.5.0
 
 repository: https://github.com/devnote-dev/cli.cr

spec/argument_spec.cr

@@ -0,0 +1,12 @@
+require "./spec_helper"
+
+describe CLI::Argument do
+  it "parses an argument" do
+    arg = CLI::Argument.new "spec", "a test argument"
+
+    arg.name.should eq "spec"
+    arg.description.should eq "a test argument"
+    arg.required?.should be_false
+    arg.value.should be_nil
+  end
+end

spec/cli_spec.cr

@@ -0,0 +1,69 @@
+require "./spec_helper"
+
+# Inspired by Clim
+
+private class ContextCmd < CLI::Command
+  def setup : Nil
+    @name = "context"
+    description = "Runs the Crystal context tool"
+  end
+
+  def run(args, options) : Nil
+    stdout.puts "Fake crystal context command!"
+  end
+end
+
+private class FormatCmd < CLI::Command
+  def setup : Nil
+    @name = "format"
+    description = "Runs the Crystal format tool"
+  end
+
+  def run(args, options) : Nil
+    stdout.puts "Fake crystal format command!"
+  end
+end
+
+private class CrystalCmd < CLI::MainCommand
+  def setup : Nil
+    super
+
+    description = "Runs some Crystal commands"
+  end
+
+  def run(args, options) : Nil
+  end
+end
+
+command = CrystalCmd.new
+command.add_command ContextCmd.new
+command.add_command FormatCmd.new
+
+describe CLI do
+  it "prints the help message" do
+    io = IO::Memory.new
+    command.stdout = io
+    command.execute ""
+
+    io.to_s.should eq "Usage:\n\tmain [options]\n\n" \
+      "Commands:\n\tcontext    \n\tformat     \n\n" \
+      "Options:\n\t-h, --help     sends help information\n" \
+      "\t-v, --version  sends the app version\n\n"
+  end
+
+  it "runs the context command" do
+    io = IO::Memory.new
+    command.children["context"].stdout = io
+    command.execute "context"
+
+    io.to_s.should eq "Fake crystal context command!\n"
+  end
+
+  it "runs the format command" do
+    io = IO::Memory.new
+    command.children["format"].stdout = io
+    command.execute "format"
+
+    io.to_s.should eq "Fake crystal format command!\n"
+  end
+end

spec/helper_spec.cr

@@ -0,0 +1,63 @@
+require "./spec_helper"
+
+private class Greet < CLI::Command
+  getter io : IO::Memory
+
+  def initialize
+    super
+
+    @io = IO::Memory.new
+  end
+
+  def setup : Nil
+    @name = "greet"
+    @description = "Greets a person"
+
+    add_argument "name", desc: "the name of the person", required: true
+    add_option 'c', "caps", desc: "greet with caps"
+  end
+
+  def pre_run(args, options)
+    unless args.has? "name"
+      io.puts CLI::Formatter.new(self).generate
+
+      false
+    end
+  end
+
+  def run(args, options) : Nil
+    msg = %(Hello, #{args.get! "name"}!)
+
+    if options.has? "caps"
+      io.puts msg.upcase
+    else
+      io.puts msg
+    end
+  end
+end
+
+describe CLI do
+  it "tests the help command" do
+    cmd = Greet.new
+    cmd.execute %w()
+
+    cmd.io.to_s.should eq "Greets a person\n\n" \
+      "Usage:\n\tgreet <arguments> [options]\n\n" \
+      "Arguments:\n\tname    the name of the person (required)\n\n" \
+      "Options:\n\t-c, --caps  greet with caps\n\n"
+  end
+
+  it "tests the main command" do
+    cmd = Greet.new
+    cmd.execute %w(Dev)
+
+    cmd.io.to_s.should eq "Hello, Dev!\n"
+  end
+
+  it "tests the main command with flag" do
+    cmd = Greet.new
+    cmd.execute %w(-c Dev)
+
+    cmd.io.to_s.should eq "HELLO, DEV!\n"
+  end
+end

spec/main_spec.cr

@@ -0,0 +1,27 @@
+require "./spec_helper"
+
+describe CLI::Option do
+  it "parses a long option" do
+    opt = CLI::Option.new "spec"
+    opt.long.should eq "spec"
+    opt.short.should be_nil
+
+    opt.is?("spec").should be_true
+  end
+
+  it "parses a short option" do
+    opt = CLI::Option.new "spec", 's'
+    opt.long.should eq "spec"
+    opt.short.should eq 's'
+
+    opt.is?("s").should be_true
+  end
+
+  it "compares options" do
+    opt1 = CLI::Option.new "spec", 's'
+    opt2 = CLI::Option.new "flag", 'f'
+
+    opt1.should_not eq opt2
+    opt1.should eq opt1.dup
+  end
+end

spec/option_spec.cr

@@ -0,0 +1,49 @@
+require "./spec_helper"
+
+describe CLI::Parser do
+  it "parses standard input arguments" do
+    parser = CLI::Parser.new %(these --are "some" -c arguments)
+    results = parser.parse
+
+    results[0].kind.should eq CLI::Parser::ResultKind::Argument
+    results[1].kind.should eq CLI::Parser::ResultKind::LongFlag
+    results[2].kind.should eq CLI::Parser::ResultKind::Argument
+    results[3].kind.should eq CLI::Parser::ResultKind::ShortFlag
+    results[4].kind.should eq CLI::Parser::ResultKind::Argument
+  end
+
+  it "parses custom flag input arguments" do
+    opts = CLI::Parser::Options.new option_delim: '+'
+    parser = CLI::Parser.new %(these ++are "some" +c arguments), opts
+    results = parser.parse
+
+    results[0].kind.should eq CLI::Parser::ResultKind::Argument
+    results[1].kind.should eq CLI::Parser::ResultKind::LongFlag
+    results[2].kind.should eq CLI::Parser::ResultKind::Argument
+    results[3].kind.should eq CLI::Parser::ResultKind::ShortFlag
+    results[4].kind.should eq CLI::Parser::ResultKind::Argument
+  end
+
+  it "parses a string argument" do
+    parser = CLI::Parser.new %w(--test "string argument" -t)
+    results = parser.parse
+
+    results[0].kind.should eq CLI::Parser::ResultKind::LongFlag
+    results[1].kind.should eq CLI::Parser::ResultKind::Argument
+    results[1].value.should eq "string argument"
+    results[2].kind.should eq CLI::Parser::ResultKind::ShortFlag
+  end
+
+  it "parses an option argument" do
+    parser = CLI::Parser.new %(--name=foo -k=bar)
+    results = parser.parse
+
+    results[0].kind.should eq CLI::Parser::ResultKind::LongFlag
+    results[0].value.should eq "name=foo"
+    results[0].parse_value.should eq "name"
+
+    results[1].kind.should eq CLI::Parser::ResultKind::ShortFlag
+    results[1].value.should eq "k=bar"
+    results[1].parse_value.should eq "k"
+  end
+end

spec/parser_spec.cr

@@ -0,0 +1,33 @@
+require "./spec_helper"
+
+describe CLI::Value do
+  it "parses a value" do
+    CLI::Value.new("foo").should be_a CLI::Value
+    CLI::Value.new(123_i64).should be_a CLI::Value
+    CLI::Value.new(4.56).should be_a CLI::Value
+    CLI::Value.new(true).should be_a CLI::Value
+    CLI::Value.new(nil).should be_a CLI::Value
+
+    # currently broken
+    # CLI::Value.new(%w[foo bar baz]).should be_a CLI::Value
+  end
+
+  it "compares values" do
+    CLI::Value.new("foo").should eq "foo"
+    CLI::Value.new(123).should eq 123
+    CLI::Value.new(4.56).should eq 4.56
+    CLI::Value.new(true).should eq true
+    CLI::Value.new(nil).should eq nil
+
+    # also broken
+    # CLI::Value.new(%[foo bar baz]).should eq ["foo", "bar", "baz"]
+  end
+
+  it "asserts types" do
+    CLI::Value.new("foo").as_s.should be_a String
+    CLI::Value.new(123).as_i32.should be_a Int32
+    CLI::Value.new(4.56).as_f64.should be_a Float64
+    CLI::Value.new(true).as_bool.should be_true
+    CLI::Value.new(nil).as_nil.should be_nil
+  end
+end