hecks 0.2.0 → 0.3.0

data/lib/hecks/bluebook/hexagon.rb

@@ -0,0 +1,60 @@
+require_relative "behaviour/hexagon"
+require_relative "../ir"
+
+module Hecks
+  module Bluebook
+    Port = Struct.new(:name, :verb, :signal, keyword_init: true) do
+      def reply?  = signal == :reply
+      def effect? = signal == :effect
+    end
+
+    Adapter = Struct.new(:name, :port, :fields, :secrets, keyword_init: true) do
+      def declares?(field) = all_fields.include?(field.to_sym)
+
+      def all_fields = (fields || []) + (secrets || [])
+    end
+
+    Bind = Struct.new(:aggregate, :verb, :adapter, :role, keyword_init: true) do
+      def aggregate_name = Naming.demodulise(aggregate)
+    end
+
+    class Hecksagon
+      include Hecks::IR
+      include Behaviour::Hecksagon
+
+      emits_ir(
+        domain:             :domain,
+        binds:              many(:binds),
+        subscriptions:      -> { subscriptions.map(&:to_s) },
+        framework_members:  -> { framework_members.map(&:to_s) },
+        vendored_bluebooks: -> { vendored_bluebooks.map(&:to_s) }
+      )
+
+      attr_reader :domain, :binds, :subscriptions, :framework_members, :vendored_bluebooks
+
+      def initialize(domain:, binds: [], subscriptions: [], framework_members: [], vendored_bluebooks: [])
+        @domain             = domain.to_s
+        @binds              = binds
+        @subscriptions      = subscriptions
+        @framework_members  = framework_members
+        @vendored_bluebooks = vendored_bluebooks
+      end
+    end
+
+    class World
+      include Hecks::IR
+      include Behaviour::World
+
+      emits_ir(domain: :domain, realm: :realm, latest: :latest, settings: :settings)
+
+      attr_reader :domain, :realm, :latest, :settings
+
+      def initialize(domain:, realm: nil, latest: nil, settings: {})
+        @domain   = domain.to_s
+        @realm    = realm&.to_s
+        @latest   = latest&.to_s
+        @settings = settings
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/lifecycle.rb

@@ -0,0 +1,42 @@
+require_relative "behaviour/lifecycle"
+
+module Hecks
+  module Bluebook
+    class StateTransition
+      attr_reader :target, :from
+
+      def initialize(target:, from: nil)
+        @target = target.to_s
+        @from   = case from
+                  when Array then from.map(&:to_s)
+                  when nil   then nil
+                  else            from.to_s
+                  end
+      end
+
+      def constrained? = !@from.nil?
+    end
+
+    class Lifecycle
+      include Hecks::IR
+      include Behaviour::Lifecycle
+
+      emits_ir(
+        field:       -> { field.to_s },
+        default:     :default,
+        # `expand` is private; a Proc runs in the construct's own
+        # context, so declared emission reaches it exactly as the
+        # hand-written to_h did.
+        transitions: -> { transitions.flat_map { |command, t| expand(command, t) } }
+      )
+
+      attr_reader :field, :default, :transitions
+
+      def initialize(field:, default:, transitions: [])
+        @field       = field.to_sym
+        @default     = default.to_s
+        @transitions = transitions
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/meta_validator/adapter_judge.rb

@@ -0,0 +1,54 @@
+module Hecks
+  module Bluebook
+    module MetaValidator
+      # Offers a built .adapter to the language that describes adapters.
+      #
+      # A sibling of a bluebook again, the same shape PortJudge already is
+      # one level over — its own file, its own door, judged through its
+      # own self-hosted language (adapter.bluebook) rather than left as a
+      # plain Ruby struct nothing checks. Whole-project table-unification
+      # survey, item #13's remaining builders.
+      class AdapterJudge
+        attr_reader :refusals
+
+        def initialize(adapter)
+          @adapter  = adapter
+          @refusals = []
+          @runtime  = MetaValidator.fresh_runtime
+          judge!
+        end
+
+        private
+
+        def v(text) = text.nil? ? nil : { value: text.to_s }
+
+        def args(pairs) = pairs.compact
+
+        def offer(label)
+          yield
+        rescue Runtime::GivenNotMet, Runtime::InvariantViolation,
+               Runtime::TypeMismatch, Runtime::NotFound => e
+          @refusals << "#{label}: #{e.message}"
+        rescue Runtime::UnknownVerb
+          nil
+        end
+
+        def send_to(verb, label, **payload)
+          offer(label) { @runtime.dispatch(verb, **args(payload)) }
+        end
+
+        def judge!
+          send_to("Adapter::Adapter.Declare", @adapter.name, name: v(@adapter.name), port: v(@adapter.port))
+
+          Array(@adapter.fields).each do |field|
+            send_to("Adapter::Adapter.AddField", @adapter.name, name: @adapter.name, value: v(field))
+          end
+
+          Array(@adapter.secrets).each do |secret|
+            send_to("Adapter::Adapter.AddSecret", @adapter.name, name: @adapter.name, value: v(secret))
+          end
+        end
+      end
+    end
+  end
+end