kerbi 0.0.1

data/lib/utils/mixing.rb

@@ -0,0 +1,181 @@
+module Kerbi
+  module Utils
+    module Mixing
+
+      ##
+      # Parses and interpolates YAML or JSON dicts and outputs
+      # their symbol-keyed Hash forms.
+      # @param [String] yaml_str plain yaml, json, or erb string
+      # @param [Hash] extras additional hash passed to ERB
+      # @return [Array<Hash>] list of inflated dicts
+      def self.yaml_str_to_dicts(yaml_str, opts={})
+        interpolated_yaml = self.interpolate_erb_string(yaml_str, **opts)
+        hashes = YAML.load_stream(interpolated_yaml)
+        self.clean_and_filter_dicts(hashes, **opts)
+      end
+
+      ##
+      # Loads a YAML/JSON/ERB file, parses it, interpolates it,
+      # and returns the resulting dicts.
+      # @param [String] fname simplified or absolute path of file
+      # @param [Hash] extras additional hash passed to ERB
+      # @return [Array<Hash>] list of res-hashes
+      def self.yaml_file_to_dicts(fname, opts={})
+        contents = File.read(fname)
+        begin
+          self.yaml_str_to_dicts(contents, **opts)
+        rescue Exception => e
+          STDERR.puts "Exception below from file #{fname}"
+          raise e
+        end
+      end
+
+      ##
+      # Performs ERB interpolation on an ERB string, and returns
+      # the interpolated string.
+      # @param [String] yaml_str contents of a yaml or yaml.erb
+      # @param [Hash] opts an additional hash available to ERB
+      # @return [String] the interpolated string
+      def self.interpolate_erb_string(yaml_str, opts={})
+        final_binding = opts[:src_binding] || binding
+        final_binding.local_variable_set(:extras, opts[:extras] || {})
+        ERB.new(yaml_str).result(final_binding)
+      end
+
+      ##
+      # Loads, interpolates, and parses all dicts found in all YAML/JSON/ERB
+      # files in a given directory.
+      # @param [String] dir relative or absolute path of the directory
+      # @param [Array<String>] file_blacklist list of filenames to avoid
+      # @return [Array<Hash>] array of processed dicts
+      def self.yamls_in_dir_to_dicts(pwd, dir, opts={})
+        file_blacklist = opts.delete(:file_blacklist)
+        blacklist = file_blacklist || []
+
+        dir ||= pwd
+        dir = "#{pwd}/#{dir}" if dir && pwd && dir.start_with?(".")
+        yaml_files = Dir["#{dir}/*.yaml"]
+        erb_files = Dir["#{dir}/*.yaml.erb"]
+
+        (yaml_files + erb_files).map do |fname|
+          is_blacklisted = blacklist.include?(File.basename(fname))
+          unless is_blacklisted
+            self.yaml_file_to_dicts(fname, **opts)
+          end
+        end.compact.flatten
+      end
+
+      ##
+      # Turns hashes into symbol-keyed hashes,
+      # and applies white/blacklisting based on filters supplied
+      # @param [Array<Hash>] dicts list of inflated hashes
+      # @param [Array<String>] white_rules list/single k8s res ID to whitelist
+      # @param [Array<String>] black_rules list/single  k8s res ID to blacklist
+      # @return [Array<Hash>] list of clean and filtered hashes
+      def self.clean_and_filter_dicts(dicts, opts={})
+        white_rules = opts[:white_rules] || opts[:only]
+        black_rules = opts[:black_rules] || opts[:except]
+        _dicts = self.hash_to_cloned_hashes(dicts)
+        _dicts = _dicts.compact.map(&:deep_symbolize_keys).to_a
+        _dicts = self.select_res_dicts_whitelist(_dicts, white_rules)
+        _dicts = self.select_res_dicts_blacklist(_dicts, black_rules)
+        self.sanitize_res_dict_list(_dicts)
+      end
+
+      def self.sanitize_res_dict_list(res_dicts)
+        pushable_list = nil
+        if res_dicts.is_a?(Array)
+          pushable_list = res_dicts
+        elsif res_dicts.is_a?(Hash)
+          pushable_list = [res_dicts]
+        end
+
+        if pushable_list.present?
+          #noinspection RubyNilAnalysis
+          pushable_list.select do |item|
+            item.present? && item.is_a?(Hash)
+          end.map(&:deep_symbolize_keys).compact
+        else
+          []
+        end
+      end
+
+      ##
+      # @return [Array<Hash>] list of clean and filtered hashes
+      def self.hash_to_cloned_hashes(hashes)
+        if !hashes.is_a?(Array)
+          [hashes]
+        else
+          hashes
+        end
+      end
+
+      ##
+      # Returns res dicts that match one or more rules
+      # @param [Array<Hash>] res_dicts k8s res-hashes
+      # @param [Array<String>] rule_dicts list of simple k8s res-ids by which to filter
+      # @return [Array<Hash>] list of clean and filtered hashes
+      def self.select_res_dicts_whitelist(res_dicts, rule_dicts)
+        _res_dicts = res_dicts.compact.map(&:deep_symbolize_keys).to_a
+        return _res_dicts if (rule_dicts || []).compact.empty?
+        _res_dicts.select do |res_dict|
+          rule_dicts.any? do |rule_dict|
+            self.res_dict_matches_rule?(res_dict, rule_dict)
+          end
+        end
+      end
+
+      ##
+      # Returns res dicts that match zero rules
+      # @param [Array<Hash>] res_dicts k8s res-hashes
+      # @param [Array<String>] rule_dicts list of simple k8s res-ids by which to filter
+      # @return [Array<Hash>] list of clean and filtered hashes
+      def self.select_res_dicts_blacklist(res_dicts, rule_dicts)
+        _res_dicts = res_dicts.compact.map(&:deep_symbolize_keys).to_a
+        return _res_dicts if (rule_dicts || []).compact.empty?
+        _res_dicts.reject do |res_dict|
+          rule_dicts.any? do |rule_dict|
+            self.res_dict_matches_rule?(res_dict, rule_dict)
+          end
+        end
+      end
+
+      ##
+      # Checks whether a dict, assumed to be a Kubernetes resource,
+      # matches a kerbi resource selection rule.
+      # @param [Hash] res_dict the Kubernetes-style resource dict
+      # @param [Hash] rule_dict the kerbi resource selector dict
+      # @return [TrueClass, FalseClass] true if the selector selects the resource
+      def self.res_dict_matches_rule?(res_dict, rule_dict)
+        return false unless res_dict.is_a?(Hash)
+        return false unless res_dict.present?
+
+        return false unless rule_dict.is_a?(Hash)
+        return false unless rule_dict.present?
+
+        target_kind = rule_dict[:kind].presence
+        target_name = rule_dict[:name].presence
+        if !target_kind || self.str_cmp(target_kind, res_dict[:kind])
+          wild = !target_name || target_name == "*"
+          res_name = res_dict[:metadata]&.[](:name)
+          wild || self.str_cmp(target_name, res_name)
+        end
+      end
+
+      ##
+      # Checks whether the value matching string given in a kerbi
+      # resource selector dict matches the value of the attribute
+      # in the Kubernetes-style resource dict. Works by performing
+      # a regex check on the two values with a full stop e.g ^$.
+      # @param [String] rule_str the regex to test the candidate string
+      # @param [String] actual_str the candidate string being tested
+      # @return [TrueClass, FalseClass] true if the rule matches the input
+      def self.str_cmp(rule_str, actual_str)
+        final_regex = Regexp.new("^#{rule_str}$")
+        match_result = actual_str =~ final_regex
+        !match_result.nil?
+      end
+
+    end
+  end
+end

