igniter 0.5.0 → 0.5.2

data/examples/collection_partial_failure.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "igniter"
-
-class TechnicianAvailabilityContract < Igniter::Contract
-  define do
-    input :technician_id
-    input :active
-
-    guard :active_technician, with: :active, eq: true, message: "Technician inactive"
-
-    compute :summary, with: %i[technician_id active_technician] do |technician_id:, active_technician:|
-      active_technician
-      { id: technician_id, status: "available" }
-    end
-
-    output :summary
-  end
-end
-
-class TechnicianAvailabilityBatchContract < Igniter::Contract
-  define do
-    input :technician_inputs, type: :array
-
-    collection :technicians,
-      with: :technician_inputs,
-      each: TechnicianAvailabilityContract,
-      key: :technician_id,
-      mode: :collect
-
-    output :technicians
-  end
-end
-
-contract = TechnicianAvailabilityBatchContract.new(
-  technician_inputs: [
-    { technician_id: 1, active: true },
-    { technician_id: 2, active: false },
-    { technician_id: 3, active: true }
-  ]
-)
-
-result = contract.result.technicians
-
-puts "summary=#{result.summary.inspect}"
-puts "items_summary=#{result.items_summary.inspect}"
-puts "failed_items=#{result.failed_items.inspect}"
-puts "---"
-puts contract.diagnostics_text

data/examples/composition.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "igniter"
-
-class PriceContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
-    input :country, type: :string
-
-    compute :vat_rate, depends_on: [:country] do |country:|
-      country == "UA" ? 0.2 : 0.0
-    end
-
-    compute :gross_total, depends_on: %i[order_total vat_rate] do |order_total:, vat_rate:|
-      order_total * (1 + vat_rate)
-    end
-
-    output :gross_total
-  end
-end
-
-class CheckoutContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
-    input :country, type: :string
-
-    compose :pricing, contract: PriceContract, inputs: {
-      order_total: :order_total,
-      country: :country
-    }
-
-    output :pricing
-  end
-end
-
-contract = CheckoutContract.new(order_total: 100, country: "UA")
-
-puts "pricing=#{contract.result.to_h.inspect}"

