dev_suite 0.2.7 → 0.2.10

data/examples/workflow/loop_workflow.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create a workflow with a looping step
+engine = DevSuite::Workflow::Engine.new(iteration_count: 0)
+
+# Add a loop step
+loop_step = DevSuite::Workflow.create_loop_step("Repeat Task", 3) do |context|
+  iteration = context.get(:iteration_count) + 1
+  context.update({ iteration_count: iteration })
+  puts "Iteration #{iteration}"
+end
+
+engine.step(loop_step)
+engine.execute

data/examples/workflow/order_processing_workflow.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "../helpers"
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Constants
+BASE_URL = "https://ecommerce.example.com"
+NUMBER_OF_USERS = 500
+CHUNK_SIZE = 50
+DEFAULT_PASSWORD = "password123"
+STORE_PATH = "tmp/order_store.json"
+
+# Headers for HTTP requests
+REQUEST_HEADERS = {
+  "accept" => "*/*",
+  "content-type" => "application/x-www-form-urlencoded",
+  "user-agent" => "Mozilla/5.0",
+}
+
+# Helper Functions
+def register_user(username, phone, password)
+  endpoint = "#{BASE_URL}/api/v1/register"
+  body_data = { "username" => username, "phone" => phone, "password" => password }
+  APIHelper.make_post_request(endpoint: endpoint, body_data: body_data, success_criteria: ->(response) {
+    response["status"] == "success"
+  })
+end
+
+def login_user(username, password)
+  endpoint = "#{BASE_URL}/api/v1/login"
+  body_data = { "username" => username, "password" => password }
+  APIHelper.make_post_request(endpoint: endpoint, body_data: body_data, success_criteria: ->(response) {
+    response["token"].present?
+  })
+end
+
+def fetch_order(token, user_id)
+  endpoint = "#{BASE_URL}/api/v1/orders"
+  body_data = { "token" => token, "user_id" => user_id }
+  APIHelper.make_post_request(endpoint: endpoint, body_data: body_data, success_criteria: ->(response) {
+    response["order_id"].present?
+  })
+end
+
+def process_payment(order_id, token, user_id)
+  endpoint = "#{BASE_URL}/api/v1/pay"
+  body_data = { "order_id" => order_id, "token" => token, "user_id" => user_id }
+  APIHelper.make_post_request(endpoint: endpoint, body_data: body_data, success_criteria: ->(response) {
+    response["status"] == "success"
+  })
+end
+
+# Workflow Steps
+register_step = DevSuite::Workflow.create_step("Register Users") do |ctx|
+  users = []
+  password = ctx.get(:password)
+
+  # Generate fake users using Faker
+  user_tasks = Array.new(NUMBER_OF_USERS) do
+    {
+      username: DataHelper.generate_human_username,
+      phone: DataHelper.generate_phone_number,
+      password: password,
+    }
+  end
+
+  user_chunks = user_tasks.each_slice(CHUNK_SIZE).to_a
+
+  user_chunks.each do |chunk|
+    parallel_step = DevSuite::Workflow.create_parallel_step("Parallel Registration") do |ctx|
+      chunk.map do |user_data|
+        ->(ctx) {
+          username = user_data[:username]
+          phone = user_data[:phone]
+          password = user_data[:password]
+
+          puts "Registering user #{username}..."
+          response = register_user(username, phone, password)
+
+          if response[:success]
+            puts "User #{username} registered successfully!"
+            users << user_data
+          else
+            puts "Failed to register #{username}: #{response&.dig(:response, "error") || "Unknown error"}"
+          end
+        }
+      end
+    end
+    parallel_step.run(ctx)
+  end
+
+  ctx.set(:users, users)
+  ctx.data
+end
+
+save_users_step = DevSuite::Workflow.create_conditional_step("Save Users to Store", ->(ctx) {
+  ctx.get(:users)&.any?
+}) do |ctx|
+  ctx.store.set(:users, ctx.get(:users))
+  puts "Saved #{ctx.get(:users).size} users to the store."
+  ctx.data
+end
+
+login_step = DevSuite::Workflow.create_conditional_step("Login Users", ->(ctx) {
+  ctx.get(:username) && ctx.get(:password)
+}) do |ctx|
+  response = login_user(ctx.get(:username), ctx.get(:password))
+
+  if response[:success]
+    ctx.set(:token, response[:response]["token"])
+    ctx.set(:user_id, response[:response]["user_id"])
+    puts "User #{ctx.get(:username)} logged in successfully!"
+  else
+    puts "Failed to log in user #{ctx.get(:username)}."
+  end
+
+  ctx.data
+end
+
+fetch_order_step = DevSuite::Workflow.create_conditional_step("Fetch Orders", ->(ctx) {
+  ctx.get(:token) && ctx.get(:user_id)
+}) do |ctx|
+  response = fetch_order(ctx.get(:token), ctx.get(:user_id))
+
+  if response[:success]
+    ctx.set(:order_id, response[:response]["order_id"])
+    puts "Order fetched for user #{ctx.get(:username)}: Order ID #{response[:response]["order_id"]}"
+  else
+    puts "Failed to fetch order for user #{ctx.get(:username)}."
+  end
+
+  ctx.data
+end
+
+process_payment_step = DevSuite::Workflow.create_conditional_step("Process Payment", ->(ctx) {
+  ctx.get(:order_id) && ctx.get(:token) && ctx.get(:user_id)
+}) do |ctx|
+  response = process_payment(ctx.get(:order_id), ctx.get(:token), ctx.get(:user_id))
+
+  if response[:success]
+    puts "Payment processed for order #{ctx.get(:order_id)}."
+  else
+    puts "Failed to process payment for order #{ctx.get(:order_id)}."
+  end
+
+  ctx.data
+end
+
+# Main Workflow Execution
+workflow = DevSuite::Workflow.create_engine(
+  { password: DEFAULT_PASSWORD },
+  driver: :file,
+  path: STORE_PATH,
+)
+
+workflow.step(register_step)
+  .step(save_users_step)
+  .step(login_step)
+  .step(fetch_order_step)
+  .step(process_payment_step)
+  .execute

