makit 0.0.0

data/lib/makit/mp/project_mp.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+require "json"
+require "yaml"
+
+module Makit
+  module V1
+    class Project
+      def to_yaml
+        data = JSON.parse(self.to_pretty_json)
+        data.to_yaml.sub(/^---\n/, '')
+      end
+
+      def self.create
+        project = nil
+        if (File.exist?(".makit.project.yml"))
+            yaml = File.read(".makit.project.yml")
+            # convert yaml to json
+            data = YAML.load(yaml)
+            json = JSON.pretty_generate(data)
+            project = Makit::V1::Project.decode_json(json)
+        
+        else
+          if (File.exist?(".makit.project.json"))
+                json = File.read("project.json")
+                project = Makit::V1::Project.decode_json(json)
+          else
+            project = Makit::V1::Project.new
+          end
+        end
+        project.set_default_values
+        project
+      end
+
+      def set_default_values
+        #self.language = "csharp"
+        #self.primary_artifact_type = "nuget"
+        if self.git_remote_url.nil? || self.git_remote_url.empty?
+            self.git_remote_url = `git remote get-url origin`.strip
+        end
+        if self.name.nil? || self.name.empty?
+            if(!self.git_remote_url.nil? && !self.git_remote_url.empty?)
+                self.name =get_name(File.basename(self.git_remote_url,".git"))# get_capitalized_name(File.basename(self.git_remote_url, ".git"))
+            else
+                self.name =get_name(File.basename(Dir.getwd))# get_capitalized_name(File.basename(Dir.getwd))
+            end
+        end
+        self
+      end
+
+      def get_name(name)
+        if !self.git_remote_url.nil? && !self.git_remote_url.empty?
+            is_dotnet = self.git_remote_url.include?("nuget")
+            if is_dotnet
+                get_capitalized_name(name)
+            end
+        end
+        name.downcase
+      end
+      def get_capitalized_name(name)
+        name.split(".").map(&:capitalize).join(".")
+      end
+
+      def save_as(filename)
+        extension = File.extname(filename)
+        case extension
+        when ".json"
+          File.write(filename, self.to_pretty_json)
+        when ".yml"
+          File.write(filename, self.to_yaml)
+        else
+          raise "unsupported file extension: #{extension}"
+        end
+      end
+
+      def with_dotnet_project(template,name,output)
+        if !self.dotnet_projects.any? { |project| project.output== output }
+          project = Makit::V1::DotNetProject.new
+            project.template = template
+            project.name = name
+            project.output = output
+            self.dotnet_projects << project
+        end
+      end
+
+      def setup_dotnet_projects
+        if self.dotnet_projects.any?
+            if(!File.exist?("#{self.name}.sln"))
+                puts "  Creating solution file: " + "#{self.name}.sln".colorize(:green)
+                "dotnet new sln -n #{self.name}".run unless File.exist?("#{self.name}.sln")
+            else
+                puts "  Solution file already exists: " + "#{self.name}.sln".colorize(:yellow)
+            end
+            self.dotnet_projects.each do |project|
+                if(!Dir.exist?("#{project.output}"))
+                    puts "  Creating project file: " + "#{project.name}/#{project.name}.csproj".colorize(:green)
+                    "dotnet new #{project.template} -n #{project.name} -o #{project.output}".run unless Dir.exist?("#{project.output}")
+
+                    # add the .csproj file to the .sln
+                    puts "  Adding project to solution: " + "#{project.output}/#{project.name}.csproj".colorize(:green)
+                    "dotnet sln #{self.name}.sln add #{project.output}/#{project.name}.csproj".run
+                else
+                    puts "  Project file already exists: " + "#{project.name}/#{project.name}.csproj".colorize(:yellow)
+                end
+            end
+        else
+            puts "  no dotnet projects found".colorize(:yellow)
+        end
+      end
+
+      def build_dotnet_projects
+        self.dotnet_projects.each do |project|
+            "dotnet build #{project.output} --configuration Release".run
+        end
+      end
+
+      def test_dotnet_projects
+        self.dotnet_projects.each do |project|
+            "dotnet test #{project.output} --configuration Release".run
+        end
+      end
+    end # class Project
+  end # module V1
+end # module Makit
+
+
+#task :setup do
+#    if(Makit::PROJECT.git_remote_url.include?("nuget") || 
+#       Makit::PROJECT.primary_artifact_type.include?("nuget"))
+  
+#      if(!File.exist?("#{Makit::PROJECT.name}.sln"))
+#        puts "  Creating solution file: " + "#{Makit::PROJECT.name}.sln".colorize(:green)
+#        "dotnet new sln -n #{Makit::PROJECT.name}".run unless File.exist?("#{Makit::PROJECT.name}.sln")
+#      end
+#    end
+  
+#    Makit::PROJECT.dotnet_projects.each do |project|  
+#      if(!Dir.exist?("#{project.output}"))
+#        puts "  Creating project file: " + "#{project.name}/#{project.name}.csproj".colorize(:green)
+#        "dotnet new #{project.template} -n #{project.name} -o #{project.output}".run unless Dir.exist?("#{project.output}")
+#      end
+#    end
+  
+    # add all .csproj file to the .sln
+#    Dir.glob("**/*.csproj").each do |file|
+#      "dotnet sln #{Makit::PROJECT.name}.sln add #{file}".run
+#    end
+    #template = "nunit"
+      #"dotnet new #{template} -n #{Makit::PROJECT.name}.Tests -o src/#{Makit::PROJECT.name}".run unless Dir.exist?("#{Makit::PROJECT.name}.Tests")
+  
+    #if(Makit::PROJECt.primary_artifact_type.include?("nuget"))
+    #  puts
+    #end
+#  end
+
+
+#"dotnet build src/Facilities.Models/Facilities.Models.csproj --configuration Release".run
+#    "dotnet build test/Facilities.Models.Tests/Facilities.Models.Tests.csproj --configuration Release".run
+#    "dotnet build examples/Facilities.Models.Wasm.Demo/Facilities.Models.Wasm.Demo.csproj --configuration Release".run
+
+#"dotnet test test/Facilities.Models.Tests/Facilities.Models.Tests.csproj --configuration Release".run