data/examples/consensus.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-# examples/consensus.rb
-#
-# Demonstrates Igniter::Consensus — a Raft-inspired consensus cluster.
-#
-# Two APIs are shown:
-#
-#   High-level  Cluster.start / write / read / read_contract
-#   Low-level   Raw Igniter::Contract with Consensus executors (BidAuction)
-#
-# The Raft protocol (leader election, log replication, quorum commits) is
-# fully encapsulated inside Igniter::Consensus::Node. Users only interact
-# with Cluster and, optionally, a custom StateMachine subclass.
-#
-# Run: bundle exec ruby examples/consensus.rb
-
-require "igniter/consensus"
-
-puts "=" * 62
-puts "  Igniter::Consensus Demo (5-node Raft cluster)"
-puts "=" * 62
-
-NODES = %i[n1 n2 n3 n4 n5].freeze
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [1] Start cluster with the default KV state machine
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[1] Starting #{NODES.size}-node cluster"
-
-cluster = Igniter::Consensus::Cluster.start(nodes: NODES)
-puts "  Nodes: #{NODES.join(", ")}"
-puts "  Quorum needed: #{cluster.quorum_size}/#{NODES.size}"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [2] Wait for a leader — Cluster#wait_for_leader polls until election completes
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[2] Waiting for leader election..."
-
-leader_ref = cluster.wait_for_leader
-puts "  Leader: #{leader_ref.state[:node_id]}  term=#{leader_ref.state[:term]}"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [3] Writes — Cluster#write dispatches to the leader
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[3] Writing to consensus log"
-
-cluster.write(key: :price,     value: 99)
-cluster.write(key: :available, value: true)
-sleep 0.5  # allow replication
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [4] Cluster status via Cluster#status
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[4] Cluster state after replication"
-puts "  #{"node".ljust(5)} #{"role".ljust(10)} #{"term".ljust(5)} " \
-     "#{"log".ljust(4)} #{"ci".ljust(4)} state_machine"
-puts "  " + "-" * 58
-
-cluster.status.each do |s|
-  puts "  #{s[:node_id].to_s.ljust(5)} #{s[:role].to_s.ljust(10)} " \
-       "#{s[:term].to_s.ljust(5)} #{s[:log_size].to_s.ljust(4)} " \
-       "#{s[:commit_index].to_s.ljust(4)} #{s[:state_machine].inspect}"
-end
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [5] ReadQuery contract — declarative graph: find_leader → read_value
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[5] ReadQuery contract: reading :price"
-
-q = cluster.read_contract(key: :price)
-q.resolve_all
-puts "  :price=#{q.result.value}"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [6] Leader crash → automatic failover
-# ─────────────────────────────────────────────────────────────────────────────
-old_leader_id = leader_ref.state[:node_id]
-puts "\n[6] Crashing leader #{old_leader_id}..."
-
-Igniter::Registry.find(old_leader_id)&.kill
-Igniter::Registry.unregister(old_leader_id)
-
-surviving_ids = NODES.reject { |n| n == old_leader_id }
-surviving = Igniter::Consensus::Cluster.new(nodes: surviving_ids)
-
-puts "  Waiting for new election..."
-new_leader_ref = surviving.wait_for_leader
-puts "  New leader: #{new_leader_ref.state[:node_id]}  term=#{new_leader_ref.state[:term]}"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [7] Post-failover write + read via ReadQuery
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[7] Write after failover"
-
-surviving.write(key: :price, value: 150)
-sleep 0.4
-
-q2 = surviving.read_contract(key: :price)
-q2.resolve_all
-puts "  :price after failover = #{q2.result.value}"
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [8] Custom state machine — counter with typed commands
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[8] Custom state machine (counter)"
-
-class CounterMachine < Igniter::Consensus::StateMachine
-  apply :increment do |state, cmd|
-    state.merge(cmd[:key] => (state[cmd[:key]] || 0) + cmd[:by])
-  end
-  apply :reset do |state, cmd|
-    state.merge(cmd[:key] => 0)
-  end
-end
-
-counter_cluster = Igniter::Consensus::Cluster.start(
-  nodes: %i[cx1 cx2 cx3],
-  state_machine: CounterMachine,
-)
-counter_cluster.wait_for_leader
-counter_cluster.write(type: :increment, key: :page_views, by: 100)
-counter_cluster.write(type: :increment, key: :page_views, by: 250)
-sleep 0.4
-puts "  page_views = #{counter_cluster.read(:page_views)}"
-counter_cluster.stop!
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [9] BidAuction — parallel bid submission with durable consensus log
-#
-# Key Igniter properties:
-#   1. bid1/bid2/bid3 have no mutual deps → thread_pool submits them concurrently
-#   2. winner depends on all three → runs only after every bid is logged
-#   3. Same SubmitBid executor reused for all three bids (captures dep name via **)
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[9] BidAuction — three vendors submit bids in parallel"
-
-class SubmitBid < Igniter::Executor
-  # Called with: cluster: + one named bid dep (vendor1_bid / vendor2_bid / …).
-  # The dep name differs per compute node; ** captures whichever is passed.
-  def call(cluster:, **bid_kwarg)
-    bid = bid_kwarg.values.first   # { vendor_id:, price: }
-    ref = cluster.leader
-    raise Igniter::ResolutionError, "No leader — cannot submit bid" unless ref
-    ref.send(:client_write, command: { key: :"bid_#{bid[:vendor_id]}", value: bid[:price] })
-    bid
-  end
-end
-
-class SelectWinner < Igniter::Executor
-  def call(bid1:, bid2:, bid3:)
-    [bid1, bid2, bid3].min_by { |b| b[:price] }
-  end
-end
-
-class BidAuction < Igniter::Contract
-  runner :thread_pool, pool_size: 3   # bid1, bid2, bid3 run concurrently
-
-  define do
-    input :cluster
-    input :vendor1_bid   # { vendor_id: String, price: Float }
-    input :vendor2_bid
-    input :vendor3_bid
-
-    compute :bid1,   with: [:cluster, :vendor1_bid], call: SubmitBid
-    compute :bid2,   with: [:cluster, :vendor2_bid], call: SubmitBid
-    compute :bid3,   with: [:cluster, :vendor3_bid], call: SubmitBid
-
-    compute :winner, with: [:bid1, :bid2, :bid3], call: SelectWinner
-
-    output :winner
-  end
-end
-
-auction = BidAuction.new(
-  cluster:     surviving,
-  vendor1_bid: { vendor_id: "alpha",   price: 45.00 },
-  vendor2_bid: { vendor_id: "betacor", price: 38.50 },
-  vendor3_bid: { vendor_id: "gamma",   price: 52.00 },
-)
-auction.resolve_all
-winner = auction.result.winner
-puts "  Winner: vendor=#{winner[:vendor_id]}  price=$#{"%.2f" % winner[:price]}"
-
-sleep 0.4
-puts "  Bids in consensus log:"
-surviving.status.each do |s|
-  bids = s[:state_machine].select { |k, _| k.to_s.start_with?("bid_") }
-                           .map    { |k, v| "#{k}=$#{"%.2f" % v}" }
-                           .join("  ")
-  puts "  #{s[:node_id].to_s.ljust(5)} #{s[:role].to_s.ljust(10)} #{bids}"
-end
-
-# ─────────────────────────────────────────────────────────────────────────────
-# [10] Quorum failure — Raft's CP safety guarantee
-#
-# With only 2/5 nodes alive (< quorum 3), no leader can be elected.
-# The cluster becomes unavailable rather than returning stale/inconsistent data.
-# ─────────────────────────────────────────────────────────────────────────────
-puts "\n[10] Quorum failure: Raft's CP guarantee"
-
-# Identify the current leader among surviving nodes, then kill it plus one follower
-minority_ids = surviving_ids.reject { |n|
-  ref = Igniter::Registry.find(n)
-  ref&.alive? && ref.state[:role] == :leader
-}.first(2)
-
-(surviving_ids - minority_ids).each do |nid|
-  Igniter::Registry.find(nid)&.kill rescue nil
-  Igniter::Registry.unregister(nid) rescue nil
-end
-
-puts "  Surviving: #{minority_ids.join(", ")}  (quorum needs #{cluster.quorum_size}/#{NODES.size})"
-puts "  Waiting — no leader should be elected..."
-sleep Igniter::Consensus::ELECTION_TIMEOUT_BASE +
-      Igniter::Consensus::ELECTION_TIMEOUT_JITTER + 0.3
-
-minority_roles = minority_ids.map { |n|
-  ref = Igniter::Registry.find(n)
-  ref&.alive? ? "#{n}:#{ref.state[:role]}" : "#{n}:dead"
-}
-puts "  States: #{minority_roles.join("  ")}"
-
-minority_cluster = Igniter::Consensus::Cluster.new(nodes: minority_ids)
-puts "  ConsensusQuery with #{minority_ids.size}/#{NODES.size} nodes:"
-begin
-  minority_cluster.read_contract(key: :price).resolve_all
-  puts "  UNEXPECTED: query succeeded"
-rescue Igniter::Error => e
-  puts "    → #{e.class.name.split("::").last}: #{e.message}"
-  puts "    (correct — cluster is unavailable, not returning stale data)"
-end
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Cleanup
-# ─────────────────────────────────────────────────────────────────────────────
-minority_ids.each { |n| Igniter::Registry.find(n)&.stop(timeout: 2) rescue nil }
-Igniter::Registry.clear
-puts "\nDone."

