k_builder 0.0.23 → 0.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1de8ff91bc3e273459d6970c8c1c136184e9c0990b0645fa426888317640eb
-  data.tar.gz: b6a5856f4bbb628422968a80a212fc6fbb1515b19c2cc29160d9cf984faa2b40
+  metadata.gz: '094bf462c5d39f6b39aa8df40e75d4623af9c5d1f6594109cb7afb4e9e82bfb2'
+  data.tar.gz: 4dd0400aa1a64e797c56aacc53d3af7ef4cda66c5aca9bbc32f13aeb1604e481
 SHA512:
-  metadata.gz: 62e85ea3f17a20cbc3bd180b74a057caab722d37de1bdb008353839f5f0159f564b69a4bcee9124857c7d24fe5b7b46afe967b86e52aaac7009960a663294886
-  data.tar.gz: 51a3c0374b57f0cfebc099df6d86c7657b50815185ea60f71e37cc9f27c5edf4afbb1933e727c1e68b81b179b079f7666c89a9273e971d7aa72fdb74e0411942
+  metadata.gz: a6196e9716b5e86f7cbdb5dba23252a5e7c477da329e2aa8a6a9989c59b790be10316130a9286fd6c5041c49d85a10282dc206a52ef5c73ce2ddf66601ad3c72
+  data.tar.gz: 301407050730841e77aad746a32bf046c636970346c4cda6f158699a571d125617eef1e15159a6495ba81fff19c125e25578a57f84407958a19c12f73f706dea

data/USAGE.md

@@ -36,7 +36,7 @@ Example folder structure for this usecase before running the builder
 
 > Note: app-templates will take preference over global templates
 
-![](_usage_folder_before.png)
+![](usage/_usage_folder_before.png)
 
 #### Run builder
 
@@ -81,24 +81,24 @@ builder
 
 Folder structure after running the builder
 
-![](_usage_folder_after.png)
+![](usage/_usage_folder_after.png)
 
 #### main.rb
 
-![main.rb](_out1.png)
+![main.rb](usage/_out1.png)
 
 #### person.rb
 
-![](_out2.png)
+![](usage/_out2.png)
 
 #### address.rb
 
-![person.rb](_out3.png)
+![person.rb](usage/_out3.png)
 
 #### configuration.log.txt
 
-![configuration.log.txt](_out4.png)
+![configuration.log.txt](usage/_out4.png)
 
 #### css/index.css
 
-![css/index.css](_out5.png)
+![css/index.css](usage/_out5.png)

data/lib/k_builder.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'k_builder/version'
+require 'k_builder/base_builder'
 require 'k_builder/base_configuration'
 require 'k_builder/configuration'
-require 'k_builder/base_builder'
-require 'k_builder/builder'
+require 'k_builder/data_helper'
+require 'k_builder/named_folders'
+require 'k_builder/layered_folders'
 
 require 'handlebars/helpers/template'
 

data/lib/k_builder/base_builder.rb

@@ -8,7 +8,11 @@ module KBuilder
   #             Setter methods (are NOT fluent) can be created as needed
   #             these methods would not be prefixed with the set_
   class BaseBuilder
-    attr_reader :hash
+    attr_reader :configuration
+
+    attr_accessor :target_folders
+
+    attr_accessor :template_folders
 
     # Factory method that provides a builder for a specified structure
     # runs through a configuration block and then builds the final structure
@@ -20,37 +24,23 @@ module KBuilder
 
     # Create and initialize the builder.
     #
-    # Initialization can be done via any of these three sequential steps.
-    #   - Configuration hash
-    #   - After new event
-    #   - Configuration block (lambda)
-    #
     # @return [Builder] Returns the builder via fluent interface
     def self.init(configuration = nil)
       builder = new(configuration)
 
-      builder.after_new
-
       yield(builder) if block_given?
 
       builder
     end
 
-    # Use after_new to massage hash values that come in via
-    # configuration into more complex values
-    #
-    # Abstract method
-    def after_new; end
-
     # assigns a builder hash and defines builder methods
     def initialize(configuration = nil)
-      @hash = {}
+      configuration = KBuilder.configuration if configuration.nil?
 
-      unless configuration.nil?
-        raise KBuilder::StandardError, 'Unknown configuration object' unless configuration.is_a?(Hash)
+      @configuration = configuration
 
