bauk-gen 0.0.2

data/lib/bauk/gen/config_utils.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Bauk
+  module Gen
+    module ConfigUtils
+      # This error is to be raised every time there are errors with the config.
+      # These can usually be fixed by the user in a config file
+      class ConfigError < StandardError; end
+
+      # Method that can be used to validate individual config items.
+      # Takes an array of keys (or singular key) that specify the item to be checked
+      #   (e.g. :a would check that {a: 123}, while [:a, :b] would check the following nested hash: {a: {b: 123}}
+      # The second argument is a hash of optional things to check.
+      # If this is not given, the check is merely to ensure that the value is set and not null.
+      # Optional items to check are:
+      #  - allow_null      : allows the value to be null or not exist
+      #  - matches         : specify a regex that the item needs to match
+      #  - options         : specify a list of valid options
+      #  - message         : specify an optional default error message to display
+      #  - null_message    : specify an optional error message to display if the value is nil
+      #  - matches_message : specify an optional error message to display if the value is not in the valid list of options
+      #  - options_message : specify an optional error message to display if the value does not match the given regex
+      #  - default_value   : Specify a default value in case of null
+      def validate_config_item(keys, map = {})
+        config_item = config
+        keys = [keys] unless keys.is_a? Array
+        parent_keys = keys.clone
+        key = parent_keys.pop
+        # Get value we are referring to
+        parent_keys.each do |parent_key|
+          config_item[parent_key] = {} unless config_item[parent_key].is_a?(Hash)
+          config_item = config_item[parent_key]
+        end
+        # Run checks
+        if config_item[key].nil?
+          if map[:default_value]
+            log.debug "Setting #{keys.join('->')} to default value: #{map[:default_value]}"
+            config_item[key] = map[:default_value]
+          else
+            map[:nil_message] ||= map[:message] || "Config item #{keys.join('->')} does not exist"
+            raise ConfigError, map[:nil_message] unless map[:allow_null]
+          end
+        elsif map[:matches] && config_item[key] !~ (map[:matches])
+          map[:matches_message] ||= map[:message] || "Config #{keys.join('->')}(#{config_item[key]}) does not match: '#{map[:matches]}'"
+          raise ConfigError, map[:matches_message]
+        elsif map[:options] && ! map[:options].include?(config_item[key])
+          map[:options_message] ||= map[:message] || "Config #{keys.join('->')}(#{config_item[key]}) needs to be one of: '#{map[:options].join(", ")}'"
+          raise ConfigError, map[:options_message]
+        end
+      end
+
+      # Method to check/validate the config being provided to the generator.
+      # It can, for example, be used to ensure mandatory config is present
+      # or that given config is in the correct format.
+      def validate_config; end
+
+      # Function copied from online thread
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/')
+                        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                        .tr('-', '_')
+                        .downcase
+      end
+    end
+  end
+end

