k_director 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3e92a5f338e4a25768bc3de0b87f0c5a72f21cf2a19047912b53d825aabe07e
+  data.tar.gz: '080715415cbcd1aa473c6f9425fa4453e19a65b05be9457d799d24436b90b1aa'
+SHA512:
+  metadata.gz: 1faaf9a00492813b5f2d90ef92106aa69629f3176eea5f605e5ba806b6a00c24367cc2ea7e1e02dd14f0f58b2f5ad44f1acf54eae873386718e2c2043747aab8
+  data.tar.gz: 477242c710691338688eebf2b1e1a41fd9ddfb4574f42bf30411fad3ecf50f069da734dbbded3d56a8f988c55f5a42734662fc822996176b83cbf06b24245f10

data/.builders/_.rb

@@ -0,0 +1,6 @@
+require_relative './dsl/builders/dom_builder'
+require_relative './dsl/builders/actions_builder'
+require_relative './dsl/directors/base_director'
+require_relative './dsl/directors/child_director'
+require_relative './dsl/github_dsl'
+require_relative './dsl/ruby_gem_dsl'

data/.builders/boot.rb

@@ -0,0 +1,71 @@
+# Boot Sequence
+
+include KLog::Logging
+
+CONFIG_KEY = :k_director
+
+log.kv 'working folder', Dir.pwd
+
+Handlebars::Helpers.configure do |config|
+  config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_helpers.json')
+  config.helper_config_file = config_file
+
+  string_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_string_formatters.json')
+  config.string_formatter_config_file = string_config_file
+end
+
+def camel
+  require 'handlebars/helpers/string_formatting/camel'
+  Handlebars::Helpers::StringFormatting::Camel.new
+end
+
+def titleize
+  require 'handlebars/helpers/string_formatting/titleize'
+  Handlebars::Helpers::StringFormatting::Titleize.new
+end
+
+def pluralize
+  require 'handlebars/helpers/inflection/pluralize'
+  Handlebars::Helpers::Inflection::Pluralize.new
+end
+
+def singularize
+  require 'handlebars/helpers/inflection/singularize'
+  Handlebars::Helpers::Inflection::Singularize.new
+end
+
+def dasherize
+  require 'handlebars/helpers/string_formatting/dasherize'
+  Handlebars::Helpers::StringFormatting::Dasherize.new
+end
+
+def k_builder
+  @k_builder ||= KBuilder::BaseBuilder.init(KBuilder.configuration(CONFIG_KEY))
+end
+
+KBuilder.configure(CONFIG_KEY) do |config|
+  builder_folder    = Dir.pwd
+  base_folder       = File.expand_path('../', builder_folder)
+  global_template   = File.expand_path('~/dev/kgems/k_templates/templates')
+
+  config.template_folders.add(:global_template    , global_template)
+  config.template_folders.add(:template           , File.expand_path('.templates', Dir.pwd))
+
+  config.target_folders.add(:app                  , base_folder)
+  config.target_folders.add(:builder              , builder_folder)
+  # config.target_folders.add(:tailwind_elements    , global_template, 'tailwind', 'elements')
+  # config.target_folders.add(:data                 , :builder, 'data')
+  # config.target_folders.add(:database             , :data, 'database')
+end
+
+KBuilder.configuration(CONFIG_KEY).debug
+
+area = KManager.add_area(CONFIG_KEY)
+resource_manager = area.resource_manager
+resource_manager
+  .fileset
+  .glob('*.rb', exclude: ['boot.rb'])
+  .glob('generators/**/*.rb')
+resource_manager.add_resources
+
+KManager.fire_actions(:load_content, :register_document, :load_document)

data/.builders/dsl/builders/actions_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dsl
+  module Builders
+    class ActionsBuilder < Dsl::Builders::DomBuilder
+      def initialize
+        super(schema)
+      end
+
+      def queue_action(action)
+        dom[:actions] << current_node(action)
+      end
+
+      def actions
+        dom[:actions]
+      end
+
+      private
+
+      def schema
+        { 
+          actions: []
+        }
+      end
+    end
+  end
+end