data/examples/workflow/parallel_workflow.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create a workflow with parallel tasks
+engine = DevSuite::Workflow::Engine.new
+
+parallel_step = DevSuite::Workflow.create_parallel_step("Parallel Task") do |context|
+  [
+    ->(ctx) { puts "Task 1 executed" },
+    ->(ctx) { puts "Task 2 executed" },
+  ]
+end
+
+engine.step(parallel_step)
+engine.execute

data/lib/dev_suite/dev_suite.rb

@@ -7,6 +7,9 @@ module DevSuite
   require_relative "performance"
   require_relative "directory_tree"
   require_relative "request_logger"
+  require_relative "request_builder"
+  require_relative "workflow"
+  require_relative "method_tracer"
 
   class Error < StandardError; end
 end

data/lib/dev_suite/method_tracer/config/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    module Config
+      include Utils::Construct::Config::Manager
+
+      require_relative "configuration"
+    end
+  end
+end

data/lib/dev_suite/method_tracer/config/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    module Config
+      class Configuration < Utils::Construct::Config::Base
+        set_default_settings(
+          show_params: false,
+          show_results: false,
+          show_execution_time: false,
+          max_depth: nil,
+        )
+      end
+    end
+  end
+end

data/lib/dev_suite/method_tracer/config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    module Config
+      require_relative "config/config"
+    end
+  end
+end

