k_starter 0.1.0 → 0.1.1

data/lib/k_starter/commands/project/project_menu.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Commands
+    # Submenu for project
+    class ProjectMenu < KStarter::Commands::Command
+      def initialize(subcommand, options)
+        @subcommand = (subcommand || '').to_sym
+
+        @options = options
+        super()
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        command = nil
+
+        loop do
+          case @subcommand
+          when :new
+            command = KStarter::Commands::SelectNewProjectType.new(:menu)
+          when :edit
+            command = KStarter::Commands::EditProject.new
+          when :bootstrap
+            command = KStarter::Commands::BootstrapProject.new
+          end
+          command&.execute(input: input, output: output) if command
+          break if menu.nil?
+        end
+      end
+
+      private
+
+      def menu
+        display_exiting_projects
+
+        choices = [
+          { name: 'New project settings', value: :new },
+          { name: 'Edit project settings', value: :edit },
+          { name: 'Bootstrap a project', value: :bootstrap }
+        ]
+
+        subcommand = prompt.select('Select your subcommand?', choices, per_page: 15, cycle: true)
+
+        command = KStarter::Commands::ProjectMenu.new(subcommand, {})
+        command.execute(input: @input, output: @output)
+      rescue KStarter::EscapePressed
+        nil
+      end
+    end
+  end
+end

data/lib/k_starter/commands/project/select_new_project_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Commands
+    # Submenu for forms
+    class SelectNewProjectType < KStarter::Commands::Command
+      def initialize(subcommand, **options)
+        @subcommand = (subcommand || '').to_sym
+
+        @options = options
+        super()
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        command = nil
+        case @subcommand
+        when :menu
+          command = select_new_project_type
+        end
+        command&.execute(input: input, output: output)
+      end
+
+      private
+
+      def select_new_project_type
+        prompt.warn('Forms for project settings')
+
+        choices = [
+          { name: 'Rails'                       , value: { type: :rails, variant: nil } },
+          { name: 'Ruby library (GEM)'          , value: { type: :gem, variant: :library } },
+          { name: 'Ruby Command line Ruby (GEM)', value: { type: :gem, variant: :cli } },
+          { name: 'Svelte'                      , value: { type: :svelte, variant: nil } }
+        ]
+
+        prompt.warn('What type of project are you creating?')
+        form = prompt.select('Select project type?', choices, per_page: 15, cycle: true)
+
+        KStarter::Commands::NewProject.new(form_type: form[:type], form_variant: form[:variant])
+      rescue KStarter::EscapePressed
+        nil
+      end
+    end
+  end
+end

data/lib/k_starter/database/base_model.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Database
+    # Handle access to project data and configuration JSON files
+    class BaseModel
+      attr_reader :folder
+      attr_reader :backup_folder
+      attr_reader :filename
+      attr_reader :data
+
+      # Split Config and Data into two classes
+      def initialize(**args)
+        @folder = args[:folder] || '~/.config'
+        @folder = File.expand_path(folder)
+        @backup_folder = File.join(folder, 'klue_backup')
+        @filename = File.join(@folder, args[:file])
+      end
+    end
+  end
+end

