ruby-ode 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4cbd1b654f43bac29c7be4dd5a330d31fe66d056dcb9760fce801a3674dab572
+  data.tar.gz: 575f036138804d7760f9827f9cec5270ea8ead5bccd87462e9cddaf7f81423a1
+SHA512:
+  metadata.gz: 8ed3d1ef2b00b2032182041e1ce1af0af1ca4664bd37eb40f265710c93697ed7d7f1c3f1a37c9286cbf9bf53d1a1533ab63bf42df21dcc794f77166159560a8a
+  data.tar.gz: 90a038e33b4e40b57bd53f1fe20cb5199d3777d22d74111333c13d5e1b6a06a07c57049e74930156f33dfe61bf5e1386675e90a33bc921767b285df55c5374f0

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 0.1.0
+
+- created the standalone `ruby-ode` gem runtime
+- added direct, chain, sequence and guard-oriented primitives

data/CONTRIBUTING.md

@@ -0,0 +1,3 @@
+# Contributing
+
+Preserve the ODE vocabulary and keep explanations aligned with the other runtimes when the concept is identical.

data/PUBLICATION.md

@@ -0,0 +1,10 @@
+# Publication Guide
+
+`ruby-ode` is structured as a standard Ruby gem.
+
+Release checklist:
+
+1. Run `ruby -Ilib test/test_runtime.rb`
+2. Update `CHANGELOG.md`
+3. Tag `v0.1.0`
+4. Publish through RubyGems when the repository is ready

data/README.md