-        hash.merge!(configuration)
-      end
+      @target_folders = configuration.target_folders.clone
+      @template_folders = configuration.template_folders.clone
 
       define_builder_setter_methods
     end
@@ -60,15 +50,210 @@ module KBuilder
     #
     # Abstract method
     def builder_setter_methods
-      raise NotImplementedError
+      []
     end
 
     # @return [Hash/StrongType] Returns data object, can be a hash
     #                           or strong typed object that you
     #                           have wrapped around the hash
     def build
-      hash
+      raise NotImplementedError
+    end
+
+    def to_h
+      {
+        target_folders: target_folders.to_h,
+        template_folders: template_folders.to_h
+      }
+    end
+
+    # ----------------------------------------------------------------------
+    # Fluent interface
+    # ----------------------------------------------------------------------
+
+    # Internal Actions are considered helpers for the builder, they do
+    # something useful, but they do not tend to implement fluent interfaces.
+    #
+    # They some times do actions, they sometimes return information.
+    #
+    # NOTE: [SRP] - These methods should probably be converted into objects
+    # ----------------------------------------------------------------------
+
+    # Add a file to the target location
+    #
+    # @param [String] file The file name with or without relative path, eg. my_file.json or src/my_file.json
+    # @option opts [String] :content Supply the content that you want to write to the file
+    # @option opts [String] :template Supply the template that you want to write to the file, template will be processed  ('nobody') From address
+    # @option opts [String] :content_file File with content, file location is based on where the program is running
+    # @option opts [String] :template_file File with handlebars templated content that will be transformed, file location is based on the configured template_path
+    #
+    # Extra options will be used as data for templates, e.g
+    # @option opts [String] :to Recipient email
+    # @option opts [String] :body The email's body
+    def add_file(file, **opts)
+      full_file = target_file(file)
+
+      FileUtils.mkdir_p(File.dirname(full_file))
+
+      content = process_any_content(**opts)
+
+      File.write(full_file, content)
+
+      # Prettier needs to work with the original file name
+      run_prettier file if opts.key?(:pretty)
+
+      self
+    end
+
+    # ----------------------------------------------------------------------
+    # Attributes: Think getter/setter
+    #
+    # The following getter/setters can be referenced both inside and outside
+    # of the fluent builder fluent API. They do not implement the fluent
+    # interface unless prefixed by set_.
+    #
+    # set_: Only setters with the prefix _set are considered fluent.
+    # ----------------------------------------------------------------------
+
+    # Target folders and files
+    # ----------------------------------------------------------------------
+
+    def set_current_folder(folder_key)
+      target_folders.current = folder_key
+
+      self
+    end
+    alias cd set_current_folder
+
+    def current_folder_key
+      target_folders.current
+    end
+
+    # Fluent adder for target folder (KBuilder::NamedFolders)
+    def add_target_folder(folder_key, value)
+      target_folders.add(folder_key, value)
+
+      self
+    end
+
+    # Get target folder
+    #
+    # Defaults to current_target_folder
+    def get_target_folder(folder_key = current_folder_key)
+      target_folders.get(folder_key)
+    end
+
+    # Get target file
+    def target_file(file_parts, folder: current_folder_key)
+      File.join(get_target_folder(folder), file_parts)
+    end
+
+    # Template folder & Files
+    # ----------------------------------------------------------------------
+
+    # Fluent adder for template folder (KBuilder::LayeredFolders)
+    def add_template_folder(folder_key, value)
+      template_folders.add(folder_key, value)
+
+      self
+    end
+
+    # Get for template folder
+    def get_template_folder(folder_key)
+      template_folders.get(folder_key)
+    end
+
+    # Gets a template_file relative to the template folder, looks first in
+    # local template folder and if not found, looks in global template folder
+    def find_template_file(file_parts)
+      template_folders.find_file(file_parts)
+    end
+
+    # Building content from templates
+    # ----------------------------------------------------------------------
+
+    # Use content from a a selection of content sources
+    #
+    # @option opts [String] :content Just pass through the :content as is.
+    # @option opts [String] :content_file Read content from the :content_file
+    #
+    # Future options
+    # @option opts [String] :content_loren [TODO]Create Loren Ipsum text as a :content_loren count of words
+    # @option opts [String] :content_url Read content from the :content_url
+    #
+    # @return Returns some content
+    def use_content(**opts)
+      return opts[:content] unless opts[:content].nil?
+
+      return unless opts[:content_file]
+
+      cf = opts[:content_file]
+
+      return "Content not found: #{File.expand_path(cf)}" unless File.exist?(cf)
+
+      File.read(cf)
+    end
+
+    # Use template from a a selection of template sources
+    #
+    # @option opts [String] :template Just pass through the :template as is.
+    # @option opts [String] :template_file Read template from the :template_file
+    #
+    # @return Returns some template
+    def use_template(**opts)
+      return opts[:template] unless opts[:template].nil?
+
+      return unless opts[:template_file]
+
+      tf = find_template_file(opts[:template_file])
+
+      return "template not found: #{opts[:template_file]}" if tf.nil?
+
+      File.read(tf)
+    end
+
+    # Process content will take any one of the following
+    #  - Raw content
+    #  - File based content
+    #  - Raw template (translated via handlebars)
+    #  - File base template (translated via handlebars)
+    #
+    # Process any of the above inputs to create final content output
+    #
+    # @option opts [String] :content Supply the content that you want to write to the file
+    # @option opts [String] :template Supply the template that you want to write to the file, template will be transformed using handlebars
+    # @option opts [String] :content_file File with content, file location is based on where the program is running
+    # @option opts [String] :template_file File with handlebars templated content that will be transformed, file location is based on the configured template_path
+    def process_any_content(**opts)
+      raw_content = use_content(**opts)
+
+      return raw_content if raw_content
+
+      template_content = use_template(**opts)
+
+      Handlebars::Helpers::Template.render(template_content, opts) unless template_content.nil?
+    end
+
+    def run_prettier(file, log_level: :log)
+      # command = "prettier --check #{file} --write #{file}"
+      command = "npx prettier --loglevel #{log_level} --write #{file}"
+
+      run_command command
+    end
+
+    def run_command(command)
+      # Deep path create if needed
+      target_folder = get_target_folder
+
+      FileUtils.mkdir_p(target_folder)
+
+      build_command = "cd #{target_folder} && #{command}"
+
+      puts build_command
+
+      system(build_command)
     end
