kerbi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 844a7ee42c68f643fd43d0a365d497061cf79b9d6176612d9af17789676a32c9
+  data.tar.gz: 0fa583609a29a99ab0019c46ab1a11f99f240477fce2ca5a8ce3c7017e1a3aa4
+SHA512:
+  metadata.gz: 9a9d89cbdb45952d3baec555ef373c16b8ca4f59fb3bd88d31335f0eb40ca5537995085c6973c58f08481782202c4371af0db57ae022f75470e547d872833005
+  data.tar.gz: 42b22d628d97405b95c96b51fd7dee0c5b013682f7e482b5792ded5570d09cc97e0bd76d7cf08c922b87cc985d508a5e7af33df64341b9822c49b53f197d54a9

data/bin/kerbi

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "kerbi"
+Kerbi::Cli::RootHandler.start(ARGV)

data/boilerplate/Gemfile.erb

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby '<%= data[:ruby_version] %>'
+
+gem 'kerbi'

data/boilerplate/kerbifile.rb.erb

@@ -0,0 +1,9 @@
+module <%= (module_name = data[:user_module_name]) %>
+  class RootMixer < Kerbi::Mixer
+    def mix
+      push dict(hello: values[:message])
+    end
+  end
+end
+
+Kerbi::Globals.mixers << <%= module_name %>::RootMixer

data/boilerplate/values.yaml.erb

@@ -0,0 +1 @@
+message: "default message"

data/lib/cli/base.rb

@@ -0,0 +1,83 @@
+module Kerbi
+  module Cli
+
+    ##
+    # Superclass for all Thor CLI handlers.
+    class BaseHandler < Thor
+
+      protected
+
+      ##
+      # Convenience method for printing dicts as YAML or JSON,
+      # according to the CLI options.
+      # @param [Hash|Array<Hash>] dicts
+      def print_dicts(dicts)
+        if self.cli_opts.outputs_yaml?
+          printable_str = Kerbi::Utils::Cli.dicts_to_yaml(dicts)
+        elsif self.cli_opts.outputs_json?
+          printable_str = Kerbi::Utils::Cli.dicts_to_json(dicts)
+        else
+          raise "Unknown output format '#{cli_opts.output_format}'"
+        end
+        puts printable_str
+      end
+
+      ##
+      # Returns single merged dict containing all values given or
+      # pointed to by the CLI args, plus the default values.yaml file.
+      # This includes values from files, inline expressions, and the
+      # state ConfigMap.
+      # @return [Hash] symbol-keyed dict of all loaded values
+      def compile_values
+        utils = Kerbi::Utils::Values
+        file_values = utils.from_files(cli_opts.fname_exprs)
+        inline_values = utils.from_inlines(cli_opts.inline_val_exprs)
+        file_values.deep_merge(inline_values)
+      end
+
+      ##
+      # Returns a re-usable instance of the CLI-args
+      # wrapper Kerbi::CliOpts
+      # @return [Kerbi::CliOpts] re-usable instance
+      def cli_opts
+        @_options_obj ||= Kerbi::CliOpts.new(self.options)
+      end
+
+      ##
+      # Convenience class method for declaring a Thor subcommand
+      # metadata bundle, in accordance with the schema in
+      # Kerbi::Consts::OptionSchemas.
+      # @param [Hash] _schema a dict from Kerbi::Consts::OptionSchemas
+      # @param [Class<Thor>] handler_cls the handler
+      def self.thor_sub_meta(_schema, handler_cls)
+        schema = _schema.deep_dup
+        desc(schema[:name], schema[:desc])
+        subcommand schema[:name], handler_cls
+      end
+
+      ##
+      # Convenience class method for declaring a Thor command
+      # metadata bundle, in accordance with the schema in
+      # Kerbi::Consts::OptionSchemas.
+      # @param [Hash] _schema a dict from Kerbi::Consts::OptionSchemas
+      def self.thor_meta(_schema)
+        schema = _schema.deep_dup
+        desc(schema[:name], schema[:desc])
+        (schema[:options] || []).each do |opt_schema|
+          opt_key = opt_schema.delete(:key).to_sym
+          self.option opt_key, opt_schema
+        end
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      def utils
+        Kerbi::Utils
+      end
+    end
+  end
+end

data/lib/cli/project_handler.rb