data/lib/utils/values.rb

@@ -0,0 +1,133 @@
+module Kerbi
+  module Utils
+    ##
+    # Utilities module for all value loading functionality.
+    module Values
+
+      DEFAULT_VALUE_PATH = "values"
+
+      def self.from_files(fname_exprs, **opts)
+        final_paths = resolve_fname_exprs(fname_exprs, **opts)
+        load_yaml_files(final_paths)
+      end
+
+      ##
+      # Resolves each filename expression given, returning an array
+      # of absolute paths. Automatically prepends the default values filename
+      # - values.yaml - to the list and does not complain if it does not exist.
+      # If two or more filename expressions resolve to the same absolute path,
+      # only one copy will be in the list.
+      # @param [Array<String>] fname_exprs cli-level values file path names
+      # @param [Hash] opts downstream options for file-loading methods
+      # @return [Array<String>] list of unique absolute filenames
+      def self.resolve_fname_exprs(fname_exprs, **opts)
+        final_exprs = [self::DEFAULT_VALUE_PATH, *fname_exprs].uniq
+        final_exprs.map do |fname_expr|
+          path = resolve_fname_expr(fname_expr, **opts)
+          if fname_expr != 'values' && !path
+            raise "Could not resolve file '#{fname_expr}'"
+          end
+          path.presence
+        end.compact.uniq
+      end
+
+      ##
+      # Loads the dicts from files pointed to by final_file_paths into
+      # memory, and returns the deep-merged hash in the order of the files.
+      # @param [Array<String>] final_file_paths absolute filenames
+      # of value assignment files
+      def self.load_yaml_files(final_file_paths)
+        final_file_paths.inject({}) do |whole, fname|
+          file_values = self.load_yaml_file(fname)
+          whole.deep_merge(file_values)
+        end
+      end
+
+      ##
+      # Parses and merges cli-level key-value assignments of the form
+      # foo.bar=baz.
+      # @param [Array<String>] inline_exprs e.g %w[foo=bar, foo.bar=baz]
+      def self.from_inlines(inline_exprs)
+        inline_exprs.inject({}) do |whole, str_assignment|
+          assignment = self.parse_inline_assignment(str_assignment)
+          whole.deep_merge(assignment)
+        end
+      end
+
+      ##
+      # Turns a user supplied values filename into a final, usable
+      # absolute filesystem path. This method calls the values_paths method,
+      # which assumes a kerbi directory structure.
+      # @param [String] expr
+      # @param [Hash] opts
+      # @return [?String] the absolute filename or nil if it does not exist
+      def self.resolve_fname_expr(expr, **opts)
+        candidate_paths = self.values_paths(expr, **opts)
+        candidate_paths.find do |candidate_path|
+          File.exists?(candidate_path) && \
+          !File.directory?(candidate_path)
+        end
+      end
+
+      ##
+      # Parses a single cli-level key-value assignment with the form
+      # foo.bar=baz. Raises an exception if the expression is malformed.
+      # @param [String] str_assign e.g foo=bar
+      # @return [Hash] corresponding symbol hash e.g {foo: bar}
+      def self.parse_inline_assignment(str_assign)
+        deep_key, value = str_assign.split("=")
+        raise "malformed assignment #{str_assign}" unless deep_key && value
+        assign_parts = deep_key.split(".") << value
+        assignment = assign_parts.reverse.inject{ |a, n| { n => a } }
+        assignment.deep_symbolize_keys
+      end
+
+      ##
+      # Loads and performs all interpolation operations on file, returns
+      # corresponding symbol hash of values. File is expected to contain
+      # one root element.
+      # @param [String] good_fname path of values file
+      #noinspection RubyResolve
+      # @return [Hash] corresponding value hash
+      def self.load_yaml_file(good_fname)
+        file_contents = File.read(good_fname)
+        interpolated = ErbWrapper.new.interpolate(file_contents)
+        YAML.load(interpolated).deep_symbolize_keys
+      end
+
+      #noinspection RubyLiteralArrayInspection
+      ##
+      # Returns all possible paths that a values filename might
+      # resolve to according to kerbi conventions. Does not check
+      # for file existence. The paths are ordered by similarity to
+      # the input expression, starting obviously with the input itself.
+      # @param [Object] fname cli-level filename expression for a values file
+      # @param [String] root optionally pass in project/mixer root dir
+      # @return [Array<String>] all possible paths
+      def self.values_paths(fname, root: nil)
+        if root.nil?
+          root = ''
+        else
+          root = "#{root}/" unless root.end_with?("/")
+        end
+        [
+          "#{root}#{fname}",
+          "#{root}#{fname}.yaml",
+          "#{root}#{fname}.json",
+          "#{root}#{fname}.yaml.erb",
+          "#{root}values/#{fname}",
+          "#{root}values/#{fname}.yaml.erb",
+          "#{root}values/#{fname}.yaml",
+          "#{root}values/#{fname}.json"
+        ]
+      end
+
+      class ErbWrapper
+        include Kerbi::Mixins::Mixer
+        def interpolate(file_cont)
+          ERB.new(file_cont).result(binding)
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/embedding.yaml.erb