+    alias rc run_command
 
     # TODO
     # Support Nesting

data/lib/k_builder/base_configuration.rb

@@ -3,104 +3,53 @@
 module KBuilder
   # Base configuration object for all k_builder* GEM
   class BaseConfiguration
-    def to_hash
-      hash = {}
-      instance_variables.each { |var| hash[var.to_s.delete('@')] = instance_variable_get(var) }
-      hash
-    end
-
-    def kv(name, value)
-      puts "#{name.rjust(30)} : #{value}"
-    end
-
-    # All of this code should be extracted into a module
-    #
-    # The module should then be extracted out into a GEM so that
-    # I can include it as needed. The GEM might be called
-    # (dynamic attributes) and would allow a regular class to act like an OpenStruct
-    # K-DSL uses data hash, while base configuration uses instance variables
-
-    def respond_to_missing?(name, *_args, &_block)
-      # puts 'respond_to_missing?'
-      # puts "respond_to_missing: #{name}"
-      n = name.to_s
-      n = n[0..-2] if n.end_with?('=')
-
-      if n.end_with?('?')
-        super
-      else
-        # This has not been fully tested
-        instance_variable_defined?("@#{n}") || super
+    def self.attach_to(klass_me, klass_target, accessor_name)
+      # Create a memoized getter to an instance of the attaching class (:klass_me)
+      #
+      # def third_party
+      #   @third_party ||= KBuilder::ThirdPartyGem::Configuration.new
+      # end
+      klass_target.send(:define_method, accessor_name) do
+        return instance_variable_get("@#{accessor_name}") if instance_variable_defined?("@#{accessor_name}")
+
+        instance_variable_set("@#{accessor_name}", klass_me.new)
       end
     end
 
-    def method_missing(name, *args, &_block)
-      # puts "method_missing: #{name}"
-      # puts "args.length   : #{args.length}"
-
-      add_getter_or_param_method(name)
-      add_setter_method(name)
+    # move out into module
+    def to_h
+      hash = {}
+      instance_variables.each do |var|
+        value = instance_variable_get(var)
 
