dev_suite 0.2.2 → 0.2.4

data/lib/dev_suite/directory_tree.rb

@@ -2,13 +2,6 @@
 
 module DevSuite
   module DirectoryTree
-    require "pathname"
-
-    require_relative "directory_tree/node"
-    require_relative "directory_tree/config"
-    require_relative "directory_tree/settings"
-    require_relative "directory_tree/renderer"
-    require_relative "directory_tree/builder"
-    require_relative "directory_tree/visualizer"
+    require_relative "directory_tree/directory_tree"
   end
 end

data/lib/dev_suite/emoji.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Emoji
+    # A frozen hash that contains all the emojis used in the application.
+    EMOJIS = {
+      start: "🚀",
+      success: "✅",
+      error: "🚨❌",
+      retry: "💥",
+      info: "ℹ️",
+      warning: "⚠️",
+      note: "📝",       # For notes or annotations
+      tip: "💡",        # For tips or helpful hints
+      important: "❗",  # For important information
+      caution: "⚠️", # For warnings or cautions
+      document: "📄",   # For representing documents or files
+      code: "💻",       # For code or technical content
+      update: "🔄",     # For updates or changes
+      bug: "🐞",        # For bugs or issues
+      fix: "🔧",        # For fixes or repairs
+    }.freeze
+
+    class << self
+      # Returns the emoji corresponding to the given key.
+      # @param key [Symbol] the key to look up the emoji
+      # @return [String] the corresponding emoji or an empty string if not found
+      def get(key)
+        EMOJIS[key] || ""
+      end
+    end
+  end
+end

data/lib/dev_suite/error_handler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module ErrorHandler
+    extend self # This makes all instance methods behave like class methods
+
+    def handle_error(error)
+      Logger.log(
+        "Oops! An error occurred: #{error.message}",
+        level: :error,
+        emoji: :error,
+      )
+      Logger.log(
+        "For more information, please refer to the README: " \
+          "https://github.com/patrick204nqh/dev_suite",
+        level: :error,
+        emoji: :document,
+      )
+      # exit(1)
+    end
+  end
+end

data/lib/dev_suite/logger.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Logger
+    LOG_DETAILS = {
+      info: { prefix: "[INFO]", color: :green },
+      warn: { prefix: "[WARNING]", color: :yellow },
+      error: { prefix: "[ERROR]", color: :red },
+      debug: { prefix: "[DEBUG]", color: :blue },
+    }.freeze
+
+    class << self
+      # Logs a message with an optional emoji and specified log level.
+      #
+      # @param message [String] The message to log.
+      # @param level [Symbol] The log level (:info, :warn, :error, :debug).
+      # @param emoji [String, Symbol] Optional emoji to prepend to the message.
+      def log(message, level: :info, emoji: nil)
+        emoji_icon = resolve_emoji(emoji)
+        formatted_message = format_message("#{emoji_icon} #{message}", level)
+        output_log(formatted_message)
+      end
+
+      private
+
+      # Resolves the emoji, either from a symbol or directly as a string.
+      #
+      # @param emoji [String, Symbol, nil] The emoji or its symbol key.
+      # @return [String] The resolved emoji or an empty string if none is provided.
+      def resolve_emoji(emoji)
+        return "" unless emoji
+
+        emoji.is_a?(Symbol) ? Emoji.get(emoji) : emoji
+      end
+
+      # Formats the log message with the appropriate prefix and color.
+      #
+      # @param message [String] The message to format.
+      # @param level [Symbol] The log level (:info, :warn, :error, :debug).
+      # @return [String] The formatted log message.
+      def format_message(message, level)
+        details = LOG_DETAILS[level]
+        raise ArgumentError, "Invalid log level: #{level}" unless details
+
+        Utils::Color.colorize("#{details[:prefix]} #{message}", color: details[:color])
+      end
+
+      # Outputs the formatted log message to the console.
+      #
+      # @param formatted_message [String] The message to output.
+      def output_log(formatted_message)
+        puts formatted_message if formatted_message
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/analyzer.rb

@@ -5,10 +5,7 @@ module DevSuite
     class Analyzer
       def initialize(description: "Block")
         @description = description
