dev_suite 0.2.7 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a7188e92386a13da83abc637b7446d68c485eff8e6e2198a53f88360ac13f02
-  data.tar.gz: f76c576284ba7b90bc671a389cd6e43065079f04ae19567b0e633a147e2b2276
+  metadata.gz: 92ff382f54afdf8f68f1f3d5f2f3bec8c496138b0af875b0970b2cceaec24e36
+  data.tar.gz: 743a74d46e4448c8e363d7b00e501bd1b2740eb5a10eb1bd019432cb01afd4ea
 SHA512:
-  metadata.gz: b565a159f2aee25115301ae629dcd2e44e844005586c2505e92cd18f75f9845a856c16f8db1c5a309eb249f645ba1e90b6c36ca4e0958f6106f39d0d86f7434a
-  data.tar.gz: 7a34933bf806f8e3fb09351b200698da8d6f5568fefc3054f7ba0591c939dc264b9962c77cd56b6f01e5304b2bb60e5301885f33f34b05bebd54858046cb1e73
+  metadata.gz: 7dffd5d2cf8ca2f1712e4e9599e5432666e654a8b6c5696fc185a7898342f574018c2d1311fd96a832a956f4c3aacf1023a7c3ffd83523c3094fb8823b3133f2
+  data.tar.gz: db80d0b5c8d9f425ac520b59b6b0988bf5dabadaaaff2647312511aa47bb5eaf738661ec6efe6253028d031baedd49012b910cd0bda65dac6872eaa7c314affe

data/.codeclimate.yml

@@ -0,0 +1,12 @@
+version: "2"
+checks:
+  argument_count:
+    enabled: true
+  file_lines:
+    enabled: true
+ratings:
+  paths:
+    - "**.rb"
+exclude_patterns:
+  - "examples/**"  # Ignore examples folder
+  - "tmp/**"       # Ignore temp files

data/.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.0  # Specify your project's Ruby version
+          ruby-version: 3.0
 
       - name: Install dependencies
         run: bundle install

data/.sonarcloud.properties

@@ -0,0 +1,23 @@
+# Project identification
+sonar.projectKey=patrick204nqh_dev_suite
+# sonar.organization=
+
+# Source code encoding
+sonar.sourceEncoding=UTF-8
+
+# Sources and tests
+sonar.sources=lib,exe
+sonar.tests=spec
+
+# Paths to coverage reports
+# sonar.ruby.coverage.reportPaths=coverage/.resultset.json
+# sonar.testExecutionReportPaths=coverage/test-reports
+
+# Exclusions
+# sonar.exclusions=log/**, tmp/**, node_modules/**
+
+# Language specific settings
+sonar.language=ruby
+
+# Specify the main branch
+sonar.branch.name=master

data/Gemfile

@@ -13,6 +13,7 @@ group :development, :test do
   gem "rspec", "~> 3.9"
   gem "simplecov", "~> 0.21"
   gem "rake", "~> 13.0"
+  gem "faker", "~> 2.18"
 end
 
 group :development do

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    dev_suite (0.2.7)
+    dev_suite (0.2.10)
       benchmark (~> 0.1)
+      csv (~> 3.0)
       get_process_mem (~> 1.0)
       thor (~> 1.1)
 
@@ -13,9 +14,13 @@ GEM
     benchmark (0.3.0)
     bigdecimal (3.1.8)
     coderay (1.1.3)
+    concurrent-ruby (1.3.4)
+    csv (3.3.0)
     diff-lcs (1.5.1)
     docile (1.4.1)
-    faraday (1.10.3)
+    faker (2.23.0)
+      i18n (>= 1.8.11, < 2)
+    faraday (1.10.4)
       faraday-em_http (~> 1.0)
       faraday-em_synchrony (~> 1.0)
       faraday-excon (~> 1.1)
@@ -38,26 +43,18 @@ GEM
     faraday-patron (1.0.0)
     faraday-rack (1.0.0)
     faraday-retry (1.0.3)
-    ffi (1.17.0)
-    ffi (1.17.0-aarch64-linux-gnu)
-    ffi (1.17.0-aarch64-linux-musl)
-    ffi (1.17.0-arm-linux-gnu)
-    ffi (1.17.0-arm-linux-musl)
     ffi (1.17.0-arm64-darwin)
