makit 0.0.99 → 0.0.111

data/lib/makit/setup/gem.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+require_relative "../configuration/project"
+
+module Makit
+  module Setup
+    class Gem
+      def self.run
+        project = Makit::Configuration::Project.default
+        Makit::Logging.default_logger.info("Setting up Ruby gem project: #{project.name}")
+        
+        # Create basic gem structure
+        create_gem_structure(project)
+        
+        # Update build and test steps
+        update_build_step(project)
+        update_test_step(project)
+        
+        project.save
+        Makit::Logging.default_logger.info("Ruby gem project setup completed")
+      end
+
+      private
+
+      def self.create_gem_structure(project)
+        # Create directories
+        FileUtils.mkdir_p("lib/#{project.name}")
+        FileUtils.mkdir_p("test")
+        FileUtils.mkdir_p("exe")
+        
+        # Create basic gem files
+        create_gemspec(project)
+        create_gemfile(project)
+        create_main_lib(project)
+        create_version_file(project)
+        create_rakefile(project)
+        create_test_helper(project)
+        create_test_file(project)
+        create_readme(project)
+      end
+
+      def self.create_gemspec(project)
+        gemspec_content = <<~GEMSPEC
+          # frozen_string_literal: true
+
+          require_relative "lib/#{project.name}/version"
+
+          Gem::Specification.new do |spec|
+            spec.name = "#{project.name}"
+            spec.version = #{project.name.capitalize}::VERSION
+            spec.authors = ["Your Name"]
+            spec.email = ["your.email@example.com"]
+
+            spec.summary = "A Ruby gem"
+            spec.description = "A Ruby gem description"
+            spec.homepage = "https://github.com/yourusername/#{project.name}"
+            spec.license = "MIT"
+
+            spec.files = Dir["lib/**/*.rb", "exe/**/*", "README.md", "LICENSE.txt"]
+            spec.bindir = "exe"
+            spec.executables = []
+            spec.require_paths = ["lib"]
+
+            spec.add_development_dependency "bundler", "~> 2.0"
+            spec.add_development_dependency "rake", "~> 13.0"
+            spec.add_development_dependency "minitest", "~> 5.0"
+          end
+        GEMSPEC
+
+        File.write("#{project.name}.gemspec", gemspec_content)
+      end
+
+      def self.create_gemfile(project)
+        gemfile_content = <<~GEMFILE
+          # frozen_string_literal: true
+
+          source "https://rubygems.org"
+
+          # Specify your gem's dependencies in #{project.name}.gemspec
+          gemspec
+        GEMFILE
+
+        File.write("Gemfile", gemfile_content)
+      end
+
+      def self.create_main_lib(project)
+        main_lib_content = <<~MAIN_LIB
+          # frozen_string_literal: true
+
+          require_relative "#{project.name}/version"
+
+          module #{project.name.capitalize}
+            class Error < StandardError; end
+            # Your code goes here...
+          end
+        MAIN_LIB
+
+        File.write("lib/#{project.name}.rb", main_lib_content)
+      end
+
+      def self.create_version_file(project)
+        version_content = <<~VERSION
+          # frozen_string_literal: true
+
+          module #{project.name.capitalize}
+            VERSION = "#{project.version}"
+          end
+        VERSION
+
+        File.write("lib/#{project.name}/version.rb", version_content)
+      end
+
+      def self.create_rakefile(project)
+        rakefile_content = <<~RAKEFILE
+          # frozen_string_literal: true
+
+          require "bundler/gem_tasks"
+          require "minitest/test_task"
+          require "makit"
+
+          Minitest::TestTask.create
+
+          task :default => [:build, :install] do
+          end
+        RAKEFILE
+
+        File.write("Rakefile", rakefile_content)
+      end
+
+      def self.create_test_helper(project)
+        test_helper_content = <<~TEST_HELPER
+          # frozen_string_literal: true
+
+          require "minitest/autorun"
+          require_relative "../lib/#{project.name}"
+        TEST_HELPER
+
+        File.write("test/test_helper.rb", test_helper_content)
+      end
+
+      def self.create_test_file(project)
+        test_content = <<~TEST
+          # frozen_string_literal: true
+
+          require "test_helper"
+
+          class #{project.name.capitalize}Test < Minitest::Test
+            def test_that_it_has_a_version_number
+              refute_nil ::#{project.name.capitalize}::VERSION
+            end
+
+            def test_it_does_something_useful
+              assert false
+            end
+          end
+        TEST
+
+        File.write("test/#{project.name}_test.rb", test_content)
+      end
+
+      def self.create_readme(project)
+        readme_content = <<~README
+          # #{project.name.capitalize}
+
+          Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/#{project.name}`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+          TODO: Delete this and the text above, and describe your gem
+
+          ## Installation
+
+          Add this line to your application's Gemfile:
+
+          ```ruby
+          gem "#{project.name}"
+          ```
+
+          And then execute:
+
+              $ bundle
+
+          Or install it yourself as:
+
+              $ gem install #{project.name}
+
+          ## Usage
+
+          ```ruby
+          require "#{project.name}"
+
+          # TODO: Write usage instructions here
+          ```
+
+          ## Development
+
+          After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+          ## Contributing
+
+          Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/#{project.name}.
+
+          ## License
+
+          The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+        README
+
+        File.write("README.md", readme_content)
+      end
+
+      def self.update_build_step(project)
+        build_commands = [
+          "bundle exec rake build"
+        ]
+        
+        steps = project.steps
+        if steps.any? { |step| step.name == "build" }
+          build_step = steps.find { |step| step.name == "build" }
+          build_step.commands = build_commands
+        else
+          build_step = Makit::Configuration::Step.new(
+            name: "build", 
+            description: "Build the gem", 
+            commands: build_commands
+          )
+          project.add_step(build_step)
+        end
+        build_step.commands = build_commands
+        project.save
+      end
+
+      def self.update_test_step(project)
+        test_commands = [
+          "bundle exec rake test"
+        ]
+        
+        steps = project.steps
+        if steps.any? { |step| step.name == "test" }
+          test_step = steps.find { |step| step.name == "test" }
+          test_step.commands = test_commands
+        else
+          test_step = Makit::Configuration::Step.new(
+            name: "test", 
+            description: "Run the tests", 
+            commands: test_commands
+          )
+          project.add_step(test_step)
+        end
+        project.save
+      end
+    end
+  end
+end

