statifier 0.0.1 → 0.1.0

data/lib/statifier.rb

@@ -1,5 +1,389 @@
-require "statifier/version"
+# frozen_string_literal: true
 
+require_relative "statifier/version"
+require_relative "statifier/xml"
+require_relative "statifier/lowering"
+require_relative "statifier/validator"
+require_relative "statifier/compiler"
+require_relative "statifier/datamodel"
+require_relative "statifier/interpreter"
+require_relative "statifier/driver"
+require_relative "statifier/position"
+require_relative "statifier/accepts"
+
+# The interpreter core of an SCXML statechart engine.
+#
+# This is the 0.1.0 rewrite of the package. {Statifier.compile} reads SCXML
+# source into a machine, through the reader, the lowering, the validator
+# and the compiler, all internal. The driver
+# ({Statifier::Driver}) steps a machine: {Statifier.start} starts a chart,
+# {Statifier.step} sends it an event, {Statifier.advance} moves its virtual
+# clock, {Statifier.report_send_failed} tells it a send failed, and
+# {Statifier.configuration} and {Statifier.done?} read it.
+# {Statifier.export_position} writes a chart's execution out as plain data a
+# host can keep, and {Statifier.import_position} reads it back in. The
+# interpreter under the driver is internal. {Statifier.check_accepts}
+# compares the event names a host declares a chart accepts with the events
+# the chart listens for.
+#
+# Every one of those calls but {Statifier.check_accepts}, which refuses
+# nothing and answers its {AcceptsCheck} directly, answers a {Result}.
+# Nothing is kept between calls but the state a call answers: there is no
+# global configuration, and a host passes its processors and its clock with
+# every call.
+#
+# The public surface is these calls and the values they take and answer:
+# {Result}, {AcceptsCheck}, {Event}, the effects under {Effect}, the
+# driver's values under {Driver} and the position's under {Position}, and
+# {VERSION}; `require "statifier/basichttp"` adds {BasicHTTP}. Every other
+# constant is private (`private_constant`), so a host cannot name it, and
+# a value a call answers whose class is private (the machine, a driver
+# state, a compile refusal) is read by its documented members.
 module Statifier
