kerbi 0.0.1

data/spec/utils/helm_spec.rb

@@ -0,0 +1,114 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::Utils::Helm do
+
+  subject { Kerbi::Utils::Helm }
+
+  def find_res(hashes, kind, name)
+    hashes.find do |hash|
+      hash['kind'] == kind && hash['metadata']['name'] == name
+    end
+  end
+
+  let :config do
+    Kerbi::Config::Manager
+  end
+
+  before(:each) do
+    # config.helm_exec = 'helm'
+  end
+
+  describe '.template' do
+    let(:repo_org) { "jetstack" }
+    let(:repo_url) { "https://charts.jetstack.io" }
+    let(:chart) { "#{repo_org}/cert-manager" }
+    let :values do
+      {
+        cainjector: {
+          serviceAccount: {
+            automountServiceAccountToken: "foo"
+          }
+        }
+      }
+    end
+
+    before :each do
+      system("helm repo add #{repo_org} #{repo_url}")
+    end
+
+    context 'with existing chart' do
+      it 'returns the templated yaml string' do
+        res_dicts = subject.template('kerbi', chart, values: values)
+        expect(res_dicts.class).to eq(Array)
+        expect(res_dicts.count).to be_within(40).of(40)
+      end
+    end
+
+    it 'cleans up' do
+      subject.template('kerbi', chart)
+      expect(File.exists?(config.tmp_helm_values_path)).to be_falsey
+    end
+  end
+
+  describe '.encode_inline_assigns' do
+    context 'when assignments are flat' do
+      it 'returns the right string' do
+        #noinspection SpellCheckingInspection
+        actual = subject.encode_inline_assigns(
+          'bar': 'bar',
+          'foo.bar': 'foo.bar'
+        )
+        expected = "--set bar=bar --set foo.bar=foo.bar"
+        expect(actual).to eq(expected)
+      end
+    end
+
+    context 'when values are nested' do
+      it 'raises an runtime error' do
+        expect do
+          subject.encode_inline_assigns('bar': { foo: 'bar'})
+        end.to raise_error("Assignments must be flat")
+      end
+    end
+  end
+
+  describe ".make_tmp_values_file" do
+    it 'creates the tmp file with yaml and returns the path' do
+      path = subject.make_tmp_values_file(foo: 'bar')
+      expect(YAML.load_file(path)).to eq('foo' => 'bar')
+    end
+  end
+
+  describe '.del_tmp_values_file' do
+    context 'when the file exists' do
+      it 'delete the file' do
+        path = subject.make_tmp_values_file(foo: 'bar')
+        expect(File.exists?(path)).to be_truthy
+        subject.del_tmp_values_file
+        expect(File.exists?(path)).to be_falsey
+      end
+    end
+
+    context 'when the file does not exist' do
+      it 'does not raise an error' do
+        subject.del_tmp_values_file
+      end
+    end
+  end
+
+  describe '#can_exec?' do
+    context 'exec working' do
+      it 'returns true' do
+        config.helm_exec = 'helm'
+        expect(subject.can_exec?).to eq(true)
+      end
+    end
+
+    context '.exec not working' do
+      it 'returns false' do
+        config.helm_exec = 'not-helm'
+        expect(subject.can_exec?).to eq(false)
+      end
+    end
+  end
+end

data/spec/utils/misc_utils_spec.rb

@@ -0,0 +1,22 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::Utils::Misc do
+
+  subject { Kerbi::Utils::Misc }
+
+  describe ".flatten_hash" do
+    context 'with an already flat hash' do
+      it 'returns the same hash' do
+        actual = subject.flatten_hash({foo: 'bar'})
+        expect(actual).to eq({foo: 'bar'})
+      end
+    end
+
+    context 'with a deep hash' do
+      it 'returns a flat hash with deep keys' do
+        actual = subject.flatten_hash({foo: { bar: 'baz' }})
+        expect(actual).to eq({'foo.bar': 'baz'})
+      end
+    end
+  end
+end