@@ -0,0 +1,3 @@
+dict: <%= embed({embedded: "scalar"}) %>
+list: <%= embed_array(["item"]) %>
+dict_list: <%= embed_array([{embedded: "item"}]) %>

data/spec/main/examples_spec.rb

@@ -0,0 +1,12 @@
+require_relative './../spec_helper'
+require_relative './../../examples/hello-kerbi/kerbifile'
+
+RSpec.describe "Examples Directory" do
+  describe "The mixer" do
+    describe "#run" do
+      it "runs" do
+        # puts Kerbi::Globals.mixers.first.new({ }).run
+      end
+    end
+  end
+end

data/spec/main/mixer_spec.rb

@@ -0,0 +1,126 @@
+require_relative './../spec_helper'
+
+class PatchTestOne < Kerbi::Mixer
+  def mix
+    patched_with({x: {y: "z"}}) do
+      push dict(x: {z: "y"})
+    end
+
+    push dict(x: {y: "z"})
+
+    patched_with({x: {y: "z", v: "k"}}) do
+      patched_with({x: {k: "v"}}) do
+        push dict(x: {z: "y"})
+      end
+      push dict(x: {z: "y"})
+    end
+  end
+end
+
+class PatchTestTwo < Kerbi::Mixer
+  def mix
+    patched_with({x: {y: "z", v: "k"}}) do
+      patched_with({x: {k: "v"}}) do
+        push dict(x: {z: "y"})
+      end
+      push dict(x: {z: "y"})
+    end
+  end
+end
+
+RSpec.describe Kerbi::Mixer do
+
+  subject { Kerbi::Mixer.new({}) }
+
+  before :each do
+    Kerbi::Testing.reset_test_yamls_dir
+    Kerbi::Mixer.locate_self Kerbi::Testing::TEST_YAMLS_DIR
+  end
+
+  describe "#patched_with" do
+    let(:mixer) { PatchTestOne.new({}) }
+    it "correctly patches output in the yielded block" do
+      expect(mixer.run.first).to eq({x: {z: "y", y: "z"}})
+      expect(mixer.patch_stack.count).to eq(0)
+    end
+
+    it "does not patch out-of-block dicts" do
+      expect(mixer.run[1]).to eq({x: {y: "z"}})
+      expect(mixer.patch_stack.count).to eq(0)
+    end
+
+    it "handles nested patches correctly" do
+      expect(mixer.run[2]).to eq({x: {z: "y", y: "z", v: "k", k: "v"}})
+      expect(mixer.patch_stack.count).to eq(0)
+
+      expect(mixer.run[3]).to eq({x: {z: "y", y: "z", v: "k"}})
+      expect(mixer.patch_stack.count).to eq(0)
+    end
+
+    it "does not affect calls that are themselves patches" do
+
+    end
+  end
+
+  describe "#push" do
+    let(:expected) { [{x: "y"}, {y: 'z'}] }
+    it "pushes" do
+      subject.push({x: "y"})
+      subject.push(nil)
+      subject.push([{y: 'z'}, "not-a-dict"])
+      expect(subject.output).to match_array(expected)
+    end
+  end
+
+  describe "#dict" do
+    it "returns the right result" do
+      result = subject.dict({foo: "bar"})
+      expect(result).to eq([{foo: "bar"}])
+    end
+    it "delegates to Utils::Mixing" do
+      expect(Kerbi::Utils::Mixing).to receive(:clean_and_filter_dicts)
+      subject.dict({foo: "bar"})
+    end
+  end
+
+  describe "#file" do
+    let(:values) { { foo: "zar" } }
+    subject { Kerbi::Mixer.new(values) }
+
+    it "works" do
+      Kerbi::Testing.reset_test_yamls_dir
+      Kerbi::Testing.make_yaml("foo.yaml", "foo: <%= values[:foo] %>")
+      result = subject.file("foo.yaml")
+      expect(result).to eq([{foo: "zar"}])
+    end
+  end
+
+  describe "#resolve_file_name" do
+    subject { Kerbi::Mixer }
+
+    context 'when fname is not a real file' do
+      it 'returns the assumed fully qualified name' do
+        expect(subject.resolve_file_name('bar')).to eq(nil)
+      end
+    end
+
+    context 'when fname is a real file' do
+      it 'returns the original fname'do
+        Kerbi::Testing.make_yaml('foo.yaml', {})
+        expected = "#{Kerbi::Testing::TEST_YAMLS_DIR}/foo.yaml"
+        expect(subject.resolve_file_name(expected)).to eq(expected)
+        expect(subject.resolve_file_name('foo')).to eq(expected)
+        expect(subject.resolve_file_name('foo.yaml')).to eq(expected)
+      end
+    end
+  end
+
+  describe ".locate_self" do
+    it "stores and later outputs the value" do
+      class Subclass < Kerbi::Mixer
+        locate_self 'foo'
+      end
+      expect(Subclass.new({}).class.pwd).to eq('foo')
+    end
+  end
+end