data/lib/makit/setup/runner.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative "classlib"
+require_relative "gem"
+
+module Makit
+  module Setup
+    class Runner
+      def self.run
+
+        # open .makit.json and get project type, to determine which setup to run
+        if File.exist?(".makit.json")
+          begin
+            project = Makit::Serializer.open(".makit.json", Makit::Configuration::Project)
+
+            # Check if the file contains compact JSON and resave as pretty JSON
+            current_content = File.read(".makit.json")
+            pretty_content = project.to_json_pretty
+
+            # Only rewrite if the content is different (i.e., if it was compact)
+            if current_content.strip != pretty_content.strip
+              File.write(".makit.json", pretty_content)
+            end
+          rescue
+            raise "Error opening .makit.json"
+          end
+          project_type = project.project_type
+          case project_type
+          when "classlib"
+            Makit::Setup::ClassLib.run
+          when "gem"
+            Makit::Setup::Gem.run
+          else
+            Makit::Logging.default_logger.warn("Unsupported project type: #{project_type}")
+            #puts "Unsupported project type: #{project_type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/makit/show.rb

@@ -8,9 +8,9 @@ module Makit
   class Show
     def modified(path)
       if File.file?(path)
-        puts "#{path} modified ".colorize(:grey) + "#{Makit::Humanize.get_humanized_timestamp(File.mtime(path))}".colorize(:cyan)
+        puts "#{path} modified ".colorize(:grey) + Makit::Humanize.get_humanized_timestamp(File.mtime(path)).to_s.colorize(:cyan)
       elsif File.directory?(path)
-        puts "#{path} modified ".colorize(:grey) + "#{Makit::Humanize.get_humanized_timestamp(Makit::Directory.modified(path))}".colorize(:cyan)
+        puts "#{path} modified ".colorize(:grey) + Makit::Humanize.get_humanized_timestamp(Makit::Directory.modified(path)).to_s.colorize(:cyan)
       else
         puts "#{path} does not exist"
       end
@@ -20,11 +20,11 @@ module Makit
       if File.file?(path)
         modified = File.mtime(path)
         age = (Time.now - modified).to_f
-        puts "#{path} age is ".colorize(:grey) + "#{Makit::Humanize.get_humanized_duration(age)}".colorize(:cyan)
+        puts "#{path} age is ".colorize(:grey) + Makit::Humanize.get_humanized_duration(age).to_s.colorize(:cyan)
       elsif File.directory?(path)
         modified = Makit::Directory.modified(path)
-        age = (Time.now -modified).to_f
-        puts "#{path} age is ".colorize(:grey) + "#{Makit::Humanize.get_humanized_duration(age)}".colorize(:cyan)
+        age = Time.now(-modified).to_f
+        puts "#{path} age is ".colorize(:grey) + Makit::Humanize.get_humanized_duration(age).to_s.colorize(:cyan)
       else
         puts "#{path} does not exist"
       end