data/.builders/dsl/builders/dom_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dsl
+  module Builders
+    class DomBuilder
+      attr_reader :dom
+      attr_reader :node
+
+      def initialize(dom = nil)
+        @dom = dom || schema
+      end
+
+      def current_node(node)
+        @node = node
+      end
+
+      alias last_node node
+
+      def reset
+        @dom = schema
+        @last_node = nil
+      end
+
+      def schema
+        {}
+      end
+
+      def logit
+        puts JSON.pretty_generate(dom)
+        # log.structure(dom)
+
+        self
+      end
+
+      def data
+        KUtil.data.to_open_struct(@dom)
+      end
+    end
+  end
+end

data/.builders/dsl/directors/base_director.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Dsl
+  module Directors
+    class BaseDirector
+      include KLog::Logging
+
+      class << self
+        def init(k_builder, builder = nil, **opts)
+          if builder.nil?
+            builder = Dsl::Builders::ActionsBuilder.new
+          else
+            builder.reset
+          end
+
+          new(k_builder, builder, **opts)
+        end
+      end
+
+      attr_reader :builder
+      attr_reader :k_builder
+      attr_reader :options
+      attr_accessor :dom
+    
+      def initialize(k_builder, builder, **opts)
+        @k_builder  = k_builder
+        @builder    = builder
+        @options    = OpenStruct.new(**opts)
+
+        @options.director_name        ||= default_director_name
+        @options.template_base_folder ||= default_template_base_folder
+        @options.on_exist             ||= :skip       # %i[skip write compare]
+        @options.on_action            ||= :queue      # %i[queue execute]
+      end
+
+      def director_name
+        @options.director_name
+      end
+
+      def template_base_folder
+        @options.template_base_folder
+      end
+
+      def on_exist
+        @options.on_exist
+      end
+
+      def on_action
+        @options.on_action
+      end
+
+      def add_file(file, **opts)
+        opts = {
+          on_exist: on_exist
+        }.merge(opts)
+
+        opts[:dom] = dom if dom
+
+        handle_action(k_builder.add_file_action(file, **opts))
+
+        self
+      end
+
+      def set_current_folder_action(folder_key)
+        # RUN (not handle)
+        run_action(k_builder.set_current_folder_action(folder_key))
+
+        self
+      end
+      alias cd set_current_folder_action
+
+      def run_command(command)
+        handle_action(k_builder.run_command_action(command))
+
+        self
+      end
+
+      def run_script(script)
+        handle_action(k_builder.run_script_action(script))
+
+        self
+      end
+
+      def play_actions
+        k_builder.play_actions(builder.actions)
+      end
+
+      def debug
+        log.section_heading director_name
+
+        h = options.to_h.sort.to_h
+        h.keys.each do |key|
+          log.kv(titleize.parse(key.to_s), h[key])
+        end
+        nil
+      end
+
+      # def debug_info
+      #   log.kv 'Template Root Folder'   , k_builder.template_folders.folder_paths
+      #   log.kv 'Template Base Folder'   , template_base_folder
+      #   log.kv 'on_exist'               , on_exist
+      #   log.kv 'on_action'              , on_action
+      # end
+
+      private
+
+      def default_template_base_folder
+        ''
+      end
+
+      def default_director_name
+        titleize.parse(self.class.name.split("::").last)
+      end
+
+      def folder_parts(*parts)
+        parts.reject(&:blank?).map(&:to_s)
+      end
+
+      def handle_action(action)
+        builder.queue_action(action)
+        k_builder.play_action(action) if on_action == :execute
+      end
+
+      # run action will queue an action just like handle_action, but it will also run it immediately
+      def run_action(action)
+        builder.queue_action(action)
+        k_builder.run_action(action)
+      end
+    end
+  end
+end

data/.builders/dsl/directors/child_director.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Dsl
+  module Directors
+    class ChildDirector < Dsl::Directors::BaseDirector
+      attr_reader :parent
+
+      def initialize(parent, **opts)
+        @parent = parent
+
+        opts = {
+          on_exist: parent.on_exist,
+          on_action: parent.on_action,
+          template_base_folder: parent.template_base_folder
+        }.merge(opts)
+
+        super(parent.k_builder, parent.builder, **opts)
+      end
+
+      def debug
+        parent.debug
+
+        super
+      end
+    end
+  end
+end