data/spec/utils/mixing_utils_spec.rb

@@ -0,0 +1,209 @@
+require_relative './../spec_helper'
+
+class TestObj
+  def get_binding
+    binding
+  end
+
+  def values
+    {k1: "baz"}
+  end
+end
+
+RSpec.describe Kerbi::Utils::Mixing do
+
+  subject { Kerbi::Utils::Mixing }
+
+  describe ".erb_str_to_dicts" do
+    describe 'logic unrelated to filtering' do
+      let(:yaml_str) { "k1: <%=extras[:k1]%>\n---\nk1: bar" }
+      it 'returns the correct list of hashes' do
+        actual = subject.yaml_str_to_dicts(
+          yaml_str,
+          extras: {k1: "foo"}
+        )
+        expect(actual).to match_array([{k1: 'foo'}, {k1: 'bar'}])
+      end
+    end
+  end
+
+  describe '.erb_file_to_dicts' do
+    context "with well formatted files" do
+      let(:fname) { "foo.yaml.erb" }
+
+      before(:each) do
+        Kerbi::Testing.reset_test_yamls_dir
+        Kerbi::Testing.make_yaml(fname, "k: <%= extras[:foo] %>")
+      end
+
+      it 'outputs the correct list of hashes' do
+        result = subject.yaml_file_to_dicts(
+          Kerbi::Testing.f_fname(fname),
+          extras: { foo: "bar" }
+        )
+        expect(result).to eq([{k: 'bar'}])
+      end
+    end
+  end
+
+  describe ".yamls_in_dir_to_dicts" do
+    let(:fname1) { "a.yaml.erb" }
+    let(:fname2) { "b.yaml" }
+    let(:pwd) { Kerbi::Testing::TEST_YAMLS_DIR }
+    let(:expected) { [{bar: "car"}, {foo: "bar"}, {bar: "baz"}] }
+
+    before :each do
+      Kerbi::Testing::reset_test_yamls_dir
+      Kerbi::Testing.make_yaml(fname1, "foo: bar\n---\nbar: <%= extras[:a] %>")
+      Kerbi::Testing.make_yaml(fname2, "bar: car")
+    end
+
+    context "without a subdirectory" do
+      it "works" do
+        result = subject.yamls_in_dir_to_dicts(
+          pwd,
+          nil,
+          extras: { a: "baz" }
+        )
+        expect(result).to match_array(expected)
+      end
+    end
+  end
+
+  describe ".interpolate_erb_string" do
+    context "passing a nil source binding" do
+
+      let(:yaml_str) { "\nfoo: \"<%=extras[:k1]%>\"\n---\nbar: \"bar\"\n" }
+      let(:exp_yaml_str) { "\nfoo: \"foo\"\n---\nbar: \"bar\"\n" }
+
+      context "correctly referencing variables" do
+        it "works normally" do
+          result = subject.interpolate_erb_string(
+            yaml_str,
+            extras: {k1: "foo"}
+          )
+          expect(result).to eq(exp_yaml_str)
+        end
+      end
+
+      context "mistakenly referencing unavailable variables" do
+        let(:yaml_str) { "k1: <%=dne%>\n---\nk1: bar" }
+        it "raises a normal NameError" do
+          expect do
+            subject.interpolate_erb_string(yaml_str)
+          end.to raise_error(NameError)
+        end
+      end
+    end
+
+    context "passing a non-nil source binding" do
+      let(:yaml_str) { "k1: \"<%=values[:k1]%>\"\n---\nk1: bar" }
+      let(:exp_result) { "k1: \"baz\"\n---\nk1: bar" }
+      it "uses the binding correctly" do
+        result = subject.interpolate_erb_string(
+          yaml_str,
+          src_binding: TestObj.new.get_binding,
+        )
+        expect(result).to eq(exp_result)
+      end
+    end
+  end
+
+  describe ".yamls_in_dir_to_dicts" do
+
+  end
+
+  describe ".str_cmp" do
+    context "when it should be true" do
+      it "returns true" do
+        expect(subject.str_cmp("Pod", "Pod")).to eq(true)
+        expect(subject.str_cmp("Po.*", "Pod")).to eq(true)
+      end
+    end
+    context "when it should be false" do
+      it "returns false" do
+        expect(subject.str_cmp("Pods", "Pod")).to eq(false)
+        expect(subject.str_cmp("Po", "Pod")).to eq(false)
+      end
+    end
+
+  end
+
+  describe ".res_dict_matches_rule?" do
+    let :res_dict do
+      {kind: "Pod", metadata: {name: "foo"}}
+    end
+
+    context "when it should be true" do
+      it "returns true" do
+        func = -> (*args) { subject.res_dict_matches_rule?(*args) }
+        expect(func[res_dict, {kind: "Pod"}]).to be_truthy
+        expect(func[res_dict, {kind: "Po.*"}]).to be_truthy
+        expect(func[res_dict, {kind: ".*"}]).to be_truthy
+
+        expect(func[res_dict, {name: "foo"}]).to be_truthy
+        expect(func[res_dict, {name: "fo[o|a]"}]).to be_truthy
+
+        expect(func[res_dict, {kind: "Pod", name: ""}]).to be_truthy
+        expect(func[res_dict, {kind: ".*", name: "foo"}]).to be_truthy
+        expect(func[res_dict, {kind: "P.*", name: "fo[o|a]"}]).to be_truthy
+      end
+    end
+
+    context "when it should be false" do
+      it "returns false" do
+        func = -> (*args) { subject.res_dict_matches_rule?(*args) }
+        expect(func[res_dict, {kind: "Pods"}]).to be_falsey
+        expect(func[res_dict, {kind: "Po"}]).to be_falsey
+        expect(func[res_dict, {kind: "Pod", name: "bar"}]).to be_falsey
+        expect(func[res_dict, {kind: ".*", name: "fo[b|a]"}]).to be_falsey
+      end
+    end
+  end
+
+  let :dirty_res_dicts do
+    [
+      {kind: "PersistentVolume", metadata: { name: "pv" }},
+      {kind: "PersistentVolumeClaim", metadata: { name: "pvc" }},
+      {kind: "Pod", metadata: { name: "pod" }}
+    ].map(&:stringify_keys)
+  end
+
+  let(:clean_res_dicts) { dirty_res_dicts.map(&:deep_symbolize_keys) }
+  let(:white_rules) { [{kind: "PersistentVolume.*"}] }
+  let(:black_rules) { [{name: "pvc"}] }
+
+  describe ".select_res_dicts_blacklist" do
+    it "excludes the res dicts that match the rule" do
+      result = subject.select_res_dicts_blacklist(dirty_res_dicts, black_rules)
+      expect(result).to match_array([clean_res_dicts[0], clean_res_dicts[2]])
+    end
+  end
+
+  describe ".select_res_dicts_blacklist" do
+    it "excludes the res dicts that do not match the rule" do
+      result = subject.select_res_dicts_whitelist(dirty_res_dicts, white_rules)
+      expect(result).to eq(clean_res_dicts[0..1])
+    end
+  end
+
+  describe ".clean_and_filter_hashes" do
+    context "without any filtering" do
+      it "returns the res_dicts unchanged and symbolized" do
+        result = subject.clean_and_filter_dicts(dirty_res_dicts)
+        expect(result).to eq(clean_res_dicts)
+      end
+    end
+
+    context "with white and black rules" do
+      it "returns the res_dicts filtered and symbolized" do
+        result = subject.clean_and_filter_dicts(
+          dirty_res_dicts,
+          white_rules: white_rules,
+          black_rules: black_rules
+        )
+        expect(result).to eq(clean_res_dicts[0..0])
+      end
+    end
+  end
+end