data/lib/makit/mp/string_mp.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require "json"
+# monkey patch String class with a run method
+
+class String
+  def run(args = nil)
+    if args.nil?
+      command = self
+      Makit::RUNNER.run(Makit::RUNNER::parse_command_request(command))
+    else
+      command = self
+      request = Makit::RUNNER.parse_args(command)
+      if args.is_a?(Hash)
+        args.each do |key, value|
+          request.send("#{key}=", value)
+        end
+      end
+      Makit::RUNNER.run(request)
+    end
+  end
+
+  def try(args = nil)
+    if args.nil?
+      command = self
+      Makit::RUNNER.try(command)
+    else
+      command = self
+      request = Makit::RUNNER.parse_args(command)
+      if args.is_a?(Hash)
+        args.each do |key, value|
+          request.send("#{key}=", value)
+        end
+      end
+      Makit::RUNNER.try(request)
+    end
+  end
+
+  # Read a value from a JSON file
+  # key is a string with the key to read, e.g. "AzureAd.Authority"
+  def get_json_value(key)
+    json = File.read(self)
+    data = JSON.parse(json)
+
+    # key delimiter is '.' so we can access nested keys
+    key.split(".").each do |k|
+      data = data[k]
+    end
+    data
+  end
+
+  alias_method :retrieve, :get_json_value
+
+  # Set a value in a JSON file
+  # key is a string with the key to set, e.g. "AzureAd.Authority"
+  def set_json_value(key, value)
+    file = File.read(self)
+    data = JSON.parse(file)
+    keys = key.split(".")
+    current = data
+
+    # Traverse and create any missing keys
+    keys[0..-2].each do |k|
+      current[k] ||= {}  # Create a new hash if the key doesn't exist
+      current = current[k]
+    end
+
+    # Set the value for the final key
+    current[keys[-1]] = value
+
+    # Write the JSON back to the file
+    File.write(self, JSON.pretty_generate(data))
+  end
+
+  # Alias for set_json_value
+  alias_method :assign, :set_json_value
+
+  def to_lines(max_length=80,indent_length=5)
+    if(self.length <= max_length)
+      return self
+    else
+      indent = " " * indent_length
+      words = self.split(" ")
+      lines = []
+      line = ""
+      words.each do |word|
+        if((line + word).length > max_length)
+          lines << line
+          line = indent + word
+        else
+          if(line.length == 0)
+            line = word
+          else
+          line += " " + word
+          end
+        end
+      end
+      lines << line
+      return lines.join("\n")
+    end
+  end
+end

data/lib/makit/nuget.rb