-  class Error < StandardError; end
+  # The driver's calls and checks, its state, and the position's bodies:
+  # private constants of {Driver} and {Position}, named here once so the
+  # calls below reach them.
+  DRIVER_CALLS = Driver.const_get(:Calls)
+  DRIVER_CHECKS = Driver.const_get(:Checks)
+  DRIVER_STATE = Driver.const_get(:State)
+  POSITION_CODEC = Position.const_get(:Codec)
+
+  # Everything the package builds a machine and steps it with is internal:
+  # a host reaches it only through the calls below and the values they
+  # answer.
+  private_constant :Accepts, :Compiler, :Datamodel, :Document, :Frozen, :Interpreter, :Lowering, :Machine,
+                   :Validator, :XML, :DRIVER_CALLS, :DRIVER_CHECKS, :DRIVER_STATE, :POSITION_CODEC
+
+  # What every public call answers: its `value`, or, as `error`, why it
+  # was refused.
+  #
+  # @!attribute [r] value
+  #   @return [Object, nil] {Statifier.compile}'s machine; the
+  #     {Driver::Moved} a driver call that moves a chart answers;
+  #     {Statifier.configuration}'s list of names; {Statifier.done?}'s
+  #     {Driver::DoneStatus}; {Statifier.export_position}'s position;
+  #     {Statifier.import_position}'s {Driver::State}. Nil when the call was
+  #     refused
+  # @!attribute [r] error
+  #   @return [Array, Symbol, Position::Refusal, nil] nil when the call
+  #     succeeded. For {Statifier.compile}, the refusals, a frozen list that
+  #     is never empty; for a driver call, the reason as a Symbol; for
+  #     {Statifier.export_position} and {Statifier.import_position}, a
+  #     {Position::Refusal}
+  Result = ::Data.define(:value, :error) do
+    # @return [Boolean] whether the call succeeded
+    def ok? = error.nil?
+  end
+
+  # Compiles SCXML source into a machine: the document is read, lowered,
+  # validated and compiled, in that order, and the first stage that refuses
+  # it stops the rest.
+  #
+  # A refused source answers a failed {Result} whose `error` is the list of
+  # that stage's refusals, in document order: the reader's one parse error,
+  # or every error of the lowering, of the validator or of the compiler (an
+  # expression predicator refused). Their classes are internal. Each is a
+  # frozen value that carries a `reason` symbol, a `message` for a person
+  # and a `location`, the span in the source it names (`start_line`,
+  # `start_column`, `start_offset`, `end_line`, `end_column` and
+  # `end_offset`); all but the reader's carry a `detail` Hash too. A
+  # validator warning never refuses: a chart that compiles carries its
+  # warnings on the machine, as the reference's machine does.
+  #
+  # The machine is a frozen value, deeply, and its shape is internal: a host
+  # hands it on and reads one of its members only, `warnings`, the
+  # validator's warnings in document order, a frozen list of warning
+  # values, each with the `reason`, `detail`, `message` and `location` an
+  # error carries (empty for a chart with none).
+  #
+  # @example
+  #   result = Statifier.compile(<<~SCXML)
+  #     <scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0">
+  #       <state id="a"><transition event="e.go" target="b"/></state>
+  #       <final id="b"/>
+  #     </scxml>
+  #   SCXML
+  #   result.ok? # => true
+  #
+  # @param source [String] the SCXML document
+  # @return [Result] the machine, or the refusals
+  # @raise [TypeError] when `source` is not a String
+  def self.compile(source)
+    parsed = XML.parse(source)
+    return refused([parsed.error]) unless parsed.ok?
+
+    compiled = chart(parsed.value, source)
+    compiled.ok? ? Result.new(value: compiled.value, error: nil) : refused(compiled.errors)
+  end
+
+  # The read tree lowered, validated and compiled: the result of the last
+  # stage that ran, each stage's result answering `ok?`, `value` and
+  # `errors`.
+  def self.chart(root, source)
+    lowered = Lowering.lower(root, source)
+    return lowered unless lowered.ok?
+
+    validated = Validator.validate(lowered.value, source)
+    return validated unless validated.ok?
+
+    Compiler.compile(validated.value, warnings: validated.warnings)
+  end
+
+  # A failed {Result} carrying `errors`.
+  def self.refused(errors) = Result.new(value: nil, error: Ractor.make_shareable(errors.dup))
+
+  private_class_method :chart, :refused
+
+  # Starts a chart: its datamodel bound, its initial states entered, and the
+  # chart run, with every event it queues for itself, to a stable
+  # configuration.
+  #
+  # @example
+  #   machine = Statifier.compile(<<~SCXML).value
+  #     <scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0">
+  #       <state id="a"><transition event="e.go" target="b"/></state>
+  #       <final id="b"/>
+  #     </scxml>
+  #   SCXML
+  #   started = Statifier.start(machine, session_id: "s1")
+  #   Statifier.configuration(started.value.state).value # => ["a"]
+  #
+  # @param machine [Machine] a compiled chart
+  # @param options [Hash] the keywords below, each optional
+  # @option options [String, nil] :session_id the session's id, which
+  #   `_sessionid` reads; the driver mints one (`sess_` and 26 base32
+  #   symbols) when nil
+  # @option options [Hash{String => Object}] :datamodel the datamodel's
+  #   starting values, under the system variables; copied, never frozen in
+  #   place
+  # @option options [Hash{String => #deliver}] :processors the host's
+  #   processor for each send type it registers ({Statifier::Driver} says
+  #   what each is handed); every later call names the same types
+  # @option options [Integer, Symbol] :max_macrostep_rounds the rounds one
+  #   macrostep may spend, a positive Integer or `:infinity`; 10000 when
+  #   absent
+  # @option options [Boolean] :trace whether the chart answers the trace
+  #   effects ({Statifier::Effect::Trace}); false when absent
+  # @option options [#call, nil] :clock the clock predicator reads for the
+  #   call; its own when nil
+  # @return [Result] a {Driver::Moved}: the state and the effects
+  # @raise [TypeError] for a machine, session id or processors of the wrong
+  #   kind
+  # @raise [ArgumentError] for an option it does not name, or a round
+  #   budget that is neither a positive Integer nor `:infinity`
+  def self.start(machine, **options)
+    raise TypeError, "expected a compiled machine, got #{machine.class}" unless machine.is_a?(Machine)
+
+    DRIVER_CALLS.start(machine, options)
+  end
+
+  # Sends the chart one external event, and runs it, and every event it
+  # queues for itself, to a stable configuration. While a macrostep's round
+  # budget has halted the chart, the event is queued and not taken.
+  #
+  # @param state [Driver::State] what the last call answered
+  # @param name [String] the event's name
+  # @param data [Object] the event's data, `Predicator::UNDEFINED` for none
+  # @param processors [Hash{String => #deliver}] as {start} took them
+  # @param clock [#call, nil] as {start} took it
+  # @return [Result] a {Driver::Moved}, or the error `:not_running` once
+  #   the chart has stopped
+  # @raise [TypeError] for a state or a name of the wrong kind
+  # @raise [ArgumentError] for processors that name other types than the
+  #   chart was started with
+  def self.step(state, name, data: Predicator::UNDEFINED, processors: {}, clock: nil)
+    DRIVER_CALLS.step(state, name, data:, processors:, clock:)
+  end
+
+  # Moves the virtual clock `milliseconds` forward, firing every pending
+  # timer due by then, earliest first and in the order they were scheduled
+  # at one due time, each run to completion before the next.
+  #
+  # @param state [Driver::State] what the last call answered
+  # @param milliseconds [Numeric] how far the clock moves, finite and not
+  #   negative
+  # @param processors [Hash{String => #deliver}] as {start} took them
+  # @param clock [#call, nil] as {start} took it
+  # @return [Result] a {Driver::Moved}, or the error `:invalid_duration`
+  # @raise [TypeError] for a state of the wrong kind
+  # @raise [ArgumentError] for processors that name other types than the
+  #   chart was started with
+  def self.advance(state, milliseconds, processors: {}, clock: nil)
+    DRIVER_CALLS.advance(state, milliseconds, processors:, clock:)
+  end
+
+  # Reports a send the host was handed and could not deliver:
+  # `error.communication` joins the chart's internal queue, its origin the
+  # send's content and its `sendid` the send's id whether or not its author
+  # named it, and the chart runs to a stable configuration, then takes
+  # whatever its external queue holds, as {step} does. The driver keeps no
+  # table of the sends it handed, so the report is not checked against one:
+  # it reaches the session `state` is for. A failure a processor knows of
+  # while it is handed the send is answered from its `deliver` as a
+  # {Driver::DeliveryFailure} instead, and fails the send within that call.
+  #
+  # Once the chart has stopped, or while a macrostep's round budget has
+  # halted it, the report is refused and nothing is written, as the
+  # reference's session drops it; the miss is then the host's to record.
+  #
+  # @example
+  #   failed = Statifier.report_send_failed(machine, moved.state, send, processors:)
+  #   failed.value.state # the chart after it took error.communication
+  #
+  # @param machine [Machine] the compiled chart `state` is an execution of
+  # @param state [Driver::State] what the last call answered
+  # @param send [Effect::Send, Effect::SendDelayed] the send the host's
+  #   processor was handed
+  # @param options [Hash] the keywords below, each optional
+  # @option options [Object, nil] :reason the host's own account of the
+  #   failure; not read, and the chart is not handed it
+  # @option options [Hash{String => #deliver}] :processors as {start} took
+  #   them
+  # @option options [#call, nil] :clock as {start} took it
+  # @return [Result] a {Driver::Moved}, or the error `:not_running` once the
+  #   chart has stopped, or `:halted` while a round budget has halted it
+  # @raise [TypeError] for a machine, a state or a send of the wrong kind
+  # @raise [ArgumentError] for an option it does not name, a state that is
+  #   not an execution of `machine`, or processors that name other types
+  #   than the chart was started with
+  def self.report_send_failed(machine, state, send, **options)
+    DRIVER_CALLS.report_send_failed(machine, state, send, options)
+  end
+
+  # The active states, by id, the `<scxml>` root left out, sorted; a state
+  # the document gave no id is named `#` and its index. Empty once the
+  # chart has stopped ({done?} names the states it stopped in).
+  #
+  # @param state [Driver::State] what a call answered
+  # @return [Result] the names, a frozen list
+  # @raise [TypeError] for a state of the wrong kind
+  def self.configuration(state) = DRIVER_CALLS.configuration(state)
+
+  # Whether the chart has stopped and, once it has, the top-level final's
+  # donedata and the states it stopped in, as the {Effect::Done} carried
+  # them.
+  #
+  # @param state [Driver::State] what a call answered
+  # @return [Result] a {Driver::DoneStatus}
+  # @raise [TypeError] for a state of the wrong kind
+  def self.done?(state) = DRIVER_CALLS.done?(state)
+
+  # Writes the chart's execution out as a position: plain data in the
+  # reference's string-id vocabulary, a frozen Hash with String keys whose
+  # values are Strings, Integers, booleans, and Arrays and Hashes of them,
+  # ready for JSON ({Statifier::Position} says what each key holds). A
+  # datamodel value is carried as text in predicator's tagged-value
+  # encoding.
+  #
+  # A position holds what the interpreter holds between two calls and
+  # nothing of the driver's own: no pending timer, no queued external
+  # event, no send a processor holds, no virtual time and no donedata.
+  #
+  # @example
+  #   started = Statifier.start(machine, session_id: "s1").value
+  #   position = Statifier.export_position(started.state).value
+  #   position["configuration"] # => ["a"]
+  #
+  # @param state [Driver::State] what a call answered
+  # @return [Result] the position, or a {Position::Refusal}:
+  #   `:internal_queue_not_empty` while an internal event waits;
+  #   `:unnameable_states`, every index (`detail[:indexes]`, sorted) of a
+  #   state the position holds that the document gave no id; or
+  #   `:unencodable_value`, the first variable (`detail[:field]`) whose
+  #   value the tagged-value encoding refuses, with the codec's reason
+  # @raise [TypeError] for a state of the wrong kind
+  def self.export_position(state) = POSITION_CODEC.export(DRIVER_CHECKS.state(state, nil))
+
+  # Reads a position back in as a driver state over `machine`, which may be
+  # a fresh compile of the same source or any machine holding every state
+  # the position names: the position's chart is not checked, as the
+  # reference's import checks none. The ids are resolved against `machine`,
+  # the root re-added, and the driver's own members start as a fresh start
+  # leaves them: the virtual clock at zero, no pending timer, nothing
+  # queued or held. The session id is the one `_sessionid` holds. A stopped
+  # position imports stopped, its donedata undefined and its configuration
+  # empty. The position is read, never frozen or changed.
+  #
+  # @example
+  #   imported = Statifier.import_position(machine, JSON.parse(JSON.generate(position)))
+  #   Statifier.configuration(imported.value).value # => ["a"]
+  #
+  # @param machine [Machine] a compiled chart
+  # @param position [Hash] what {export_position} answered, or the same
+  #   data read back from JSON
+  # @param processors [Hash{String => #deliver}] the host's processors, as
+  #   {start} takes them; every later call names the same types
+  # @return [Result] the {Driver::State}, or a {Position::Refusal}:
+  #   `:malformed_export` when `position` is not a Hash
+  #   (`detail[:kind]` `:not_a_hash`), lacks a key (`:missing_keys`, every
+  #   one in `detail[:keys]`, sorted), holds a field of the wrong shape
+  #   (`:bad_shape`, the first in `detail[:field]`), a datamodel text that
+  #   does not decode (`:undecodable_value`) or no String `_sessionid`
+  #   (`:no_session_id`); or `:unknown_state_ids`, every id `machine` holds
+  #   no state for (`detail[:ids]`, sorted)
+  # @raise [TypeError] for a machine or processors of the wrong kind
+  def self.import_position(machine, position, processors: {})
+    raise TypeError, "expected a compiled machine, got #{machine.class}" unless machine.is_a?(Machine)
+
+    POSITION_CODEC.import(machine, position, processors)
+  end
+
+  # Compares `declared_events`, the event names a chart is declared to
+  # accept, with the chart's event vocabulary: every event descriptor on a
+  # transition whose source state can be active, as authored, a pattern
+  # never expanded. "Can be active" is a static rule over the chart's
+  # structure that reads no `cond` (a state some path of transitions and
+  # initial, parallel and history defaults enters, with its ancestors), so
+  # it over-counts and never under-counts. The reference's
+  # `Statifier.Chart.check_accepts/2` answers the same two lists.
+  #
+  # A descriptor matches a declared name as transition selection matches an
+  # event, on token boundaries: a declared `e.go` is matched by the
+  # descriptors `e.go`, `e.*`, `e.`, `e` and `*`, and not by `e.gone` or
+  # `e.go.now`. A declared name is a name, not a descriptor: a `*` in it is
+  # an ordinary token, so a declared `e.*` is matched by the descriptor `e`
+  # and not by `e.go`.
+  #
+  # - `unreachable`: each declared name no descriptor matches, in the
+  #   declaration's order and without duplicates.
+  # - `undeclared`: each descriptor that matches no declared name, in
+  #   document order of the transitions (a state's own before its
+  #   children's), each descriptor once.
+  #
+  # An empty declaration declares that the chart accepts nothing:
+  # `unreachable` is empty and `undeclared` is the whole vocabulary. With
+  # nil, no declaration, the vocabulary is the contract, so both lists are
+  # empty; a host asking whether one name `n` is in the vocabulary passes
+  # `[n]` and reads `unreachable`. It reports and refuses nothing: which
+  # list a host refuses a chart on, if either, is the host's decision. The
+  # declared names are read, never frozen or changed.
+  #
+  # @example
+  #   machine = Statifier.compile(<<~SCXML).value
+  #     <scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0">
+  #       <state id="a"><transition event="e.go" target="b"/></state>
+  #       <state id="b"><transition event="e.back" target="a"/></state>
+  #     </scxml>
+  #   SCXML
+  #   check = Statifier.check_accepts(machine, ["e.go", "e.stop"])
+  #   check.unreachable # => ["e.stop"]
+  #   check.undeclared  # => ["e.back"]
+  #
+  # @param machine [Machine] a compiled chart
+  # @param declared_events [Array<String>, nil] the declared event names,
+  #   or nil for no declaration
+  # @return [AcceptsCheck] the two lists, frozen
+  # @raise [TypeError] for a machine of the wrong kind, a declaration that
+  #   is neither an Array nor nil, or a declared name that is not a String
+  def self.check_accepts(machine, declared_events)
+    raise TypeError, "expected a compiled machine, got #{machine.class}" unless machine.is_a?(Machine)
+    unless declared_events.nil? || declared_events.is_a?(Array)
+      raise TypeError, "expected the declared events as an Array or nil, got #{declared_events.class}"
+    end
+
+    stray = declared_events&.find { !_1.is_a?(String) }
+    raise TypeError, "expected every declared event to be a String, got #{stray.class}" unless stray.nil?
+
+    Accepts.check(machine, declared_events)
+  end
 end