@@ -33,9 +33,9 @@ module Makit
     def file(path)
       if File.file?(path)
         modified = File.mtime(path)
-        age = (Time.now - modified).to_f
+        (Time.now - modified).to_f
         humanized_size = Makit::Humanize.get_humanized_size(File.size(path))
-        #puts "#{file_symbol} ".colorize(:grey) + "#{humanized_size.rjust(10)} ".colorize(:cyan) + " #{path} ".colorize(:grey)
+        # puts "#{file_symbol} ".colorize(:grey) + "#{humanized_size.rjust(10)} ".colorize(:cyan) + " #{path} ".colorize(:grey)
         puts "#{file_symbol} ".colorize(:grey) + "#{File.basename(path)} ".colorize(:green) + "#{humanized_size.rjust(10)} ".colorize(:cyan) + " #{path} ".colorize(:grey) # + "modified #{Makit::Humanize.get_humanized_timestamp(modified)}".colorize(:grey) + " age #{Makit::Humanize.get_humanized_duration(age)}".colorize(:grey)
       else
         puts "#{path} does not exist"
@@ -49,8 +49,8 @@ module Makit
     end
 
     def file_symbol
-      #📄 (U+1F4C4) – "Page with Curl"
-      #"\u{1F4C4}"
+      # 📄 (U+1F4C4) – "Page with Curl"
+      # "\u{1F4C4}"
       "@"
     end
 
@@ -71,9 +71,9 @@ module Makit
 
     def size(path)
       if File.file?(path)
-        puts "#{path} size is ".colorize(:grey) + "#{Makit::Humanize.get_humanized_size(File.size(path))}".colorize(:cyan)
+        puts "#{path} size is ".colorize(:grey) + Makit::Humanize.get_humanized_size(File.size(path)).to_s.colorize(:cyan)
       elsif File.directory?(path)
-        puts "#{path} size is ".colorize(:grey) + "#{Makit::Humanize.get_humanized_size(Makit::Directory.get_size(path))}".colorize(:cyan)
+        puts "#{path} size is ".colorize(:grey) + Makit::Humanize.get_humanized_size(Makit::Directory.get_size(path)).to_s.colorize(:cyan)
       else
         puts "#{path} does not exist"
       end
@@ -81,16 +81,16 @@ module Makit
 
     def task(task)
       puts ("=" * 80).colorize(:grey)
-      puts "  ".colorize(:grey) + "#{task}".colorize(:green)
-      #puts ("=" * 100).colorize(:grey)
+      puts "  ".colorize(:grey) + task.to_s.colorize(:green)
+      # puts ("=" * 100).colorize(:grey)
     end
 
     def info(text)
-      puts "  ".colorize(:grey) + "#{text}".colorize(:cyan)
+      puts "  ".colorize(:grey) + text.to_s.colorize(:cyan)
     end
 
     def success(text)
-      puts "  ".colorize(:grey) + "#{text}".colorize(:green)
+      puts "  ".colorize(:grey) + text.to_s.colorize(:green)
     end
 
     def version(path)
@@ -104,7 +104,7 @@ module Makit
     end
 
     def git_branch
-      puts "#{git_branch_symbol} ".colorize(:grey) + "#{Makit::Git.branch}".colorize(:green) + " branch".colorize(:grey)
+      puts "#{git_branch_symbol} ".colorize(:grey) + Makit::Git::Repository.branch.to_s.colorize(:green) + " branch".colorize(:grey)
     end
   end
 end

data/lib/makit/storage.rb

@@ -7,18 +7,17 @@ module Makit
   class Storage
     # declare a private class variable, connection_string
     attr_accessor :directory #= nil
-    attr_accessor :protoc_json_serializer # = Makit::Serializer::new()
-    attr_accessor :protoc_binary_serializer # = Makit::Serializer::new()
+    attr_accessor :protoc_json_serializer, :protoc_binary_serializer # = Makit::Serializer::new() # = Makit::Serializer::new()
 
     def initialize(directory)
       @directory = directory
-      @protoc_json_serializer = Makit::Serializer::new(Makit::Proto3Formats::JSON)
-      @protoc_binary_serializer = Makit::Serializer::new(Makit::Proto3Formats::BINARY)
+      @protoc_json_serializer = Makit::Serializer.new(Makit::Proto3Formats::JSON)
+      @protoc_binary_serializer = Makit::Serializer.new(Makit::Proto3Formats::BINARY)
     end
 
     def save(object, key)