data/spec/main/project_code_gen_spec.rb

@@ -0,0 +1,25 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::CodeGen::ProjectGenerator do
+
+  let(:klass) { Kerbi::CodeGen::ProjectGenerator }
+  let(:root) { Kerbi::Testing::TEST_YAMLS_DIR }
+  let(:project_name) { "test-project" }
+  let(:dir_path) { "#{root}/#{project_name}" }
+
+  before :each do
+    Kerbi::Testing.reset_test_yamls_dir
+  end
+
+  describe "#run" do
+    let(:expected_files) { %w[Gemfile kerbifile.rb values.yaml] }
+    it "creates a new dir and writes the files" do
+      expect(File.exists?(dir_path)).to be_falsey
+      generator = klass.new(project_name: project_name, root_dir: root)
+      generator.run
+      expect(File.exists?(dir_path)).to be_truthy
+      actual = Dir.entries(dir_path)
+      expect((expected_files - actual)).to be_empty
+    end
+  end
+end

data/spec/main/state_manager_spec.rb

@@ -0,0 +1,84 @@
+# require_relative './../spec_helper'
+
+# RSpec.describe Kerbi::StateManager do
+#
+#   subject { Kerbi::StateManager.new }
+#
+#   context = ENV['KERBI_RSPEC_K8S_CONTEXT'] || 'kind-kind'
+#
+  # before :each do
+  #   puts "KONTEXT #{context}"
+  # end
+  #
+  # describe "#patch" do
+  #   context "when there is no entry for variables" do
+  #
+  #     before :each do
+  #       system(
+  #         "kubectl delete cm state -n default --context #{context}",
+  #         out: File::NULL,
+  #         err: File::NULL
+  #       )
+  #     end
+  #
+  #     it "patches the configmap" do
+  #       argue("--context #{context} --set foo.bar=baz")
+  #       old_values = subject.get_crt_vars
+  #       expect(old_values).to eq({})
+  #       subject.patch
+  #       new_values = subject.get_crt_vars
+  #       expect(new_values).to eq({foo: {bar: "baz"}})
+  #     end
+  #   end
+  #
+  #   context "when there is an entry for variables" do
+  #
+  #     before :each do
+  #       system "kubectl delete cm state -n default --context #{context}"
+  #     end
+  #
+  #     it "patches the configmap" do
+  #       argue("--context #{context} --set foo.bar=baz")
+  #       subject.patch
+  #
+  #       argue("--context #{context} --set foo.bar=car")
+  #       subject.patch
+  #
+  #       new_values = subject.get_crt_vars
+  #       expect(new_values).to eq({foo: {bar: "car"}})
+  #     end
+  #
+  #   end
+  # end
+  #
+  # describe "#get_configmap" do
+  #   context "when it does not exist" do
+  #
+  #     before :each do
+  #       system "kubectl delete cm state -n default --context #{context}"
+  #     end
+  #
+  #     it "returns the configmap as a hash" do
+  #       argue("--context #{context}")
+  #       result = subject.get_configmap(raise_on_er: false)
+  #       expect(result).to be_nil
+  #     end
+  #   end
+  #
+  #   context "when it does exist" do
+  #     before :each do
+  #       system "kubectl create cm state -n default --context #{context}"
+  #     end
+  #
+  #     it "returns the configmap as a hash" do
+  #       argue("--context #{context}")
+  #       result = subject.get_configmap
+  #       expect(result).to_not be_nil
+  #       must_have = { name: "state", namespace: "default" }
+  #       expect(result[:metadata].slice(:name, :namespace)).to eq(must_have)
+  #     end
+  #   end
+  # end
+
+
+# end