data/lib/dev_suite/method_tracer/helpers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    module Helpers
+      class << self
+        def internal_call?(tp)
+          tp.path&.include?("<internal:") || tp.defined_class.to_s.start_with?("TracePoint")
+        end
+
+        def format_method_name(tp)
+          "#{tp.defined_class}##{tp.method_id}"
+        end
+
+        def format_params(tp)
+          param_values = tp.binding.local_variables.map do |var|
+            tp.binding.local_variable_get(var).inspect
+          end.join(", ")
+          "(#{param_values})"
+        end
+
+        def format_result(tp)
+          " #=> #{tp.return_value.inspect}"
+        end
+
+        def format_execution_time(duration)
+          duration ? " in #{duration}ms" : ""
+        end
+
+        def calculate_duration(tp, start_times)
+          start_time = start_times.delete(tp.method_id)
+          start_time ? ((Time.now - start_time) * 1000.0).round(2) : nil
+        end
+
+        def calculate_indent(depth)
+          "  " * [(depth - 1), 0].max
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/method_tracer/logger.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    module Logger
+      class << self
+        def log_method_call(tp, tracer)
+          tracer.depth += 1
+
+          method_name = Helpers.format_method_name(tp)
+          params_str = Helpers.format_params(tp) if tracer.show_params
+          indent = Helpers.calculate_indent(tracer.depth)
+
+          # Store the start time for execution time calculation
+          tracer.start_times[tp.method_id] = Time.now
+
+          message = "#{indent}#depth:#{tracer.depth} > #{method_name} at #{tp.path}:#{tp.lineno} #{params_str}"
+          Utils::Logger.log(
+            message,
+            emoji: :start,
+            color: :blue,
+          )
+        end
+
+        def log_method_return(tp, tracer)
+          duration = Helpers.calculate_duration(tp, tracer.start_times)
+
+          method_name = Helpers.format_method_name(tp)
+          result_str = Helpers.format_result(tp) if tracer.show_results
+          exec_time_str = Helpers.format_execution_time(duration) if tracer.show_execution_time
+          indent = Helpers.calculate_indent(tracer.depth)
+
+          message = "#{indent}#depth:#{tracer.depth} < #{method_name}#{result_str} at #{tp.path}:#{tp.lineno}#{exec_time_str}"
+          Utils::Logger.log(
+            message,
+            emoji: :finish,
+            color: :cyan,
+          )
+
+          # Decrement depth safely
+          tracer.depth = [tracer.depth - 1, 0].max
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/method_tracer/method_tracer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    require_relative "tracer"
+    require_relative "logger"
+    require_relative "helpers"
+    require_relative "config"
+
+    class << self
+      def trace(options = {}, &block)
+        # Merge global configuration with options provided in the call
+        settings = Config.configuration.settings.merge(options)
+
+        # Use the merged settings to initialize the tracer
+        Tracer.new(**settings).trace(&block)
+      end
+    end
+  end
+end

data/lib/dev_suite/method_tracer/tracer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    class Tracer
+      attr_reader :show_params, :show_results, :show_execution_time, :max_depth
+      attr_accessor :depth, :trace_point, :start_times
+
+      def initialize(
+        show_params: false,
+        show_results: false,
+        show_execution_time: false,
+        max_depth: nil
+      )
+        @show_params = show_params
+        @show_results = show_results
+        @show_execution_time = show_execution_time
+        @max_depth = max_depth
+        @depth = 0
+        @start_times = {}
+      end
+
+      def trace(&block)
+        setup_trace_point
+        trace_point.enable
+        block.call
+      ensure
+        trace_point&.disable
+      end
+
+      private
+
+      def setup_trace_point
+        self.trace_point = TracePoint.new(:call, :return) do |tp|
+          next if Helpers.internal_call?(tp)
+
+          handle_trace_point_event(tp)
+        end
+      end
+
+      def handle_trace_point_event(tp)
+        case tp.event
+        when :call
+          handle_call_event(tp)
+        when :return
+          handle_return_event(tp)
+        else
+          raise "Unknown event type: #{tp.event}"
+        end
+      end
+
+      def handle_call_event(tp)
+        Logger.log_method_call(tp, self) if depth_within_limit?
+      end
+
+      def handle_return_event(tp)
+        Logger.log_method_return(tp, self) if depth_within_limit?
+      end
+
+      def depth_within_limit?
+        max_depth.nil? || @depth < max_depth
+      end
+    end
+  end
+end