data/lib/k_starter/database/config_model.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Database
+    # Handle access to configuration data files
+    class ConfigModel < KStarter::Database::BaseModel
+      DEFAULT_FILE_NAME = 'k_starter.config.json'
+
+      def initialize(**args)
+        args = { file: DEFAULT_FILE_NAME }.merge(args)
+        super(**args)
+
+        initialize_model
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def set_project_type(project_type)
+        project_type = project_type.to_h unless project_type.is_a?(Hash)
+
+        index = project_type_index(project_type[:type], project_type[:variant])
+
+        if index.nil?
+          data[:project_types] << project_type
+        else
+          data[:project_types][index] = project_type
+        end
+
+        write
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def get_project_type(type, variant = nil)
+        index = project_type_index(type, variant)
+
+        return nil if index.nil?
+
+        @data[:project_types][index]
+      end
+
+      def project_variants(type)
+        type = as_sym(type)
+
+        # project variants without nil or empty
+        data[:project_types]
+          .select { |t| t[:type]&.to_sym == type }
+          .map { |t| t[:variant]&.to_sym }
+          .compact
+      end
+
+      def github_user
+        data[:github][:user]
+      end
+
+      def github_organizations
+        data[:github][:organizations]
+      end
+
+      private
+
+      def initialize_model
+        if File.exist?(filename)
+          read
+          return
+        end
+
+        @data = {
+          github: {
+            user: 'not_set',
+            organizations: []
+          },
+          project_types: []
+        }
+
+        write
+      end
+
+      def read
+        @data = JSON.parse(File.read(filename), symbolize_names: true)
+      end
+
+      def write
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.write(filename, JSON.pretty_generate(data))
+      end
+
+      def project_type_index(type, variant = nil)
+        type = as_sym(type)
+        variant = as_sym(variant)
+
+        @data[:project_types].find_index { |t| t[:type]&.to_sym == type && (variant.nil? || t[:variant]&.to_sym == variant) }
+      end
+
+      def as_sym(value)
+        value.to_sym if value.is_a?(String)
+        value
+      end
+    end
+  end
+end

data/lib/k_starter/database/project_model.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Database
+    # Handle access to project data files
+    class ProjectModel < KStarter::Database::BaseModel
+      DEFAULT_FILE_NAME = 'k_starter.projects.json'
+
+      # def reset_data
+      #   require 'fileutils'
+
+      #   source_file = App.data.find_file
+
+      #   return unless File.exist?(source_file)
+
+      #   backup_folder = App.backup_folder
+      #   time = Time.now.strftime('%Y%m%d%H%M%S')
+
+      #   target_file = File.join(backup_folder, "#{time}_#{App::DATA_FILE}")
+
+      #   FileUtils.mkdir_p backup_folder
+      #   FileUtils.cp(source_file, target_file)
+      #   File.delete(source_file)
+
+      #   @data = nil
+      # end
+
+      def initialize(**args)
+        args = { file: DEFAULT_FILE_NAME }.merge(args)
+        super(**args)
+
+        initialize_model
+      end
+
+      def project_list
+        @project_list ||= begin
+          projects = data[:projects]
+          projects.map { |project| KStarter::Map.project(project) }
+        end
+      end
+
+      def find_project(name, variant = nil)
+        index = find_project_index(name, variant)
+
+        return project_list[index] if index
+      end
+
+      def find_project_index(name, variant = nil)
+        project_list.find_index { |p| p.name == name && (variant.nil? || p.variant == variant) }
+      end
+
+      def save_project(project, project_index = nil)
+        project = project.to_h unless project.is_a?(Hash)
+
+        index = project_index || find_project_index(project[:name])
+
+        if index.nil?
+          data[:projects] << project
+        else
+          data[:projects][index] = project
+        end
+
+        write
+        clear_memoization
+      end
+
+      private
+
+      def initialize_model
+        if File.exist?(filename)
+          read
+          return
+        end
+
+        @data = { projects: [] }
+
+        write
+      end
+
+      def clear_memoization
+        @project_list = nil
+      end
+
+      def read
+        @data = JSON.parse(File.read(filename), symbolize_names: true)
+      end
+
+      def write
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.write(filename, JSON.pretty_generate(data))
+      end
+    end
+  end
+end