-      #puts "=" * 80
-      #puts "Saving object to storage"
+      # puts "=" * 80
+      # puts "Saving object to storage"
       # puts "=" * 80
       raise "directory is nil" if @directory.nil?
       raise "Object is nil" if object.nil?
@@ -26,14 +25,14 @@ module Makit
 
       # get the fully qualfied type name of the object
       type_name = object.class.to_s
-      #puts "Type name: #{type_name}"
+      # puts "Type name: #{type_name}"
 
       type_rel_dir = type_name.downcase.gsub("::", "/")
-      #puts "Type relative directory: #{type_rel_dir}"
+      # puts "Type relative directory: #{type_rel_dir}"
 
       # extract the file extension from the key
       file_extension = File.extname(key)
-      #puts "File extension: #{file_extension}"
+      # puts "File extension: #{file_extension}"
 
       serializer = nil
       if file_extension == ".json"
@@ -44,22 +43,20 @@ module Makit
         raise "Unknown file extension: #{file_extension}"
       end
       bytes = serializer.serialize(object)
-      #puts "Serialized object size: #{bytes.size} bytes"
+      # puts "Serialized object size: #{bytes.size} bytes"
 
-      rel_filename = File.join(type_rel_dir, "#{key}")
-      #puts "Relative filename: #{rel_filename}"
+      rel_filename = File.join(type_rel_dir, key.to_s)
+      # puts "Relative filename: #{rel_filename}"
 
       filename = File.join(@directory, rel_filename)
-      #puts "Saving object to file: #{filename}"
+      # puts "Saving object to file: #{filename}"
 
       # make sure the file directory has been created
       FileUtils.mkdir_p(File.dirname(filename)) unless File.directory?(File.dirname(filename))
       # write the bytes to the file
-      File.open(filename, "wb") do |file|
-        file.write(bytes)
-      end
+      File.binwrite(filename, bytes)
 
-      #puts "=" * 80
+      # puts "=" * 80
     end
 
     def load(type, key)
@@ -68,31 +65,31 @@ module Makit
 
       # get the fully qualfied type name of the object
       type_name = type.to_s # object.class.to_s
-      #puts "Type name: #{type_name}"
+      # puts "Type name: #{type_name}"
 
       type_rel_dir = type_name.downcase.gsub("::", "/")
-      #puts "Type relative directory: #{type_rel_dir}"
+      # puts "Type relative directory: #{type_rel_dir}"
 
       # extract the file extension from the key
-      file_extension = File.extname(key)
-      #puts "File extension: #{file_extension}"
+      File.extname(key)
+      # puts "File extension: #{file_extension}"
 
-      rel_filename = File.join(type_rel_dir, "#{key}")
-      #puts "Relative filename: #{rel_filename}"
+      rel_filename = File.join(type_rel_dir, key.to_s)
+      # puts "Relative filename: #{rel_filename}"
 
       filename = File.join(@directory, rel_filename)
-      #puts "Loading object from file: #{filename}"
+      # puts "Loading object from file: #{filename}"
 
       # make sure the file exists
       raise "File does not exist: #{filename}" unless File.exist?(filename)
 
       # read the bytes from the file
       bytes = File.read(filename, mode: "rb")
-      #puts "Read object from file: #{filename}"
+      # puts "Read object from file: #{filename}"
 
       # extract the file extension from the key
       file_extension = File.extname(key)
-      #puts "File extension: #{file_extension}"
+      # puts "File extension: #{file_extension}"
 
       serializer = nil
       if file_extension == ".json"
@@ -104,28 +101,26 @@ module Makit
       end
 
       # deserialize the object
-      object = serializer.deserialize(type, bytes)
-      #puts "Deserialized object size: #{bytes.size} bytes"
+      serializer.deserialize(type, bytes)
+      # puts "Deserialized object size: #{bytes.size} bytes"
 
       # if the object type inherits from Google::Protobuf::AbstractMessage,
       # then serialize to protobuf json format
-      #if object.is_a? Google::Protobuf::MessageExts
+      # if object.is_a? Google::Protobuf::MessageExts
       #  puts "Serializing to protobuf json format"
       #  serialized_object = object.to_json
       #  pretty_json = JSON.pretty_generate(JSON.parse(serialized_object))
       #  puts pretty_json
-      #else
+      # else
       #  puts "Serializing to Marshal format"
       #  serialized_object = Marshal.dump(object)
-      #end
+      # end
       # serialize the object
-      #serialized_object = Marshal.dump(object)
+      # serialized_object = Marshal.dump(object)
 
       # save the object to the storage
       # ...