@@ -0,0 +1,17 @@
+module Kerbi
+  module Cli
+    class ProjectHandler < BaseHandler
+
+      thor_meta Kerbi::Consts::CommandSchemas::NEW_PROJECT
+      def new_project(project_name)
+        generator = Kerbi::CodeGen::ProjectGenerator.new(
+          project_name: project_name,
+          ruby_version: cli_opts.ruby_version,
+          verbose: true
+        )
+        success = generator.run
+        exit(success)
+      end
+    end
+  end
+end

data/lib/cli/root_handler.rb

@@ -0,0 +1,47 @@
+module Kerbi
+
+  class Console
+    attr_reader :values
+    def initialize(values)
+      @values = values
+    end
+
+    def to_s
+      "kerbi"
+    end
+  end
+
+  module Cli
+
+    ##
+    # Top level CLI command handler with Thor.
+    class RootHandler < BaseHandler
+
+      cmd_schemas = Kerbi::Consts::CommandSchemas
+
+      thor_meta cmd_schemas::TEMPLATE
+      # @param [String] release_name helm-like Kubernetes release name
+      # @param [String] path root dir from which to search for kerbifile.rb
+      def template(release_name, path)
+        utils::Cli.load_kerbifile(path)
+        values = self.compile_values
+        mixer_classes = Kerbi::Globals.mixers
+        res_dicts = utils::Cli.run_mixers(mixer_classes, values, release_name)
+        print_dicts(res_dicts)
+      end
+
+      thor_meta cmd_schemas::CONSOLE
+      def console
+        utils::Cli.load_kerbifile(".")
+        values = self.compile_values
+        ARGV.clear
+        IRB.setup(eval("__FILE__"), argv: [])
+        workspace = IRB::WorkSpace.new(Console.new(values))
+        IRB::Irb.new(workspace).run(IRB.conf)
+      end
+
+      thor_sub_meta cmd_schemas::VALUES_SUPER, ValuesHandler
+      thor_sub_meta cmd_schemas::PROJECT_SUPER, ProjectHandler
+    end
+  end
+end

data/lib/cli/values_handler.rb

@@ -0,0 +1,11 @@
+module Kerbi
+  module Cli
+    class ValuesHandler < BaseHandler
+      thor_meta Kerbi::Consts::CommandSchemas::SHOW_VALUES
+      def show
+        values = self.compile_values
+        print_dicts(values)
+      end
+    end
+  end
+end

data/lib/config/cli_opts.rb

@@ -0,0 +1,50 @@
+module Kerbi
+
+  ##
+  # Convenience accessor struct for getting values from
+  # the CLI args.
+  class CliOpts
+
+    attr_reader :options
+
+    def initialize(options={})
+      @options = options.deep_dup
+    end
+
+    def output_format
+      value = options[consts::OUTPUT_FMT]
+      value || "yaml"
+    end
+
+    def outputs_yaml?
+      self.output_format == 'yaml'
+    end
+
+    def outputs_json?
+      self.output_format == 'json'
+    end
+
+    def ruby_version
+      options[consts::RUBY_VER]
+    end
+
+    def fname_exprs
+      options[consts::VALUE_FNAMES] || []
+    end
+
+    def inline_val_exprs
+      options[consts::INLINE_ASSIGNMENT] || []
+    end
+
+    def use_state?
+      options[consts::USE_STATE_VALUES].present?
+    end
+
+    private
+
+    def consts
+      Kerbi::Consts::OptionKeys
+    end
+
+  end
+end

data/lib/config/cli_schema.rb