metadata

@@ -1,40 +1,150 @@
 --- !ruby/object:Gem::Specification
 name: statifier
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - JohnnyT
-autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
-dependencies: []
-description: 
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: predicator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: 'Interprets SCXML statecharts as a value step: an immutable state and
+  an event in, a new state and plain-data effects out. Conditions and expressions
+  are evaluated by the predicator gem.'
 email:
 - ubergeek3141@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- CODE_OF_CONDUCT.md
-- Gemfile
-- Gemfile.lock
-- LICENSE.txt
+- CHANGELOG.md
+- LICENSE
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
 - lib/statifier.rb
+- lib/statifier/accepts.rb
+- lib/statifier/basichttp.rb
+- lib/statifier/basichttp/decode.rb
+- lib/statifier/basichttp/encoding.rb
+- lib/statifier/basichttp/net_http_transport.rb
+- lib/statifier/basichttp/outbound.rb
+- lib/statifier/basichttp/processor.rb
+- lib/statifier/basichttp/request.rb
+- lib/statifier/basichttp/response.rb
+- lib/statifier/compiler.rb
+- lib/statifier/compiler/content.rb
+- lib/statifier/compiler/error.rb
+- lib/statifier/compiler/expressions.rb
+- lib/statifier/compiler/numbering.rb
+- lib/statifier/compiler/parts.rb
+- lib/statifier/compiler/walk.rb
+- lib/statifier/datamodel.rb
+- lib/statifier/datamodel/data_binding.rb
+- lib/statifier/datamodel/delay.rb
+- lib/statifier/datamodel/location.rb
+- lib/statifier/datamodel/program.rb
+- lib/statifier/datamodel/reason_value.rb
+- lib/statifier/datamodel/reasons.rb
+- lib/statifier/datamodel/stores.rb
+- lib/statifier/datamodel/system_variables.rb
+- lib/statifier/document.rb
+- lib/statifier/document/data.rb
+- lib/statifier/document/executable.rb
+- lib/statifier/document/invoke.rb
+- lib/statifier/document/states.rb
+- lib/statifier/driver.rb
+- lib/statifier/driver/calls.rb
+- lib/statifier/driver/checks.rb
+- lib/statifier/driver/delivery.rb
+- lib/statifier/driver/invocations.rb
+- lib/statifier/driver/mailbox.rb
+- lib/statifier/driver/routing.rb
+- lib/statifier/driver/session_id.rb
+- lib/statifier/driver/work.rb
+- lib/statifier/effect.rb
+- lib/statifier/event.rb
+- lib/statifier/frozen.rb
+- lib/statifier/interpreter.rb
+- lib/statifier/interpreter/blocks.rb
+- lib/statifier/interpreter/content.rb
+- lib/statifier/interpreter/entering.rb
+- lib/statifier/interpreter/exit_entry.rb
+- lib/statifier/interpreter/foreach.rb
+- lib/statifier/interpreter/invoke.rb
+- lib/statifier/interpreter/invoke/arguments.rb
+- lib/statifier/interpreter/invoke/passes.rb
+- lib/statifier/interpreter/loop.rb
+- lib/statifier/interpreter/machine_state.rb
+- lib/statifier/interpreter/macrostep.rb
+- lib/statifier/interpreter/name_match.rb
+- lib/statifier/interpreter/selection.rb
+- lib/statifier/interpreter/send.rb
+- lib/statifier/interpreter/step.rb
+- lib/statifier/interpreter/stop.rb
+- lib/statifier/interpreter/targets.rb
+- lib/statifier/lowering.rb
+- lib/statifier/lowering/branches.rb
+- lib/statifier/lowering/data.rb
+- lib/statifier/lowering/error.rb
+- lib/statifier/lowering/executable.rb
+- lib/statifier/lowering/placement.rb
+- lib/statifier/lowering/reading.rb
+- lib/statifier/lowering/states.rb
+- lib/statifier/machine.rb
+- lib/statifier/machine/content.rb
+- lib/statifier/machine/data.rb
+- lib/statifier/machine/states.rb
+- lib/statifier/machine/values.rb
+- lib/statifier/position.rb
+- lib/statifier/position/rebuild.rb
+- lib/statifier/position/shape.rb
+- lib/statifier/position/text.rb
+- lib/statifier/validator.rb
+- lib/statifier/validator/attributes.rb
+- lib/statifier/validator/context.rb
+- lib/statifier/validator/data.rb
+- lib/statifier/validator/error.rb
+- lib/statifier/validator/executable.rb
+- lib/statifier/validator/history.rb
+- lib/statifier/validator/messages.rb
+- lib/statifier/validator/states.rb
 - lib/statifier/version.rb
-- statifier.gemspec
+- lib/statifier/xml.rb
+- lib/statifier/xml/character_data.rb
+- lib/statifier/xml/cursor.rb
+- lib/statifier/xml/markup.rb
+- lib/statifier/xml/nodes.rb
+- lib/statifier/xml/parser.rb
+- lib/statifier/xml/scope.rb
+- lib/statifier/xml/tags.rb
 homepage: https://github.com/riddler/statifier-rb
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/riddler/statifier-rb
-post_install_message: 
+  source_code_uri: https://github.com/riddler/statifier-rb
+  changelog_uri: https://github.com/riddler/statifier-rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -42,15 +152,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Statecharts in Ruby
+summary: The interpreter core of an SCXML statechart engine.
 test_files: []

data/.gitignore

@@ -1,8 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at ubergeek3141@gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -1,11 +0,0 @@
-source "https://rubygems.org"
-
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-gem "bundler"
-gem "minitest"
-gem "minitest-focus"
-gem "pry-nav"
-gem "rake"
-
-gemspec