-      send(name, args[0]) if args.length == 1 # name.end_with?('=')
+        value = KBuilder.data.struct_to_hash(value) if complex_type?(value)
 
-      super unless self.class.method_defined?(name)
+        hash[var.to_s.delete('@')] = value
+      end
+      hash
     end
 
-    # Handles Getter method and method with single parameter
-    # object.my_name
-    # object.my_name('david')
-    def add_getter_or_param_method(name)
-      # L.progress(1, 'add_getter_or_param_method')
-      self.class.class_eval do
-        # L.progress(2, 'add_getter_or_param_method')
-        name = name.to_s.gsub(/=$/, '')
-        # L.progress(3, 'add_getter_or_param_method')
-        # L.kv 'name', name
-        define_method(name) do |*args|
-          # L.progress(4, 'add_getter_or_param_method')
-          # L.kv 'add_getter_or_param_method', name
-          raise KBuilder::Error, 'Multiple setting values is not supported' if args.length > 1
-
-          if args.length.zero?
-            get_value(name)
-          else
-            send("#{name}=", args[0])
-          end
-        end
-      end
+    # Any basic (aka primitive) type
+    def basic_type?(value)
+      value.is_a?(String) ||
+        value.is_a?(Symbol) ||
+        value.is_a?(FalseClass) ||
+        value.is_a?(TrueClass) ||
+        value.is_a?(Integer) ||
+        value.is_a?(Float)
     end
 
-    # Handles Setter method
-    # object.my_name = 'david'
-    def add_setter_method(name)
-      # L.progress(1, 'add_setter_method')
-      self.class.class_eval do
-        # L.progress(2, 'add_setter_method')
-        name = name.to_s.gsub(/=$/, '')
-        # L.progress(3, 'add_setter_method')
-        # L.kv 'add_setter_method', name
-        define_method("#{name}=") do |value|
-          # L.progress(4, 'add_setter_method')
-          # L.kv 'name', name
-          # L.kv 'value', value
-          instance_variable_set("@#{name}", value)
-          # my_data[name.to_s] = value
-        end
-      end
+    # Anything container that is not a regular class
+    def complex_type?(value)
+      value.is_a?(Array) ||
+        value.is_a?(Hash) ||
+        value.is_a?(Struct) ||
+        value.is_a?(OpenStruct) ||
+        value.respond_to?(:to_h)
     end
 
-    def get_value(name)
-      instance_variable_get("@#{name}")
+    def kv(name, value)
+      puts "#{name.rjust(30)} : #{value}"
     end
   end
-
-  # class L
-  #   def self.progress(index, label)
-  #     puts "#{index} - #{label}"
-  #   end
-
-  #   def self.kv(name, value)
-  #     puts "#{name.rjust(30)} : #{value}"
-  #   end
-  # end
 end

data/lib/k_builder/configuration.rb

@@ -21,23 +21,41 @@ module KBuilder
 
   # Configuration class
   class Configuration < BaseConfiguration
-    attr_accessor :target_folder
-    attr_accessor :template_folder
-    attr_accessor :global_template_folder
+    attr_accessor :target_folders
+    attr_accessor :template_folders
 
     def initialize
       super
-      @target_folder = Dir.getwd
-      @template_folder = File.join(Dir.getwd, '.templates')
-      @global_template_folder = nil
+      # @target_folder = Dir.getwd
+      # @template_folder = File.join(Dir.getwd, '.templates')
+      # @global_template_folder = nil
+      @target_folders = NamedFolders.new
+      @template_folders = LayeredFolders.new
     end
 
+    def initialize_copy(orig)
+      super(orig)
+
+      @target_folders = orig.target_folders.clone
+      @template_folders = orig.template_folders.clone
+    end
+
+    # rubocop:disable Metrics/AbcSize
     def debug
       puts '-' * 120
       puts 'kbuilder base configuration'
-      kv 'target_folder'         , target_folder
-      kv 'template_folder'       , template_folder
-      kv 'global_template_folder', global_template_folder
+
+      puts 'target_folders'
+      target_folders.folders.each_key do |key|
+        folder = target_folders.folders[key]
+        kv key.to_s, folder
+      end
+
+      puts 'template folders (search order)'
+      template_folders.ordered_folders.each do |folder|
+        puts folder.to_s
+      end
     end