-
-        @benchmark_profiler = Profiler::Benchmark.new
-        @memory_profiler = Profiler::Memory.new
-        @memory_usage = Data::MemoryUsage.new
+        @profiler_manager = ProfilerManager.new
       end
 
       # Analyzes the performance of the given block
@@ -17,34 +14,20 @@ module DevSuite
       def analyze(&block)
         raise ArgumentError, "No block given" unless block_given?
 
-        memory_before = @memory_usage.current
-        benchmark_result = profile_benchmark(&block)
-        memory_after = @memory_usage.current
-
-        memory_stats = @memory_profiler.stats(memory_before, memory_after)
-
-        generate_report(benchmark_result, memory_stats)
+        outcome = @profiler_manager.run(&block)
+        generate_report(@profiler_manager.results)
+        outcome
       end
 
       private
 
-      # Profiles the benchmark of the given block
-      # @param block [Proc] The block to be benchmarked
-      # @return [Benchmark::Tms] The benchmark result
-      def profile_benchmark(&block)
-        @benchmark_profiler.run do
-          @memory_profiler.profile(&block)
-        end
-      end
-
       # Generates a performance report
       # @param benchmark_result [Benchmark::Tms] The benchmark result
       # @param memory_stats [Hash] The memory statistics
-      def generate_report(benchmark_result, memory_stats)
+      def generate_report(results)
         Config.configuration.reportor.generate(
           description: @description,
-          benchmark_result: benchmark_result,
-          memory_stats: memory_stats,
+          results: results,
         )
       end
     end

data/lib/dev_suite/performance/config.rb

@@ -5,11 +5,32 @@ module DevSuite
     class Config
       include Utils::ConfigTools::Configuration
 
-      attr_reader :reportor
+      # Define configuration attributes
+      config_attr :profilers, default_value: [:execution_time, :memory]
+      config_attr :reportor, default_value: :simple
 
-      def initialize(reportor: :simple)
-        @reportor = Reportor.create(reportor)
-        freeze # Make the instance of this class immutable
+      private
+
+      def validate_attr!(attr, value)
+        case attr
+        when :profilers
+          validate_array!(attr, value)
+        when :reportor
+          validate_symbol!(attr, value)
+        else
+          raise ArgumentError, "Invalid attribute: #{attr}"
+        end
+      end
+
+      def resolve_attr(attr, value)
+        case attr
+        when :profilers
+          Profiler.create_multiple(value)
+        when :reportor
+          Reportor.create(value)
+        else
+          value
+        end
       end
     end
   end