@@ -0,0 +1,104 @@
+module Kerbi
+  module Consts
+
+    module OptionKeys
+      OUTPUT_FMT = "output"
+      INLINE_ASSIGNMENT = "inline-value"
+      VALUE_FNAMES = "values-file"
+      USE_STATE_VALUES = "use-state-values"
+      RUBY_VER = "ruby-version"
+      VERBOSE = "verbose"
+    end
+
+    module OptionSchemas
+      OUTPUT_FMT = {
+        key: OptionKeys::OUTPUT_FMT,
+        desc: "Specify YAML or JSON. Defaults to YAML",
+        enum: %w[yaml json]
+      }
+
+      USE_STATE_VALUES = {
+        key: OptionKeys::USE_STATE_VALUES,
+        desc: "If true, merges in values loaded from state ConfigMap",
+        type: "boolean"
+      }
+
+      INLINE_ASSIGNMENT = {
+        key: OptionKeys::INLINE_ASSIGNMENT,
+        aliases: "--set",
+        desc: "An inline variable assignment, e.g --set x.y=foo --set x.z=bar",
+        repeatable: true
+      }
+
+      VALUE_FNAMES = {
+        key: OptionKeys::VALUE_FNAMES,
+        aliases: "-f",
+        desc: "Name of a values file to be loaded.",
+        repeatable: true
+      }
+
+      RUBY_VER = {
+        key: OptionKeys::RUBY_VER,
+        desc: "Specify ruby version for Gemfile in a new project"
+      }
+
+      VERBOSE = {
+        key: OptionKeys::VERBOSE,
+        desc: "Run in verbose mode",
+        enum: %w[true false]
+      }
+    end
+
+    module CommandSchemas
+
+      VALUES_SUPER = {
+        name: "values",
+        desc: "Command group for values actions: show, get"
+      }
+
+      PROJECT_SUPER = {
+        name: "project",
+        desc: "Command group for project actions: new, info"
+      }
+
+      TEMPLATE = {
+        name: "template [KERBIFILE] [RELEASE_NAME]",
+        desc: "Runs mixers for RELEASE_NAME",
+        options: [
+          OptionSchemas::OUTPUT_FMT,
+          OptionSchemas::VALUE_FNAMES,
+          OptionSchemas::INLINE_ASSIGNMENT
+        ]
+      }
+
+      CONSOLE = {
+        name: "console",
+        desc: "Opens an IRB console so you can play with your mixers",
+        options: [
+          OptionSchemas::VALUE_FNAMES,
+          OptionSchemas::INLINE_ASSIGNMENT
+        ]
+      }
+
+      NEW_PROJECT = {
+        name: "new",
+        desc: "Create a new directory with boilerplate files",
+        options: [
+          OptionSchemas::RUBY_VER,
+          OptionSchemas::VERBOSE
+        ]
+      }
+
+      SHOW_VALUES = {
+        name: "show",
+        desc: "Print out loaded values as YAML",
+        options: [
+          OptionSchemas::OUTPUT_FMT,
+          OptionSchemas::VALUE_FNAMES,
+          OptionSchemas::INLINE_ASSIGNMENT
+        ]
+      }
+    end
+  end
+end
+

data/lib/config/globals.rb

@@ -0,0 +1,7 @@
+module Kerbi
+  module Globals
+    def self.mixers
+      $_mixers ||= []
+    end
+  end
+end

data/lib/config/manager.rb

@@ -0,0 +1,36 @@
+module Kerbi
+  module Config
+    class Manager
+      attr_reader :bundle
+
+      def initialize
+        # TODO load me from filesystem
+        @bundle = {
+          tmp_helm_values_path: '/tmp/kerbi-helm-vals.yaml',
+          helm_exec: "helm"
+        }
+      end
+
+      def self.inst
+        # TODO create ~/.config/kerbi etc...
+        @_instance ||= self.new
+      end
+
+      def self.tmp_helm_values_path
+        inst.bundle[:tmp_helm_values_path]
+      end
+
+      def self.helm_exec
+        inst.bundle[:helm_exec]
+      end
+
+      def self.tmp_helm_values_path=(val)
+        inst.bundle[:tmp_helm_values_path] = val
+      end
+
+      def self.helm_exec=(val)
+        inst.bundle[:helm_exec] = val
+      end
+    end
+  end
+end

data/lib/kerbi.rb

@@ -0,0 +1,43 @@
+##
+# Loads all dependencies for all Kerbi code.
+#
+require 'erb'
+require "irb"
+require 'open3'
+require "http"
+require 'json'
+require 'yaml'
+require "thor"
+require "base64"
+require 'optparse'
+require 'colorize'
+
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/deep_dup'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/indent.rb'
+
+require_relative './utils/misc'
+
+require_relative './config/cli_schema'
+require_relative './config/manager'
+require_relative './config/globals'
+require_relative './config/cli_opts'
+
+require_relative './mixins/mixer'
+
+require_relative './utils/mixing'
+require_relative './utils/helm'
+require_relative './utils/kubectl'
+require_relative './utils/cli'
+require_relative './utils/values'
+require_relative './main/code_gen'
+
+require_relative './cli/base'
+require_relative './cli/values_handler'
+require_relative './cli/project_handler'
+require_relative './cli/root_handler'
+require_relative './main/mixer'

data/lib/main/code_gen.rb