data/lib/dev_suite/method_tracer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module MethodTracer
+    require_relative "method_tracer/method_tracer"
+  end
+end

data/lib/dev_suite/request_builder/builder/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Builder
+      class Base
+        attr_reader :url, :headers, :tool
+
+        def initialize(url:, headers: {}, tool:)
+          @url = url
+          @headers = headers
+          @tool = tool
+        end
+
+        def build_command
+          raise NotImplementedError, "Subclasses must implement the `build_command` method"
+        end
+
+        protected
+
+        def format_headers
+          headers.map { |key, value| "#{key}: #{value}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/builder/builder.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Builder
+      require_relative "base"
+      require_relative "http"
+    end
+  end
+end

data/lib/dev_suite/request_builder/builder/http.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Builder
+      class Http < Base
+        attr_reader :http_method, :body
+
+        def initialize(url:, http_method: "GET", headers: {}, body: nil, tool:)
+          super(url: url, headers: headers, tool: tool)
+          @http_method = http_method.upcase
+          @body = body
+        end
+
+        def build_command
+          case tool
+          when :curl
+            Tool::Curl.new.build_command(http_method: http_method, url: url, headers: headers, body: format_body(body))
+          else
+            raise ArgumentError, "Unknown tool: #{tool}"
+          end
+        end
+
+        private
+
+        def format_body(body)
+          Formatter::Graphql.new.format_body(body)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/builder.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Builder
+      require_relative "builder/builder"
+    end
+  end
+end

data/lib/dev_suite/request_builder/config/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Config
+      include Utils::Construct::Config::Manager
+
+      require_relative "configuration"
+    end
+  end
+end

data/lib/dev_suite/request_builder/config/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Config
+      class Configuration < Utils::Construct::Config::Base
+        set_default_settings(
+          tool: {
+            curl: {
+              use_insecure: false,
+              raw_data: false,
+              verbose: false,
+              follow_redirects: true,
+              cookie: nil,
+              user_agent: "Mozilla/5.0 (compatible; RequestBuilder/1.0)",
+              max_time: nil,
+              connect_timeout: nil,
+            },
+          },
+        )
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Config
+      require_relative "config/config"
+    end
+  end
+end

data/lib/dev_suite/request_builder/formatter/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Formatter
+      class Base
+        def format_body(body)
+          raise NotImplementedError, "Subclasses must implement the `format_body` method"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/formatter/formatter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Formatter
+      require_relative "base"
+      require_relative "graphql"
+    end
+  end
+end

data/lib/dev_suite/request_builder/formatter/graphql.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Formatter
+      class Graphql < Base
+        def format_body(body)
+          if body.is_a?(Hash) && body[:query] && body[:variables]
+            { query: body[:query], variables: body[:variables] }.to_json
+          elsif body.is_a?(String)
+            { query: body, variables: {} }.to_json
+          else
+            raise ArgumentError, "Invalid GraphQL body format"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/formatter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Formatter
+      require_relative "formatter/formatter"
+    end
+  end
+end

data/lib/dev_suite/request_builder/request_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    require_relative "config"
+    require_relative "formatter"
+    require_relative "tool"
+    require_relative "builder"
+
+    class << self
+      def build(protocol:, tool:, **options)
+        case protocol
+        when :http
+          Builder::Http.new(tool: tool, **options)
+        else
+          raise ArgumentError, "Unknown protocol: #{protocol}"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      class Base < Utils::Construct::Component::Base
+        def build_command(http_method:, url:, headers:, body: nil)
+          raise NotImplementedError
+        end
+
+        private
+
+        def fetch_setting(key, default: nil)
+          Config.configuration.settings.get(key, default: default)
+        end
+      end
+    end
+  end
+end