data/.builders/dsl/github_dsl.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Dsl
+  class Github < Dsl::Directors::ChildDirector
+    def initialize(parent, **opts)
+      super(parent, **opts)
+
+      @options.repo_name          ||= parent.options.repo_name
+      @options.repo_organization  ||= parent.options.repo_organization
+    end
+
+    def repo_name
+      @options.repo_name
+    end
+
+    def repo_organization
+      @options.repo_organization
+    end
+
+    def list_repositories
+      repos = api.all_repositories
+
+      KExt::Github::Printer::repositories_as_table repos
+
+      log.kv 'Repository count', repos.length
+    rescue StandardError => error
+      log.exception(error)
+    end
+
+    def open_repository(**opts)
+      info = repo_info(**opts)
+
+      system("open -a 'Google Chrome' #{info.link}")
+    end
+
+    def create_repository(**opts)
+      info = repo_info(**opts)
+
+      repo = api.all_repositories.find { |r| r.full_name == info.full_name }
+
+      if repo.nil?
+        log.heading 'Repository create'
+        log.kv 'Repository Name', info.name
+        log.kv 'Repository Full Name', info.full_name
+        log.kv 'Organization Name', info.organization if info.organization
+        success = api.create_repository(info.name, organization: info.organization)
+        log.info "Repository: #{info.full_name} created" if success
+        log.error "Repository: #{info.full_name} was not created" unless success
+
+        system("open -a 'Google Chrome' #{info.link}") if opts[:open]
+      else
+        log.warn 'Repository already exists, nothing to create'
+      end
+
+      log_repo_info(info)
+    rescue StandardError => error
+      log.exception(error)
+    end
+
+    def delete_repository(**opts)
+      info = repo_info(**opts)
+
+      repo = api.all_repositories.find { |r| r.full_name == info.full_name }
+
+      if repo.present?
+        log.heading 'Repository delete'
+        log.kv 'Repository Name', info.name
+        log.kv 'Repository Full Name', info.full_name
+        log.kv 'Organization Name', info.organization if info.organization
+        success = delete_api.delete_repository(info.full_name, organization: info.organization)
+        log.info "Repository: #{info.full_name} deleted" if success
+        log.error "Repository: #{info.full_name} was not deleted" unless success
+        # system("open -a 'Google Chrome' #{info.link}") if opts[:open]
+      else
+        log.warn 'Repository does not exist, nothing to delete'
+      end
+
+      log_repo_info(info)
+    rescue StandardError => error
+      log.exception(error)
+    end
+    
+    def repo_info(**opts)
+      name          = opts[:name] || self.repo_name
+      name          = name.to_s
+      username      = opts[:username] || self.username
+      organization  = opts[:organization] || self.repo_organization
+      account       = organization || username
+      full_name     = [account, name].compact.join("/")
+      link          = "https://github.com/#{full_name}"
+      ssh_link      = "git@github.com:#{full_name}.git"
+
+      OpenStruct.new(
+        name: name,
+        full_name: full_name,
+        link: link,
+        ssh_link: ssh_link,
+        username: username,
+        organization: organization
+      )
+    end
+
+    private
+
+
+    def username
+      KExt::Github.configuration.user
+    end
+
+    def api
+      token = KExt::Github.configuration.personal_access_token
+      KExt::Github::Api.instance(token)
+    end
+
+    def delete_api
+      token = KExt::Github.configuration.personal_access_token_delete
+      KExt::Github::Api.instance(token)
+    end
+
+    def log_repo_info(info)
+      log.kv 'SSH', info.ssh_link
+      log.kv 'HTTPS', info.git_link
+      log.kv 'GITHUB', KUtil.console.hyperlink(info.link, info.link)
+
+      # log.json repo.to_h
+    end
+
+  end
+end

