caml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8112aee1b07f561a5a61568f3d53d7c4bf002de6eb011be5e835490c404cb0f
+  data.tar.gz: a72ec8bf5815f84abb80b585c6ab0d1d84802b23e91672a47844c16cf2894f46
+SHA512:
+  metadata.gz: 113daadc8195e7ea3667d3ac463455e3e9c2f18ff022f3ee030ce68672c14e4ce022b91e16f479b12a6060c2aa626ab8bf16596af29d8e2cd018a0c4fc4ef9c1
+  data.tar.gz: d9d5127a760273c578b486b4754e97d24b278e215f9d9edc3a1ac730ec24fc5a9ae6add0525e183c821ed0c65528d955c136360f58ae51668f2fe49025587a92

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Ian Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# 🐪 caml
+
+> Build CLI apps with YAML
+
+`caml` allows you to build command line applications using declarative yaml.
+`caml` aims to be like `make`, but by using descriptive, declarative yaml.
+
+## Usage
+
+Running the command without any arguments displays the commands defined in the `caml.yaml` file:
+
+```sh
+bin/caml
+```
+
+## Declaring commands
+
+`caml` reads a file called `caml.yaml` in the current directory and converts those commands into a unified CLI command.
+
+The basic structure is to have a `command`, which has a `desc` and an `execute` for the bash command to execute.
+
+```yaml
+command:
+  desc: Command description
+  execute: script.sh
+```
+
+This yaml will create the following command:
+
+```yaml
+bin/caml command # Command description
+```
+
+And it will run any bash command defined.
+
+Arguments may be added under `args` in a nested fashion as displayed below.
+
+```yaml
+command:
+  args:
+    one:
+      desc: First argument
+      type: string
+    two:
+      desc: Second argument
+      type: string
+```
+
+## Examples
+
+```yaml
+build:
+  desc: Build our project
+  execute: make
+clean:
+  desc: Clean our project
+  execute: make clean
+```
+
+```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
+```

data/bin/caml

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require_relative '../lib/caml/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
+
+  def self.build_command(directive)
+    Caml::Command.new(directive)
+  end
+
+  no_commands do
+    def execute
+      successful = system yield
+      exit successful
+    end
+  end
+
+end
+
+CamlCli.load
+CamlCli.start(ARGV)

data/lib/caml/caml.rb

@@ -0,0 +1,107 @@
+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

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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: caml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian Johnson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: "# \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"
+email: tacoda@hey.com
+executables:
+- caml
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/caml
+- lib/caml/caml.rb
+- spec/caml/caml_spec.rb
+homepage: https://github.com/tacoda/caml
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Build CLI apps using YAML
+test_files:
+- spec/caml/caml_spec.rb