data/examples/dataflow.rb

@@ -1,308 +0,0 @@
-# frozen_string_literal: true
-
-# examples/dataflow.rb
-#
-# Demonstrates Igniter's incremental dataflow:
-#
-# Part 1 — Incremental Collection (mode: :incremental)
-#   Only added/changed items have their child contract re-run.
-#   Removed items are retracted automatically.
-#   window: { last: N } keeps a bounded sliding window in memory.
-#
-# Part 2 — Maintained Aggregates
-#   Aggregate nodes (count, sum, avg, min, max, group_count, custom) update
-#   in O(change) time — only the diff contributes, not the full collection.
-#
-# Typical use-cases:
-#   • IoT sensor streams   — thousands of sensors, updates arrive as diffs
-#   • Live analytics       — sliding-window aggregates with O(change) compute
-#   • Event-driven systems — process only the delta, not the full dataset
-#
-# Run with: bundle exec ruby examples/dataflow.rb
-
-require_relative "../lib/igniter"
-require_relative "../lib/igniter/extensions/dataflow"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PART 1 — Incremental Collection + Sliding Window
-# ═══════════════════════════════════════════════════════════════════════════════
-
-# ─── Child contract: process a single sensor reading ──────────────────────────
-class SensorAnalysis < Igniter::Contract
-  define do
-    input :sensor_id
-    input :value, type: :numeric
-    input :unit
-
-    compute :status, depends_on: :value do |value:|
-      case value
-      when (..0)    then :error
-      when (0..25)  then :normal
-      when (26..75) then :warning
-      else               :critical
-      end
-    end
-
-    compute :label, depends_on: %i[sensor_id status] do |sensor_id:, status:|
-      "[#{sensor_id}] #{status.upcase}"
-    end
-
-    output :status
-    output :label
-  end
-end
-
-# ─── Pipeline with sliding window ─────────────────────────────────────────────
-class SensorPipeline < Igniter::Contract
-  define do
-    input :readings, type: :array
-
-    collection :processed,
-               with: :readings,
-               each: SensorAnalysis,
-               key: :sensor_id,
-               mode: :incremental,
-               window: { last: 5 }
-
-    output :processed
-  end
-end
-
-# ─── Helpers ──────────────────────────────────────────────────────────────────
-
-def print_diff(label, diff)
-  puts "\n#{label}"
-  puts "  added:     #{diff.added.inspect}"
-  puts "  changed:   #{diff.changed.inspect}"
-  puts "  removed:   #{diff.removed.inspect}"
-  puts "  unchanged: #{diff.unchanged.inspect}"
-  puts "  processed: #{diff.processed_count} child contract(s) re-run"
-end
-
-def print_results(processed)
-  processed.successes.each_value do |item|
-    puts "  #{item.result.label}"
-  end
-end
-
-puts "═" * 60
-puts "PART 1 — Incremental Collection + Sliding Window"
-puts "═" * 60
-
-# ── Round 1: initial batch — 4 sensors, all treated as :added ─────────────────
-
-initial_readings = [
-  { sensor_id: "tmp-1",  value: 20, unit: "°C" },
-  { sensor_id: "tmp-2",  value: 45, unit: "°C" },
-  { sensor_id: "hum-1",  value: 80, unit: "%" },
-  { sensor_id: "pres-1", value: 5,  unit: "kPa" }
-]
-
-pipeline = SensorPipeline.new(readings: initial_readings)
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 1: initial batch ──────────────────────────", diff)
-print_results(pipeline.result.processed)
-
-# ── Round 2: one sensor crosses critical threshold ────────────────────────────
-
-pipeline.feed_diff(:readings, update: [{ sensor_id: "tmp-2", value: 90, unit: "°C" }])
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 2: tmp-2 value 45 → 90 ───────────────────", diff)
-print_results(pipeline.result.processed)
-
-# ── Round 3: new sensor arrives ───────────────────────────────────────────────
-
-pipeline.feed_diff(:readings, add: [{ sensor_id: "wind-1", value: 15, unit: "m/s" }])
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 3: wind-1 joins the stream ────────────────", diff)
-print_results(pipeline.result.processed)
-
-# ── Round 4: sensor goes offline ──────────────────────────────────────────────
-
-pipeline.feed_diff(:readings, remove: ["hum-1"])
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 4: hum-1 removed ──────────────────────────", diff)
-print_results(pipeline.result.processed)
-
-# ── Round 5: identical update — zero re-runs ──────────────────────────────────
-
-pipeline.update_inputs(readings: pipeline.execution.inputs[:readings].dup)
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 5: no data changed (zero re-runs) ─────────", diff)
-
-# ── Round 6: sliding window — adding 6th sensor evicts oldest ─────────────────
-
-pipeline.feed_diff(:readings, add: [{ sensor_id: "co2-1", value: 60, unit: "ppm" }])
-pipeline.resolve_all
-
-diff = pipeline.collection_diff(:processed)
-print_diff("── Round 6: co2-1 added (window: last 5) ───────────", diff)
-puts "\n  Active sensors in window: #{pipeline.result.processed.keys.inspect}"
-
-# ─── Summary ──────────────────────────────────────────────────────────────────
-
-puts "\n── Summary ─────────────────────────────────────────────"
-puts "  Final window: #{pipeline.result.processed.keys.inspect}"
-puts "  Diff explain: #{pipeline.collection_diff(:processed).explain}"
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# PART 2 — Maintained Aggregates
-#
-# Aggregates update in O(change) time — only the diff items are processed.
-# The AggregateState stores per-key contributions so that removed/changed items
-# can be retracted without rescanning the full collection.
-# ═══════════════════════════════════════════════════════════════════════════════
-
-puts "\n"
-puts "═" * 60
-puts "PART 2 — Maintained Aggregates"
-puts "═" * 60
-
-# ─── Child contract: classify sensor with zone info ───────────────────────────
-
-class SensorMetrics < Igniter::Contract
-  define do
-    input :sensor_id
-    input :value, type: :numeric
-    input :zone
-
-    compute :status, depends_on: :value do |value:|
-      value > 75 ? :critical : :normal
-    end
-
-    output :status
-    output :value   # exposed for sum/avg/min/max projections
-    output :zone    # exposed for group_count
-  end
-end
-
-# ─── Analytics pipeline with all built-in aggregate operators ─────────────────
-
-class AnalyticsPipeline < Igniter::Contract
-  define do # rubocop:disable Metrics/BlockLength
-    input :sensors, type: :array
-
-    collection :processed,
-               with: :sensors,
-               each: SensorMetrics,
-               key: :sensor_id,
-               mode: :incremental
-
-    # ── Built-in operators ──────────────────────────────────────────────────
-    aggregate :total, from: :processed # count all
-    aggregate :high_count,
-              from: :processed,
-              count: ->(item) { item.result.status == :critical }
-    aggregate :total_value,
-              from: :processed,
-              sum: ->(item) { item.result.value.to_f }
-    aggregate :avg_value,
-              from: :processed,
-              avg: ->(item) { item.result.value.to_f }
-    aggregate :peak,
-              from: :processed,
-              max: ->(item) { item.result.value.to_f }
-    aggregate :by_zone,
-              from: :processed,
-              group_count: ->(item) { item.result.zone }
-
-    # ── Custom retractable aggregate ────────────────────────────────────────
-    # Maintains a sorted list of unique critical sensor IDs
-    critical_add = lambda do |acc, item|
-      item.result.status == :critical ? (acc + [item.key]).sort.uniq : acc
-    end
-    aggregate :critical_ids,
-              from: :processed,
-              initial: [],
-              add: critical_add,
-              remove: ->(acc, item) { acc - [item.key] }
-
-    output :processed
-    output :total
-    output :high_count
-    output :total_value
-    output :avg_value
-    output :peak
-    output :by_zone
-    output :critical_ids
-  end
-end
-
-# ─── Helper ───────────────────────────────────────────────────────────────────
-
-def print_aggregates(result) # rubocop:disable Metrics/AbcSize
-  r = result
-  puts "  total       = #{r.total}"
-  puts "  high_count  = #{r.high_count}  (critical sensors)"
-  puts "  total_value = #{r.total_value.round(1)}"
-  puts "  avg_value   = #{r.avg_value.round(2)}"
-  puts "  peak        = #{r.peak.inspect}"
-  puts "  by_zone     = #{r.by_zone.inspect}"
-  puts "  critical_ids= #{r.critical_ids.inspect}"
-end
-
-sensor = ->(id, value, zone) { { sensor_id: id, value: value, zone: zone } }
-
-# ── Round A: initial batch ─────────────────────────────────────────────────────
-
-sensors_a = [
-  sensor.call("s1", 20, "north"), # normal
-  sensor.call("s2", 80, "north"), # critical
-  sensor.call("s3", 90, "south"), # critical
-  sensor.call("s4", 30, "south")  # normal
-]
-
-ap = AnalyticsPipeline.new(sensors: sensors_a)
-ap.resolve_all
-
-puts "\n── Round A: initial batch (4 sensors) ──────────────────"
-puts "  diff: #{ap.collection_diff(:processed).processed_count} child contract(s) run"
-print_aggregates(ap.result)
-
-# ── Round B: s2 value drops (critical → normal) ───────────────────────────────
-
-ap.feed_diff(:sensors, update: [sensor.call("s2", 40, "north")])
-ap.resolve_all
-
-puts "\n── Round B: s2 value 80 → 40  (critical → normal) ──────"
-puts "  diff: #{ap.collection_diff(:processed).processed_count} child contract(s) run"
-print_aggregates(ap.result)
-
-# ── Round C: new sensor added in a new zone ────────────────────────────────────
-
-ap.feed_diff(:sensors, add: [sensor.call("s5", 95, "east")])
-ap.resolve_all
-
-puts "\n── Round C: s5 added in zone 'east' (critical) ─────────"
-puts "  diff: #{ap.collection_diff(:processed).processed_count} child contract(s) run"
-print_aggregates(ap.result)
-
-# ── Round D: peak sensor removed ──────────────────────────────────────────────
-
-ap.feed_diff(:sensors, remove: ["s5"])
-ap.resolve_all
-
-puts "\n── Round D: s5 removed (peak was 95) ───────────────────"
-puts "  diff: #{ap.collection_diff(:processed).processed_count} child contract(s) run"
-print_aggregates(ap.result)
-
-# ── Round E: no change — zero re-runs, aggregates stable ──────────────────────
-
-ap.update_inputs(sensors: ap.execution.inputs[:sensors].dup)
-ap.resolve_all
-
-puts "\n── Round E: no change (zero re-runs, aggregates stable) "
-puts "  diff: #{ap.collection_diff(:processed).processed_count} child contract(s) run"
-print_aggregates(ap.result)
-
-puts "\nDone."

data/examples/diagnostics.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "igniter"
-
-class PriceContract < Igniter::Contract
-  define do
-    input :order_total, type: :numeric
-    input :country, type: :string
-
-    compute :vat_rate, depends_on: [:country] do |country:|
-      country == "UA" ? 0.2 : 0.0
-    end
-
-    compute :gross_total, depends_on: %i[order_total vat_rate] do |order_total:, vat_rate:|
-      order_total * (1 + vat_rate)
-    end
-
-    output :gross_total
-  end
-end
-
-contract = PriceContract.new(order_total: 100, country: "UA")
-contract.result.gross_total
-
-puts contract.diagnostics_text
-puts "---"
-puts contract.result.as_json.inspect