caml 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8112aee1b07f561a5a61568f3d53d7c4bf002de6eb011be5e835490c404cb0f
-  data.tar.gz: a72ec8bf5815f84abb80b585c6ab0d1d84802b23e91672a47844c16cf2894f46
+  metadata.gz: b6c99302250394b3a09b78b2391b5ede1d3b6fa8304ab2d6dbf3733ad8f67726
+  data.tar.gz: 8c8c7532d97bfa544fa857238f94f3e6b104e71974714a367ddb3b418bcaefb2
 SHA512:
-  metadata.gz: 113daadc8195e7ea3667d3ac463455e3e9c2f18ff022f3ee030ce68672c14e4ce022b91e16f479b12a6060c2aa626ab8bf16596af29d8e2cd018a0c4fc4ef9c1
-  data.tar.gz: d9d5127a760273c578b486b4754e97d24b278e215f9d9edc3a1ac730ec24fc5a9ae6add0525e183c821ed0c65528d955c136360f58ae51668f2fe49025587a92
+  metadata.gz: 549fe339f84b6c62de4786fbbab80abdcc06145b8b8aadcfe6ff3e6cc43dba18136622f6af6abf76978ec187de7f7d88418d845e49c3c9820fb0b12ec3aa1b5c
+  data.tar.gz: c404fe5c3d691c00bf6ba641696df230adac242da11403986c0ae1d4a72a70e90e85a20fb49ee12e80d3a85019e5ac251beaaafdffe8761b005fc9af12225a1a

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes follow [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Semantic Versioning](https://semver.org/).
+
+## [1.0.0] — 2026-05-01
+
+First stable release.
+
+### Added
+- Positional arguments with `{{name}}` interpolation, shell-escaped via `Shellwords`
+- Typed options (string / boolean / numeric) with aliases, defaults, and per-option `execute` overrides
+- Task-level command aliases via Thor's `map`
+- Multi-line `execute:` arrays joined with `&&` for fail-fast semantics
+- Task dependencies via `needs:`, resolved with cycle detection and dedup
+- Pure orchestrator tasks (only `needs:`, no `execute:`)
+- `caml init` scaffolds a starter `caml.yaml`
+- `caml --version` prints the installed version
+- Walks up from the current directory to find `caml.yaml`
+- Friendly errors for missing or malformed YAML
+
+### Changed
+- Replaced the `class_eval`-of-source-strings command generator with a typed pipeline (Config → Task → Runner → Plan → Thor adapter)
+- Single canonical "no such task" error: `Caml::Plan::UnknownTask`
+- Minimum Ruby is now 3.0
+- Runtime deps declared in the gemspec; dev deps in the Gemfile
+
+### Security
+- YAML loads via `safe_yaml` with `raise_on_unknown_tag: true`; `!ruby/object` tags are stripped, never instantiated
+- Argument interpolation always shell-escapes substituted values; the only place caml shells out is `Caml::Shell#run`
+
+## [0.1.1]
+
+Initial scaffolding (pre-1.0; experimental).

data/README.md

@@ -1,70 +1,175 @@
-# 🐪 caml
+# caml
 
-> Build CLI apps with YAML
+> Build CLI apps from a declarative `caml.yaml` file.
 
-`caml` allows you to build command line applications using declarative yaml.
-`caml` aims to be like `make`, but by using descriptive, declarative yaml.
+`caml` turns well-documented YAML tasks into a runnable CLI. Inspired by `make` and `just`, but YAML-driven.
 
-## Usage
-
-Running the command without any arguments displays the commands defined in the `caml.yaml` file:
+## Install
 
 ```sh
-bin/caml
+gem install caml
+```
+
+Or in a `Gemfile`:
+
+```ruby
+gem 'caml'
 ```
 
-## Declaring commands
+## Quickstart
+
+```sh
+caml init                # scaffold a starter caml.yaml
+caml                     # list tasks
+caml hello               # run the starter task
+```
 
-`caml` reads a file called `caml.yaml` in the current directory and converts those commands into a unified CLI command.
+## Tasks
 
-The basic structure is to have a `command`, which has a `desc` and an `execute` for the bash command to execute.
+A task has a name, a `desc`, and an `execute` shell command:
 
 ```yaml
-command:
-  desc: Command description
-  execute: script.sh
+test:
+  desc: Run the test suite
+  execute: bundle exec rspec
 ```
 
-This yaml will create the following command:
+`caml` and `caml help` list every task with its description.
+
+## Multi-line execute
+
+Pass a list to run multiple steps. Steps run with fail-fast semantics — the first non-zero exit aborts:
 
 ```yaml
-bin/caml command # Command description
+setup:
+  desc: Install and migrate
+  execute:
+    - bundle install
+    - bin/rails db:migrate
 ```
 
-And it will run any bash command defined.
+## Arguments
 
-Arguments may be added under `args` in a nested fashion as displayed below.
+Positional arguments substitute into the `execute` template via `{{name}}`. Values are shell-escaped:
 
 ```yaml
-command:
+greet:
+  desc: Say hello to someone
   args:
-    one:
-      desc: First argument
-      type: string
-    two:
-      desc: Second argument
+    name:
+      desc: Person to greet
       type: string
+  execute: echo Hello, {{name}}!
+```
+
+```sh
+caml greet world
+# Hello, world!
 ```
 
-## Examples
+## Options
+
+Flags with type, optional aliases, default value, and an optional override `execute`:
 
 ```yaml
 build:
-  desc: Build our project
-  execute: make
-clean:
-  desc: Clean our project
-  execute: make clean
+  desc: Build the project
+  opts:
+    target:
+      type: string
+      default: dist
+      aliases:
+        - t
+      desc: Output directory
+    verbose:
+      type: boolean
+      aliases:
+        - v
+      desc: Print verbose output
+  execute: make build TARGET={{target}}
 ```
 
+```sh
+caml build --target release
+caml build -t release -v
+```
+
+### Option-driven dispatch
+
+When a boolean option has its own `execute`, that command runs instead of the task's default:
+
+```yaml
+start:
+  desc: Start the app
+  opts:
+    background:
+      type: boolean
+      aliases:
+        - b
+      desc: Run as a daemon
+      execute: app start --daemon
+  execute: app start
+```
+
+```sh
+caml start                # app start
+caml start --background   # app start --daemon
+```
+
+## Aliases
+
+Add shortcut names for a task:
+
+```yaml
+test:
+  desc: Run the test suite
+  aliases:
+    - t
+  execute: bundle exec rspec
+```
+
+```sh
+caml t   # same as caml test
+```
+
+## Dependencies
+
+A task can declare prerequisites with `needs`. Deps run in declared order, each at most once per invocation; failures abort the run:
+
 ```yaml
-build:
-  desc: Bundle
-  execute: bundle install
-migrate:
-  desc: Migrate the test database
-  execute: rails db:migrate RAILS_ENV=test
 test:
   desc: Run tests
-  execute: rspec
+  execute: bundle exec rspec
+
+lint:
+  desc: Check style
+  execute: bundle exec rubocop
+
+ci:
+  desc: Lint and test
+  needs:
+    - lint
+    - test
+```
+
+```sh
+caml ci   # runs lint, then test
 ```
+
+A task with only `needs:` and no `execute` is a pure orchestrator — useful for grouping.
+
+## Discovery
+
+`caml` walks up from the current directory to find a `caml.yaml`, just like `git`. You can run it from any subdirectory of your project.
+
+## Built-in commands
+
+| Command           | Description                                        |
+|-------------------|----------------------------------------------------|
+| `caml init`       | Scaffold a starter `caml.yaml`                     |
+| `caml --version`  | Print the installed version                        |
+| `caml help [cmd]` | Show help for a specific task (its args and opts)  |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/bin/caml

@@ -1,64 +1,30 @@
 #!/usr/bin/env ruby
 
-require 'thor'
-require_relative '../lib/caml/caml'
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'caml'
 
-# TODO:
-# x Yaml
-# x Metaprogramming
-# _ Thor commands, options, arguments, etc.
-# _ Add bash and ruby commands
-# _ Turn into gem
-# _ Distribute via CMM gem server
-# _ Make some noise
-# _ Make it better with Rust
-# _ Distribute a release on GHE
-# _ Make some more noise
-
-
-class CamlCli < Thor
-  def self.load
-    Caml::Config.new.directives.each do |entry|
-      directive = build_directive(entry)
-      args = build_args(directive['args'])
-      opts = build_opts(directive['opts'])
-      command = build_command(directive.merge({'args' => args, 'opts' => opts}))
-      puts command
-      puts ''
-      class_eval command.to_s
-    end
-  end
-
-  private
-
-  def self.build_directive(entry)
-    entry.last.merge({'name' => entry.first, 'args' => entry.last['args'] || [], 'opts' => entry.last['opts'] || []})
-  end
-
-  def self.build_args(args)
-    args.reject { |arg| arg.empty? }
-        .map { |name, arg| arg.merge({'name' => name}) }
-        .map { |arg| Caml::Argument.new(arg) }
-  end
-
-  def self.build_opts(opts)
-    opts.reject { |opt| opt.empty? }
-        .map { |name, opt| opt.merge({'name' => name}) }
-        .map { |opt| Caml::Option.new(opt) }
-  end
+if %w[--version -v].include?(ARGV.first)
+  puts Caml::VERSION
+  exit 0
+end
 
-  def self.build_command(directive)
-    Caml::Command.new(directive)
-  end
+config_path = Caml::Config.discover(Dir.getwd)
 
-  no_commands do
-    def execute
-      successful = system yield
-      exit successful
-    end
+if config_path
+  begin
+    config = Caml::Config.load(config_path)
+  rescue Caml::Config::Malformed => e
+    warn "caml: #{e.message}"
+    exit 1
   end
 
+  runner = Caml::Runner.new(tasks: config.tasks, shell: Caml::Shell.new)
+  Caml::CLI.register(config: config, runner: runner)
+elsif !ARGV.empty? && !%w[init help -h --help].include?(ARGV.first)
+  warn 'caml: no caml.yaml found in this directory or any parent.'
+  warn 'Run `caml init` to scaffold one.'
+  exit 1
 end
 
-CamlCli.load
-CamlCli.start(ARGV)
+result = Caml::CLI.start(ARGV)
+exit(result == false ? 1 : 0)

data/lib/caml/argument.rb

@@ -0,0 +1,11 @@
+module Caml
+  class Argument
+    attr_reader :name, :desc, :type
+
+    def initialize(name:, desc:, type: 'string')
+      @name = name
+      @desc = desc
+      @type = type
+    end
+  end
+end

data/lib/caml/cli.rb

@@ -0,0 +1,62 @@
+require 'thor'
+
+module Caml
+  class CLI < Thor
+    THOR_TYPES = {
+      'string' => :string,
+      'boolean' => :boolean,
+      'numeric' => :numeric
+    }.freeze
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'init', 'Scaffold a starter caml.yaml in the current directory'
+    def init
+      target = File.join(Dir.pwd, 'caml.yaml')
+      Init.scaffold(target)
+      say "Created #{target}", :green
+    rescue Init::Conflict => e
+      say "caml init: #{e.message}", :red
+      exit 1
+    end
+
+    def self.register(config:, runner:)
+      config.tasks.each { |task| register_task(task, runner) }
+    end
+
+    def self.register_task(task, runner)
+      task.opts.each { |opt| register_option(opt) }
+      desc usage(task), task.desc.to_s
+      task.aliases.each { |alias_name| map alias_name => task.name.to_sym }
+      define_dispatcher(task, runner)
+    end
+
+    def self.define_dispatcher(task, runner)
+      define_method(task.name) do |*positional|
+        args_hash = task.args.each_with_index.to_h { |arg, i| [arg.name, positional[i]] }
+        runner.run(task.name, args: args_hash, opts: options.to_h)
+      end
+    end
+
+    def self.register_option(opt)
+      attrs = {
+        type: thor_type(opt.type),
+        desc: opt.desc.to_s,
+        aliases: opt.aliases.map { |a| "-#{a}" }
+      }
+      attrs[:default] = opt.default unless opt.default.nil?
+      method_option opt.name, **attrs
+    end
+
+    def self.thor_type(yaml_type)
+      THOR_TYPES.fetch(yaml_type, :string)
+    end
+
+    def self.usage(task)
+      positional = task.args.map { |arg| arg.name.upcase }.join(' ')
+      positional.empty? ? task.name : "#{task.name} #{positional}"
+    end
+  end
+end

data/lib/caml/config.rb

@@ -0,0 +1,98 @@
+require 'safe_yaml/load'
+
+module Caml
+  class Config
+    class NotFound < StandardError
+    end
+
+    class Malformed < StandardError
+    end
+
+    attr_reader :tasks
+
+    def self.load(path)
+      raise NotFound, "caml.yaml not found at #{path}" unless File.file?(path)
+
+      raw = parse(File.read(path), path)
+      from_raw(raw)
+    end
+
+    def self.discover(start_dir)
+      dir = File.expand_path(start_dir)
+      loop do
+        candidate = File.join(dir, 'caml.yaml')
+        return candidate if File.file?(candidate)
+
+        parent = File.dirname(dir)
+        return nil if parent == dir
+
+        dir = parent
+      end
+    end
+
+    def self.from_tasks(tasks)
+      new(tasks)
+    end
+
+    def initialize(tasks)
+      @tasks = tasks
+    end
+
+    def self.parse(content, path)
+      SafeYAML.load(content, nil, safe: true, raise_on_unknown_tag: true) || {}
+    rescue Psych::SyntaxError, SafeYAML::UnknownTagError => e
+      raise Malformed, "could not parse #{path}: #{e.message.sub(/\A\([^)]*\):\s*/, '')}"
+    end
+    private_class_method :parse
+
+    def self.from_raw(raw)
+      tasks = raw.map { |name, body| build_task(name, body || {}) }
+      new(tasks)
+    end
+    private_class_method :from_raw
+
+    def self.build_task(name, body)
+      Task.new(
+        name: name,
+        desc: body['desc'],
+        execute: body['execute'],
+        args: build_args(body['args']),
+        opts: build_opts(body['opts']),
+        aliases: body['aliases'] || [],
+        needs: body['needs'] || []
+      )
+    end
+    private_class_method :build_task
+
+    def self.build_args(raw)
+      return [] unless raw
+
+      raw.map { |name, fields| build_argument(name, fields || {}) }
+    end
+    private_class_method :build_args
+
+    def self.build_argument(name, fields)
+      attrs = { name: name, desc: fields['desc'] }
+      attrs[:type] = fields['type'] if fields['type']
+      Argument.new(**attrs)
+    end
+    private_class_method :build_argument
+
+    def self.build_opts(raw)
+      return [] unless raw
+
+      raw.map { |name, fields| build_option(name, fields || {}) }
+    end
+    private_class_method :build_opts
+
+    def self.build_option(name, fields)
+      attrs = { name: name, desc: fields['desc'] }
+      attrs[:type] = fields['type'] if fields['type']
+      attrs[:aliases] = fields['aliases'] if fields['aliases']
+      attrs[:default] = fields['default'] unless fields['default'].nil?
+      attrs[:execute] = fields['execute'] if fields['execute']
+      Option.new(**attrs)
+    end
+    private_class_method :build_option
+  end
+end

data/lib/caml/init.rb

@@ -0,0 +1,18 @@
+module Caml
+  module Init
+    class Conflict < StandardError
+    end
+
+    TEMPLATE = <<~YAML.freeze
+      hello:
+        desc: A starter task — replace me
+        execute: echo Hello, caml!
+    YAML
+
+    def self.scaffold(path)
+      raise Conflict, "#{path} already exists" if File.exist?(path)
+
+      File.write(path, TEMPLATE)
+    end
+  end
+end

data/lib/caml/interpolation.rb

@@ -0,0 +1,19 @@
+require 'shellwords'
+
+module Caml
+  module Interpolation
+    class Missing < StandardError
+    end
+
+    TOKEN = /\{\{(\w+)\}\}/
+
+    def self.apply(template, values)
+      template.gsub(TOKEN) do
+        name = Regexp.last_match(1)
+        raise Missing, "no value for {{#{name}}}" unless values.key?(name)
+
+        Shellwords.escape(values[name].to_s)
+      end
+    end
+  end
+end

data/lib/caml/option.rb

@@ -0,0 +1,14 @@
+module Caml
+  class Option
+    attr_reader :name, :desc, :type, :aliases, :default, :execute
+
+    def initialize(name:, desc:, type: 'boolean', aliases: [], default: nil, execute: nil)
+      @name = name
+      @desc = desc
+      @type = type
+      @aliases = aliases
+      @default = default
+      @execute = execute
+    end
+  end
+end

data/lib/caml/plan.rb

@@ -0,0 +1,39 @@
+module Caml
+  module Plan
+    class Cycle < StandardError
+    end
+
+    class UnknownTask < StandardError
+    end
+
+    def self.resolve(target_name, tasks)
+      index = tasks.to_h { |task| [task.name, task] }
+      state = { ordered: [], visiting: [], visited: {} }
+      visit(target_name, index, state)
+      state[:ordered]
+    end
+
+    def self.visit(name, index, state)
+      return if state[:visited][name]
+
+      raise_if_cycle(state, name)
+      task = index[name] or raise UnknownTask, "no such task: #{name}"
+
+      state[:visiting] << name
+      task.needs.each { |dep| visit(dep, index, state) }
+      state[:visiting].pop
+
+      state[:visited][name] = true
+      state[:ordered] << task
+    end
+    private_class_method :visit
+
+    def self.raise_if_cycle(state, name)
+      return unless state[:visiting].include?(name)
+
+      path = state[:visiting].drop_while { |n| n != name } + [name]
+      raise Cycle, "cycle detected: #{path.join(' -> ')}"
+    end
+    private_class_method :raise_if_cycle
+  end
+end

data/lib/caml/runner.rb

@@ -0,0 +1,37 @@
+module Caml
+  class Runner
+    def initialize(tasks:, shell:)
+      @tasks = tasks
+      @shell = shell
+    end
+
+    def run(name, args: {}, opts: {})
+      plan = Plan.resolve(name, @tasks)
+      plan.each do |task|
+        bindings = task.name == name ? { args: args, opts: opts } : { args: {}, opts: {} }
+        return false unless execute_task(task, **bindings)
+      end
+      true
+    end
+
+    private
+
+    def execute_task(task, args:, opts:)
+      return true if task.execute.nil? || Array(task.execute).empty?
+
+      command = build_command(task, args, opts)
+      @shell.run(command)
+    end
+
+    def build_command(task, args, opts)
+      execute = effective_execute(task, opts)
+      bindings = args.merge(opts)
+      Array(execute).map { |step| Interpolation.apply(step, bindings) }.join(' && ')
+    end
+
+    def effective_execute(task, opts)
+      override = task.opts.find { |opt| opt.execute && opts[opt.name] }
+      override ? override.execute : task.execute
+    end
+  end
+end

data/lib/caml/shell.rb

@@ -0,0 +1,7 @@
+module Caml
+  class Shell
+    def run(command)
+      system(command) ? true : false
+    end
+  end
+end

data/lib/caml/task.rb

@@ -0,0 +1,15 @@
+module Caml
+  class Task
+    attr_reader :name, :desc, :execute, :args, :opts, :aliases, :needs
+
+    def initialize(name:, desc:, execute:, args: [], opts: [], aliases: [], needs: [])
+      @name = name
+      @desc = desc
+      @execute = execute
+      @args = args
+      @opts = opts
+      @aliases = aliases
+      @needs = needs
+    end
+  end
+end

data/lib/caml/version.rb

@@ -0,0 +1,3 @@
+module Caml
+  VERSION = '1.0.0'.freeze
+end

data/lib/caml.rb

@@ -0,0 +1,14 @@
+require 'caml/version'
+require 'caml/argument'
+require 'caml/option'
+require 'caml/task'
+require 'caml/interpolation'
+require 'caml/config'
+require 'caml/plan'
+require 'caml/shell'
+require 'caml/runner'
+require 'caml/init'
+require 'caml/cli'
+
+module Caml
+end

metadata

@@ -1,62 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: caml
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ian Johnson
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: safe_yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-description: "# \U0001F42A caml\n\n> Build CLI apps with YAML\n\n`caml` allows you
-  to build command line applications using declarative yaml.\n`caml` aims to be like
-  `make`, but by using descriptive, declarative yaml.\n\n## Usage\n\nRunning the command
-  without any arguments displays the commands defined in the `caml.yaml` file:\n\n```sh\nbin/caml\n```\n\n##
-  Declaring commands\n\n`caml` reads a file called `caml.yaml` in the current directory
-  and converts those commands into a unified CLI command.\n\nThe basic structure is
-  to have a `command`, which has a `desc` and an `execute` for the bash command to
-  execute.\n\n```yaml\ncommand:\n  desc: Command description\n  execute: script.sh\n```\n\nThis
-  yaml will create the following command:\n\n```yaml\nbin/caml command # Command description\n```\n\nAnd
-  it will run any bash command defined.\n\nArguments may be added under `args` in
-  a nested fashion as displayed below.\n\n```yaml\ncommand:\n  args:\n    one:\n      desc:
-  First argument\n      type: string\n    two:\n      desc: Second argument\n      type:
-  string\n```\n\n## Examples\n\n```yaml\nbuild:\n  desc: Build our project\n  execute:
-  make\nclean:\n  desc: Clean our project\n  execute: make clean\n```\n\n```yaml\nbuild:\n
-  \ desc: Bundle\n  execute: bundle install\nmigrate:\n  desc: Migrate the test database\n
-  \ execute: rails db:migrate RAILS_ENV=test\ntest:\n  desc: Run tests\n  execute:
-  rspec\n```\n"
+        version: 1.0.1
+description: caml turns well-documented YAML tasks into a runnable CLI. Inspired by
+  make and just, but YAML-driven.
 email: tacoda@hey.com
 executables:
 - caml
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - bin/caml
-- lib/caml/caml.rb
-- spec/caml/caml_spec.rb
+- lib/caml.rb
+- lib/caml/argument.rb
+- lib/caml/cli.rb
+- lib/caml/config.rb
+- lib/caml/init.rb
+- lib/caml/interpolation.rb
+- lib/caml/option.rb
+- lib/caml/plan.rb
+- lib/caml/runner.rb
+- lib/caml/shell.rb
+- lib/caml/task.rb
+- lib/caml/version.rb
 homepage: https://github.com/tacoda/caml
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  source_code_uri: https://github.com/tacoda/caml
+  changelog_uri: https://github.com/tacoda/caml/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -64,16 +101,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.9'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
-summary: Build CLI apps using YAML
-test_files:
-- spec/caml/caml_spec.rb
+summary: Build CLI apps from a declarative caml.yaml file
+test_files: []

data/lib/caml/caml.rb

@@ -1,107 +0,0 @@
-require 'safe_yaml/load'
-
-module Caml
-  # def self.wrap(object)
-  #   if object.nil?
-  #     []
-  #   elsif object.respond_to?(:to_ary)
-  #     object.to_ary || [object]
-  #   else
-  #     [object]
-  #   end
-  # end
-
-  class Config
-    def initialize
-      # Recursively load (prompt to init if it doesn't exist)
-      SafeYAML::OPTIONS[:default_mode] = :safe
-      @config = YAML.load_file(File.join(Dir.getwd, 'caml.yaml'))
-    end
-
-    def directives
-      @config
-    end
-
-    def to_s
-      inspect
-    end
-  end
-
-  class Command
-    attr_reader :name, :desc, :aliases, :args, :opts, :execute
-
-    def initialize(options = {})
-      @name = options['name']
-      @desc = options['desc']
-      @aliases = options['aliases']
-      @args = options['args']
-      @opts = options['opts']
-      @execute = options['execute']
-    end
-
-    def dispatcher
-      if opts.empty?
-        executor
-      else
-        first_clause = "if options[:#{opts.first.name.to_sym}]\nexecute { \"#{opts.first.execute}\" }\n"
-        # else_clause = directive.execute.nil? ? "#\n" : "else\nexecute { \"#{wrap(directive.execute).join(';')}\" }\nend"
-        # clauses = directive.options.drop(1).map { |option| "elsif options[:#{option.name.to_sym}]\nexecute { \"#{wrap(option.execute).join(';')}\" }\n" }.join
-        # dispatcher = first_clause + clauses + else_clause
-        puts first_clause
-        executor
-      end
-    end
-
-    def executor
-      if execute.respond_to?(:join)
-<<-EOS
-execute do
-<<-COMMANDS
-#{execute.join("\n")}
-COMMANDS
-end
-EOS
-      else
-        "execute { \"#{execute}\" }\n"
-      end
-    end
-
-    def to_s
-      descriptor = "desc '#{name}', '#{desc}'\n"
-      options = opts.empty? ? '' : opts.join("\n") + "\n"
-      signature = "def #{name}\n" # TODO: args
-      close_scope = "end\n"
-      descriptor + options + signature + executor + close_scope
-    end
-  end
-
-  class Option
-    attr_reader :name, :type, :desc, :aliases, :execute
-
-    def initialize(options = {})
-      @name = options['name']
-      @type = options['type']
-      @desc = options['desc']
-      @aliases = options['aliases']
-      @execute = options['execute']
-    end
-
-    def to_s
-      "option :#{name}, type: :#{type}, desc: '#{desc}'"
-    end
-  end
-
-  class Argument
-    attr_reader :name, :type, :desc, :value
-
-    def initialize(options ={})
-      @name = options['name']
-      @desc = options['desc']
-      @type = options['type']
-    end
-
-    def to_s
-        inspect
-    end
-  end
-end

data/spec/caml/caml_spec.rb

@@ -1,9 +0,0 @@
-require 'caml/caml'
-
-module Caml
-  describe Caml do
-    it 'works' do
-      expect(1).to eq(1)
-    end
-  end
-end