data/lib/bauk/gen/configs/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'deep_merge'
+
+module Bauk
+  module Gen
+    module Configs
+      # Base class for all config generators.
+      # Each child class needs to overwrite the following method:
+      # - generate_config()
+      #   -> This returns a hash of the config it obtains
+      class Base
+        include Bauk::Utils::Log
+
+        # Takes optional options:
+        # - keys: an array of where this config will be located in the final config hash
+        def initialize(map = {})
+          @keys = map[:keys] || []
+        end
+
+        # This method takes a config and adds the config that the config_generator
+        #  will generate. It adds the generated config in a position on the hash
+        #  dependant on which keys were passed to the config generator
+        def add_config!(config, keys = @keys)
+          log.debug 'adding config'
+          return config.deep_merge! generate_config if keys.empty?
+
+          key = keys.shift
+          config[key] = {} if (config[key] == true) || !(config[key])
+          # config[key] = add_config(config[key], keys)
+          add_config!(config[key], keys)
+          config
+        end
+
+        def symbolize(obj)
+          if obj.is_a? Hash
+            return obj.reduce({}) do |memo, (k, v)|
+              memo.tap { |m| m[k.to_sym] = symbolize(v) }
+            end
+          elsif obj.is_a? Array
+            return obj.each_with_object([]) do |v, memo|
+              memo << symbolize(v)
+            end
+          end
+
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/configs/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Bauk
+  module Gen
+    module Configs
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/bauk/gen/configs/files.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'bauk/gen/configs/base'
+require 'deep_merge'
+require 'yaml'
+require 'find'
+
+module Bauk
+  module Gen
+    module Configs
+      class Files < Base
+        include Bauk::Utils::Log
+        def initialize(map = {})
+          super map
+          @files = map[:files] || default_files
+          @files << map[:extra_files] if map[:extra_files]
+          log.debug "Searching for the following files: #{@files.join ', '}"
+          sanitise_files
+          log.debug "Files used for config: #{YAML.dump @files}"
+        end
+
+        def default_files
+          [
+            '.bauk/generator/config.yaml',
+            '~/.bauk/generator/config.yaml'
+          ]
+        end
+
+        def sanitise_files
+          files_map = {}
+          @files = @files.select do |file|
+            path = file.is_a?(Hash) ? file[:path] : file
+            File.exist?(path) or Dir.exist?(path)
+          end.map do |file|
+            if file.is_a?(Hash)
+              file[:path] = File.expand_path file[:path]
+              file
+            else
+              {
+                path: File.expand_path(file)
+              }
+            end
+          end
+          @files.each do |file|
+            log.warn("Config file included twice: '#{file}'") if files_map[file[:path]]
+            files_map[file[:path]] = {}
+          end
+        end
+
+        # TODO: get working with custom base key
+        # Method that collects config from config files
+        def generate_config
+          conf = {}
+          log.warn 'No config files found' if @files.empty?
+          @files.each do |file_data|
+            file = file_data[:path]
+            if Dir.exist?(file)
+              log.debug "Adding config from dir: #{file}"
+              Find.find(file) do |path|
+                next if Dir.exist?(path)
+                base_keys = path.sub(/\.[a-z]*$/, '').sub(%r{^#{file}/*}, '').gsub('/', '.').split('.').map(&:to_sym)
+                log.debug("Adding nested config file '#{path}' as #{base_keys.join("->")}")
+                nested_config = conf
+                base_keys.each do |key|
+                  nested_config[key] ||= {}
+                  nested_config = nested_config[key]
+                end
+                nested_config.deep_merge!(symbolize(YAML.load_file(path)))
+              end
+            else
+              log.debug "Adding config from file: #{file}"
+              conf.deep_merge!(symbolize((YAML.load_file(file))))
+            end
+          end
+          conf
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/contents/base_content.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'ostruct'
+
+module Bauk
+  module Gen
+    module Contents
+      class BaseContent
+        include Bauk::Utils::Log
+        def initialize(opts)
+          @attributes = opts[:attributes]
+          @config = opts[:config]
+        end
+
+        def content
+          renderer = ERB.new(File.read(@file))
+          begin
+            renderer.result(OpenStruct.new(@config).instance_eval { binding })
+          rescue => e
+            log.error("ERROR IN FILE: #{@file}")
+            throw e
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/bauk/gen/contents/erb_content.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'ostruct'
+require 'json'
+require 'bauk/gen/contents/base_content'
+
+module Bauk
+  module Gen
+    module Contents
+      class ErbContent < BaseContent
+        SECTION_START_REGEX = /BAUK-GEN CUSTOM SECTION ([0-9A-Z_]+) START/
+        SECTION_END_REGEX   = /BAUK-GEN CUSTOM SECTION ([0-9A-Z_]+) END/
+
+        def initialize(opts)
+          super(opts)
+          @file = opts[:file]
+        end
+
+        def content
+          renderer = ERB.new(File.read(@file))
+          erb_binding = OpenStruct.new(@config)
+          (((@config[:contents] ||= {})[:erb] ||= {})[:mixins] ||= []).each do |mixin|
+            erb_binding.extend(mixin)
+          end
+          begin
+            renderer.result(erb_binding.instance_eval { binding })
+          rescue => e
+            log.error("ERROR IN FILE: #{@file}")
+            throw e
+          end
+        end
+
+        def merge(current_content)
+          if @attributes[:merge] == true
+            merge_sections current_content, content
+          elsif @attributes[:merge] == "json"
+            merge_json current_content, content
+          else
+            raise "Invalid merge type provided: #{@attributes[:merge]} for template: #{@name}"
+          end
+        end
+
+        def merge_json(current_content, template_content)
+          current_json = JSON.parse(current_content)
+          template_json = JSON.parse(template_content)
+          if @attributes[:overwrite] == false
+            JSON.pretty_generate(template_json.deep_merge!(current_json))
+          else
+            JSON.pretty_generate(current_json.deep_merge!(template_json))
+          end
+        end
+
+        def merge_sections(current_content, template_content)
+          sections = {}
+          section = nil
+          section_no = nil
+          current_content.split("\n").each do |line|
+            if match = line.match(SECTION_START_REGEX)
+              section_no = match.captures[0]
+              raise "Section #{section_no} started inside previous section for file: #{@file}" if section
+              raise "Section #{section_no} has been defined more than once: #{@file}" if sections[section_no]
+              section = []
+            elsif match = line.match(SECTION_END_REGEX)
+              raise "Section #{match.captures[0]} ended before section started for file: #{@file}" unless section
+              raise "Secionn #{match.captures[0]} end block found inside section #{section_no} for file: #{@file}" unless section_no == match.captures[0]
+              sections[section_no] = section.join("\n")
+              section = nil
+            else
+              if section
+                section << line
+              end
+            end
+          end
+
+          new_content = []
+          section_no = nil
+          template_content.split("\n").each do |line|
+            if match = line.match(SECTION_START_REGEX)
+              raise "Section #{match.captures[0]} started inside previous section for template: #{@file}" if section_no
+              section_no = match.captures[0]
+              new_content << line
+            elsif match = line.match(SECTION_END_REGEX)
+              raise "Section #{match.captures[0]} ended before section started for template: #{@file}" unless section_no
+              raise "Secionn #{match.captures[0]} end block found inside section #{section_no} for template: #{@file}" unless section_no == match.captures[0]
+              if sections[section_no]
+                new_content.push(sections[section_no])
+              else
+                log.error "Section #{section_no} not found so replacing with template contents: #{@file}"
+              end
+              new_content << line
+              section_no = nil
+            else
+              unless section_no and sections[section_no]
+                new_content << line
+              end
+            end
+          end
+          new_content.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/contents/file_content.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'bauk/gen/contents/base_content'
+
+module Bauk
+  module Gen
+    module Contents
+      class FileContent < BaseContent
+        attr_reader :file
+
+        def initialize(opts)
+          super(opts)
+          @file = File.new(opts[:file])
+        end
+
+        def content
+          @file.read
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/contents/string_content.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bauk/gen/contents/base_content'
+
+module Bauk
+  module Gen
+    module Contents
+      class StringContent < BaseContent
+        def initialize(opts)
+          super(opts)
+          @string = File.new(opts[:string])
+        end
+        def content
+          @string
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/generator.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'bauk/gen/inputs/templates'
+require 'bauk/gen/outputs/filesystem'
+require 'bauk/gen/inputs/error'
+require 'bauk/gen/configs/files'
+require 'bauk/gen/config_utils'
+require 'bauk/gen/init'
+require 'deep_merge'
+
+module Bauk
+  module Gen
+    # This class is the base generator that all others should extend from.
+    # It contains methods for listing inputs, outputs and trnasformations.
+    # The input generators cteate a map of items. These items are then handed to the output generators.
+    # In the base example, the only inout is from Templates and the output is the Filesystem output. So the templates are parsed to a hash, which is then passed to any transformers. After transformation, the items are passed to the Filesystem output.
+    class Generator
+      include Bauk::Utils::Log
+      include ConfigUtils
+      include Init
+      CONTENT_KEYS = %w[string file].freeze
+      # Map of items
+      # Example:
+      # {
+      #   "path/to/file" => {
+      #     content: {
+      #       string: "...", # Could also be file: 'path/to/source',
+      #     },
+      #     name: "path/to/file",
+      #     attributes: {
+      #       merge: true,
+      #       onetime: true
+      #     },
+      #   }
+      # }
+      @items = {}
+
+      def initialize(data)
+        @input_config = data[:config]
+      end
+
+      # This method lists modules that you want to include
+      def modules
+        []
+      end
+
+      # This function contains the default list of configs
+      def config_generators
+        [
+          Bauk::Gen::Configs::Files
+        ]
+      end
+
+      # This function contains the default list of inputs
+      def input_generators
+        [
+          Bauk::Gen::Inputs::Templates
+        ]
+      end
+
+      # This function contains the default list of outputs
+      def output_generators
+        [
+          Bauk::Gen::Outputs::Filesystem
+        ]
+      end
+
+      # This function contains the default transformations applied to each template
+      # TODO: It is still not implemented
+      def transformations
+        [
+        ]
+      end
+
+      def generate
+        log.warn "Generating #{name} generator"
+        validate_config
+        input_items
+        validate_items
+        output_items
+        log.warn "Finished generating #{@items.size} items"
+      end
+
+      # This function gets the items from the inputs
+      def input_items
+        log.info "Generating items for generator: #{name} (#{self.class.name})"
+        @items = {}
+        modules.each do |mod|
+          mod.input_items(@items)
+        end
+        input_generators.each do |i_gen|
+          i_gen.new(self, config).input_items(@items)
+        end
+      end
+
+      def validate_items
+        @items.each do |name, item|
+          item[:name] ||= name
+          item[:attributes] ||= {}
+          raise Inputs::Error, "No content found for item: #{name}" unless item[:content]
+
+          unless item[:content].respond_to? :content
+            raise Inputs::Error, "Invalid content found found. Found #{item[:content]}"
+          end
+        end
+        raise Inputs::Error, 'No items found to generate' if @items.empty?
+      end
+
+      # This function writes the items to outputs
+      def output_items
+        output_generators.each do |o_gen|
+          o_gen.new(self, config).output_items(@items)
+        end
+      end
+
+      # This method can be overridden to provide default values to config.
+      # These should be enough to get the generator/module working and are placed into the init config file
+      def default_config
+        {
+          config: {
+            name: "ExampleName",
+            description: "Example project description"
+          }
+        }
+      end
+
+      # Default config specific to this generator (injected at the generator level)
+      def default_generator_config
+        {}
+      end
+
+      # This function obtains the config for this generator
+      # Example config:
+      # c = {
+      #  name: "Project Name",
+      #  description: "Project Description",
+      #  name => {
+      #    custom_conf: 123
+      #  },
+      # }
+      def config
+        if @config
+          return @config if name.empty?
+
+          return @config.deep_merge! @config[:generators][name]
+        end
+        @config = default_config.deep_merge!({generators:{name => default_generator_config }}).deep_merge!(@input_config)
+        config_generators.each do |c_gen|
+          c_gen.new.add_config! @config
+        end
+        unless @config
+          log.error 'No config found'
+          return {}
+        end
+        log.debug "Obtained config: #{@config}"
+        config
+      end
+
+      # Method to get generator name from class
+      def name
+        underscore(self.class.name.split('::').join('_').sub(/_*generator$/i, '')).to_sym
+      end
+    end
+  end
+end