yatm 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: be3ead1b208b860b2ef2021496657196eff8a1bc42fc25c569cf77d3be6f37ff
+  data.tar.gz: a502d0f27f32c4a8686f5edca9aaf6e53f842a524b3e6cd26f34140528966bc5
+SHA512:
+  metadata.gz: 8f63ffe798d7500425b9d2de058fbc4704584b5a9b3fbc20ac440677df16b5b1a1d1fb512cc5c3efcf5e97fb5c89d974c5cf15560cf8fad22bf54e511bdd9602
+  data.tar.gz: fa8a1cfef51c8cc0673a17c461e53319ab3d953e7cc8b85803e6136a3f010665c27992d7ae26f83f0bcfa162369691e9778414d88e9391ef31f88b1212bb8e5d

data/lib/yatm/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class YATM::Error < StandardError
+  def text
+    raise NotImplementedError
+  end
+
+  def to_s
+    super == self.class.to_s ? text : super
+  end
+end

data/lib/yatm/machine/machine.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class YATM::Machine
+  attr_reader :tape, :state_machine, :history
+
+  def initialize(position: 0, content: [nil])
+    @tape = YATM::Tape.new(content, position: position)
+    @state_machine = YATM::StateMachine.new
+    @history = []
+  end
+
+  def initial_state(...); @state_machine.initial_state(...); end
+
+  def final_state(...); @state_machine.final_state(...); end
+
+  def states(...); @state_machine.states(...); end
+
+  def events(...); @state_machine.events(...); end
+
+  def event(...); @state_machine.event(...); end
+
+  def reset(...)
+    @history = []
+    @tape.reset(...)
+    @state_machine.reset
+  end
+
+  def to_h
+    {
+      state: @state_machine.current_state,
+      final: @state_machine.final_states.include?(@state_machine.current_state),
+      position: @tape.pos
+    }
+  end
+
+  def to_s; to_h.to_s; end
+
+  def to_txt
+    <<~TO_S
+      ,_______________
+      | State Machine
+      `---------------
+      #{@state_machine}
+      ,______
+      | Tape
+      `------
+      #{@tape}
+    TO_S
+  end
+
+  def step!(n = 1)
+    return if n < 1
+
+    (1..n).each do
+      result = @state_machine.process!(@tape.read)
+      @history << result
+      break if result[:final]
+
+      @tape.write result[:write]
+      @tape.move result[:move]
+    end
+
+    @history.last
+  end
+
+  def step(...)
+    step!(...) rescue YATM::Error
+  end
+
+  def run!(max = Float::INFINITY)
+    (1..max).each do
+      latest = step!
+      break to_h if latest[:final]
+    end
+  end
+
+  def run(...)
+    run!(...) rescue YATM::Error
+  end
+end

data/lib/yatm/state_machine/state_machine.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative "state_machine_errors"
+require_relative "event"
+
+class YATM::StateMachine
+  attr_reader :current_state, :events, :final_states, :initial_state
+
+  def initialize
+    @events = {}
+    @final_states = []
+  end
+
+  def reset
+    @current_state = @initial_state
+  end
+
+  def to_s
+    <<~TO_S.chomp
+      | states:  #{states}
+      | current: #{@current_state}
+      | events: #{@events.map(&:name)}
+    TO_S
+  end
+
+  def states
+    @events.map do |_name, event|
+      event.keys + event.map { |_, val| val[:to] }
+    end.flatten.uniq
+  end
+
+  def initial_state(state)
+    @initial_state = self.class.statify(state)
+    @current_state = @initial_state
+  end
+
+  def final_state(*states)
+    states.each do |state|
+      (@final_states << self.class.statify(state)).uniq!
+    end
+  end
+
+  def event(name, **transitions)
+    @events[name] = YATM::Event.new(name, **transitions)
+  end
+
+  def process(value)
+    process!(value)
+  rescue StateMachineError
+    nil
+  end
+
+  def process!(value)
+    return { final: @current_state } if @final_states.include?(@current_state)
+    raise InitialStateNotSet unless @current_state
+    raise InvalidEvent, value unless (event = @events[value])
+    raise InvalidTransition.new(@current_state, event) unless (
+      transition = event[@current_state] || event[YATM::ANY]
+    )
+
+    @current_state = transition[:to] unless transition[:to] == YATM::SAME
+    transition
+  end
+
+  def self.statify(state)
+    raise InvalidState, state unless state.respond_to?(:to_s)
+
+    state = state.to_s
+    raise InvalidState, state unless state.respond_to?(:to_sym)
+
+    state.to_sym
+  end
+end