data/spec/utils/state_utils.rb

@@ -0,0 +1,15 @@
+module Kerbi
+  module Utils
+    module State
+      def self.kubectl_get_cm(res_name, opts={})
+        kmd = "get configmap #{res_name} #{opts[:kubectl_args]}"
+        Utils::Kubectl.jkmd(kmd, **opts)
+      end
+
+      def self.read_cm_data(configmap)
+        json_enc_vars = configmap.dig(:data, :variables) || '{}'
+        JSON.parse(json_enc_vars).deep_symbolize_keys
+      end
+    end
+  end
+end

data/spec/utils/values_utils_spec.rb

@@ -0,0 +1,146 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::Utils::Values do
+
+  subject { Kerbi::Utils::Values }
+  let(:root) { Kerbi::Testing::TEST_YAMLS_DIR }
+  before(:each) { Kerbi::Testing.reset_test_yamls_dir }
+
+  describe ".resolve_fname_expr" do
+    def func(*args, **kwargs)
+      subject.resolve_fname_expr(*args, **kwargs, root: root)
+    end
+
+    context "when the expression can be resolved" do
+      context "when the filename is an exact match" do
+        before :each do
+          Kerbi::Testing.make_yaml("x", "n/a")
+          Kerbi::Testing.make_yaml("x.yaml", "n/a")
+          Kerbi::Testing.make_yaml("x.yaml.erb", "n/a")
+        end
+        it "returns that file instead over similar ones" do
+          expect(func("x")).to eq("#{root}/x")
+          expect(func("x.yaml")).to eq("#{root}/x.yaml")
+          expect(func("x.yaml.erb")).to eq("#{root}/x.yaml.erb")
+        end
+      end
+
+      context "when the filename is not an exact match" do
+        before :each do
+          Kerbi::Testing.make_yaml("y.yaml", "n/a")
+          Kerbi::Testing.make_yaml("y.yaml.erb", "n/a")
+        end
+
+        it "returns the closes match" do
+          expect(func("y")).to eq("#{root}/y.yaml")
+          Kerbi::Testing.del_testfile("y.yaml")
+          expect(func("y")).to eq("#{root}/y.yaml.erb")
+        end
+      end
+    end
+
+    context "when the expression cannot be resolved" do
+      it "returns nil" do
+        expect(func("dne")).to be_nil
+      end
+    end
+  end
+
+  describe ".resolve_fname_exprs" do
+
+    def func(*args, **kwargs)
+      subject.resolve_fname_exprs(*args, **kwargs, root: root)
+    end
+
+    before :each do
+      Kerbi::Testing.make_yaml("x.yaml", "n/a")
+      Kerbi::Testing.make_yaml("y.yaml", "n/a")
+    end
+
+    context "with no missing files and values present" do
+      let(:expected) { %W[#{root}/values.yaml #{root}/x.yaml ] }
+
+      it "returns the expect list of final paths" do
+        Kerbi::Testing.make_yaml("values.yaml", "n/a")
+        expect(func(["x.yaml"])).to eq(expected)
+      end
+    end
+
+    context "with no missing file other than 'values'" do
+      it "returns the expect list of final paths" do
+        expect(func(["x.yaml"])).to eq(["#{root}/x.yaml"])
+        expect(func(%w[x.yaml x])).to eq(["#{root}/x.yaml"])
+      end
+    end
+
+    context "with a missing file other than 'values'" do
+      it "raises an exception" do
+        expect{ func(["dne"]) }.to raise_exception(Exception)
+      end
+    end
+  end
+
+  describe ".parse_inline_assignment" do
+    def func(expr)
+      subject.parse_inline_assignment(expr)
+    end
+
+    context "a malformed expression" do
+      it "raises an exception" do
+        expect { func("foo=") }.to raise_error(Exception)
+        expect { func("foo:bar") }.to raise_error(Exception)
+        expect { func("=bar") }.to raise_error(Exception)
+        expect { func("=") }.to raise_error(Exception)
+        expect { func("none") }.to raise_error(Exception)
+      end
+    end
+
+    context "a well formed expression" do
+      it "outputs a symbol-keyed dict" do
+        expect(func("foo=bar")).to eq({foo: "bar"})
+        expect(func("foo.bar=baz")).to eq({foo: { bar: "baz" }})
+      end
+    end
+  end
+
+  describe ".from_inlines" do
+    def func(*args, **kwargs)
+      subject.from_inlines(*args, **kwargs)
+    end
+
+    it "parses and deep merges the expressions" do
+      result = func(%w[foo=bar foo.bar=baz bar=foo])
+      expect(result).to eq({foo: {bar: "baz"}, bar: "foo"})
+    end
+  end
+
+  describe ".load_yaml_files" do
+
+    def func(*args, **kwargs)
+      subject.load_yaml_files(*args, **kwargs)
+    end
+
+    before :each do
+      Kerbi::Testing.make_yaml("x.yaml", "x: y")
+      Kerbi::Testing.make_yaml("y.yaml", "y: z")
+    end
+
+    it "loads and merges the values from the given files" do
+      result = func(%W[#{root}/x.yaml #{root}/y.yaml])
+      expect(result).to eq(x: 'y', y: 'z')
+    end
+  end
+
+  describe ".load_yaml_file" do
+    context "with a valid yaml ERB file" do
+      let(:yaml_content) { "foo: <%=b64enc('foo') %>" }
+      it "loads, interpolates, and outputs an array of dicts" do
+        fname = Kerbi::Testing.make_yaml("x.yaml", yaml_content)
+        expect(subject.load_yaml_file(fname)).to eq(foo: "Zm9v")
+      end
+    end
+    context "with an invalid yaml ERB file" do
+      let(:yaml_content) { "foo: <%=b64enc('foo') %>\n---\nfoo: bar" }
+    end
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: kerbi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Xavier Millot
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: Kerbi is a multi-strategy Kubernetes manifest templating engine.
+email: xavier@nmachine.io
+executables:
+- kerbi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/kerbi
+- boilerplate/Gemfile.erb
+- boilerplate/kerbifile.rb.erb
+- boilerplate/values.yaml.erb
+- lib/cli/base.rb
+- lib/cli/project_handler.rb
+- lib/cli/root_handler.rb
+- lib/cli/values_handler.rb
+- lib/config/cli_opts.rb
+- lib/config/cli_schema.rb
+- lib/config/globals.rb
+- lib/config/manager.rb
+- lib/kerbi.rb
+- lib/main/code_gen.rb
+- lib/main/mixer.rb
+- lib/main/state_manager.rb
+- lib/mixins/mixer.rb
+- lib/utils/cli.rb
+- lib/utils/helm.rb
+- lib/utils/kubectl.rb
+- lib/utils/misc.rb
+- lib/utils/mixing.rb
+- lib/utils/values.rb
+- spec/fixtures/embedding.yaml.erb
+- spec/main/examples_spec.rb
+- spec/main/mixer_spec.rb
+- spec/main/project_code_gen_spec.rb
+- spec/main/state_manager_spec.rb
+- spec/mixins/mixer_mixin_spec.rb
+- spec/spec_helper.rb
+- spec/utils/helm_spec.rb
+- spec/utils/misc_utils_spec.rb
+- spec/utils/mixing_utils_spec.rb
+- spec/utils/state_utils.rb
+- spec/utils/values_utils_spec.rb
+homepage: https://nmachine-io.github.io/kerbi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Multi-strategy Kubernetes manifest templating engine.
+test_files:
+- spec/spec_helper.rb
+- spec/mixins/mixer_mixin_spec.rb
+- spec/main/mixer_spec.rb
+- spec/main/project_code_gen_spec.rb
+- spec/main/state_manager_spec.rb
+- spec/main/examples_spec.rb
+- spec/fixtures/embedding.yaml.erb
+- spec/utils/helm_spec.rb
+- spec/utils/state_utils.rb
+- spec/utils/values_utils_spec.rb
+- spec/utils/mixing_utils_spec.rb
+- spec/utils/misc_utils_spec.rb