data/.builders/dsl/ruby_gem_dsl.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Dsl
+  class RubyGemDsl < Dsl::Directors::BaseDirector
+    def default_director_name
+      'Ruby Gem'
+    end
+
+    def repo_name
+      options.repo_name
+    end
+
+    def repo_account
+      options.repo_account
+    end
+
+    # def default_template_base_folder
+    # end
+    # def initialize(k_builder, builder, **opts)
+    #   super(k_builder, builder, **opts)
+    #   # @on_action  = opts[:on_action] || :queue      # %i[queue execute]
+    # end
+    def github(**opts, &block)
+      github = Dsl::Github.new(self, **opts)
+      github.instance_eval(&block) 
+
+      self
+    end
+
+    def blueprint(**opts, &block)
+      blueprint = Dsl::RubyGemBlueprint.new(self, **opts)
+      blueprint.instance_eval(&block) 
+
+      self
+    end
+  end
+
+  class RubyGemBlueprint < Dsl::Directors::ChildDirector
+    def template_content(template_filename)
+      template_parts = [template_base_folder, template_filename]
+      template_file = File.join(*template_parts)
+
+      file = k_builder.find_template_file(template_file)
+      File.read(file)
+    end
+
+    def run_template_script(template_filename, **opts)
+      template_parts = [template_base_folder, template_filename]
+      template_file = File.join(*template_parts)
+      
+      script = k_builder.process_any_content(template_file: template_file, **opts)
+
+      run_script(script)
+      # action = k_builder.run_script_action(script)
+      # run_action(action)
+    end
+
+    # Create a single file
+    #
+    # @param [String] output_filename The output file name, this can be a relative path
+    # @param [Hash] **opts The options
+    # @option opts [String] :template_filename Template filename can be set or it will default to the same value as the output file name
+    # @option opts [String] :template_subfolder Template subfolder
+    def add(output_file, **opts)
+      template_file = opts[:template_file] || output_file
+      template_parts = [template_base_folder, opts[:template_subfolder], opts[:template_variant], template_file].reject(&:blank?)
+
+      opts[:template_file] = File.join(*template_parts)
+
+      add_file(output_file, **opts)
+    end
+
+    def oadd(name, **opts); add(name, **{ open: true          }.merge(opts)); end
+    def tadd(name, **opts); add(name, **{ open_template: true }.merge(opts)); end
+    def fadd(name, **opts); add(name, **{ on_exist: :write    }.merge(opts)); end
+  end
+end

data/.builders/generators/01-bootstrap.rb