@@ -0,0 +1,105 @@
+# ruby-ode
+
+`ruby-ode` is the Ruby member of the ODE runtime family.
+
+It provides:
+
+- direct `UseCase` execution
+- `ChainUseCase` dependent comparison flow
+- `SequenceUseCase` ordered execution
+- guard-first rejection before business work begins
+
+## Narrative Readability
+
+ODE is designed so code can be read as narrative. A developer should be able to identify `guard`, `execute`, `chain`, `sequence`, `dispatch` and `publish` steps even in a language they do not use every day.
+
+This does not mean every runtime has identical syntax. It means the conceptual reading path remains stable enough that a Java developer can follow a Go or Ruby flow, and a Swift developer can follow a TypeScript or Python flow, without relearning the product story from scratch.
+
+## What ODE Does Not Claim
+
+ODE does not promise identical syntax across languages, and it does not remove the need to understand native platform idioms. It also does not require every runtime to expose the same UI layer.
+
+The reason is pragmatic: forcing textual symmetry across Kotlin, Swift, Go, Ruby, PHP, TypeScript or Python would usually make the libraries feel unnatural inside their host ecosystems. ODE prefers semantic stability over artificial syntactic cloning.
+
+## Validation
+
+```bash
+ruby -Ilib test/test_runtime.rb
+```
+
+## Repository
+
+- source: [github.com/animalab-netizen/ruby-ode](https://github.com/animalab-netizen/ruby-ode)
+
+## Coordinates
+
+- gem: `ruby-ode`
+- version: `0.1.0`
+
+## Public API
+
+- `RubyODE::UseCase`
+- `RubyODE::ChainUseCase`
+- `RubyODE::SequenceUseCase`
+- `RubyODE::UseCaseDispatcher`
+- `RubyODE::ValueOutput`, `RubyODE::ErrorOutput`, `RubyODE::EmptyOutput`, `RubyODE::Outputs`
+- `RubyODE::HttpError`, `RubyODE::ConnectionError`, `RubyODE::GuardRejectedError`, `RubyODE::UnexpectedResponseError`
+
+## Core Concepts
+
+### 1. UseCase
+
+`RubyODE::UseCase` keeps guard, execution and output normalization in the same explicit template flow.
+
+### 2. ChainUseCase
+
+`RubyODE::ChainUseCase` models a two-step dependent narrative.
+
+### 3. SequenceUseCase
+
+`RubyODE::SequenceUseCase` preserves input order across three or more values.
+
+### 4. UseCaseDispatcher
+
+`RubyODE::UseCaseDispatcher` triggers a use case and can yield the same output to a block for publication.
+
+## Basic Examples
+
+### Direct UseCase
+
+```ruby
+class LoadPokemonUseCase < RubyODE::UseCase
+  def execute(param)
+    "spotlight:#{param}"
+  end
+end
+```
+
+### Guarded UseCase
+
+```ruby
+class ComparePokemonUseCase < RubyODE::UseCase
+  def guard(param)
+    raise RubyODE::GuardRejectedError, "comparison requires distinct entries" if param[0] == param[1]
+  end
+
+  def execute(param)
+    "#{param[0]} vs #{param[1]}"
+  end
+end
+```
+
+### Publish While Dispatching
+
+```ruby
+dispatcher = RubyODE::UseCaseDispatcher.new
+output = dispatcher.dispatch("pikachu", LoadPokemonUseCase.new) do |result|
+  puts result.inspect
+end
+```
+
+## Additional Guides
+
+- [PUBLICATION.md](/Users/caiosanchezchristino/Desktop/ode-projects/ruby-ode/PUBLICATION.md)
+- [PARITY.md](/Users/caiosanchezchristino/Desktop/ode-projects/ruby-ode/PARITY.md)
+- [USECASE_GUIDE.md](/Users/caiosanchezchristino/Desktop/ode-projects/ruby-ode/USECASE_GUIDE.md)

data/USECASE_GUIDE.md

@@ -0,0 +1,3 @@
+# UseCase Guide
+
+Use `UseCase` for direct delivery, `ChainUseCase` for two-step dependent flow, `SequenceUseCase` for ordered execution across three or more values, and guards to reject invalid dispatch before business work starts.

data/lib/ruby_ode/runtime.rb

@@ -0,0 +1,101 @@
+module RubyODE
+  class ValueOutput
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  class ErrorOutput
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+  end
+
+  class EmptyOutput
+  end
+
+  module Outputs
+    def self.value(value) = ValueOutput.new(value)
+    def self.error(error) = ErrorOutput.new(error)
+    def self.empty = EmptyOutput.new
+  end
+
+  class GuardRejectedError < StandardError; end
+  class ConnectionError < StandardError; end
+  class UnexpectedResponseError < StandardError; end
+
+  class HttpError < StandardError
+    attr_reader :status_code
+
+    def initialize(status_code, message)
+      @status_code = status_code
+      super("http #{status_code}: #{message}")
+    end
+  end
+
+  class UseCase
+    def process(param)
+      guard(param)
+      on_result(execute(param))
+    rescue StandardError => error
+      on_error(error)
+    end
+
+    def guard(_param); end
+
+    def execute(_param)
+      raise NotImplementedError
+    end
+
+    def on_result(result)
+      Outputs.value(result)
+    end
+
+    def on_error(error)
+      Outputs.error(error)
+    end
+  end
+
+  class ChainUseCase
+    def initialize(first:, second:)
+      @first = first
+      @second = second
+    end
+
+    def process(param)
+      first_output = @first.process(param)
+      return Outputs.error(first_output.error) if first_output.is_a?(ErrorOutput)
+      return Outputs.empty if first_output.is_a?(EmptyOutput)
+
+      Outputs.value(@second.call(first_output.value, param))
+    rescue StandardError => error
+      Outputs.error(error)
+    end
+  end
+
+  class SequenceUseCase
+    def initialize(step:)
+      @step = step
+    end
+
+    def process(values)
+      return Outputs.empty if values.empty?
+
+      Outputs.value(values.map { |value| @step.call(value) })
+    rescue StandardError => error
+      Outputs.error(error)
+    end
+  end
+
+  class UseCaseDispatcher
+    def dispatch(param, use_case)
+      output = use_case.process(param)
+      yield output if block_given?
+      output
+    end
+  end
+end

data/lib/ruby_ode.rb

@@ -0,0 +1 @@
+require_relative "ruby_ode/runtime"

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: ruby-ode
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ÂnimaLab
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Ruby runtime for direct, chain, sequence and guard-oriented ODE flows.
+email:
+- animalab.desenvolvimento@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- PUBLICATION.md
+- README.md
+- USECASE_GUIDE.md
+- lib/ruby_ode.rb
+- lib/ruby_ode/runtime.rb
+homepage: https://github.com/animalab-netizen/ruby-ode
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/animalab-netizen/ruby-ode
+  source_code_uri: https://github.com/animalab-netizen/ruby-ode
+  changelog_uri: https://github.com/animalab-netizen/ruby-ode/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/animalab-netizen/ruby-ode/blob/main/README.md
+  bug_tracker_uri: https://github.com/animalab-netizen/ruby-ode/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.11
+specification_version: 4
+summary: Opinionated delivery engine for Ruby applications.
+test_files: []