molder 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2480986a1941cf8389155f51644915554997ce09b92437f3eb24c1b4bd6fbe9
+  data.tar.gz: 3001d82af80718bc6f4db8ade5bef766e27d199f16fac8136d7a30a5924a036e
+SHA512:
+  metadata.gz: f94f91528b905aea08c623e7a50fa575304f6dfbd9ef8d8c8c821252ee1e3c7919237eff400c3398f0d78d868a7034524a6b63ec55d8eafc04cd487656ef3cb5
+  data.tar.gz: 13f261c86a9ea2892d26790ef2b5bf17d76b4235d05e22e909df334f599821cfa777fad1079a78fc71ab6f3f868552c90399fbe807db13a353d33349b930fa4f

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+Gemfile.lock
+coverage
+pkg
+doc
+spec/reports
+tmp
+vendor/
+**/.DS_Store
+.idea/
+log/
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format progress
+--color

data/.rspec_status

@@ -0,0 +1,4 @@
+example_id                 | status | run_time        |
+-------------------------- | ------ | --------------- |
+./spec/molder_spec.rb[1:1] | passed | 0.00067 seconds |
+./spec/molder_spec.rb[1:2] | failed | 0.00965 seconds |

data/.travis.yml

@@ -0,0 +1,26 @@
+language: ruby
+env:
+  global:
+    - CODECLIMATE_REPO_TOKEN=49ca8c0e2d56ab70e7eabc237692e21cc8fe43ef13ed5d411fa20bf1e8997a44
+rvm:
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
+cache:
+- bundler
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
+script: bundle exec rspec
+notifications:
+  slack:
+    rooms:
+  email:
+    recipients:
+      - kigster@gmail.com
+    on_success: change
+    on_failure: always

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in molder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Konstantin Gredeskoul
+
+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,209 @@
+[![Build Status](https://travis-ci.org/kigster/molder.svg?branch=master)](https://travis-ci.org/kigster/molder)
+
+# Molder
+
+Molder is a command line tool for generating and running (in parallel) a set of related but similar commands. A key
+use-case is auto-generation of the host provisioning commands for an arbitrary cloud environment. The gem is not constrained to any particular cloud tool or even a command, and can be used to generate a consistent set of commands based on several customizable dimensions.
+
+For example, you could generate 600 provisioning commands for hosts in EC2, numbered from 1 to 100, constrained to the dimensions "zone-id" (values: ["a", "b", "c"]) and the data center "dc" (values: ['us-west2', 'us-east1' ]).
+
+## Usage
+
+Molder works in the following way:
+
+ * It reads the configuration YAML file, described further below
+ 
+ * It parses command line arguments, and extracts the **command name** and **template name(s)**
+ 
+ * It matches the command name with one of the commands specified in the YAML file
+ 
+ * It matches the template name(s) with those in the YAML file
+ 
+ * It then uses [Liquid template language](https://shopify.github.io/liquid/) to substitute tokens in the command template, possibly enumerating over provided numbers.
+  
+ * Tokens are taken from the template definition, and two more tokens are added: `formatted_number` and `number`. 
+
+### YAML Configuration File
+
+Here is the semi-minimal YAML file that demonstrates all features.
+
+First, at the top, we define the global section. The only arguments there are `log_dir` and `index_format`, the latter is the `sprintf` pattern applied to the numeric index.
+
+```yaml
+global:
+  log_dir: ./log
+  index_format: '%03.3d'
+```
+
+Second, we have a `configuration` section that is not really used by the library, but is used within this YAML file to define the templates with the minimum repetition. Note, how we are using `? role[base]` to indicate a hash key with a nil value. These can be merged down below, and `molder` converts all hashes with nil values into an array of keys.
+
+Note how in the name of the instances we are using Liquid markup to reference `formatted_number` and `zone_id`. The former is provided by the gem, and the latter is provided by the template itself.
+
+```yaml
+configuration:
+  ec2-base: &ec2-base
+    image: ami-f9u98f
+    flavor: c5.4xlarge
+    security_group_id: ssg-f8987987
+    ssh_user: ubuntu
+    ssh_key: ubuntu_key
+    identity_file: '~/.ssh/ec2.pem'
+    run_list: &run_list_base
+      ? role[base]
+
+  web: &ec2-web
+    <<: *ec2-base
+    name: web{{ formatted_number }}-{{ zone_id }}
+    run_list: &run_list_web
+      ? role[web]
+
+  job: &ec2-job
+    <<: *ec2-base
+    flavor: c5.2xlarge
+    name: job{{ formatted_number }}-{{ zone_id }}
+    run_list: &run_list_job
+      ? role[job]
+
+  us-east1-a: &us-east1-a
+    subnet: subnet-ff09898
+    zone: us-east1-a
+    zone_id: a
+    run_list: &run_list_zone_a
+      ? role[zone-a]
+
+  us-east1-b: &us-east1-b
+    subnet: subnet-f909809
+    zone: us-east1-b
+    zone_id: b
+    run_list: &run_list_zone_b
+      ? role[zone-b]
+```
+
+Next, we define the actual templates. These are composed of several YAML entries defined above.
+
+Note that we define both zone-specific instances of two types (web and job), as well as an array of web instances (comprised of both zones a and b), and job instances.
+
+
+```yaml
+templates:
+  web-a: &web-a
+    <<: *us-east1-a
+    <<: *ec2-web
+    run_list:
+      <<: *run_list_base
+      <<: *run_list_web
+      <<: *run_list_zone_a
+
+  web-b: &web-b
+    <<: *ec2-web
+    <<: *us-east1-b
+    run_list:
+      <<: *run_list_base
+      <<: *run_list_web
+      <<: *run_list_zone_b
+
+  job-a: &job-a
+    <<: *ec2-job
+    <<: *us-east1-a
+    run_list:
+      <<: *run_list_base
+      <<: *run_list_job
+      <<: *run_list_zone_a
+
+  job-b: &job-b
+    <<: *ec2-job
+    <<: *us-east1-b
+    run_list:
+      <<: *run_list_base
+      <<: *run_list_job
+      <<: *run_list_zone_b
+
+  web:
+    - <<: *web-a
+    - <<: *web-b
+
+  job:
+    - <<: *job-a
+    - <<: *job-b
+```
+
+The final section defines commands that we can generate using this YAML file. We are only including one command here, called `provision`, which comes with a description and args.  Args include extensive set of liquid tokens that are pulled from the template attributes applied to this command.
+
+```yaml
+commands:
+  provision:
+    desc: Provision hosts on AWS EC2 using knife ec2 plugin.
+    args: |
+      echo knife ec2 server create
+        -N {{ name }}
+        -I {{ image }}
+        -Z {{ zone }}
+        -f {{ flavor  }}
+        --environment {{ environment }}
+        --subnet {{ subnet }}
+        -g {{ security_group_id }}
+        -r {{ run_list }}
+        -S {{ ssh_key }}
+        -i {{ identity_file }}
+        --ssh-user {{ ssh_user }}; sleep 2
+```
+
+So how would we use molder to generate commands that provision a bunch of ec2 hosts for us?
+
+```bash
+$ molder provision web[1..5]/job[1,4,6] -a environment=production -c config/molder.yml   
+```
+
+This is the output we would see:
+
+![output](docs/molder.png)
+
+Let's understand this command:
+
+ * first argument is `provision` — it has to match one of the commands in the YAML file.
+ 
+ * second argument consists of template names, followed by the numbers in square brackets. Either comma-separated numbers are supported, or a range (not that a range must also be included in square brackets)
+ 
+   * multiple template names can be separated by a slash, as seen here.
+   
+ * next we pass `-a environment=production` — notice that our provision command defined in the template uses `{{ environment }}` token, even though no such attribute is defined in any of the templates. if we do not supply this argument, the value of environment in the command line would be blank.
+ 
+   * Note that you can pass multiple attributes, separated by a slash, like so: `-a environment=production/flavor=c5.4xlarge`
+    
+ * The final argument is the template file. The default location is `config/molder.yml` — so if you place the file in that folder you don't need to pass `-c` argument. 
+ 
+### Complete Options List
+ 
+If you run `molder -h` you would see the following:
+
+![cli](docs/molder-cli.png)    
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'molder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install molder
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kigster/molder.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,35 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+def shell(*args)
+  puts "running: #{args.join(' ')}"
+  system(args.join(' '))
+end
+
+task :clean do 
+  shell 'rm -rf log/ pkg/ tmp/ coverage/ doc/'
+end
+
+task :gem => [:build] do
+  shell('gem install pkg/*')
+end
+
+task :permissions => [ :clean ] do 
+  shell("chmod -v o+r,g+r * */* */*/* */*/*/* */*/*/*/* */*/*/*/*/*")
+  shell("find . -type d -exec chmod o+x,g+x {} \\;")
+end
+
+task :build => :permissions
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = %w(lib/**/*.rb exe/*.rb - README.md LICENSE.txt)
+  t.options.unshift('--title','Molder - command generator based on templates')
+  t.after = ->() { exec('open doc/index.html') }
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "molder"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/molder

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'molder'
+
+Molder::CLI.new(ARGV).execute!

data/lib/molder.rb

@@ -0,0 +1,9 @@
+require 'molder/version'
+require 'require_dir'
+module Molder
+  RequireDir.enable_require_dir!(self, __FILE__)
+
+  dir_r 'molder'
+end
+
+

data/lib/molder/app.rb

@@ -0,0 +1,81 @@
+require 'hashie/mash'
+require 'hashie/extensions/mash/symbolize_keys'
+require 'molder/errors'
+require 'parallel'
+require 'fileutils'
+module Molder
+  class App
+
+    attr_accessor :config, :options, :command, :command_name, :commands, :templates, :log_dir
+
+    def initialize(config:, options:, command_name:)
+      self.config       = config
+      self.options      = options
+      self.command_name = command_name
+      self.commands     = []
+      self.log_dir      = options[:log_dir] || config.global.log_dir || './log'
+
+      resolve_command!
+
+      resolve_templates!
+    end
+
+    def execute!
+        colors = %i(yellow blue red green magenta cyan white)
+
+        FileUtils.mkdir_p(log_dir)
+        puts "Executing #{commands.size} commands using a pool of up to #{options.max_processes} processes:\n".bold.cyan.underlined
+        ::Parallel.each((1..commands.size),
+                        :in_processes => options.max_processes) do |i|
+
+          color = colors[(i - 1) % colors.size]
+          cmd   = commands[i - 1]
+
+          printf('%s', "Worker: #{Parallel.worker_number}, command #{i}\n".send(color)) if options.verbose
+          puts "#{cmd}\n".send(color)
+
+          system %Q(( #{cmd} ) > #{log_dir}/#{command_name}.#{i}.log) unless options.dry_run
+      end
+    end
+
+    private
+
+    def resolve_templates!
+      self.templates ||= []
+      options.names.each_pair do |name, indexes|
+        if config.templates[name]
+          template_array = config.templates[name].is_a?(Array) ?
+                             config.templates[name] :
+                             [config.templates[name]]
+
+          template_array.flatten.each do |attrs|
+            attributes = attrs.dup
+            attributes.merge!(options.override) if options.override
+            self.templates << ::Molder::Template.new(config:     config,
+                                                     name:       name,
+                                                     indexes:    indexes,
+                                                     command:    command,
+                                                     attributes: attributes)
+          end
+        else
+          raise ::Molder::InvalidTemplateName, "Template name #{name} is not valid."
+        end
+      end
+
+      self.templates.each do |t|
+        t.each_command do |cmd|
+          self.commands << cmd
+        end
+      end
+    end
+
+    def resolve_command!
+      unless config.commands.include?(command_name)
+        raise(::Molder::InvalidCommandError, "Command #{command_name} is not defined in the configuration file #{options[:config]}")
+      end
+
+      command_hash = Hashie::Extensions::SymbolizeKeys.symbolize_keys(config.commands[command_name].to_h)
+      self.command = Molder::Command.new(name: command_name, config: config, **command_hash)
+    end
+  end
+end

data/lib/molder/cli.rb

@@ -0,0 +1,188 @@
+require 'hashie/mash'
+require 'colored2'
+require 'optionparser'
+
+require 'etc'
+
+module Molder
+  class CLI
+    attr_accessor :argv, :original_argv, :options, :config, :command
+
+    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+
+      self.options                 = Hashie::Mash.new
+      self.options[:max_processes] = Etc.nprocessors - 2
+      self.argv                    = argv.dup
+      self.original_argv           = argv.dup
+
+      self.argv << '-h' if argv.empty?
+
+      parser.parse!(self.argv)
+      exit(0) if options.help
+
+      pre_parse!
+
+      if options.indexes
+        override = {}
+        options.names.each_pair do |name, values|
+          if values.nil?
+            override[name] = option.indexes
+          end
+        end
+        options.names.merge!(override)
+      end
+
+      self.config = if options.config
+                      if File.exist?(options.config)
+                        Configuration.load(options.config)
+                      else
+                        report_error(message: "file #{options.config} does not exist.")
+                      end
+                    else
+                      Configuration.default
+                    end
+    end
+
+    def execute!
+      exit_code = begin
+        $stderr = @stderr
+        $stdin  = @stdin
+        $stdout = @stdout
+
+        App.new(config: config, options: options, command_name: command).execute!
+
+        0
+      rescue StandardError => e
+        report_error(exception: e)
+        1
+      rescue SystemExit => e
+        e.status
+      ensure
+        $stderr = STDERR
+        $stdin  = STDIN
+        $stdout = STDOUT
+      end
+      @kernel.exit(exit_code)
+    end
+
+    private
+
+    def pre_parse!
+      if argv[0] && !argv[0].start_with?('-')
+        self.command = argv.shift
+      end
+
+      if self.argv[0] && !self.argv[0].start_with?('-')
+        options[:names] = Hashie::Mash.new
+        self.argv.shift.split('/').each { |arg| parse_templates(arg) }
+      end
+    end
+
+    def parser
+      OptionParser.new(nil, 35) do |opts|
+        opts.separator 'OPTIONS:'.bold.yellow
+
+        opts.on('-c', '--config [file]',
+                'Main YAML configuration file') { |config| options[:config] = config }
+
+        opts.on('-t', '--template [n1/n2/..]',
+                'Names of the templates to use') do |value|
+          options[:names] ||= Hashie::Mash.new
+          value.split('/').each { |arg| parse_templates(arg) }
+        end
+
+        opts.on('-i', '--index [range/array]',
+                'Numbers to use in generating commands',
+                'Can be a comma-separated list of values,',
+                'or a range, eg "1..5"') do |value|
+          options[:indexes] = index_expression_to_array(value)
+        end
+
+        opts.on('-a', '--attrs [k1=v1/k2=v2/...]',
+                'Provide additional attributes, or override existing ones') do |value|
+          h = {}
+          value.split('/').each do |pair|
+            key, value = pair.split('=')
+            h[key]     = value
+          end
+          options[:override] = h
+        end
+
+        opts.on('-m', '--max-processes [number]',
+                'Do not start more than this many processes at once') { |value| options[:max_processes] = value.to_i }
+
+        opts.on('-l', '--log-dir [dir]',
+                'Directory where STDOUT of running commands is saved') { |value| options[:log_dir] = value }
+
+        opts.on('-n', '--dry-run',
+                'Don\'t actually run commands, just print them') { |_value| options[:dry_run] = true }
+
+        opts.on('-v', '--verbose',
+                'Print more output') { |_value| options[:verbose] = true }
+
+        opts.on('-b', '--backtrace',
+                'Show error stack trace if available') { |_value| options[:backtrace] = true }
+
+        opts.on('-h', '--help',
+                'Show help') do
+          @stdout.puts opts
+          options[:help] = true
+        end
+
+      end.tap do |p|
+        p.banner = <<-eof
+#{'DESCRIPTION'.bold.yellow}
+    Molder is a template based command generator and runner for cases where you need to 
+    generate many similar and yet somewhat different commands, defined in the 
+    YAML template. Please read #{'https://github.com/kigster/molder'.bold.blue.underlined} for 
+    a detailed explanation of the config file structure.
+
+    Note that the default configuration file is #{Molder::Configuration::DEFAULT_CONFIG.bold.green}. 
+
+#{'USAGE'.bold.yellow}
+    #{'molder [-c config.yml] command template1[n1..n2]/template2[n1,n2,..]/...  [options]'.bold.blue} 
+    #{'molder [-c config.yml] command -t template -i index [options]'.blue.bold}
+
+#{'EXAMPLES'.bold.yellow}
+    #{'# The following commands assume YAML file is in the default location:'.bold.black}
+    #{'molder provision web[1,3,5]'.bold.blue}
+
+    #{'# -n flag means dry run — so instead of running commands, just print them:'.bold.black}
+    #{'molder provision web[1..4]/job[1..4] -n'.bold.blue}
+
+        eof
+      end
+    end
+
+    def report_error(message: nil, exception: nil)
+      if options[:backtrace] && exception.backtrace
+        @stderr.puts exception.backtrace.reverse.join("\n").yellow.italic
+      end
+      @stderr.puts "Error: #{exception.to_s.bold.red}" if exception
+      @stderr.puts "Error: #{message.bold.red}" if message
+      @kernel.exit(1)
+    end
+
+    def parse_templates(arg)
+      options[:names] ||= Hashie::Mash.new
+      templates       = arg.split('/')
+      templates.each do |t|
+        name, indexes         = parse_name(t)
+        options[:names][name] = indexes
+      end
+    end
+
+    def parse_name(t)
+      name, values = t.split('[')
+      values.gsub!(/\]/, '') if values
+      [name, index_expression_to_array(values)]
+    end
+
+    def index_expression_to_array(value = nil)
+      return nil if value.nil?
+      value.include?('..') ? eval("(#{value}).to_a") : eval("[#{value}]")
+    end
+  end
+end
+

data/lib/molder/command.rb

@@ -0,0 +1,16 @@
+module Molder
+  class Command
+    attr_accessor :name, :config, :desc, :supervise, :concurrent, :examples, :args
+
+    def initialize(name:, config:, desc:, supervise: true, concurrent: true, examples: [], args:)
+      self.name       = name
+      self.config     = config
+      self.desc       = desc
+      self.supervise  = supervise
+      self.concurrent = concurrent
+      self.examples   = examples
+      self.args       = args
+    end
+
+  end
+end

data/lib/molder/configuration.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+require 'hashie/mash'
+require 'hashie/extensions/parsers/yaml_erb_parser'
+
+module Molder
+  class Configuration < Hashie::Mash
+    DEFAULT_CONFIG = 'config/molder.yml'.freeze
+    class << self
+      def default_config
+        DEFAULT_CONFIG
+      end
+
+      def default
+        if File.exist?(default_config)
+          load(default_config)
+        else
+          raise ::Molder::ConfigNotFound, "Default file #{default_config} was not found"
+        end
+
+      end
+
+      def load(file)
+        self.new(YAML.load(File.read(file)))
+      end
+    end
+  end
+end

data/lib/molder/errors.rb

@@ -0,0 +1,7 @@
+module Molder
+  class MolderError < StandardError; end
+  class InvalidCommandError < MolderError; end
+  class InvalidTemplateName < MolderError; end
+  class ConfigNotFound < MolderError; end
+  class LiquidTemplateError < MolderError; end
+end

data/lib/molder/renderer.rb

@@ -0,0 +1,109 @@
+require 'fileutils'
+require 'liquid'
+require 'hashie'
+require 'colored2'
+
+class Symbol
+  def to_liquid
+    to_i
+  end
+end
+
+module Molder
+  #
+  # == Usage
+  #
+  # Generally you first generate a set of parameters (a nested hash) that
+  # represents configuration of your application. As was mentioned above, the
+  # parameter hash can be self-referential – it will be automatically expanded.
+  #
+  # Once you create a Renderer instance with a given parameter set, you can then
+  # use the +#render+ method to convert content with Renderer placeholers into a
+  # fully resolved string.
+  #
+  # == Example
+  #/
+  #    require 'molder/renderer'
+  #
+  #    params = { 'invitee' => 'Adam',
+  #                 'extra' => 'Eve',
+  #            'salutation' => 'Dear {{ invitee }} & {{ extra }}',
+  #                 'from'  => 'Jesus'
+  #    }
+  #    @Renderer = ::Molder::Renderer.new(params)
+  #    ⤷ #<Molder::Renderer:0x007fb90b9c32d8>
+  #    content = '{{ salutation }}, please attend my birthday. Sincerely, {{ from }}.'
+  #    ⤷ {{ salutation }}, please attend my birthday. Sincerely, {{ from }}.
+  #    @Renderer.render(content)
+  #     ⤷ "Dear Adam & Eve, please attend my birthday. Sincerely, Jesus."
+  #
+  # == Troubleshooting
+  #
+  # See errors documented under this class.
+  #
+  class Renderer
+
+    # When the parameter hash contains a circular reference, this
+    # error will be thrown. It is thrown after the params hash is attempted
+    # to be expanded MAX_RECURSIONS times.
+    class TooManyRecursionsError < StandardError;
+    end
+
+    # When a Renderer (or params) contain a reference that can not be resolved
+    # this error is raised.
+    class UnresolvedReferenceError < ArgumentError;
+    end
+
+    # During parameter resolution phase (constructor) this error indicates that
+    # internal representation of the params hash (YAML) no longer compiles after
+    # some parameters have been resolved. This would be an internal error that
+    # should be coded around and fixed as a bug if it ever to occur.
+    class SyntaxError < StandardError;
+    end
+
+    MAX_RECURSIONS = 100
+
+    attr_accessor :template
+
+    # Create Renderer object, while storing and auto-expanding params.
+    def initialize(template)
+      self.template = template
+    end
+
+    # Render given content using expanded params.
+    def render(params)
+      attributes      = expand_arguments(Hashie.stringify_keys(params.to_h))
+      liquid_template = Liquid::Template.parse(template)
+      liquid_template.render(attributes, { strict_variables: true }).tap do
+        unless liquid_template.errors.empty?
+          raise LiquidTemplateError, "#{liquid_template.errors.map(&:message).join("\n")}"
+        end
+      end.gsub(/\n/, ' ').gsub(/\s{2,}/, ' ').strip
+    rescue ArgumentError => e
+      raise UnresolvedReferenceError.new(e)
+    end
+
+    private
+
+    def expand_arguments(params)
+      current    = YAML.dump(params)
+      recursions = 0
+
+      while current =~ %r[{{\s*[a-z_]+\s*}}]
+        recursions += 1
+        raise TooManyRecursionsError.new if recursions > MAX_RECURSIONS
+        previous = current
+        current  = ::Liquid::Template.parse(previous).render(params)
+      end
+
+      begin
+        Hashie::Mash.new(YAML.load(current))
+      rescue Psych::SyntaxError => e
+        STDERR.puts "Error parsing YAML Renderer:\n" +
+                      e.message.red +
+                      "\n#{current}"
+        raise SyntaxError.new(e)
+      end
+    end
+  end
+end

data/lib/molder/template.rb

@@ -0,0 +1,35 @@
+require 'molder/renderer'
+module Molder
+  class Template
+    attr_accessor :config, :name, :attributes, :indexes, :command
+
+    def initialize(config:, name:, indexes:, attributes: {}, command:)
+      self.config     = config
+      self.name       = name
+      self.indexes    = indexes
+      self.command    = command
+      self.attributes = self.class.normalize(attributes)
+    end
+
+    def each_command
+      indexes.map do |i|
+        self.attributes[:number] = i
+        self.attributes[:formatted_number] = sprintf(config.global.index_format, i)
+        ::Molder::Renderer.new(command.args).render(attributes.dup).tap do |cmd|
+          yield(cmd) if block_given?
+        end
+      end
+    end
+
+    def self.normalize(attrs)
+      override = {}
+      attrs.each_pair do |key, value|
+        if value.is_a?(Hash) && value.values.compact.empty?
+          override[key] = value.keys.to_a.join(',')
+        end
+      end
+      attrs.merge!(override)
+    end
+
+  end
+end

data/lib/molder/version.rb

@@ -0,0 +1,7 @@
+module Molder
+  VERSION = '0.1.4'.freeze
+  DESCRIPTION = <<-eof
+Molder is a command line tool for generating and running (in parallel, across a configurable number of processes) a set of related but similar commands that are generated based on a merge of a template with a set of attributes. A key use-case is auto-generation of the host provisioning commands for an arbitrary cloud environment. The gem is not constrained to any particular cloud tool or even a command, and can be used to generate a consistent set of commands based on several customizable dimensions. For example, you could generate 600 provisioning commands for hosts in EC2, numbered from 1 to 100, constrained to the dimensions "zone-id" (values: ["a", "b", "c"]) and the data center "dc" (values: ['us-west2', 'us-east1' ]).
+  eof
+    .gsub(/\s{2,}/, ' ')
+end

data/molder.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'molder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'molder'
+  spec.version       = ::Molder::VERSION
+  spec.authors       = ['Konstantin Gredeskoul']
+  spec.email         = ['kigster@gmail.com']
+
+  spec.summary       = Molder::DESCRIPTION
+  spec.description   = Molder::DESCRIPTION
+  spec.homepage      = 'https://github.com/kigster/molder'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'liquid'
+  spec.add_dependency 'hashie'
+  spec.add_dependency 'colored2'
+  spec.add_dependency 'parallel'
+  spec.add_dependency 'require_dir', '~> 2'
+
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'awesome_print'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'rspec-its'
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: molder
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Konstantin Gredeskoul
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colored2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: require_dir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: awesome_print
+  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: rake
+  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: 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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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: 'Molder is a command line tool for generating and running (in parallel,
+  across a configurable number of processes) a set of related but similar commands
+  that are generated based on a merge of a template with a set of attributes. A key
+  use-case is auto-generation of the host provisioning commands for an arbitrary cloud
+  environment. The gem is not constrained to any particular cloud tool or even a command,
+  and can be used to generate a consistent set of commands based on several customizable
+  dimensions. For example, you could generate 600 provisioning commands for hosts
+  in EC2, numbered from 1 to 100, constrained to the dimensions "zone-id" (values:
+  ["a", "b", "c"]) and the data center "dc" (values: [''us-west2'', ''us-east1'' ]).
+
+'
+email:
+- kigster@gmail.com
+executables:
+- molder
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rspec_status"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/molder-cli.png
+- docs/molder.png
+- exe/molder
+- lib/molder.rb
+- lib/molder/app.rb
+- lib/molder/cli.rb
+- lib/molder/command.rb
+- lib/molder/configuration.rb
+- lib/molder/errors.rb
+- lib/molder/renderer.rb
+- lib/molder/template.rb
+- lib/molder/version.rb
+- molder.gemspec
+homepage: https://github.com/kigster/molder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: 'Molder is a command line tool for generating and running (in parallel, across
+  a configurable number of processes) a set of related but similar commands that are
+  generated based on a merge of a template with a set of attributes. A key use-case
+  is auto-generation of the host provisioning commands for an arbitrary cloud environment.
+  The gem is not constrained to any particular cloud tool or even a command, and can
+  be used to generate a consistent set of commands based on several customizable dimensions.
+  For example, you could generate 600 provisioning commands for hosts in EC2, numbered
+  from 1 to 100, constrained to the dimensions "zone-id" (values: ["a", "b", "c"])
+  and the data center "dc" (values: [''us-west2'', ''us-east1'' ]).'
+test_files: []