@@ -0,0 +1,57 @@
+require "tmpdir"
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the  Nuget package cache
+  #
+  # Example:
+  #
+  #   Makit::Directory.cache("Google.Protobuf", "3.27.2")
+  #
+  # dotnet nuget locals all --list
+  # dotnet nuget locals all --clear
+  #
+  class NuGet
+    def self.get_cache_dir(package, version)
+      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package, version)
+    end
+
+    def self.cache(package, version)
+      # if the package is already cached, there is nothing to do
+      if (!Dir.exist?(get_cache_dir(package, version)))
+        Dir.mktmpdir do |dir|
+          # Use the temp directory here
+          Dir.chdir(dir) do
+            system("dotnet new classlib -n ClassLib")
+            Dir.chdir("ClassLib") do
+
+              # display a list of directories in the current directory
+              puts Dir.entries(Dir.pwd)
+              # display a list of files in the current directory
+              puts Dir.entries(Dir.pwd)
+              puts "dotnet add ClassLib.csproj package #{package} --version #{version}"
+              system("dotnet add ClassLib.csproj package #{package} --version #{version}")
+            end
+          end
+          # The directory and its contents will be removed automatically after the block
+        end
+      end
+    end
+
+    def self.clear_cache(package, version)
+      if (Dir.exist?(get_cache_dir(package, version)))
+        FileUtils.rm_rf(get_cache_dir(package, version))
+      end
+    end
+
+    # get the latest version of the package
+    def self.get_latest_version(package)
+      dir = File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package)
+      if (Dir.exist?(dir))
+        versions = Dir.entries(dir).select { |entry| File.directory?(File.join(dir, entry)) && !(entry == "." || entry == "..") }
+        highest_version = Makit::Version::get_highest_version(versions)
+        return highest_version
+      end
+      nil
+    end
+  end
+end

data/lib/makit/protoc.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  class Protoc
+    def self.grpc_tools_path
+      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, "grpc.tools", Makit::Protoc::get_latest_grpc_tools_version)
+    end
+
+    def self.grpc_csharp_plugin_path
+      Makit::Protoc::find_plugin_path("grpc_csharp_plugin")
+    end
+    def self.setup
+      if (!Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE))
+        puts "  warning: Nuget package cache directory #{Makit::Directories::NUGET_PACKAGE_CACHE} not found".colorize(:red)
+        puts "  warning: Unable to proceed with protoc setup".colorize(:red)
+      else
+        Makit::NuGet::cache("Grpc.Tools", "2.66.0")
+        raise "Nuget package path #{Makit::Directories::NUGET_PACKAGE_CACHE} not found" if !Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE)
+
+        # test if protoc is installed by running >protoc --version
+        which_protoc = Makit::Environment.which("protoc")
+        if (Makit::Environment.which("protoc").nil?)
+          puts "  protoc not found, installing...".colorize(:red)
+          "go version".run
+          "go install google.golang.org/protobuf/cmd/protoc-gen-go@latest".run
+          "go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest".run
+          "go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@latest".run
+        else
+          puts "  protoc found at #{which_protoc}".colorize(:green)
+        end
+        raise "protoc not found" if !Makit::Environment.which("protoc")
+
+        #"git clone https://github.com/googleapis/googleapis.git third_party".run unless File.directory?("third_party/google")
+        puts "  grpc_tools_path " + "#{Makit::Protoc::grpc_tools_path}".colorize(:green)
+        puts "  grpc_csharp_plugin_path " + "#{Makit::Protoc::grpc_csharp_plugin_path}".colorize(:green)
+      end
+    end
+
+    # get the latest version of the grpc.tools package
+    def self.get_latest_grpc_tools_version
+      Makit::NuGet::get_latest_version("Grpc.Tools")
+    end
+
+    #GRPC_CSHARP_PLUGIN_PATH = Makit::Protoc::find_plugin_path("grpc_csharp_plugin")
+    def self.find_plugin_path(plugin_name)
+      # search for a file matching the pattern *grpc_csharp_plugin* in the grpc.tools directory
+      # should match on Windows and Linux
+      if (Makit::Environment.is_windows?)
+        plugin_name = plugin_name + ".exe"
+      end
+
+      plugin_path = Dir.glob("#{Makit::Directories::GRPC_TOOLS_PATH}/**/#{plugin_name}").first
+
+      raise "Plugin path #{plugin_path} not found" if !File.exist?(plugin_path)
+      plugin_path
+    end
+  end
+end