+    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/k_builder/data_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Attach data helper to the KBuilder module
+module KBuilder
+  # Data helpers/utils for Kbuilder
+  class << self
+    attr_writer :data
+  end
+
+  def self.data
+    @data ||= DataHelper.new
+  end
+
+  # Helper methods attached to the namespace for working with Data
+  #
+  # Usage: KBuilder.data.to_struct(data)
+  class DataHelper
+    # Convert a hash into a deep OpenStruct or array an array
+    # of objects into an array of OpenStruct
+    def to_struct(data)
+      case data
+      when Hash
+        OpenStruct.new(data.transform_values { |v| to_struct(v) })
+
+      when Array
+        data.map { |o| to_struct(o) }
+
+      else
+        # Some primitave type: String, True/False, Symbol or an ObjectStruct
+        data
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def struct_to_hash(data)
+      # No test yet
+      if data.is_a?(Array)
+        return data.map { |v| v.is_a?(OpenStruct) ? struct_to_hash(v) : v }
+      end
+
+      return struct_to_hash(data.to_h) if !data.is_a?(Hash) && data.respond_to?(:to_h)
+
+      data.each_pair.with_object({}) do |(key, value), hash|
+        case value
+        when OpenStruct, Struct, Hash
+          hash[key] = struct_to_hash(value)
+        when Array
+          # No test yet
+          values = value.map do |v|
+            v.is_a?(OpenStruct) || v.is_a?(Struct) || v.is_a?(Hash) ? struct_to_hash(v) : v
+          end
+          hash[key] = values
+        else
+          hash[key] = value
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def clean_symbol(value)
+      return value if value.nil?
+
+      value.is_a?(Symbol) ? value.to_s : value
+    end
+  end
+end

data/lib/k_builder/layered_folders.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module KBuilder
+  #
+  # Named folders makes sense for generated/output folders because you may want
+  # more than one type of location to generate output.
+  #
+  # Don't confuse multiple named output folders with sub-paths, when you want to
+  # build up a file name in a child folder, you can do that as part of building
+  # the filename.
+  #
+  # The idea behind named folders is for when you have two or more totally different
+  # outputs that (may live in the a similar location) or live in different locations.
+
+  # Layered folders allow files to be found in any of the searchable folders
+  #
+  # They derive from and thus work just like named folders in that they allow folders
+  # to be stored with easy to remember names/alias's.
+  #
+  # Where they differ is that they are retrieved in preferential search order that is
+  # by default (First In, Last Out) priority aka a Stack (Last In, First Out) or
+  # optionally over ridden via the search_order method
+  #
+  # Layered folders makes sense for use with template files and source data/model
+  # where you can have specific usage files available and if they are not found then
+  # you can use fall-back files in other folders.
+  #
+  # example:
+  #   folders = LayeredFolders.new
+  #   folders.add(:global       , '~/global_templates')
+  #   folders.add(:domain       , '/my-project/domain_templates')
+  #   folders.add(:app          , '/my-project/my-app/.templates')
+  #
+  #   # Find a file and folder will in folders in this order
+  #   # app_templates, then domain_templates and then finally global templates
+  #   # ['/my-project/my-app/.templates', '/my-project/domain_templates', '~/global_templates']
+  #   #
+  #   # Find a file called template1.txt and return its fully-qualified path
+  #   folders.find_file('template1.txt')
+  #
+  #   # As above, but returns the folder only, file name and sub-paths are ignored
+  #   folders.find_file_folder('template1.txt')
+  #   folders.find_file_folder('abc/xyz/deep-template.txt')
+  #
+  #   # If an additional folder is added, say in child configuration that is designed
+  #   # to override some of the global templates, then you can run a search_order
+  #   # method to re-order the templates
+  #
+  #   folders.add(:global_shim  , '~/global_templates_shim')
+  #   folders.search_order(:app, :domain, :global_shim, :global)
+  #
+  # class Builder < KBuilder::BaseBuilder
+  class LayeredFolders < KBuilder::NamedFolders
+    attr_reader :ordered_keys
+    attr_reader :ordered_folders
+
+    def initialize
+      super()
+
+      @ordered_keys = []
+      @ordered_folders = []
+    end
+
+    def initialize_copy(orig)
+      super(orig)
+
+      @ordered_keys = orig.ordered_keys.clone
+      @ordered_folders = orig.ordered_folders.clone
+    end
+
+    def add(folder_key, folder)
+      folder = super(folder_key, folder)
+
+      ordered_keys.prepend(folder_key)
+      ordered_folders.prepend(folder)
+
+      folder
+    end
+
+    # File name or array of sub-paths plus file
+    #
+    # Return the folder that a file is found in
+    def find_file(file_parts)
+      folder = find_file_folder(file_parts)
+      folder.nil? ? nil : File.join(folder, file_parts)
+    end
+
+    # File name or array of sub-paths plus file
+    #
+    # Return the folder that a file is found in
+    def find_file_folder(file_parts)
+      ordered_folders.find { |folder| File.exist?(File.join(folder, file_parts)) }
+    end
+
+    def to_h
+      {
+        ordered: {
+          keys: ordered_keys,
+          folders: ordered_folders
+        }
+      }.merge(@folders)
+    end
+  end
+end