data/lib/dev_suite/performance/profiler/execution_time.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    module Profiler
+      class ExecutionTime < Base
+        attr_reader :stats
+
+        def run(&block)
+          result = nil
+          timing = ::Benchmark.measure { result = yield }
+          @stats = calculate_stats(timing)
+          result
+        end
+
+        private
+
+        def calculate_stats(timing)
+          {
+            real: timing.real,
+            utime: timing.utime,
+            stime: timing.stime,
+            total: timing.total,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/profiler/memory.rb

@@ -4,7 +4,7 @@ module DevSuite
   module Performance
     module Profiler
       class Memory < Base
-        attr_reader :max_memory, :min_memory, :average_memory
+        attr_reader :stats
 
         def initialize
           super
@@ -12,30 +12,36 @@ module DevSuite
           @memory_points = []
         end
 
-        def profile(&block)
-          yield
-          record_memory
+        def run(&block)
+          before_memory = record_memory
+          result = yield
+          after_memory = record_memory
+
+          @stats = calculate_stats(before_memory, after_memory)
+          result
+        end
+
+        private
+
+        def record_memory
+          current_mem = @memory_usage.current
+          @memory_points << current_mem
+          current_mem
         end
 
-        def stats(before, after)
+        def calculate_stats(before, after)
           memory_used = after - before
-          @average_memory = @memory_points.sum / @memory_points.size
+          average_memory = @memory_points.sum / @memory_points.size
+
           {
             before: before,
             after: after,
             used: memory_used,
             max: @memory_points.max,
             min: @memory_points.min,
-            avg: @average_memory,
+            avg: average_memory,
           }
         end
-
-        private
-
-        def record_memory
-          current_mem = @memory_usage.current
-          @memory_points << current_mem
-        end
       end
     end
   end

data/lib/dev_suite/performance/profiler.rb

@@ -4,8 +4,25 @@ module DevSuite
   module Performance
     module Profiler
       require_relative "profiler/base"
-      require_relative "profiler/benchmark"
+      require_relative "profiler/execution_time"
       require_relative "profiler/memory"
+
+      class << self
+        def create(profiler)
+          case profiler
+          when :execution_time
+            ExecutionTime.new
+          when :memory
+            Memory.new
+          else
+            raise ArgumentError, "Invalid profiler: #{profiler}"
+          end
+        end
+
+        def create_multiple(profilers)
+          profilers.map { |profiler| create(profiler) }
+        end
+      end
     end
   end
 end

data/lib/dev_suite/performance/profiler_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    class ProfilerManager
+      attr_reader :results
+
+      def initialize
+        @results = {}
+      end
+
+      # Runs the configured profilers and returns the final result
+      def run(&block)
+        outcome = block.call
+        run_profilers(outcome)
+      end
+
+      private
+
+      # Runs each profiler and updates the results
+      # @param result [Object] The initial result from the block
+      # @return [Object] The final result after running all profilers
+      def run_profilers(outcome)
+        Config.configuration.profilers.each do |profiler|
+          outcome = run_profiler(profiler, outcome)
+        end
+        outcome
+      end
+
+      # Runs a single profiler and updates the results
+      # @param profiler [Profiler] The profiler to run
+      # @param result [Object] The current result
+      # @return [Object] The result after running the profiler
+      def run_profiler(profiler, outcome)
+        outcome = profiler.run { outcome }
+        update_results(profiler)
+        outcome
+      end
+
+      # Updates the results hash with the stats from the profiler
+      # @param profiler [Profiler] The profiler whose stats to update
+      def update_results(profiler)
+        key = to_snake_case(profiler.class.name.split("::").last)
+        @results[key] = profiler.stats
+      end
+
+      # Convert a class name to a snake_case symbol
+      # @param class_name [String] The class name to convert
+      # @return [Symbol] The snake_case symbol
+      def to_snake_case(class_name)
+        class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/reportor/helpers/stat_mappings.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    module Reportor
+      module Helpers
+        module StatMappings
+          PROFILER_STAT_TITLES = {
+            execution_time: {
+              real: "Total Time (s)",
+              utime: "User CPU Time (s)",
+              stime: "System CPU Time (s)",
+              total: "User + System CPU Time (s)",
+            },
+            memory: {
+              before: "Memory Before (MB)",
+              after: "Memory After (MB)",
+              used: "Memory Used (MB)",
+              max: "Max Memory Used (MB)",
+              min: "Min Memory Used (MB)",
+              avg: "Avg Memory Used (MB)",
+            },
+          }.freeze
+
+          class << self
+            def title_for(profiler_name, stat_name)
+              PROFILER_STAT_TITLES.dig(profiler_name, stat_name) || format_default_title(stat_name)
+            end
+
+            private
+
+            def format_default_title(metric)
+              metric.to_s.split("_").map(&:capitalize).join(" ")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/reportor/helpers/table_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    module Reportor
+      module Helpers
+        module TableBuilder
+          class << self
+            def build_table(description, results)
+              table = initialize_table
+              add_description(table, description)
+              add_profiler_data(table, results)
+              table
+            end
+
+            private
+
+            def initialize_table
+              Utils::Table::Table.new.tap do |table|
+                table.title = "Performance Analysis"
+                table.add_columns("Metric", "Value")
+              end
+            end
+
+            def add_description(table, description)
+              table.add_row(["Description", description])
+            end
+
+            def add_profiler_data(table, results)
+              results.each do |profiler_name, stats|
+                # table.add_row(["#{profiler_name.to_s.capitalize} Profiler", ""])
+                stats.each do |metric, value|
+                  title = StatMappings.title_for(profiler_name, metric)
+                  table.add_row([title, format_value(value)])
+                end
+              end
+            end
+
+            def format_value(value)
+              format("%.6f", value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/reportor/helpers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    module Reportor
+      module Helpers
+        require_relative "helpers/stat_mappings"
+        require_relative "helpers/table_builder"
+      end
+    end
+  end
+end

data/lib/dev_suite/performance/reportor/simple.rb

@@ -7,79 +7,25 @@ module DevSuite
         #
         # Generates the performance report
         #
-        def generate(description:, benchmark_result:, memory_stats:)
-          table = create_table
-          populate_table(
-            table,
-            description: description,
-            benchmark_result: benchmark_result,
-            memory_stats: memory_stats,
-          )
+        # @param description [String] The description of the analysis
+        # @param results [Hash] The profiling results from the profilers
+        #
+        def generate(description:, results:)
+          table = Helpers::TableBuilder.build_table(description, results)
           render_table(table)
         end
 
         private
 
         #
-        # Creates a new table with the specified configuration
-        #
-        def create_table
-          table = Utils::Table::Table.new
-          table.tap do |t|
-            t.title = "Performance Analysis"
-            t.add_columns("Metric", "Value")
-          end
-        end
-
-        #
-        # Populates the table with benchmark and memory statistics
-        #
-        def populate_table(table, description: "", benchmark_result: nil, memory_stats: {})
-          validate_benchmark_result(benchmark_result)
-          validate_memory_stats(memory_stats)
-
-          table.add_row(["Description", description])
-          table.add_row(["Total Time (s)", format("%.6f", benchmark_result.real)])
-          table.add_row(["User CPU Time (s)", format("%.6f", benchmark_result.utime)])
-          table.add_row(["System CPU Time (s)", format("%.6f", benchmark_result.stime)])
-          table.add_row(["User + System CPU Time (s)", format("%.6f", benchmark_result.total)])
-          table.add_row(["Memory Before (MB)", format("%.2f", memory_stats[:before])])
-          table.add_row(["Memory After (MB)", format("%.2f", memory_stats[:after])])
-          table.add_row(["Memory Used (MB)", format("%.2f", memory_stats[:used])])
-          table.add_row(["Max Memory Used (MB)", format("%.2f", memory_stats[:max])])
-          table.add_row(["Min Memory Used (MB)", format("%.2f", memory_stats[:min])])
-          table.add_row(["Avg Memory Used (MB)", format("%.2f", memory_stats[:avg])])
-        end
-
+        # Renders the table using the configured renderer
         #
-        # Renders the table using the specified renderer
+        # @param table [Utils::Table::Table] The table to render
         #
         def render_table(table)
           renderer = Utils::Table::Config.configuration.renderer
           puts renderer.render(table)
         end
-
-        #
-        # Validates the benchmark_result object
-        #
-        def validate_benchmark_result(benchmark_result)
-          required_methods = [:real, :utime, :stime, :total]
-          missing_methods = required_methods.reject { |method| benchmark_result.respond_to?(method) }
-          unless missing_methods.empty?
-            raise ArgumentError, "benchmark_result is missing required methods: #{missing_methods.join(", ")}"
-          end
-        end
-
-        #
-        # Validates the memory_stats hash
-        #
-        def validate_memory_stats(memory_stats)
-          required_keys = [:before, :after, :used, :max, :min, :avg]
-          missing_keys = required_keys.reject { |key| memory_stats.key?(key) }
-          unless missing_keys.empty?
-            raise ArgumentError, "memory_stats is missing required keys: #{missing_keys.join(", ")}"
-          end
-        end
       end
     end
   end

data/lib/dev_suite/performance/reportor.rb

@@ -5,6 +5,7 @@ module DevSuite
     module Reportor
       require_relative "reportor/base"
       require_relative "reportor/simple"
+      require_relative "reportor/helpers"
 
       class << self
         def create(reportor)

data/lib/dev_suite/performance.rb

@@ -7,6 +7,7 @@ module DevSuite
 
     require_relative "performance/data"
     require_relative "performance/profiler"
+    require_relative "performance/profiler_manager"
     require_relative "performance/reportor"
     require_relative "performance/analyzer"
     require_relative "performance/config"