-      #puts "=" * 80
-
-      object
+      # puts "=" * 80
     end
-  end # class Storage
-end # module Makit
+  end
+end

data/lib/makit/symbols.rb

@@ -4,6 +4,11 @@ require "rainbow"
 
 # https://symbl.cc/en/unicode/table/
 module Makit
+  # Unicode symbol utilities with colorization
+  #
+  # This class provides a collection of Unicode symbols with appropriate
+  # colors for use in terminal output. Symbols are provided for various
+  # purposes including status indicators, directional arrows, and decorative elements.
   class Symbols
     def self.checkmark
       "\u2713"
@@ -129,6 +134,13 @@ module Makit
       Rainbow("\u266B").yellow  # Beamed eighth notes
     end
 
+    # Get appropriate symbol for log severity level
+    #
+    # Returns a colored Unicode symbol that matches the given log severity level.
+    # Used primarily in log formatting to provide visual indicators.
+    #
+    # @param severity [String] The severity level (DEBUG, WARN, ERROR, FATAL)
+    # @return [String] Colored Unicode symbol or space for unrecognized levels
     def self.get_severity_symbol(severity)
       case severity
       when "DEBUG"

data/lib/makit/task_hooks.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+
+module Makit
+  # Task hooks for automatic timing, logging, and lifecycle management
+  # This provides optional instrumentation for Rake tasks
+  class TaskHooks
+    class << self
+      attr_reader :enabled, :task_stack, :performance_log
+
+      def initialize!
+        @enabled = false # Start disabled - must be explicitly enabled
+        @task_stack = []
+        @performance_log = "artifacts/task_performance.log"
+        @hooks_installed = false
+      end
+
+      def setup!
+        return if @hooks_installed
+
+        initialize! unless defined?(@enabled)
+
+        Rake::Task.class_eval do
+          alias_method :makit_original_execute, :execute
+
+          def execute(args = nil)
+            if Makit::TaskHooks.enabled?
+              Makit::TaskHooks.before_execute(name, args)
+              result = makit_original_execute(args)
+              Makit::TaskHooks.after_execute(name, args, result)
+              result
+            else
+              makit_original_execute(args)
+            end
+          rescue StandardError => e
+            Makit::TaskHooks.on_error(name, args, e) if Makit::TaskHooks.enabled?
+            raise
+          end
+        end
+
+        @hooks_installed = true
+      end
+
+      def enable!
+        initialize! unless defined?(@enabled)
+        @enabled = true
+        puts "🔧 Task timing enabled".colorize(:grey) if defined?(String.instance_method(:colorize))
+      end
+
+      def disable!
+        @enabled = false
+      end
+
+      def enabled?
+        @enabled == true
+      end
+
+      def before_execute(name, _args)
+        return unless enabled?
+
+        @task_stack.push({
+                           name: name,
+                           start_time: Time.now,
+                           level: @task_stack.length,
+                         })
+      end
+
+      def after_execute(name, _args, _result)
+        return unless enabled?
+
+        task_info = @task_stack.pop
+        return unless task_info && task_info[:name] == name
+
+        duration = Time.now - task_info[:start_time]
+        log_task_performance(name, duration, task_info[:level]) if duration > 0.1
+      end
+
+      def on_error(name, _args, error)
+        return unless enabled?
+
+        task_info = @task_stack.pop
+        return unless task_info
+
+        duration = Time.now - task_info[:start_time]
+        log_task_failure(name, duration, error, task_info[:level])
+      end
+
+      def clear_performance_logs
+        FileUtils.rm_f(@performance_log)
+        FileUtils.rm_f("artifacts/task_failures.log")
+      end
+
+      private
+
+      def log_task_performance(name, duration, level)
+        return if ENV["CI"] == "true" && duration < 1.0
+
+        FileUtils.mkdir_p("artifacts")
+        File.open(@performance_log, "a") do |f|
+          f.puts "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")},#{name},#{duration.round(4)},#{level}"
+        end
+      rescue StandardError
+        # Silently fail performance logging to not interrupt tasks
+      end
+
+      def log_task_failure(name, duration, error, _level)
+        failure_log = "artifacts/task_failures.log"
+        FileUtils.mkdir_p("artifacts")
+
+        File.open(failure_log, "a") do |f|
+          timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+          message = error.message.gsub(",", ";")
+          f.puts "#{timestamp},#{name},#{duration.round(4)},#{error.class.name},#{message}"
+        end
+      rescue StandardError
+        # Silently fail error logging
+      end
+    end
+
+    # Initialize when loaded
+    initialize!
+  end
+end