@@ -0,0 +1,131 @@
+module Kerbi
+  module CodeGen
+    class ProjectGenerator
+
+      ERB_EXT = ".erb"
+      BOILER_REL_PATH = "/../../boilerplate"
+
+      ##
+      # Serves as both the new project's dir name and the mixer's _module name
+      attr_accessor :project_name
+
+      ##
+      # Mostly for testing, uses this dir as root instead of Dir.pwd
+      attr_accessor :root_dir
+
+      ##
+      # Optional ruby version to use in the Gemfile
+      attr_accessor :ruby_version
+
+      ##
+      # Print as you go?
+      attr_accessor :verbose
+
+      ##
+      # Set accessors, no other side effects.
+      def initialize(params={})
+        self.project_name = params[:project_name]
+        self.root_dir = params[:root_dir]
+        self.ruby_version = params[:ruby_version]
+        self.verbose = params[:verbose]
+      end
+
+      ##
+      # Creates a new directory, writes new interpolated files to it.
+      def run
+        return false unless create_dir
+        self.class.boiler_file_abs_paths.each do |src_name, src_path|
+          process_file(src_name, src_path)
+        end
+        true
+      end
+
+      def create_dir
+        begin
+          Dir.mkdir(new_dir_path)
+          print_created('Created project at', new_dir_path)
+          true
+        rescue Errno::EEXIST
+          message = "Error dir already exists: #{new_dir_path}"
+          $stderr.puts message.colorize(:red)
+        end
+      end
+
+      ## Root function for processing a single file, e.g reading its
+      # original un-interpolated form, interpolating it, and finally
+      # writing the new content to destination directory.
+      # @param [String] src_file_name src file name w/o path e.g Gemfile.erb
+      # @param [String] src_file_path src file name including abs path
+      def process_file(src_file_name, src_file_path)
+        data = generate_data
+        new_file_content = self.class.interpolate_file(src_file_path, data)
+        new_file_path = mk_dest_path(src_file_name)
+        File.write(new_file_path, new_file_content)
+        print_file_processed(src_file_name)
+      end
+
+      def print_file_processed(src_file_name)
+        pretty_fname = "#{self.class.src_to_dest_file_name(src_file_name)}"
+        pretty_name = "#{project_name}/#{pretty_fname}"
+        self.print_created("Created file", pretty_name)
+      end
+
+      #noinspection RubyResolve
+      def print_created(bold_part, colored_part)
+        return unless verbose
+        puts "#{bold_part.bold} #{colored_part.colorize(:blue)}"
+      end
+
+      ##
+      # Returns a dict with all the key value assignments the ERBs
+      # need to do their work.
+      # @return [Hash{Symbol->String}] data bundle for interpolation
+      def generate_data
+        module_name = project_name.underscore.classify
+        version = ruby_version || RUBY_VERSION
+        {
+          user_module_name: module_name,
+          ruby_version: version
+        }
+      end
+
+      ##
+      # Generates absolute path of destination file based on filename
+      # of source file. E.g Gemfile.erb -> /home/foo/Gemfile
+      # @param [String] src_file_name src file name w/o path e.g Gemfile.erb
+      # @return [String] E.g Gemfile.erb -> /home/foo/Gemfile
+      def mk_dest_path(src_file_name)
+        new_fname = self.class.src_to_dest_file_name(src_file_name)
+        "#{new_dir_path}/#{new_fname}"
+      end
+
+      def self.src_to_dest_file_name(src_file_name)
+        src_file_name[0..-(ERB_EXT.length + 1)]
+      end
+
+      ## Returns the absolute path of the new project directory
+      # based on the constructor arguments
+      # @return [String] e.g /home/john/hello-kerbi
+      def new_dir_path
+        "#{root_dir || Dir.pwd}/#{project_name}"
+      end
+
+      def self.boiler_file_abs_paths
+        boiler_dir_path = "#{__dir__}#{BOILER_REL_PATH}"
+
+        is_boiler = ->(fname) { fname.end_with?(ERB_EXT) }
+        to_abs = ->(fname) { "#{boiler_dir_path}/#{fname}" }
+
+        boiler_fnames = Dir.entries(boiler_dir_path)
+        actual_fnames = boiler_fnames.select(&is_boiler)
+        Hash[actual_fnames.map { |f| [f, to_abs[f]] }]
+      end
+
+      def self.interpolate_file(src_path, data)
+        contents = File.read(src_path)
+        binding.local_variable_set(:data, data)
+        ERB.new(contents).result(binding)
+      end
+    end
+  end
+end