data/spec/mixins/mixer_mixin_spec.rb

@@ -0,0 +1,55 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::Mixins::Mixer do
+
+  subject { Kerbi::Mixer.new({}) }
+
+  describe "#embed" do
+    subject { Kerbi::EmbeddingMixerTest.new({}) }
+    let(:expected) do
+      {
+        dict: { embedded: "scalar" },
+        list: ["item"],
+        dict_list: [{ embedded: "item" }]
+      }
+    end
+
+    it "embeds the values correctly" do
+      result = subject.run
+      expect(result).to eq([expected])
+    end
+  end
+
+  describe "#b64enc" do
+    it "base 64 encodes the value" do
+      mixer = Kerbi::Mixer.new({})
+      result = mixer.b64enc("hello world")
+      expect(result).to eq("aGVsbG8gd29ybGQ=")
+    end
+  end
+
+  describe '#b64enc' do
+    context 'when the value is truthy' do
+      it 'returns the base64 encoding' do
+        expect(subject.b64enc('demo')).to eq("ZGVtbw==")
+      end
+    end
+    context 'when the value is blank or nil' do
+      it 'returns an empty string' do
+        expect(subject.b64enc('')).to eq('')
+        expect(subject.b64enc(nil)).to eq('')
+      end
+    end
+  end
+
+
+end
+
+module Kerbi
+  class EmbeddingMixerTest < Kerbi::Mixer
+    locate_self "#{Dir.pwd}/spec/fixtures"
+    def mix
+      push file("embedding")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'tempfile'
+require 'simplecov'
+
+SimpleCov.start
+
+require_relative './../lib/kerbi'
+
+module Kerbi
+  module Testing
+
+    TEST_YAMLS_DIR = '/tmp/kerbi-yamls'
+
+    def self.make_yaml(fname, contents)
+      File.open(full_name = self.f_fname(fname), "w") do |f|
+        contents = YAML.dump(contents) if contents.is_a?(Hash)
+        f.write(contents)
+      end
+      full_name
+    end
+
+    def self.del_testfile(fname)
+      full_name = self.f_fname(fname)
+      if File.exists?(full_name)
+        File.delete(full_name)
+      end
+    end
+
+    def self.f_fname(fname)
+      "#{TEST_YAMLS_DIR}/#{fname}"
+    end
+
+    def self.reset_test_yamls_dir
+      system "rm -rf #{TEST_YAMLS_DIR}"
+      system "mkdir #{TEST_YAMLS_DIR}"
+    end
+
+  end
+end
+