@@ -0,0 +1,127 @@
+
+KManager.action :bootstrap do
+  def on_action
+    application_name = :k_director
+    director = Dsl::RubyGemDsl
+      .init(k_builder,
+        template_base_folder:       'ruby/gem',
+        on_exist:                   :skip,                      # %i[skip write compare]
+        on_action:                  :queue,                     # %i[queue execute]
+        ruby_version:               '2.7',
+        repo_name:                  application_name,
+        application:                application_name,
+        application_description:    'KDirector provides domain specific language implementations for code generation',
+        application_lib_path:       application_name.to_s,
+        application_lib_namespace:  'KDirector',
+        namespaces:                 ['KDirector'],
+        author:                     'David Cruwys',
+        author_email:               'david@ideasmen.com.au',
+        avatar:                     'Developer',
+        initial_semver:             '0.0.1',
+        main_story:                 'As a Developer, I want to generate code using a DSL, so that I can speed up application development',
+        copyright_date:             '2022',
+        website:                    'http://appydave.com/gems/k_director'
+      )
+      .github do
+        parent.options.repo_info = repo_info
+
+        # create_repository # (:k_director)
+        # delete_repository # (:k_director)
+        # list_repositories
+        # open_repository # (:k_director)
+        # run_command('git init')
+      end
+      .blueprint(
+        name: :bin_hook,
+        description: 'BIN/Hook structures',
+        on_exist: :compare) do
+
+        cd(:app)
+        self.dom = OpenStruct.new(parent.options.to_h.merge(options.to_h))
+
+        # # add('bin/runonce/git-setup.sh', dom: dom)
+        # run_template_script('bin/runonce/git-setup.sh', dom: dom)
+
+        # add('.githooks/commit-msg') #, template_subfolder: 'ruby', template_file: 'commit-msg')
+        # add('.githooks/pre-commit') #, template_subfolder: 'ruby', template_file: 'pre-commit')
+
+        # run_command('chmod +x .githooks/commit-msg')
+        # run_command('chmod +x .githooks/pre-commit')
+
+        # add('.gitignore')
+
+        # add('bin/setup')
+        # add('bin/console')
+
+        # # enable sharable githooks (developer needs to turn this on before editing rep)
+        # run_command('git config core.hooksPath .githooks')
+
+        # run_command("git add .; git commit -m 'chore: #{self.options.description.downcase}'; git push")
+      end
+      .blueprint(
+        name: :opinionated,
+        description: 'opinionated GEM files',
+        on_exist: :write) do
+
+        cd(:app)
+        self.dom = OpenStruct.new(parent.options.to_h.merge(options.to_h))
+
+        # add("lib/#{dom.application}.rb"             , template_file: 'lib/applet_name.rb'         , dom: dom)
+        # add("lib/#{dom.application}/version.rb"     , template_file: 'lib/applet_name/version.rb' , dom: dom)
+        # add(".ver", dom: dom)
+    
+        # add('spec/spec_helper.rb')
+        # add("spec/#{dom.application}_spec.rb"       , template_file: 'spec/applet_name_spec.rb', dom: dom)
+
+        # add("#{dom.application}.gemspec"            , template_file: 'applet_name.gemspec', dom: dom)
+        # add('Gemfile', dom: dom)
+        # add('Guardfile', dom: dom)
+        # add('Rakefile', dom: dom)
+        # add('.rspec', dom: dom)
+        # add('.rubocop.yml', dom: dom)
+        # add('README.md', dom: dom)
+        # add('docs/CODE_OF_CONDUCT.md', dom: dom)
+        # add('docs/LICENSE.txt', dom: dom)
+
+        # run_command("rubocop -a")
+      
+        # run_command("git add .; git commit -m 'chore: #{self.options.description.downcase}'; git push")
+      end
+      .blueprint(
+        name: :ci_cd,
+        description: 'github actions (CI/CD)',
+        on_exist: :write) do
+
+        cd(:app)
+        self.dom = OpenStruct.new(parent.options.to_h.merge(options.to_h))
+
+        # run_command("gh secret set SLACK_WEBHOOK --body \"$SLACK_REPO_WEBHOOK\"")
+        # add('.github/workflows/main.yml')
+        # add('.github/workflows/semver.yml')
+        # add('.releaserc')
+
+        # run_command("git add .; git commit -m 'chore: #{self.options.description.downcase}'; git push")
+      end
+      .blueprint(
+        name: :intitial_gem_release,
+        description: 'initial GEM release',
+        on_exist: :write) do
+
+        cd(:app)
+        self.dom = OpenStruct.new(parent.options.to_h.merge(options.to_h))
+
+        # run_command("rake publish && rake clean")
+        # run_command("gh secret set GEM_HOST_API_KEY --body \"$GEM_HOST_API_KEY\"")
+        # add('.github/workflows/main.yml')
+        # add('.github/workflows/semver.yml')
+        # add('.releaserc')
+
+        # run_command("git add .; git commit -m 'chore: #{self.options.description.downcase}'; git push")
+      end
+
+
+    # director.k_builder.debug
+    director.play_actions
+    # director.builder.logit
+  end
+end

data/.builders/run.rb

@@ -0,0 +1,15 @@
+KManager.action :run do
+  def on_action
+    puts 'run away, run away'
+  end
+end
+
+KManager.opts.app_name                    = 'RubyGem Generator'
+KManager.opts.sleep                       = 2
+KManager.opts.reboot_on_kill              = 0
+KManager.opts.reboot_sleep                = 4
+KManager.opts.exception_style             = :short
+KManager.opts.show.time_taken             = true
+KManager.opts.show.finished               = true
+KManager.opts.show.finished_message       = 'FINISHED :)'
+

data/.githooks/commit-msg

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+# template_variant: :ruby
+
+if ! head -1 "$1" | grep -qE "^.{1,200}$"; then
+  echo -e "\033[41mAborting commit. Your commit message is too long.\033[0m" >&2
+  exit 1
+fi
+if ! head -1 "$1" | grep -qE "^(merge master)"; then
+  exit 0
+fi
+if ! head -1 "$1" | grep -qE "^(feat|fix|ci|chore|docs|test|style|refactor|perf|build|revert)(\(.+?\))?!?: .{1,}$"; then
+  echo -e "\033[41mWARNING: this commit does not follow conventional commit message guidelines\033[0m" >&2
+fi