data/lib/yatm/tape/tape.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "tape_errors"
+
+class YATM::Tape
+  attr_accessor :pos
+
+  def initialize(...)
+    reset(...)
+  end
+
+  def reset(content = [nil], position: 0)
+    @pos = position
+    @p_tape = content
+    @n_tape = [nil]
+  end
+
+  def read
+    tape[table_pos]
+  end
+
+  def write(value)
+    tape[table_pos] = value
+  end
+
+  def move(direction = YATM::NONE)
+    case direction
+    when YATM::RIGHT
+      @pos += 1
+      expand if table_pos == tape.size
+    when YATM::LEFT
+      @pos -= 1
+      expand if table_pos > tape.size
+    when YATM::NONE
+    else
+      raise InvalidMove
+    end
+  end
+
+  def to_s
+    full = @n_tape.reverse + @p_tape
+    full.map.with_index do |val, idx|
+      cell_txt(val, idx)
+    end.join(" ")
+        .gsub(/^\[_\] +/, "")
+        .gsub(/(\[_\] )*\[_\]\z/, "")
+        .gsub(/ \z/, "")
+  end
+
+  def to_txt
+    full = @n_tape.reverse + @p_tape
+    str = ""
+    full.each_with_index do |val, idx|
+      str += (idx - @n_tape.size).to_s.rjust(4) + " | #{val.inspect}".ljust(8)
+      str += " <=" if idx == abs_pos
+      str += "\n"
+    end
+
+    str
+  end
+
+  private
+
+  def cell_txt(val, idx)
+    str = idx == @n_tape.size ? "|:| " : ""
+    str += idx == abs_pos ? ">|" : "["
+    str += val.nil? ? "_" : val.to_s
+    str += idx == abs_pos ? "|<" : "]"
+    str
+  end
+
+  def tape
+    @pos >= 0 ?
+      @p_tape :
+      @n_tape
+  end
+
+  def abs_pos
+    @pos + @n_tape.size
+  end
+
+  def table_pos
+    @pos >= 0 ?
+      @pos :
+      -@pos - 1
+  end
+
+  def expand
+    current_size = tape.size
+    (1..current_size).each { tape << nil }
+  end
+end

data/lib/yatm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module YATM
+  VERSION = "0.2.0"
+end

data/lib/yatm.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "yatm/version"
+require_relative "yatm/tape/tape"
+require_relative "yatm/state_machine/state_machine"
+require_relative "yatm/machine/machine"
+
+module YATM
+  ANY   = :*
+  SAME  = :_
+  LEFT  = :l
+  RIGHT = :r
+  NONE  = nil
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: yatm
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- tiago-macedo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-08-19 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  This gem provides you with the module `YATM`.
+  The class YATM::Machine, specifically, allows you to program a functioning
+  turing machine and load it with a tape containing arbitrary symbols.
+
+  Check out files `lib/example_*.rb` to see it in action.
+email:
+- tiagomacedo@ufrj.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yatm.rb
+- lib/yatm/error.rb
+- lib/yatm/machine/machine.rb
+- lib/yatm/state_machine/state_machine.rb
+- lib/yatm/tape/tape.rb
+- lib/yatm/version.rb
+homepage: https://github.com/tiago-macedo/yatm
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tiago-macedo/yatm
+  source_code_uri: https://github.com/tiago-macedo/yatm
+  changelog_uri: https://github.com/tiago-macedo/yatm
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Yet Another Turing Machine implementation.
+test_files: []