data/lib/makit/serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require "google/protobuf"
+# This module provides classes for the Makit gem.
+module Makit
+  module Proto3Formats
+    JSON = 0,
+           PRETTY_JSON = 1,
+    BINARY = 3
+  end
+
+  # This class provide methods for serializing and deserializing objects.
+  #
+  class Serializer
+    attr_accessor :format_map
+
+    def initialize(proto3_format = Proto3Formats::PRETTY_JSON)
+      @format_maps = {
+        ::Google::Protobuf::MessageExts => proto3_format,
+      }
+    end
+
+    # Serialize an object to a byte[] or a string
+    def serialize(object)
+      raise "Object is nil" if object.nil?
+      raise "object is not of type ::Google::Protobuf::MessageExts" if !object.is_a? ::Google::Protobuf::MessageExts
+
+      case @format_maps[::Google::Protobuf::MessageExts]
+      when Proto3Formats::JSON
+        puts "Serializing to protobuf json format"
+        object.to_json
+      when Proto3Formats::PRETTY_JSON
+        puts "Serializing to protobuf pretty json format"
+        json = object.to_json
+        pretty_json = JSON.pretty_generate(JSON.parse(json))
+        pretty_json
+      when Proto3Formats::BINARY
+        puts "Serializing to protobuf binary format"
+        serialized_object = object.to_proto
+      else
+        raise "Unknown serialization format"
+      end
+    end
+
+    # Deserialize a byte[] or a string to an object
+    def deserialize(type, data)
+      raise "data is nil" if data.nil?
+      case @format_maps[::Google::Protobuf::MessageExts]
+      when Proto3Formats::JSON
+        raise "data is not of type string" if !data.is_a? String
+        json = data
+        puts "Deserializing from protobuf json format into type #{type}"
+        # use the from_json method to deserialize the object
+        type.decode_json(json)
+      when Proto3Formats::PRETTY_JSON
+        raise "data is not of type string" if !data.is_a? String
+        json = data
+        puts "Deserializing from protobuf pretty json format into type #{type}"
+        # use the from_json method to deserialize the object
+        type.decode_json(json)
+      when Proto3Formats::BINARY
+        #raise "data is not of type byte[]" if !data.is_a? Array
+        bytes = data
+        puts "Deserializing from protobuf binary format into type #{type}"
+        type.decode(bytes)
+      else
+        raise "Unknown serialization format"
+      end
+    end
+  end # class Storage
+end # module Makit

data/lib/makit/storage.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for serializing and deserializing objects.
+  #
+  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()
+
+    def initialize(directory)
+      @directory = directory
+      @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
+      raise "directory is nil" if @directory.nil?
+      raise "Object is nil" if object.nil?
+      raise "Key is nil" if key.nil?
+
+      # get the fully qualfied type name of the object
+      type_name = object.class.to_s
+      puts "Type name: #{type_name}"
+
+      type_rel_dir = type_name.downcase.gsub("::", "/")
+      puts "Type relative directory: #{type_rel_dir}"
+
+      # extract the file extension from the key
+      file_extension = File.extname(key)
+      puts "File extension: #{file_extension}"
+
+      serializer = nil
+      if file_extension == ".json"
+        serializer = @protoc_json_serializer
+      elsif file_extension == ".pb"
+        serializer = @protoc_binary_serializer
+      else
+        raise "Unknown file extension: #{file_extension}"
+      end
+      bytes = serializer.serialize(object)
+      puts "Serialized object size: #{bytes.size} bytes"
+
+      rel_filename = File.join(type_rel_dir, "#{key}")
+      puts "Relative filename: #{rel_filename}"
+
+      filename = File.join(@directory, rel_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
+
+      puts "=" * 80
+    end
+
+    def load(type, key)
+      raise "directory is nil" if @directory.nil?
+      raise "Key is nil" if key.nil?
+
+      # get the fully qualfied type name of the object
+      type_name = type.to_s # object.class.to_s
+      puts "Type name: #{type_name}"
+
+      type_rel_dir = type_name.downcase.gsub("::", "/")
+      puts "Type relative directory: #{type_rel_dir}"
+
+      # extract the file extension from the key
+      file_extension = File.extname(key)
+      puts "File extension: #{file_extension}"
+
+      rel_filename = File.join(type_rel_dir, "#{key}")
+      puts "Relative filename: #{rel_filename}"
+
+      filename = File.join(@directory, rel_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}"
+
+      # extract the file extension from the key
+      file_extension = File.extname(key)
+      puts "File extension: #{file_extension}"
+
+      serializer = nil
+      if file_extension == ".json"
+        serializer = @protoc_json_serializer
+      elsif file_extension == ".pb"
+        serializer = @protoc_binary_serializer
+      else
+        raise "Unknown file extension: #{file_extension}"
+      end
+
+      # deserialize the object
+      object = 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
+      #  puts "Serializing to protobuf json format"
+      #  serialized_object = object.to_json
+      #  pretty_json = JSON.pretty_generate(JSON.parse(serialized_object))
+      #  puts pretty_json
+      #else
+      #  puts "Serializing to Marshal format"
+      #  serialized_object = Marshal.dump(object)
+      #end
+      # serialize the object
+      #serialized_object = Marshal.dump(object)
+
+      # save the object to the storage
+      # ...
+      puts "=" * 80
+
+      object
+    end
+  end # class Storage
+end # module Makit