-    ffi (1.17.0-x86-linux-gnu)
-    ffi (1.17.0-x86-linux-musl)
-    ffi (1.17.0-x86_64-darwin)
-    ffi (1.17.0-x86_64-linux-gnu)
-    ffi (1.17.0-x86_64-linux-musl)
     get_process_mem (1.0.0)
       bigdecimal (>= 2.0)
       ffi (~> 1.0)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
     method_source (1.1.0)
     multipart-post (2.4.1)
-    parallel (1.25.1)
-    parser (3.3.4.1)
+    parallel (1.26.3)
+    parser (3.3.5.0)
       ast (~> 2.4.1)
       racc
     pry (0.14.2)
@@ -67,8 +64,6 @@ GEM
     rainbow (3.1.1)
     rake (13.2.1)
     regexp_parser (2.9.2)
-    rexml (3.3.6)
-      strscan
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -82,18 +77,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.1)
-    rubocop (1.65.1)
+    rubocop (1.66.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.4, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
+      rubocop-ast (>= 1.32.2, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.32.0)
+    rubocop-ast (1.32.3)
       parser (>= 3.3.1.0)
     rubocop-shopify (2.15.1)
       rubocop (~> 1.51)
@@ -105,25 +99,15 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    strscan (3.1.0)
-    thor (1.3.1)
+    thor (1.3.2)
     unicode-display_width (2.5.0)
 
 PLATFORMS
-  aarch64-linux-gnu
-  aarch64-linux-musl
-  arm-linux-gnu
-  arm-linux-musl
-  arm64-darwin
-  ruby
-  x86-linux-gnu
-  x86-linux-musl
-  x86_64-darwin
-  x86_64-linux-gnu
-  x86_64-linux-musl
+  arm64-darwin-23
 
 DEPENDENCIES
   dev_suite!
+  faker (~> 2.18)
   faraday (~> 1.4)
   pry (~> 0.14)
   rake (~> 13.0)

data/README.md

@@ -214,6 +214,222 @@ Log detailed HTTP requests and responses across different adapters like Net::HTT
   ```
 </details>
 
+### Workflow Engine
+Manage complex workflows consisting of multiple sequential steps, including handling data between steps and supporting dynamic operations like conditionals, loops, and parallel execution.
+
+<details>
+  <summary>Show more</summary>
+
+  **How to Use**:
+  ```ruby
+  workflow = DevSuite::Workflow.create_engine(initial_context)
+
+  # Define steps
+  step1 = DevSuite::Workflow.create_step("Step 1") do |ctx|
+    ctx.update({ result: "Step 1 Complete" })
+  end
+
+  step2 = DevSuite::Workflow.create_step("Step 2") do |ctx|
+    puts "Previous Result: #{ctx.get(:result)}"
+    ctx.update({ result: "Step 2 Complete" })
+  end
+
+  # Chain steps together
+  workflow.step(step1).step(step2)
+
+  # Execute workflow
+  workflow.execute
+  ```
+
+  **Chaining Steps**:
+  You can chain multiple steps together to create a workflow:
+  ```ruby
+  workflow = DevSuite::Workflow.create_engine(initial_context)
+  
+  step1 = DevSuite::Workflow.create_step("Step 1") { |ctx| ctx.update({ data: 'Data from Step 1' }) }
+  step2 = DevSuite::Workflow.create_step("Step 2") { |ctx| puts "Received: #{ctx.get(:data)}" }
+
+  workflow.step(step1)
+          .step(step2)
+          .execute
+  ```
+
+  **Data Handling**:
+  Each step in the workflow has access to a shared context, where you can store and retrieve data:
+  ```ruby
+  workflow = DevSuite::Workflow.create_engine({ some_key: 'initial_value' })
+
+  step1 = DevSuite::Workflow.create_step("Step 1") do |ctx|
+    # Retrieve data
+    puts ctx.get(:some_key)  # Output: initial_value
+    # Set data
+    ctx.update({ new_key: 'new_value' })
+  end
+
+  step2 = DevSuite::Workflow.create_step("Step 2") do |ctx|
+    # Use updated data
+    puts ctx.get(:new_key)  # Output: new_value
+  end
+
+  workflow.step(step1).step(step2).execute
+  ```
+
+  **Conditional Execution**:
+  Conditionally execute steps based on logic defined in the workflow context:
+  ```ruby
+  conditional_step = DevSuite::Workflow.create_conditional_step("Conditional Step", condition: ->(ctx) { ctx.get(:result) == "Step 1 Complete" }) do |ctx|
+    puts "Condition met! Executing conditional step."
+    ctx.update({ result: "Conditional Step Executed" })
+  end
+
+  workflow.step(conditional_step).execute
+  ```
+
+  **Parallel Execution**:
+  You can execute multiple steps in parallel:
+  ```ruby
+  parallel_step = DevSuite::Workflow.create_parallel_step("Parallel Step") do |ctx|
+    [
+      ->(ctx) { ctx.update({ task1: "Task 1 done" }) },
+      ->(ctx) { ctx.update({ task2: "Task 2 done" }) }
+    ]
+  end
+
+  workflow.step(parallel_step).execute
+  ```
+
+  **Save and Load Context**:
+  Save the workflow's context to a file and reload it for later use:
+  ```ruby
+  # Saving context to a YAML file
+  workflow = DevSuite::Workflow.create_engine({ user: 'John' })
+  workflow.step(DevSuite::Workflow.create_step("Example") { |ctx| ctx.update({ status: 'completed' }) })
+  workflow.execute
+
+  File.open('context.yml', 'w') { |file| file.write(YAML.dump(workflow.context.data)) }
+
+  # Loading context from a YAML file
+  loaded_data = YAML.load_file('context.yml')
+  workflow = DevSuite::Workflow.create_engine(loaded_data)
+  ```
+
+  **Looping**:
+  You can loop steps in the workflow, for instance, if you need to repeat a step multiple times:
+  ```ruby
+  loop_step = DevSuite::Workflow.create_loop_step("Repeat 5 Times", iterations: 5) do |ctx|
+    count = ctx.get(:count) || 0
+    ctx.update({ count: count + 1 })
+    puts "Iteration: #{ctx.get(:count)}"
+  end
+
+  workflow.step(loop_step).execute
+  ```
+
+  **Using the Store**:
+  By default, the workflow context provides access to an integrated store via ctx.store. You can save and retrieve data across steps:
+  ```ruby
+  # Using the store in the workflow
+  workflow = DevSuite::Workflow.create_engine(
+    {},
+    driver: :file,
+    path: "tmp/workflow.yml",
+  )
+  step = DevSuite::Workflow.create_step("Store Example") do |ctx|
+    ctx.store.set(:step_result, "Step 1 Completed")
+  end
+
+  workflow.step(step).execute
+
+  # Fetch data from the store
+  puts ctx.store.fetch(:step_result)  # Output: Step 1 Completed
+  ```
+
+  **Sample Output**:
+  ```bash
+  Step 1 executed: result => Step 1 Complete
+  Step 2 executed: Previous Result: Step 1 Complete
+  Task 1 done
+  Task 2 done
+  Iteration: 1
+  Iteration: 2
+  ...
+  Condition met! Executing conditional step.
+  Store contains: { name: "John Doe", age: 30 }
+  Step 1 Completed
+  ```
+
+</details>
+
+### Method Tracer
+Trace all method calls within a specific block of code, including optional logging of parameters, results, and execution time. This feature is useful for debugging, profiling, and understanding the flow of method calls in your code.
+
+<details>
+  <summary>Show more</summary>
+  
+  **How to Use**:
+  ```ruby
+  # Sample class for demonstration
+  class MathOperations
+    def add(a, b)
+      multiply(a, b) + 3
+    end
+
+    def multiply(a, b)
+      a * b
+    end
+
+    def greet(name)
+      "Hello, #{name}!"
+    end
+  end
+
+  # Using MethodTracer to trace method calls
+  DevSuite::MethodTracer.trace(show_params: true, show_results: true, show_execution_time: true) do
+    math = MathOperations.new
+    result = math.add(5, 3)
+    puts result
+    
+    greeting = math.greet("Ruby")
+    puts greeting  # Should print the greeting
+  end
+  ```
+
+  **Configuration Guide**:
+  Customize the method tracing behavior by setting configuration options:
+  ```ruby
+  DevSuite::MethodTracer.trace(
+    show_params: true,
+    show_results: true,
+    show_execution_time: true,
+    max_depth: 2
+  ) do
+    # Code block to trace
+  end
+  ```
+
+  **Configuration Options**:
+  
+  Below is a table describing the available options for `MethodTracer`:
+
+  | Option               | Description                                         | Default Value | Example Values            |
+  |----------------------|-----------------------------------------------------|---------------|---------------------------|
+  | `:show_params`       | Enables logging of method parameters.               | `false`       | `true`, `false`           |
+  | `:show_results`      | Logs the return values of the methods.              | `false`       | `true`, `false`           |
+  | `:show_execution_time` | Logs the execution time for each method.          | `false`       | `true`, `false`           |
+  | `:max_depth`         | Limits the depth of method calls to log.            | `nil`         | `1`, `2`, `3`, ...        |
+
+  **Sample Output**:
+  ```bash
+   🚀 #depth:1 > MathOperations#add at (irb):2 (5, 3)
+      🚀 #depth:2 > MathOperations#multiply at (irb):6 (5, 3)
+      🏁 #depth:2 < MathOperations#multiply #=> 15 at (irb):8 in 0.02ms
+   🏁 #depth:1 < MathOperations#add #=> 23 at (irb):4 in 7.35ms
+   🚀 #depth:1 > MathOperations#greet at (irb):10 ("Ruby")
+   🏁 #depth:1 < MathOperations#greet #=> "Hello, Ruby!" at (irb):12 in 0.02ms
+Hello, Ruby!
+```
+</details>
+
 ## Development
 
 After checking out the repo, run `bin/setup`for an interactive prompt that will allow you to experiment.

data/dev_suite.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies
   spec.add_dependency("benchmark", "~> 0.1")
+  spec.add_dependency("csv", "~> 3.0")
   spec.add_dependency("get_process_mem", "~> 1.0")
   spec.add_dependency("thor", "~> 1.1")
 end

data/examples/helpers/api_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module APIHelper
+  require "net/http"
+  require "uri"
+
+  class << self
+    def make_post_request(endpoint:, headers:, body_data:, success_criteria: nil)
+      uri = URI.parse(endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+      request.body = URI.encode_www_form(body_data)
+
+      response = http.request(request)
+      parsed_response = JSON.parse(response.body)
+
+      success = if success_criteria
+        success_criteria.call(parsed_response)
+      else
+        response.is_a?(Net::HTTPSuccess)
+      end
+
+      { success: success, response: parsed_response }
+    rescue StandardError => e
+      DevSuite::Utils::Logger.log("Error during POST request: #{e.message}", level: :error)
+      { success: false, error: e.message }
+    end
+
+    def make_get_request(endpoint:, headers:, success_criteria: nil)
+      uri = URI.parse(endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Get.new(uri.request_uri, headers)
+
+      response = http.request(request)
+      parsed_response = JSON.parse(response.body)
+
+      success = if success_criteria
+        success_criteria.call(parsed_response)
+      else
+        response.is_a?(Net::HTTPSuccess)
+      end
+
+      { success: success, response: parsed_response }
+    rescue StandardError => e
+      DevSuite::Utils::Logger.log("Error during GET request: #{e.message}", level: :error)
+      { success: false, error: e.message }
+    end
+  end
+end

data/examples/helpers/data_helper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DataHelper
+  require "faker"
+
+  class << self
+    # Generate a human-readable username with a random number inserted
+    def generate_human_username
+      base_username = Faker::Internet.username(specifier: 8..12)
+      random_number = rand(100..999)
+      random_position = rand(0..base_username.length)
+      base_username.insert(random_position, random_number.to_s)
+    end
+
+    # Generate a random phone number (can specify format: :national, :international, :mobile)
+    def generate_phone_number(format: :national)
+      case format
+      when :national
+        Faker::PhoneNumber.phone_number
+      when :international
+        Faker::PhoneNumber.cell_phone_in_e164
+      when :mobile
+        Faker::PhoneNumber.cell_phone
+      else
+        Faker::PhoneNumber.phone_number
+      end
+    end
+
+    # Generate a random email address (can specify domain)
+    def generate_email(username = nil, domain = "example.com")
+      username ||= Faker::Internet.username(specifier: 8..12)
+      "#{username}@#{domain}"
+    end
+
+    # Generate a secure random password
+    def generate_secure_password(length: 12)
+      Faker::Internet.password(min_length: length, mix_case: true, special_characters: true)
+    end
+
+    # Generate a random full name (first and last)
+    def generate_full_name
+      "#{Faker::Name.first_name} #{Faker::Name.last_name}"
+    end
+
+    # Generate a random address
+    def generate_address
+      "#{Faker::Address.street_address}, #{Faker::Address.city}, #{Faker::Address.zip}"
+    end
+
+    # Generate a random date of birth (for users between min_age and max_age)
+    def generate_date_of_birth(min_age: 18, max_age: 65)
+      Faker::Date.birthday(min_age: min_age, max_age: max_age)
+    end
+
+    # Generate a random company name
+    def generate_company_name
+      Faker::Company.name
+    end
+
+    # Generate a random IPv4 or IPv6 address
+    def generate_ip_address(version: :v4)
+      case version
+      when :v4
+        Faker::Internet.ip_v4_address
+      when :v6
+        Faker::Internet.ip_v6_address
+      else
+        Faker::Internet.ip_v4_address
+      end
+    end
+  end
+end

data/examples/helpers/helpers.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "api_helper"
+require_relative "data_helper"

data/examples/workflow/basic_workflow.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create a basic workflow
+engine = DevSuite::Workflow::Engine.new(user: "Alice")
+
+# Add a basic step
+basic_step = DevSuite::Workflow.create_step("Greet User") do |context|
+  puts "Hello, #{context.get(:user)}!"
+end
+
+engine.step(basic_step)
+engine.execute

data/examples/workflow/composite_workflow.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create a workflow with multiple sub-steps
+engine = DevSuite::Workflow::Engine.new
+
+composite_step = DevSuite::Workflow.create_composite_step("Composite Task")
+
+# Add sub-steps
+sub_step1 = DevSuite::Workflow.create_step("Sub-Step 1") do |context|
+  puts "Executing Sub-Step 1"
+end
+sub_step2 = DevSuite::Workflow.create_step("Sub-Step 2") do |context|
+  puts "Executing Sub-Step 2"
+end
+
+composite_step.step(sub_step1).step(sub_step2)
+engine.step(composite_step)
+engine.execute

data/examples/workflow/conditional_workflow.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create a conditional workflow
+engine = DevSuite::Workflow::Engine.new(user: "Bob", role: "admin")
+
+# Add a conditional step
+conditional_step = DevSuite::Workflow.create_conditional_step("Admin Greeting", ->(ctx) {
+  ctx.get(:role) == "admin"
+}) do |context|
+  puts "Welcome Admin, #{context.get(:user)}!"
+end
+
+engine.step(conditional_step)
+engine.execute

data/examples/workflow/full_workflow.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "dev_suite"
+
+# Create the workflow engine with an initial context
+engine = DevSuite::Workflow.create_engine(
+  {
+    user: "Alice",
+    role: "admin",
+    iteration_count: 0,
+  },
+  driver: :file,
+  path: "tmp/workflow_store.json",
+)
+
+# Step 1: Create a basic step to greet the user
+greet_step = DevSuite::Workflow.create_step("Greet User") do |context|
+  puts "Hello, #{context.get(:user)}!"
+end
+
+# Step 2: Create a conditional step to greet only admins
+admin_step = DevSuite::Workflow.create_conditional_step("Admin Greeting", ->(ctx) {
+  ctx.get(:role) == "admin"
+}) do |context|
+  puts "Welcome, Admin #{context.get(:user)}!"
+end
+
+# Step 3: Create a loop step that repeats 3 times
+loop_step = DevSuite::Workflow.create_loop_step("Loop Step", 3) do |ctx|
+  iteration = ctx.get(:iteration_count) + 1
+  ctx.update({ iteration_count: iteration })
+  puts "Iteration #{iteration} completed."
+end
+
+# Step 4: Create a parallel step to run two tasks simultaneously
+parallel_step = DevSuite::Workflow.create_parallel_step("Parallel Task") do |context|
+  [
+    ->(ctx) { puts "Task 1 executed" },
+    ->(ctx) { puts "Task 2 executed" },
+  ]
+end
+
+# Step 5: Create a composite step that combines two sub-steps
+composite_step = DevSuite::Workflow.create_composite_step("Composite Task")
+
+# Sub-Step 1
+sub_step1 = DevSuite::Workflow.create_step("Sub-Step 1") do |context|
+  puts "Executing Sub-Step 1"
+end
+
+# Sub-Step 2
+sub_step2 = DevSuite::Workflow.create_step("Sub-Step 2") do |context|
+  puts "Executing Sub-Step 2"
+end
+
+# Add sub-steps to the composite step
+composite_step.step(sub_step1).step(sub_step2)
+
+# Step 6: A step to store the final workflow result
+store_step = DevSuite::Workflow.create_step("Store Result") do |context|
+  context.store.set(:workflow_result, "Workflow Completed")
+  puts "Result stored in context."
+end
+
+# Add all steps to the workflow engine
+engine.step(greet_step)
+  .step(admin_step)
+  .step(loop_step)
+  .step(parallel_step)
+  .step(composite_step)
+  .step(store_step)
+
+# Execute the workflow
+puts "Executing workflow..."
+engine.execute
+
+# Retrieve the result from the context store after execution
+puts "Final result from context store: #{engine.context.store.fetch(:workflow_result)}"