data/lib/k_starter/map.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'pry'
+require 'date'
+require 'thor'
+
+module KStarter
+  # Handle the global access such as configuration
+  class Map
+    class << self
+      def project(project_hash)
+        case project_hash[:type].to_sym
+        when :gem
+          KStarter::Schema::GemProject.new(project_hash)
+        when :rails
+          KStarter::Schema::RailsProject.new(project_hash)
+        when :svelte
+          KStarter::Schema::SvelteProject.new(project_hash)
+        when :nuxt
+          KStarter::Schema::NuxtProject.new(project_hash)
+        else
+          raise "Unknown project type: #{project_hash[:type]}"
+        end
+      rescue StandardError => e
+        puts e.message
+      end
+
+      def starter(project_data)
+        project = project_data.is_a?(Hash) ? project(project_data) : project_data
+
+        raise "Unknown project type: #{project_data[:type]}" if project.nil?
+
+        case project.type
+        when :gem
+          KStarter::Starters::Gem.new(project)
+        when :rails
+          KStarter::Starters::Rails.new(project)
+        when :svelte
+          KStarter::Starters::Svelte.new(project)
+        when :nuxt
+          KStarter::Starters::Nuxt.new(project)
+        end
+      end
+    end
+  end
+end

data/lib/k_starter/questions/ask_questions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module KStarter
+  module Questions
+    # Select a form with questions and load it up as a New form or
+    # an Edit form by optionally providing data
+    class AskQuestions
+      class << self
+        def for(form_type, form_variant = nil, **data)
+          return KStarter::Questions::Rails.new(**data)       if form_type == :rails
+          return KStarter::Questions::LibraryGem.new(**data)  if form_type == :gem && form_variant == :library
+          return KStarter::Questions::CliGem.new(**data)      if form_type == :gem && form_variant == :cli
+          return KStarter::Questions::Svelte.new(**data)      if form_type == :svelte
+
+          raise "Unknown form type: #{form_type}"
+        end
+              end
+    end
+  end
+end