data/lib/k_builder/named_folders.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module KBuilder
+  # Named folders allow folders to be stored with easy to remember names/alias's
+  # Secondarily, you can also build up file names based on these named folders.
+  #
+  # Named folders makes sense for generated/output folders because you may want
+  # more than one type of location to generate output.
+  #
+  # Don't confuse multiple named output folders with sub-paths, when you want to
+  # build up a file name in a child folder, you can do that as part of building
+  # the filename.
+  #
+  # The idea behind named folders is for when you have two or more totally different
+  # outputs that (may live in the a similar location) or live in different locations.
+  # Samples:
+  #   name: :code       - generating source code into a project
+  #   name: :slide      - generating slide deck into a documentation folder
+  #   name: :webpack    - folder where you might generate webpack files, e.g. webpack.config.*.json
+  #
+  # example:
+  #   folders = NamedFolders.new
+  #   folders.add(:csharp       , '~/dev/csharp/cool-project')
+  #   folders.add(:package_json , :csharp)
+  #   folders.add(:webpack      , folders.join(:csharp, 'config'))
+  #   folders.add(:builder      , folders.join(:csharp, 'builder'))
+  #   folders.add(:slides       , '~/doc/csharp/cool-project')
+  #
+  #   puts folders.get(:builder)
+  #
+  #   puts folders.get_filename(:csharp, 'Program.cs')
+  #   puts folders.get_filename(:csharp, 'Models/Order.cs')
+  #   puts folders.get_filename(:csharp, 'Models', 'Order.cs')
+  #
+  # Do I need to support :default?
+  class NamedFolders
+    attr_reader :folders
+
+    attr_reader :current
+
+    def initialize
+      @folders = {}
+      @current = nil
+    end
+
+    def initialize_copy(orig)
+      super(orig)
+
+      @folders = orig.folders.clone
+    end
+
+    def current=(folder_key)
+      guard_folder_key(folder_key)
+      @current = folder_key
+    end
+
+    def add(folder_key, folder)
+      # get a predefined folder by symbol
+      if folder.is_a?(Symbol)
+        folder = get(folder)
+      elsif folder.start_with?('~')
+        folder = File.expand_path(folder)
+      end
+
+      @current = folder_key if @current.nil?
+      folders[folder_key] = folder
+    end
+
+    # Get a folder
+    def get(folder_key)
+      guard_folder_key(folder_key)
+      folders[folder_key]
+    end
+
+    # Join the lookup folder key with the subpath folder parts (optionally + filename) and return the folder or filename
+    #
+    # Return fully qualified filename
+    def join(folder_key, *file_folder_parts)
+      folder = get(folder_key)
+
+      File.join(folder, file_folder_parts)
+    end
+    # Get a file name using the lookup folder key and the file name or array of sub-paths plus filename
+    alias get_filename join
+
+    def folder_keys
+      @folders.keys
+    end
+
+    def to_h
+      @folders
+    end
+
+    private
+
+    def guard_folder_key(folder_key)
+      raise KBuilder::Error, "Folder not found, this folder key not found: #{folder_key}" unless folders.key?(folder_key)
+    end
+  end
+end

data/lib/k_builder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KBuilder
-  VERSION = '0.0.23'
+  VERSION = '0.0.37'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_builder
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.37
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-14 00:00:00.000000000 Z
+date: 2021-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: handlebars-helpers
@@ -44,13 +44,6 @@ files:
 - Rakefile
 - STORIES.md
 - USAGE.md
