bauk-gen 0.0.2

data/lib/bauk/gen/init.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'bauk/gen/configs/files'
+require 'fileutils'
+
+module Bauk
+  module Gen
+    # Class purely used for init
+    module Init
+      include Bauk::Utils::Log
+      def init
+        FileUtils.mkdir_p '.bauk/generator'
+        init_templates.each do |file,content|
+          file = ".bauk/generator/templates/#{name}/#{file}"
+          FileUtils.mkdir_p File.dirname(file.to_s)
+          File.write(file.to_s, content)
+        end
+        init_files.each do |file,content|
+          FileUtils.mkdir_p File.dirname(file.to_s)
+          File.write(file.to_s, content)
+        end
+        init_config_file
+      end
+
+      def init_files
+        {}
+      end
+
+      def init_templates
+        {
+          'exampleGenerated/example..erb': <<~FILE
+            <%= name %>
+          FILE,
+          'example_generated..erb': <<~FILE
+            Name: <%= name %>
+            Description: <%= description %>
+          FILE
+        }
+      end
+
+      def init_config_file
+        file = Bauk::Gen::Configs::Files.new.default_files[0]
+        if File.exist? file
+          log.error "File already exists: #{file}"
+        else
+          init_config = default_config
+          unless init_config[:generators]
+            init_config[:generators] = {}
+            init_config[:generators][name.to_sym] = {}
+          end
+          File.write(file, YAML.dump(init_config))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+
+module Bauk
+  module Gen
+    module Inputs
+      # Base class for inputs
+      # Each input needs to overwrite the following methods:
+      # - input_items(items)
+      #   -> Takes a hash of items and adds
+      class Base
+        def input_items(_items)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

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