data/lib/k_starter/questions/base_question.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# see: bundle --help
+# example: bundle gem --coc --test=rspec --mit k_project
+# km2 new k_project -t ruby_gem \
+#   --description "k_project is a command line GEM for building new ruby, rails and other language projects" \
+#   --user-story "As a Developer, I want a simple path to creating new projects in different languages, so that I be productive quickly"
+
+module KStarter
+  module Questions
+    # Ask code generations for a new projects.
+    class BaseQuestion
+      include TtyHelpers
+
+      attr_reader :name                   # project name
+      attr_reader :type                   # project type
+      attr_reader :variant                # project variant
+      attr_reader :root_path              # project root path
+      attr_reader :sub_path               # project sub path, useful for folders under the root such as klueless projects
+      attr_reader :github_key             # github user_name or organization name
+      attr_reader :description            # project description
+      attr_reader :story_active           # is story required?
+      attr_reader :actor                  # who is the actor
+      attr_reader :problem                # what problem do they have
+      attr_reader :solution               # what is the intended solution
+      attr_reader :user_story             # what is the primary user story
+      attr_reader :klue_template_active   # is klue_template used?
+      attr_reader :klue_template_name     # name of the klue template
+
+      def initialize(**args)
+        initialize_attributes(**args)
+        apply_attribute_defaults
+        clean_attributes
+      end
+
+      def default_questions; end
+
+      def question
+        @question ||= prompt
+      end
+
+      def ask_root_path
+        project_type_config = App.config.get_project_type(type, variant)
+        configured_path = project_type_config.nil? ? '~/unknown_project' : project_type_config[:path]
+
+        @root_path = question.ask('Root project path') do |q|
+          q.default(configured_path)
+          q.required(true)
+        end
+      end
+
+      def ask_sub_path
+        project_type_config = App.config.get_project_type(type, variant)
+        configured_path = project_type_config.nil? ? '~/unknown_project' : project_type_config[:sub_path]
+
+        @sub_path = question.ask('Sub path within the project') do |q|
+          q.default(configured_path)
+          q.required(true)
+        end
+      end
+
+      def ask_github_key
+        choices = [App.config.github_user] + App.config.github_organizations
+        @github_key = prompt.select('Select Github user or organization', choices, cycle: true, filter: true, default: @github_key)
+      end
+
+      def ask_description
+        @description = question.ask('Description', default: @description)
+      end
+
+      def ask_story_active?
+        @story_active = question.yes?('Is a user story required?', default: @story_active)
+        show_story(actor: @actor, problem: @problem, solution: @solution)
+        @story_active
+      end
+
+      def ask_actor
+        @actor = prompt.ask('Who is the primary actor for this project?', default: @actor || 'Developer')
+        # show_story(actor: @actor)
+      end
+
+      def ask_problem
+        @problem = question.ask('What problem are you solving?', default: @problem)
+        # show_story(actor: @actor, problem: @problem)
+      end
+
+      def ask_solution
+        @solution = question.ask('What is the intended solution?', default: @solution)
+        # show_story(actor: @actor, problem: @problem, solution: @solution)
+      end
+
+      def show_story(**args)
+        prompt.warn("As a #{args[:actor] || 'ACTOR'}, I want to #{args[:problem] || 'SOLVE PROBLEM'} so that I can #{args[:solution] || 'HAVE BENEFIT'}")
+      end
+
+      def ask_user_story
+        @user_story = question.ask('User Story', default: "As a #{actor}, I want to #{problem} so that I can #{solution}")
+      end
+
+      def story_questions
+        return unless ask_story_active?
+
+        ask_actor
+        ask_problem
+        ask_solution
+        ask_user_story
+      end
+
+      # ask_user_story
+
+      def ask_klue_template_active?
+        @klue_template_active = question.yes?('Does this project use a Klue Templates?', default: @klue_template_active)
+        @klue_template_active
+      end
+
+      def ask_klue_template_name
+        prompt.warn('Location: ~/dev/kgems/k_templates/definitions/starter')
+        @klue_template_name = prompt.ask('Klue starter template name', default: infer_klue_template_name(@klue_template_name)) do |q|
+          q.required(true)
+        end
+      end
+
+      def klue_template_questions
+        return unless ask_klue_template_active?
+
+        ask_klue_template_name
+      end
+
+      def infer_klue_template_name(klue_template_name)
+        return klue_template_name unless klue_template_name.nil?
+
+        case type
+        when :rails, :svelte, :nuxt3
+          return type.to_s
+        when :gem
+          # return variant == :library ? 'ruby_gem' : 'ruby_gem_cli'
+          return 'ruby_gem'
+        end
+        nil
+      end
+
+      def default_story_active
+        @story_active = true if @story_active.nil?
+      end
+
+      def default_klue_template_active
+        @klue_template_active = true if @klue_template_active.nil?
+      end
+
+      def to_h
+        {
+          name: name,
+          type: type,
+          variant: variant,
+          root_path: root_path,
+          description: description,
+          github_key: github_key,
+          story: {
+            active: story_active,
+            actor: actor,
+            problem: problem,
+            solution: solution,
+            user_story: user_story
+          },
+          klue_template: {
+            active: klue_template_active,
+            name: klue_template_name
+          }
+        }
+      end
+
+      private
+
+      def initialize_attributes(**args)
+        @name = args[:name]
+        @type = args[:type]
+        @variant = args[:variant]
+        @root_path = args[:root_path]
+        @sub_path = args[:sub_path]
+        @github_key = args[:github_key]
+        @description = args[:description]
+        @story_active = args.dig(:story, :active)
+        @actor = args.dig(:story, :actor)
+        @problem = args.dig(:story, :problem)
+        @solution = args.dig(:story, :solution)
+        @user_story = args.dig(:story, :user_story)
+        @klue_template_active = args.dig(:klue_template, :active)
+        @klue_template_name = args.dig(:klue_template, :name)
+      end
+
+      def apply_attribute_defaults; end
+
+      def clean_attributes
+        @story_active = handle_boolean(@story_active)
+        @klue_template_active = handle_boolean(@klue_template_active)
+      end
+
+      def handle_boolean(value)
+        case value
+        when true, 'true', 't', 'yes', 'y', '1'
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end