-- _out1.png
-- _out2.png
-- _out3.png
-- _out4.png
-- _out5.png
-- _usage_folder_after.png
-- _usage_folder_before.png
 - bin/console
 - bin/k
 - bin/kgitsync
@@ -62,9 +55,18 @@ files:
 - lib/k_builder.rb
 - lib/k_builder/base_builder.rb
 - lib/k_builder/base_configuration.rb
-- lib/k_builder/builder.rb
 - lib/k_builder/configuration.rb
+- lib/k_builder/data_helper.rb
+- lib/k_builder/layered_folders.rb
+- lib/k_builder/named_folders.rb
 - lib/k_builder/version.rb
+- usage/_out1.png
+- usage/_out2.png
+- usage/_out3.png
+- usage/_out4.png
+- usage/_out5.png
+- usage/_usage_folder_after.png
+- usage/_usage_folder_before.png
 homepage: http://appydave.com
 licenses:
 - MIT

data/lib/k_builder/builder.rb

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-module KBuilder
-  # Base builder defines builder methods, build method and configuration
-  class Builder < KBuilder::BaseBuilder
-    # builder_setter_methods = %w[].freeze
-    # target_folder
-    # template_folder
-    # global_template_folder
-
-    def initialize(configuration = nil)
-      configuration = KBuilder.configuration.to_hash if configuration.nil?
-
-      super(configuration)
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    def after_new
-      # ensure that any configured folders are expanded
-      self.target_folder = hash['target_folder'] unless hash['target_folder'].nil?
-      self.template_folder = hash['template_folder'] unless hash['template_folder'].nil?
-      self.global_template_folder = hash['global_template_folder'] unless hash['global_template_folder'].nil?
-    end
-    # rubocop:enable Metrics/AbcSize
-
-    # Return an array of symbols to represent the fluent setter methods in this builder.
-    def builder_setter_methods
-      # Currently I have manually created my settings because I needed custom
-      # logic in the settings to handle path expansion
-      []
-    end
-
-    # def build
-    #   # SomeDryStruct.new(hash)
-    # end
-
-    # ----------------------------------------------------------------------
-    # Fluent interface
-    # ----------------------------------------------------------------------
-
-    # Add a file to the target location
-    #
-    # @param [String] file The file name with or without relative path, eg. my_file.json or src/my_file.json
-    # @option opts [String] :content Supply the content that you want to write to the file
-    # @option opts [String] :template Supply the template that you want to write to the file, template will be processed  ('nobody') From address
-    # @option opts [String] :content_file File with content, file location is based on where the program is running
-    # @option opts [String] :template_file File with handlebars templated content that will be transformed, file location is based on the configured template_path
-    #
-    # Extra options will be used as data for templates, e.g
-    # @option opts [String] :to Recipient email
-    # @option opts [String] :body The email's body
-    def add_file(file, **opts)
-      full_file = target_file(file)
-
-      FileUtils.mkdir_p(File.dirname(full_file))
-
-      content = process_any_content(**opts)
-
-      File.write(full_file, content)
-
-      # Prettier needs to work with the original file name
-      run_prettier file if opts.key?(:pretty)
-
-      self
-    end
-
-    # ----------------------------------------------------------------------
-    # Attributes: Think getter/setter
-    #
-    # The following getter/setters can be referenced both inside and outside
-    # of the fluent builder fluent API. They do not implement the fluent
-    # interface unless prefixed by set_.
-    #
-    # set_: Only setters with the prefix _set are considered fluent.
-    # ----------------------------------------------------------------------
-
-    # Target folder
-    # ----------------------------------------------------------------------
-
-    # Fluent setter for target folder
-    def set_target_folder(value)
-      self.target_folder = value
-
-      self
-    end
-
-    # Setter for target folder
-    def target_folder=(value)
-      hash['target_folder'] = File.expand_path(value)
-    end
-
-    # Getter for target folder
-    def target_folder
-      hash['target_folder']
-    end
-
-    # Template folder
-    # ----------------------------------------------------------------------
-
-    # Fluent setter for template folder
-    def set_template_folder(value)
-      self.template_folder = value
-
-      self
-    end
-
-    # Setter for template folder
-    # Refactor: Make Private
-    def template_folder=(value)
-      hash['template_folder'] = File.expand_path(value)
-    end
-
-    # Getter for template folder
-    # Refactor: generate
-    def template_folder
-      hash['template_folder']
-    end
-
-    # Global Target folder
-    # ----------------------------------------------------------------------
-
-    # Fluent setter for global template folder
-    def set_global_template_folder(value)
-      self.global_template_folder = value
-
-      self
-    end
-
-    # Setter for global template folder
-    # Refactor: Make Private
-    def global_template_folder=(value)
-      hash['global_template_folder'] = File.expand_path(value)
-    end
-
-    # Setter for global template folder
-    # Refactor: generate
-    def global_template_folder
-      hash['global_template_folder']
-    end
-
-    # Internal Actions are considered helpers for the builder, they do
-    # something useful, but they do not tend to implement fluent interfaces.
-    #
-    # They some times do actions, they sometimes return information.
-    #
-    # NOTE: [SRP] - These methods should probably be converted into objects
-    # ----------------------------------------------------------------------
-
-    # Gets a target_file relative to target folder
-    def target_file(file)
-      File.join(target_folder, file)
-    end
-
-    # Gets a template_file relative to the template folder
-    def template_file(file)
-      File.join(template_folder, file)
-    end
-
-    # Gets a global_template_file relative to the global template folder
-    def global_template_file(file)
-      File.join(global_template_folder, file)
-    end
-
-    # Gets a template_file relative to the template folder, looks first in
-    # local template folder and if not found, looks in global template folder
-    def find_template_file(file)
-      full_file = template_file(file)
-      return full_file if File.exist?(full_file)
-
-      full_file = global_template_file(file)
-      return full_file if File.exist?(full_file)
-
-      # File not found
-      nil
-    end
-
-    # Use content from a a selection of content sources
-    #
-    # @option opts [String] :content Just pass through the :content as is.
-    # @option opts [String] :content_file Read content from the :content_file
-    #
-    # Future options
-    # @option opts [String] :content_loren [TODO]Create Loren Ipsum text as a :content_loren count of words
-    # @option opts [String] :content_url Read content from the :content_url
-    #
-    # @return Returns some content
-    def use_content(**opts)
-      return opts[:content] unless opts[:content].nil?
-
-      return unless opts[:content_file]
-
-      cf = opts[:content_file]
-
-      return "Content not found: #{File.expand_path(cf)}" unless File.exist?(cf)
-
-      File.read(cf)
-    end
-
-    # Use template from a a selection of template sources
-    #
-    # @option opts [String] :template Just pass through the :template as is.
-    # @option opts [String] :template_file Read template from the :template_file
-    #
-    # @return Returns some template
-    def use_template(**opts)
-      return opts[:template] unless opts[:template].nil?
-
-      return unless opts[:template_file]
-
-      tf = find_template_file(opts[:template_file])
-
-      return "template not found: #{opts[:template_file]}" if tf.nil?
-
-      File.read(tf)
-    end
-
-    # Process content will take any one of the following
-    #  - Raw content
-    #  - File based content
-    #  - Raw template (translated via handlebars)
-    #  - File base template (translated via handlebars)
-    #
-    # Process any of the above inputs to create final content output
-    #
-    # @option opts [String] :content Supply the content that you want to write to the file
-    # @option opts [String] :template Supply the template that you want to write to the file, template will be transformed using handlebars
-    # @option opts [String] :content_file File with content, file location is based on where the program is running
-    # @option opts [String] :template_file File with handlebars templated content that will be transformed, file location is based on the configured template_path
-    def process_any_content(**opts)
-      raw_content = use_content(**opts)
-
-      return raw_content if raw_content
-
-      template_content = use_template(**opts)
-
-      Handlebars::Helpers::Template.render(template_content, opts) unless template_content.nil?
-    end
-
-    def run_prettier(file, log_level: :log)
-      # command = "prettier --check #{file} --write #{file}"
-      command = "npx prettier --loglevel #{log_level} --write #{file}"
-
-      run_command command
-    end
-
-    def run_command(command)
-      # Deep path create if needed
-      FileUtils.mkdir_p(target_folder)
-
-      build_command = "cd #{target_folder} && #{command}"
-
-      puts build_command
-
-      system(build_command)
-    end
-    alias rc run_command
-  end
-end