data/lib/bauk/gen/inputs/templates.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'bauk/gen/inputs/base'
+require 'bauk/gen/contents/erb_content'
+require 'bauk/gen/contents/file_content'
+require 'ostruct'
+require 'deep_merge'
+
+module Bauk
+  module Gen
+    module Inputs
+      class Templates < Base
+        require 'bauk/utils/array_utils'
+        include Bauk::Utils::Log
+
+        Contents = Bauk::Gen::Contents
+        TEMPLATE_KEYS = %i[name dirs extra_dirs].freeze
+        ATTRIBUTE_VALUE_MAPPINGS = {
+          /^(yes|true)$/ => true,
+          /^(no|false|)$/ => false # Empty string is also false
+        }.freeze
+
+        def initialize(generator, config = {})
+          @generator = generator
+          config[:inputs] ||= {}
+          config[:inputs][:templates] ||= {}
+          template_config = config[:inputs][:templates]
+          @template_name = template_config[:template_name] || generator.name
+          setup_dirs template_config
+          invalid_keys = template_config.keys.reject { |key| TEMPLATE_KEYS.include? key }
+          unless invalid_keys.empty?
+            raise "Invalid keys passed to Bauk::Gen::Inputs::Templates: #{invalid_keys.join ', '}"
+          end
+        end
+
+        def setup_dirs(template_config)
+          template_dirs = template_config[:dirs] || default_template_dirs
+          template_dirs.unshift(*template_config[:extra_dirs]) if template_config.include?(:extra_dirs)
+          log.debug "Checking template dirs: #{template_dirs.join(', ')} (#{@template_name})"
+          @template_dirs = sanitise_dirs template_dirs
+          if @template_dirs.empty?
+            log.error "No template directories found for generator: '#{@generator.name}'. Searched dirs: #{template_dirs.join_custom}"
+          else
+            log.info "Using template dirs: #{@template_dirs}"
+          end
+        end
+
+        def default_template_dirs
+          [
+            '.bauk/generator/templates',
+            '~/.bauk/generator/templates',
+            File.expand_path('../../../../templates', __dir__)
+          ]
+        end
+
+        # This function returns the absolute paths of only the provided dirs that exist
+        def sanitise_dirs(dirs)
+          dirs.map do |dir|
+            File.expand_path("#{dir}/#{@template_name}")
+          end.select do |dir|
+            File.directory? dir
+          end
+        end
+
+        def input_items(items)
+          @template_dirs.each do |dir|
+            input_items_from_dir(items, dir)
+          end
+        end
+
+        def input_items_from_dir(items, base_dir, sub_dir = '', dir_attributes = {})
+          dir = "#{base_dir}/#{sub_dir}"
+          log.debug "Adding items from dir: #{dir}"
+          Dir.entries(dir).reject { |d| %w[. ..].include?(d) || d =~ /\.\.config$/ }.each do |filename|
+            path = sub_dir.empty? ? filename.clone : "#{sub_dir}/#{filename}"
+            full_path = "#{base_dir}/#{path}"
+            name = path.clone.dup
+            attributes = dir_attributes.merge(strip_attributes_from_name!(name))
+            # Check if there is a config file to read in
+            config_file = "#{base_dir}/#{name}..config"
+            if File.exist? config_file
+              log.debug "Loading in config for #{name} from file: #{config_file}"
+              eval File.read(config_file)
+            end
+            if File.directory? full_path
+              next if attributes.key?(:if) and not check_if(attributes[:if])
+              input_items_from_dir(items, base_dir, path, attributes)
+            else
+              if attributes[:foreach]
+                foreach = @generator.config.dig(*attributes[:foreach].split(':').map{|i| i.to_sym})
+                log.debug "Looping through foreach: #{foreach}"
+                if foreach.is_a? Hash
+                  foreach.each do |key,value|
+                    add_file_to_items items: items, name: name, attributes: attributes, full_path: full_path, config: {key: key, value: value}
+                  end
+                elsif foreach.is_a? ::Array
+                  foreach.each do |value|
+                    add_file_to_items items: items, name: name, attributes: attributes, full_path: full_path, config: {value: value}
+                  end
+                else
+                  log.debug "Foreach: #{foreach}"
+                  raise "Cannot itterate though foreach(#{attributes[:foreach]})"
+                end
+              else
+                add_file_to_items items: items, name: name, attributes: attributes, full_path: full_path
+              end
+            end
+          end
+        end
+
+        # Config variable extra complex (extra_if_config) to ensure it does notclash with a key in @generator.config as this causes issues
+        def check_if(if_value, extra_if_config = {})
+          # TODO: Use Openstruct to remove this self-binding config issue
+          b = binding
+          @generator.config.each do |key,value|
+            b.local_variable_set(key.to_sym, value)
+          end
+          extra_if_config.each do |key,value|
+            b.local_variable_set(key.to_sym, value)
+          end
+          if if_value.is_a? String
+            if eval(if_value, b)
+              return true
+            end
+          elsif if_value
+            return true
+          end
+          false
+        end
+
+        def add_file_to_items(items:, name:, attributes:, full_path:, config: {})
+          return if attributes.key?(:if) and not check_if(attributes[:if], config)
+          merged_config = @generator.config.clone
+          merged_config.deep_merge!(config)
+
+          # Substitute any variables in the name
+          dst_name = name.clone
+          name.scan(/%=([^%]*)%/).flatten.each do |path_item|
+            path_value = merged_config.dig(*path_item.split('.').map{|i| i.to_sym})
+            raise "Could not file '#{path_item}' config for '#{name}'" unless path_value
+            dst_name.sub!("%=#{path_item}%", path_value.to_s)
+          end
+
+          log.debug "Adding item: '#{dst_name}'. Attributes: #{attributes}"
+          if items[dst_name]
+            log.warn "Overwriting #{dst_name} with template: #{full_path}"
+          end
+          items[dst_name] = {
+            name: dst_name,
+            attributes: attributes,
+            content: if attributes[:erb]
+                       Contents::ErbContent.new(file: full_path, config: merged_config, attributes: attributes)
+                     else
+                       Contents::FileContent.new(file: full_path, config: merged_config, attributes: attributes)
+                     end
+          }
+        end
+
+        def strip_attributes_from_name!(name)
+          return {} unless name =~ /\.\./
+          log.debug("strip_attributes_from_name!(#{name})")
+
+          # First strip any attributes from parent folders as those are merged in by default
+          # If a folder started with .. then that whole folder should be removed
+          name.gsub!(%r{\.\.([^/\.]+\.?)+/}, '/')
+          name.gsub!(%r{^/*}, '')
+          name.gsub!(%r{//*}, '/')
+
+          parts = name.split('/').last().split('..')
+          attr_string = parts.pop
+          name.sub!("..#{attr_string}", '')
+          log.debug("strip_attributes_from_name!.attr_string = #{attr_string}")
+
+          attributes = {}
+          attr_string.split('.').each do |attribute|
+            if attribute =~ /=/
+              vals = attribute.split('=')
+              key = vals.shift.to_sym
+              value = vals.join('=')
+              ATTRIBUTE_VALUE_MAPPINGS.each do |mapping, val|
+                next unless value =~ mapping
+
+                value = val
+                break
+              end
+              attributes[key] = value
+            else
+              attributes[attribute.to_sym] = true
+            end
+          end
+          attributes
+        end
+      end
+    end
+  end
+end

data/lib/bauk/gen/module.rb

@@ -0,0 +1,87 @@
+# 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 'deep_merge'
+
+module Bauk
+  module Gen
+    # This class is the base module that all others should extend from.
+    # It contains methods for generating items and creating default config.
+    # It itself is not a valid module as modules need names
+    # All config for a module needs to be in the config modules->#name
+    # It takes 3 arguments:
+    # - Calling generator
+    # - Config generated by the generator
+    # - Map of options
+    #   This map contains the possible keys:
+    #   - disable_by_default: Whether to not enable this generator unless the
+    #                         config explicity sets this value to true or a hash.
+    #                         e.g {modules:{moduleA:true}
+    class Module
+      include Bauk::Utils::Log
+      include ConfigUtils
+
+      def initialize(generator, config, map = {})
+        @generator_config = config
+        @generator = generator
+        @map = map
+      end
+
+      def config
+        return @config if @config
+        @config = default_config.deep_merge! @generator_config
+        @config = @generator_config
+        @config[:modules] ||= {}
+        @config[:modules][name] ||= {}
+        @config[:modules][name] = {} if config[:modules][name].eql? true
+        # Overwrite values with this module values
+        @config = @config.deep_merge! @config[:modules][name]
+        config
+      end
+
+      # Function to tell the calling generator whether this module is active andshould be used
+      # to generate items. It depends on whether the config privided
+      def active?
+        if @map[:disable_by_default] then @config
+        else !@config.eql?(false)
+        end
+      end
+
+      # Method to check validate the config being provided to the generator.
+      # This overrride also takes an argument of the generator config in case
+      # default values want to be derived.
+      def validate_config(_generator_config); end
+
+      # This function contains the default list of inputs
+      # It defaults to using the inputs from the root generator
+      def input_generators
+        @generator.input_generators
+      end
+
+      # This function gets the items from the inputs.
+      # It does so by itterating though each input and passing it
+      # the global list of items to add to.
+      def input_items(items)
+        log.info "Inputting items from module: #{name} (#{self.class.name})"
+        input_generators.each do |i_gen|
+          i_gen.new(self, config).input_items(items)
+        end
+      end
+
+      # Method to get generator name from class
+      def name
+        return @name if @name
+
+        @name = underscore(self.class.name.split('::').join('_').sub(/_*module$/i, '')).to_sym
+        raise "Invalid nameless module provided: #{self.class.name}" if @name.empty?
+
+        @name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'fileutils'
+
+module Bauk
+  module Gen
+    module Outputs
+      # Base class for all outputters
+      # Each outputter needs to implement the following methods:
+      # - output_items(items)
+      class Base
+        include Bauk::Utils::Log
+
+        def initialize(_generator, config = {})
+          config[:outputs] ||= {}
+        end
+      end
+    end
+  end
+end

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

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

data/lib/bauk/gen/outputs/filesystem.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'bauk/utils/log'
+require 'fileutils'
+require 'bauk/gen/contents/file_content'
+require 'bauk/gen/outputs/base'
+
+module Bauk
+  module Gen
+    module Outputs
+      class Filesystem < Base
+        include Bauk::Utils::Log
+        FILESYSTEM_KEYS = %s(output_base)
+        Contents = Bauk::Gen::Contents
+
+        def initialize(generator, config = {})
+          super generator, config
+          config[:outputs][:filesystem] ||= {}
+          filesystem_config = config[:outputs][:filesystem]
+          @output_base = File.expand_path(filesystem_config[:output_base] || '.')
+          invalid_keys = filesystem_config.keys.reject { |key| FILESYSTEM_KEYS.include? key }
+          unless invalid_keys.empty?
+            raise "Invalid keys passed to Bauk::Gen::Outputs::Filesystem: #{invalid_keys.join ', '}"
+          end
+        end
+
+        def default_template_dirs
+          [
+            '.bauk/generator/templates',
+            '~/.bauk/generator/templates',
+            File.expand_path('../../../../templates', __dir__)
+          ]
+        end
+
+        # This function returns the absoluts path of only the provided dirs that exist
+        def sanitise_dirs(dirs)
+          dirs.map do |dir|
+            File.expand_path("#{dir}/#{@template_name}")
+          end.select do |dir|
+            File.directory? dir
+          end
+        end
+
+        def output_items(items)
+          Dir.chdir(@output_base) do
+            log.info "Outputting items to dir: #{@output_base}"
+            items.each do |name, item|
+              log.debug "Outputting item: #{name}(#{item})"
+              if name =~ %r{/}
+                parent_dir = name.sub(%r{/[^/]*$}, '')
+                FileUtils.mkdir_p parent_dir
+              end
+              if item[:attributes][:merge] and File.exist?(name)
+                merge_item name, item
+              elsif item[:attributes][:overwrite] == false and File.exist?(name)
+                log.info "Not overwriting file: '#{name}'"
+              else
+                output_item name, item
+              end
+            end
+          end
+        end
+
+        def merge_item(name, item)
+          if item[:content].respond_to? :merge
+            File.write(name, item[:content].merge(File.read(name)))
+          else
+            log.warn "Content type for '#{name}' does not respond to merge request: #{item[:content]} (Outputting without merge)"
+            output_item name, item
+          end
+        end
+
+        def output_item(name, item)
+          if item[:content].is_a? Contents::FileContent
+            FileUtils.cp item[:content].file.path, name
+          elsif item[:content].respond_to? :content
+            File.write(name, item[:content].content)
+          else
+            raise "Invalid content found for #{name}: #{item[:content]}"
+          end
+        end
+      end
+    end
+  end
+end