moory 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b7874ce91e148aa1ee25266790efe1bbcd41a200c03a57af8ad1c73f350ffc0
-  data.tar.gz: 5df6382f80e74bd23374f1d22d1a2e67544534ea682563ab89fe4488d042a153
+  metadata.gz: 7f7daefff33b5cf15d86669bbaff8c8a8507d54259ac1b4199a8f173aef7bd38
+  data.tar.gz: 2d3cf62ea14e5ef8d3164ff5bbeeb84f415c806bdf7f1da63990a1fa53da4553
 SHA512:
-  metadata.gz: 27ef54b9755d39c18c51d13b7cd5be867a6fbc31a0ee7fcea4b8598ee98cf29c67fccc1b144001ecb9be577305100cac7c17dd7ce19849dd490e6a2b78658652
-  data.tar.gz: bb90b7506b1dd352cafcd6f52315d63668eb9c5aeba386e463203aeb1fd632c1617e9a53e2d6990c5b029e17d7eca8cd5d14abe4b65e45a7bb6f0ab338ef74ab
+  metadata.gz: d7b95ea00e217342548717c61b75909c63e610110a2597f1d0b78c78b25c171d893d9a9b743799a206a78cdeb748df25d1f636892e59fe570d62040de7695928
+  data.tar.gz: c54777928180b9365eabef5ef140b75d67cbd5401483a046862b31a339f588a90a9894e6cdcbf4af5d8364b9dea9455fa18b929303ae2ed3727835166c6470cb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moory (0.6.0)
+    moory (1.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,206 +1,6 @@
 # Moory
 Welcome to the Moory gem!
 
-You can use this gem to create various kinds of finite machines, and even teach objects manners using a simple plain-text specification language.
-
-The [wiki](https://github.com/elclavijero/moory/wiki) is where to go if you are for looking for tutorial material.  Perhaps also look in the examples directory.
-
-Until you do, here are two examples: the first is an acceptor, and the second is a **well mannered** object.
-
-## Example: An acceptor for ab*
-
-### Motivation
-
-Imagine that you want to create an incredible machine. One capable of determining whether a given character string belongs to the language described by the regular expression `ab*`.  You're not going to use a Regexp. That would be far too easy.  Instead you derive from the regular expression a Deterministic Finite Automaton (DFA) that does the job.  Here's what it might look like:
-
-![ab_star](images/ab_star.png)
-
-Of course, you've set up and solved a system of equations verifying that the design is correct.  Now how do you implement this in Ruby?  You won't bother trying to apply the State design pattern, because it is a pain.  Instead, you'll employ Moory, which is one of the 200+ gems that exist to make creating finite machines easy.
-
-### Implementing the Acceptor
-
-The first step is to install the Moory gem, achieved by issuing the following command:
-
-```
-gem install moory
-```
-
-When that's done, start up `irb` and paste the following:
-
-```ruby
-require 'moory'
-
-ab_star = Moory::Acceptor.create(
-  initial: '0',
-  transitions: %q{
-    0 : a : 1
-    0 : b : 2
-    1 : a : 2
-    1 : b : 1
-    2 : a : 2
-    2 : b : 2
-  },
-  final: %w{ 1 }
-)
-```
-
-I'll explain the syntax of the transitions later (see the [wiki](https://github.com/elclavijero/moory/wiki)) but you have done enough to confidently type:
-
-```ruby
-ab_star.accepts?(string: "ab")
-```
-
-and be delighted to see that the answer is `true`.
-
-If you are naturally curious, then you might want to put `ab_star` through its paces with further candidates:
-
-```ruby
-ab_star.accepts?(string: "abbb") # => true
-ab_star.accepts?(string: "aab")  # => false
-ab_star.accepts?(string: "aba")  # => false
-```
-
-You aren't stuck with testing the strings against the initial state.  You can ask the machine to begin its match in any state:
-
-```ruby
-ab_star.accepts?(string: "bbb", in_state: '1') 
-# => true
-```
-
-But what about including characters that don't belong to the machine's alphabet?
-
-```ruby
-ab_star.accepts?(string: "bbc", in_state: '1')
-```
-
-Well this one will be unceremoniously rejected with a runtime error (unless you are using version 0.1.0, where I forgot to handle bad input, sorry!).  Incidentally, if you want to change that behaviour, you should override the `default_proc`.
-```ruby
-ab_star.default_proc = proc { |msg| puts "I'm going to ignore that #{msg}" }
-```
-
-Now look
-```ruby
-ab_star.accepts?(string: "abcbb")
-# I'm going to ignore that c
-# => true
-```
-
-That's better.
-
-## Example: A well mannered object
-If you haven't already, open up `irb` and create an uncouth object
-
-```ruby
-uncouth = Object.new
-```
-
-and teach it how to speak
-
-```ruby
-def uncouth.say_foo
-  p 'foo'
-end
-def uncouth.say_bar
-  p 'bar'
-end
-def uncouth.say_something_nice(name)
-  p "Hello, #{name}. You look nice."
-end
-```
-
-Do you see anything wrong here? Doesn't that object seem a little dangerous? Everybody knows that `"foo"` comes before `"bar"` in code examples.  That absurd object might ruin everything! Is there anything we can do to prevent it from doing the unthinkable?
-
-```ruby
-uncouth.say_bar
-uncouth.say_foo
-```
-
-Yes. We can filter calls to the uncouth object using Moory's WellMannered class.  We need it's methods to be called according to foo-bar-etiquette:
-
-![ab_star](images/foo_bar_etiquette.png)
-
-Let's describe those rules using a language Moory understands:
-
-```ruby
-the_rules_of_foo_bar_etiquette = """
-  start        : say_foo  : said_foo
-    
-  said_foo     : say_foo  : said_foo
-  said_foo     : say_bar  : said_foo_bar
-
-  said_foo_bar : say_foo  : said_foo_bar
-  said_foo_bar : say_bar  : said_foo_bar
-"""
-```
-
-Let's make a postive change, and hereon refer to the uncouth object as the `well_mannered_object`.
-It will be our `protege`:
-
-```ruby
-require 'moory'
-
-well_mannered_object = Moory::WellMannered.new(
-  protege: uncouth,
-  rules:   the_rules_of_foo_bar_etiquette
-)
-```
-Now let's have a conversation with our protege.
-```ruby
-well_mannered_object.say_something_nice('Adam')
-# "Hello, Adam. You look nice."
-```
-That is nice.
-```ruby
-well_mannered_object.say_bar
-```
-So far so good. Our well mannered object is proving to be polite.  If someone asks it to depart from protocol, it will just quietly refuse.  But what if that isn't enough? What should it do if someone asks it to do something really bad?  The trouble is that well mannered objects are so well-behaved, they won't do depart from the protocol unless we say its OK. Let's do that.
-
-```ruby
-well_mannered_object.response_to_rule_breaking = proc { |msg|
-  p "You shouldn't ask me to #{msg}! I'm telling!"
-}
-```
-
-Now when we ask it to do something it out of turn
-```ruby
-well_mannered_object.say_bar
-# "You shouldn't ask me to say_bar! I'm telling!"
-```
-it will tell on you.  What a nice object!  Now don't be such a telltale.
-```ruby
-well_mannered_object.response_to_rule_breaking = nil
-```
-Let's continue
-```ruby
-well_mannered_object.say_bar
-```
-Good. You didn't complain.
-```ruby
-well_mannered_object.say_foo
-# "foo"
-```
-Promising.  You haven't yet spoken out of turn.
-```ruby
-well_mannered_object.say_foo
-# "foo"
-```
-A perfectly acceptable repetition.
-```ruby
-well_mannered_object.say_bar
-# "bar"
-```
-Wonderful!
-```ruby
-well_mannered_object.say_something_nice('Adam')
-# "Hello, Adam. You look nice."
-```
-Yes. Thank you.
-
-### Before you go...
-
-There's more to Moory than its Acceptors and WellMannered objects.  I'll show you how to use its other features in the [wiki](https://github.com/elclavijero/moory/wiki).
-
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/examples/ab_star.rb

@@ -1,8 +1,8 @@
 require 'moory'
 
-ab_star = Moory::Acceptor.create(
+rcg = Moory::Recogniser.new(
   initial: '0',
-  transitions: %q{
+  rules: %q{
     0 : a : 1
     0 : b : 2
     1 : a : 2
@@ -10,11 +10,15 @@ ab_star = Moory::Acceptor.create(
     2 : a : 2
     2 : b : 2
   },
-  final: %w{ 1 }
+  final:  [
+    '1'
+  ]
 )
 
-
-ab_star.accepts?(string: "abb")      
-# => true
-ab_star.accepts?(string:"abb", in_state: '1')
-# => false
+pp rcg.accepts?("a")   # => true
+pp rcg.accepts?("b")   # => false
+pp rcg.accepts?("c")   # => false
+pp rcg.accepts?("ab")  # => true
+pp rcg.accepts?("ac")  # => false
+pp rcg.accepts?("abb") # => true
+pp rcg.accepts?("abc") # => false

data/examples/decoder.rb

@@ -0,0 +1,16 @@
+require 'moory'
+
+decoder = Moory::Decoder.new(
+  rules: %q{
+    0 : a / a : 1
+    0 : b / b : 2
+    1 : a     : 1
+    1 : b / b : 2
+    2 : a / a : 1
+    2 : b     : 2
+  },
+  initial: '0'
+)
+
+decoder.decode("abababababbabbabaa")
+# => abababababababa

data/lib/moory.rb

@@ -1,9 +1,14 @@
 require "moory/version"
-require "moory/interpreter"
-require "moory/parser"
-require "moory/acceptor"
+require "moory/refinement"
+require "moory/pair"
+require "moory/machine"
+require "moory/transitions"
+require "moory/repertoire"
+
+require "moory/ruleparser"
+require "moory/loader"
+require "moory/recogniser"
 require "moory/decoder"
-require "moory/wellmannered"
 
 module Moory
   # Your code goes here...

data/lib/moory/decoder.rb

@@ -1,20 +1,32 @@
 module Moory
-  module Decoder
-    def Decoder.create(config)
-      Interpreter.new do |i|
-        i.load(config[:transitions])
-      
-        define_singleton_method(:decode) do |string|
-          i.state = config[:initial]
-          i.fallback_effector = config
-            .fetch(:ostream, $stdout)
-            .method(:write)
-      
-          string.each_char do |c|
-            i.putm(c)
-          end
-        end
-      end
+  class Decoder
+    include Efferent
+
+    def initialize(rules:, initial:, ostream:$stdout)
+      @initial = initial
+      @state = initial
+      @ostream = ostream
+      configure(rules)
+    end
+
+    # Decode a string according to the rules.  Writes the decoded string to the output 
+    #   stream configured at initialisation (which is $stdout, by default).  Characters
+    #   not belonging to the alphabet will be dropped.
+    #
+    # @param string [String] the string you wish to decode
+    def decode(string)
+      string.each_char { |c| issue(c) }
+    end
+
+    private
+
+    def configure(rules)
+      Loader.load(rules: rules, machine: self)
+      repertoire.always = method(:write)
+    end
+
+    def write(output=nil)
+      @ostream.write(output) if output
     end
   end
 end

data/lib/moory/loader.rb

@@ -0,0 +1,11 @@
+module Moory
+  module Loader
+    def Loader.load(rules:, machine:)
+      prs = Moory::RuleParser::FileReader.new
+      ary = prs.analyse(rules)
+      ary.each do |params|
+        machine.transitions.store(params)
+      end
+    end
+  end
+end

data/lib/moory/machine.rb

@@ -0,0 +1,93 @@
+require 'forwardable'
+
+module Moory
+  module Afferent
+    attr_accessor :transitions
+    attr_accessor :state
+
+    extend Forwardable
+    def_delegators :@transitions, :states, :alphabet
+
+    def transitions
+      @transitions ||= Moory::Transition::Storage.new
+    end
+
+    # Issue a stimulus to the machine.
+    #
+    # @return will either be the new `settlement`, or `nil` if the stimulus is not understood.
+    def issue(stimulus)
+      if response = transitions.response(origin: state, stimulus: stimulus)
+        honour(response)
+      end
+    end
+
+    # Reveals the stimuli to which the machine may respond in its current state.
+    #
+    # @return [Set] 
+    def awaits
+      transitions.egresses(state:state)
+    end
+
+    # Answers whether a machine can respond to the given stimlus in its current state.
+    #
+    # @return [Boolean]
+    def understand?(stimulus)
+      awaits.include?(stimulus)
+    end
+
+    private
+
+    def settle_accordingly(response)
+      @state = response[:settlement]
+    end
+
+    def honour(response)
+      settle_accordingly(response)
+    end
+  end
+
+  module Efferent
+    include Afferent
+
+    attr_accessor :repertoire
+
+    extend Forwardable
+    def_delegators :@repertoire, :always=, :always
+    def_delegators :@repertoire, :fallback=, :fallback
+
+    def repertoire
+      @repertoire ||= Moory::Repertoire.new
+    end
+
+    private
+
+    def honour(response)
+      perform(response) if repertoire
+      super
+    end
+
+    def perform(response)
+      perform_always(response[:output])
+      perform_special(response)
+    end
+
+    def perform_always(output)
+      guarded_call(always, output)
+    end
+
+    def perform_special(response)
+      guarded_call(
+        repertoire.recall(response[:effector]),
+        response[:output]
+      ) if response[:effector]
+    end
+
+    def guarded_call(receiver, output)
+      output ? receiver.call(output) : receiver.call
+    end
+  end
+
+  class Transducer
+    include Efferent
+  end
+end

data/lib/moory/recogniser.rb

@@ -0,0 +1,32 @@
+module Moory
+  class Recogniser
+    include Afferent
+    
+    def initialize(rules:, initial:, final:)
+      @initial = initial
+      @final   = final
+      Loader.load(rules: rules, machine: self)
+    end
+    
+    # Answers whether the given string is accepted; that is, does it belong to
+    # the language described by the rules?
+    #
+    # @param string [String] the candidate string.
+    # @return [Boolean] true if the string is accepted; false, otherwise.
+    def accepts?(string)
+      reset
+
+      string.each_char.all? { |c| issue(c) } && accepting?
+    end
+
+    private
+
+    def reset
+      @state = @initial
+    end
+
+    def accepting?
+      @final.include?(state)
+    end
+  end
+end

data/lib/moory/refinement.rb

@@ -0,0 +1,41 @@
+module Moory
+  module Refinement
+    module ArrayRefinement
+      refine Array do
+        def map_to(other)
+          Hash[*self.zip(other).flatten].compact
+        end
+
+        def identity_map
+          map_to(self)
+        end
+      end
+    end
+
+    module HashRefinement
+      refine Hash do
+        using ArrayRefinement
+        def domain
+          keys.to_set
+        end
+
+        def range
+          values.to_set
+        end
+
+        def composable?(other)
+          !(range & other.domain).empty?
+        end
+
+        def then(other)
+          return {} if other.empty?
+          transform_values { |v| other[v] }.compact
+        end
+
+        def project(*args)
+          args.identity_map.then(self)
+        end
+      end
+    end
+  end
+end

data/lib/moory/repertoire.rb

@@ -0,0 +1,68 @@
+module Moory
+  class Repertoire
+    SKIP = proc {}
+
+    attr_reader :knowledge
+    attr_reader :fallback
+    attr_reader :always
+
+    # Create a repertoire from a Hash mapping names to callable objects.
+    #
+    # @return [Repertoire]
+    def Repertoire.from_hash(hash={})
+      new.tap { |r| r.cram(hash) }
+    end
+
+    def initialize
+      @fallback  = SKIP
+      @always    = SKIP
+      @knowledge = {}
+    end
+
+    # Learn multiple items of knowledge.
+    def cram(hash={})
+      hash.each { |k,v| learn(name: k, item: v) }
+    end
+
+    # Associate a name with a callable object.  The item will not be stored unless it is callable; 
+    #   that is, it must respond to `:call`.
+    #
+    # @param item the callable object you want to store.
+    # @param name the name you will use to identify the `item`.
+    def learn(item:,name:)
+      @knowledge.store(name, item) if (
+        appropriate?(item) && name
+      )
+    end
+
+    # Recall a callable object by name.
+    #
+    # @param the name identifying the object you want to retrieve.
+    # @return if the given value represents knowledge, then that which has been learned is returned.
+    #   If the name does not represent an item of knowledge, then the `fallback` is returned.  You will
+    #   always get something callable when you call this method.
+    def recall(name)
+      name ? 
+        knowledge.fetch(name, fallback) : 
+        fallback
+    end
+
+    def fallback=(obj)
+      @fallback = censor(obj)
+    end
+
+    def always=(obj)
+      @always = censor(obj)
+    end
+
+    private
+
+    def appropriate?(obj)
+      obj.respond_to?(:call)
+    end
+
+    def censor(obj)
+      appropriate?(obj) ? obj : SKIP
+    end
+  end
+end

data/lib/moory/ruleparser.rb

@@ -0,0 +1,82 @@
+module Moory
+  module RuleParser
+    RULES = [
+      { origin: 'origin',   stimulus: ':', settlement: 'stimulus'   },
+      
+      { origin: 'stimulus', stimulus: ':', settlement: 'settlement' },
+      { origin: 'stimulus', stimulus: '/', settlement: 'output'     },
+      
+      { origin: 'output',   stimulus: ':', settlement: 'settlement' },
+      { origin: 'output',   stimulus: '/', settlement: 'effector'   },
+      
+      { origin: 'effector', stimulus: ':', settlement: 'settlement' },
+    ].freeze
+
+    Transitions = Moory::Transition::Storage.new.tap { |ts|
+      RULES.each { |r| ts.store(r) }
+    }
+
+    class LineReader < Moory::Transducer
+      attr_reader :scan_data
+
+      IGNORE = [ ' ', '\t' ]
+
+      def initialize
+        @transitions = Transitions
+        prepare
+      end
+
+      def reset
+        @state     = 'origin'
+        @scan_data = {}
+      end
+
+      def <<(string)
+        puts(string)
+      end
+
+      private
+
+      def puts(string)
+        string.each_char { |c| putc(c) }
+        scan_data
+      end
+
+      alias special? understand?
+
+      def putc(char)
+        (special?(char) ?
+          issue(char) :
+          target(state) << char) unless ignore?(char)
+      end
+
+      def prepare
+        reset
+      end
+
+      def target(state)
+        @scan_data.fetch(state.to_sym) { |k| @scan_data[k] = '' }
+      end
+
+      def ignore?(char)
+        IGNORE.include?(char)
+      end
+    end
+
+    class FileReader
+      def initialize
+        @line_reader = Moory::RuleParser::LineReader.new
+      end
+
+      def analyse(input)
+        input
+          .each_line
+          .reduce([]) do |list, line|
+            list << (@line_reader << (line.chomp))
+            @line_reader.reset
+            list
+          end
+      end
+    end
+  end
+end

data/lib/moory/transitions.rb

@@ -0,0 +1,115 @@
+require 'set'
+
+module Moory
+  module Transition
+    # Serves as a transition relation.
+    class Storage
+      def count
+        storage.size
+      end
+      
+      # Store a transition described by a hash
+      #
+      # @param params [Hash] a hash describing a transition.  At a minimum,
+      #   it should include `:origin`, `:stimulus`, and `:settlement`.  
+      #   It may also include `:output` and `:effector`.
+      def store(params)
+        storage.merge!(Hasher.new(params)) do |key, oldval, newval|
+          oldval.merge!(newval)
+        end
+      end
+
+      # Retrieve the unique response to a stimulus from a given origin.
+      #
+      # @return [Hash, nil] if the given parameters represent a transition, a Hash is returned
+      #   including at least a `:settlement`, and maybe one/both of `:output` and `:effector`.
+      #   If the paremeters do not correspond to a uniqu transition, `nil` is returned.
+      def response(origin:, stimulus:)
+        storage.dig(origin, stimulus)
+      end
+
+      # Retrieve the states represented by the transition relation.
+      #
+      # @return [Set]
+      def states
+        storage
+          .keys
+          .to_set
+      end
+
+      # Retrieve the alphabet
+      #
+      # @param restrict retricts the alphabet to that subset applicable to the state named by 
+      #   the given value.
+      # @return [Set]
+      def alphabet(restrict:nil)
+        storage
+          .select  { |k| restrict ? k == restrict : true }
+          .values
+          .collect { |r| r.keys }
+          .flatten
+          .to_set
+      end
+
+      # Retrieve the egresses for the given state.
+      #
+      # @param state identifies the state for which egresses are being sought.
+      # @return [Set]
+      def egresses(state:)
+        alphabet(restrict: state)
+      end
+
+      # Returns the transition relation.
+      #
+      # @return [Hash] represents the transition relation as a mapping from 
+      #   (state, stimulus) to (settlement, output, effector).
+      def storage
+        @storage ||= {}
+      end
+    end
+
+    # Helps expand a flat-hash description of a transition into a form
+    # amenable to storage.
+    Hasher = Struct.new(
+      :origin,
+      :stimulus,
+      :settlement,
+      :output,
+      :effector, 
+      keyword_init: true
+    ) do
+
+      def valid?
+        origin && stimulus && settlement
+      end
+
+      def to_hash(for_storage: true)
+        return {} unless valid?
+
+        for_storage ?  storage_hash : flat_hash
+      end
+
+      private
+
+      def storage_hash
+        p = Pair.new(left: origin, right: stimulus)
+
+        p.shunt({ 
+          settlement: settlement,
+          output:     output,
+          effector:   effector
+        }.compact)
+      end
+
+      def flat_hash
+        {
+          origin: origin,
+          stimulus: stimulus,
+          settlement: settlement,
+          output: output,
+          effector: effector
+        }
+      end
+    end
+  end
+end

data/lib/moory/version.rb

@@ -1,3 +1,3 @@
 module Moory
-  VERSION = "0.6.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moory
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam W. Grant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-11 00:00:00.000000000 Z
+date: 2018-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,21 +70,18 @@ files:
 - bin/console
 - bin/setup
 - examples/ab_star.rb
-- examples/readme_example.rb
-- examples/silly.rb
-- examples/single_as_and_bs.rb
-- examples/well_mannered_objects.rb
-- images/ab_star.png
-- images/foo_bar_etiquette.png
+- examples/decoder.rb
 - lib/moory.rb
-- lib/moory/acceptor.rb
-- lib/moory/arrow.rb
 - lib/moory/decoder.rb
-- lib/moory/interpreter.rb
+- lib/moory/loader.rb
+- lib/moory/machine.rb
 - lib/moory/pair.rb
-- lib/moory/parser.rb
+- lib/moory/recogniser.rb
+- lib/moory/refinement.rb
+- lib/moory/repertoire.rb
+- lib/moory/ruleparser.rb
+- lib/moory/transitions.rb
 - lib/moory/version.rb
-- lib/moory/wellmannered.rb
 - moory.gemspec
 homepage: https://github.com/elclavijero/moory
 licenses:

data/examples/readme_example.rb

@@ -1,38 +0,0 @@
-require 'moory'
-
-# Create an acceptor for the language described by ab*
-ab_star = Moory::Acceptor.create(
-  initial: '0',
-  transitions: %q{
-    0 : a : 1
-    0 : b : 2
-    1 : a : 2
-    1 : b : 1
-    2 : a : 2
-    2 : b : 2
-  },
-  final: %w{ 1 }
-)
-
-# Check some strings
-ab_star.accepts?(string: "ab")   # => true
-ab_star.accepts?(string: "abbb") # => true
-ab_star.accepts?(string: "aab")  # => false
-ab_star.accepts?(string: "aba")  # => false
-
-# Check a string against another starting state
-ab_star.accepts?(string: "bbb", in_state: '1')
-# => true
-
-# Uncomment the next line, and you'll see a runtime error
-# ab_star.accepts?(string: "bbc", in_state: '1')
-
-# Assign a default_proc, which is called when the Acceptor 
-# encounters a character not in its alphabet e.g. 'c'
-ab_star.default_proc = proc { |msg| puts "I'm going to ignore that #{msg}" }
-
-# Deliberately give the Acceptor a bad character.
-ab_star.accepts?(string: "abcbb")
-# I'm going to ignore that c
-# => true
-

data/examples/silly.rb

@@ -1,34 +0,0 @@
-require 'moory'
-
-silly = Moory::Interpreter.new do |i|
-  i.load """
-    0 : a / u / foo : 1
-    0 : b / v / foo : 2
-    1 : a / w / bar : 1
-    1 : b / x / bar : 2
-    2 : a / y /     : 1
-    2 : b / z       : 2
-  """
-end
-
-# Tell the interpreter where we want to start
-silly.state = '0'
-
-# Define some handlers for the effectors named in the 
-# loaded specification.
-silly.effectors = {
-  'foo' => proc { |msg| pp "#{msg} says: fooby fooby foo" },
-  'bar' => proc { |msg| pp "#{msg} says: barby barby bar" },
-}
-
-# Tell the interpreter the name of the effector we want to use
-# if a transition has output, but no effector.
-silly.fallback_effector = 'bar'
-
-
-# Send the interpreter some messages: putm means "PUT Message"
-silly.putm('b') # outputs: "v says: fooby fooby foo"
-silly.putm('b') # outputs: "z says: barby barby bar"
-silly.putm('a') # outputs: "y says: barby barby bar"
-silly.putm('a') # outputs: "w says: barby barby bar"
-

data/examples/single_as_and_bs.rb

@@ -1,21 +0,0 @@
-require 'moory'
-require 'stringio'
-
-ostream = StringIO.new
-
-mealy = Moory::Decoder.create(
-  initial: '0',
-  transitions: %q{
-    0 : a / a : 1
-    0 : b / b : 2
-    1 : a     : 1
-    1 : b / b : 2
-    2 : a / a : 1
-    2 : b     : 2
-  },
-  ostream: ostream
-)
-
-mealy.decode("abbbbbbaaaabaabbba")
-
-ostream.string # => "abababa"

data/examples/well_mannered_objects.rb

@@ -1,81 +0,0 @@
-# Well-mannered objects
-
-# Suppose we have an uncouth object 
-uncouth = Object.new
-
-# and it can speak
-def uncouth.say_foo
-  p 'foo'
-end
-def uncouth.say_bar
-  p 'bar'
-end
-def uncouth.say_something_nice(name)
-  p "Hello, #{name}. You look nice."
-end
-
-# Do you see anything wrong here?
-# Doesn't that object seem a little dangerous? Everybody knows that "foo" comes before "bar" in 
-# code examples.  That absurd object might ruin everything! Is there anything we can do to prevent 
-# it from doing the unthinkable?
-# 
-# uncouth.say_bar
-# uncouth.say_foo
-#
-
-# Yes, of course there is!  We can filter calls to the uncouth object using Moory's WellManered 
-# class.
-require 'moory'
-
-# We can go no further until we write down the rules of foo-bar-etiquette
-
-the_rules_of_foo_bar_etiquette = """
-  start        : say_foo  : said_foo
-    
-  said_foo     : say_foo  : said_foo
-  said_foo     : say_bar  : said_foo_bar
-
-  said_foo_bar : say_foo  : said_foo_bar
-  said_foo_bar : say_bar  : said_foo_bar
-"""
-
-# Let's make a postive change, and hereon refer to the uncouth object as the `well_mannered_object`.
-# It will be our `protege`, and the instantiation of a WellMannered object won't surprise us:
-
-well_mannered_object = Moory::WellMannered.new(
-  protege: uncouth,
-  rules:   the_rules_of_foo_bar_etiquette
-)
-
-# Now let's have a conversation with our protege.
-well_mannered_object.say_something_nice('Adam')
-# That is nice.
-well_mannered_object.say_bar    
-# Good.  I'm glad you didn't fall for that
-
-# So far so good. Our well mannered object is proving to be polite.  If someone asks it 
-# to depart from protocol, it will just quietly refuse.  But what if that isn't enough?
-# What should it do if someone asks it to do something really bad?  The trouble is,
-# well-mannered objects are so well-behaved, they won't do anything unless we say its OK.
-# Let's do that.
-
-well_mannered_object.response_to_rule_breaking = proc { |msg|
-  pp "You shouldn't ask me to #{msg}! I'm telling!"
-}
-
-# Now when we ask it to do something it out of turn
-well_mannered_object.say_bar
-# it will tell on you.  What a nice object!  Now don't be such a telltale.
-well_mannered_object.response_to_rule_breaking = nil
-# Let's continue
-well_mannered_object.say_bar
-# Good. You didn't complain.
-well_mannered_object.say_foo    
-# Promising.  You haven't yet spoken out of turn.
-well_mannered_object.say_foo
-# A perfectly acceptable reptition.
-well_mannered_object.say_bar
-# Wonderful!
-well_mannered_object.say_something_nice('Adam')
-# Yes. Thank you.
-

data/lib/moory/acceptor.rb

@@ -1,21 +0,0 @@
-module Moory
-  module Acceptor
-    def Acceptor.create(specification)
-      Moory::Interpreter.new do |i|
-        i.load(specification[:transitions])
-        
-        i.default_proc = proc { |msg| 
-          raise "#{i} in state #{i.state} did not understand #{msg}.  Input rejected!"
-        }
-      
-        define_singleton_method(:accepts?) do |string:, in_state: nil|
-          i.state = in_state ? in_state : specification[:initial]
-          
-          string.each_char { |c| putm(c) }
-      
-          specification[:final].include?(i.state)
-        end
-      end
-    end
-  end
-end

data/lib/moory/arrow.rb

@@ -1,12 +0,0 @@
-module Moory
-  Arrow = Struct.new(
-    :source,
-    :label,
-    :target,
-    keyword_init: true
-  ) do
-    def valid?
-      source && label && target
-    end
-  end
-end

data/lib/moory/interpreter.rb

@@ -1,109 +0,0 @@
-require 'set'
-
-module Moory
-  class Interpreter
-    attr_accessor :graph, :effectors, :state
-    attr_reader   :fallback_effector, :default_proc
-
-    SKIP = proc {}
-    WARN = proc { |msg| warn "Did not understand: #{msg}" }
-
-    def initialize(graph: {}, effectors: {}, default_proc: SKIP, fallback_always: true, &block)
-      @graph        = graph
-      @effectors    = effectors
-      @default_proc = default_proc
-      @fallback_always = fallback_always
-
-      instance_eval &block if block_given?
-    end
-
-    def load(source)
-      p = Moory::Parser.new
-      @graph.merge!(p.analyse(source))
-    end
-
-    def fallback_effector=(obj)
-      candidate = obj.kind_of?(String) ? effectors[obj] : obj
-      
-      @fallback_effector = candidate.respond_to?(:call) ? candidate : nil
-    end
-
-    def fallback_always=(bool)
-      @fallback_always = bool
-    end
-
-    def default_proc=(obj)
-      @default_proc = obj.respond_to?(:call) ? obj : nil
-    end
-
-    def putm(msg)
-      warn """
-      #{self} received #{msg} before being assigned a state.
-      The message will be passed to the default_proc.
-      """ unless state
-      
-      understand?(msg) ? respond(msg) : bad_call(msg)
-    end
-
-    def understand?(msg)
-      receptors.include?(msg)
-    end
-
-    def receptors
-      graph.fetch(state,{}).keys.to_set
-    end
-
-    def states
-      @states ||= graph.keys.to_set
-    end
-
-    def alphabet
-      @alphabet ||= Set.new(
-        graph.each_value.collect { |m| m.keys }.flatten
-      )
-    end
-
-    private
-
-    def respond(msg)
-      dispatch(msg)
-      resettle(msg)
-    end
-
-    def dispatch(msg)
-      _effector, _output = effector(msg), output(msg)
-
-      if _effector.respond_to?(:call)
-        _effector.arity == 0 ?
-          _effector.call :
-          _effector.call(_output)
-      end
-    end
-
-    def resettle(msg)
-      @state = graph[state][msg][:state]
-    end
-
-    def effector(msg)
-      candidate = graph[state][msg][:effector]
-
-      if candidate.kind_of?(String)
-        effectors[candidate]
-      else
-        candidate || (fallback_effector if fallback_appropriate_for?(msg))
-      end
-    end
-
-    def fallback_appropriate_for?(msg)
-      @fallback_always ? @fallback_always : output(msg)
-    end
-
-    def output(msg)
-      graph[state][msg][:output]
-    end
-
-    def bad_call(msg)
-      default_proc.call(msg) if default_proc
-    end
-  end
-end

data/lib/moory/parser.rb

@@ -1,127 +0,0 @@
-require 'moory/pair'
-
-module Moory
-  class Parser
-    attr_reader :graph, :staged
-  
-    def initialize
-      @graph   = {}
-      prime_interpreter
-    end
-  
-    def analyse(input)
-      input.each_line do |line| 
-        scan(line); store if valid?
-        reset_interpreter
-      end
-
-      return graph
-    end
-  
-    private
-  
-    def scan(string)
-      string.chomp.each_char { |c| route(c) }
-    end
-  
-    def route(char)
-      special?(char) ? interpret(char) : write_to_focus(char)
-    end
-
-    def special?(char)
-      interpreter.understand?(char)
-    end
-
-    def write_to_focus(char)
-      staged.fetch(@focus) { |k| staged[k] = '' } << char
-    end
-
-    def interpret(char)
-      interpreter.putm(char)
-    end
-  
-    def store
-      graph.merge!(transition)
-    end
-
-    def transition
-      poise.shunt(response)
-    end
-
-    def poise
-      Moory::Pair.new(
-        left: staged['source'],
-        right: staged['stimulus']
-      )
-    end
-
-    def response
-      { 
-        state:    staged['target'],
-        output:   staged['output'],
-        effector: staged['effector']
-      }.compact
-    end
-  
-    def valid?
-      staged['source']   && 
-      staged['stimulus'] && 
-      staged['target']
-    end
-
-    def prime_interpreter
-      interpreter.state = '0'
-      @staged   = {}
-      source
-    end
-
-    alias reset_interpreter prime_interpreter
-
-    def interpreter
-      @interpreter ||= Moory::Interpreter.new(config)
-    end
-
-    def config
-      {
-        graph: {
-          '0' => {
-            ':'  => { state: '1', effector: 'stimulus' },
-            ' '  => { state: '0' },
-            '\t' => { state: '0' }
-          },
-          '1' => { 
-            '/'  => { state: '2', effector: 'output' },
-            ':'  => { state: '4', effector: 'target' },
-            ' '  => { state: '1' },
-            '\t' => { state: '1' }
-          },
-          '2' => {
-            ':'  => { state: '4', effector: 'target' },
-            '/'  => { state: '3', effector: 'effector' },
-            ' '  => { state: '2' },
-            '\t' => { state: '2' }
-          },
-          '3' => {
-            ':'  => { state: '4', effector: method(:target) },
-            ' '  => { state: '2' },
-            '\t' => { state: '2' }
-          },
-          '4' => {
-            ' '  => { state: '4' },
-            '\t' => { state: '4' }
-          }
-        },
-        effectors: {
-            'stimulus' => method(:stimulus),
-            'output'   => method(:output),
-            'target'   => method(:target),
-            'effector' => method(:effector),
-        }
-      }
-    end
-
-    %w{
-      source stimulus target output effector
-    }.each { |c| define_method(c) { @focus = c } }
-  end
-end

data/lib/moory/wellmannered.rb

@@ -1,54 +0,0 @@
-module Moory
-  class WellMannered
-    attr_reader :response_to_rule_breaking
-
-    IGNORE = proc {}
-
-    def initialize(protege:, rules:, initial:'start', response_to_rule_breaking: IGNORE)
-      @protege  = protege
-      @rules    = rules
-      @initial  = initial
-      @response_to_rule_breaking = response_to_rule_breaking
-      prepare
-    end
-
-    def restricted_messages
-      interpreter.alphabet
-    end
-
-    def response_to_rule_breaking=(obj)
-      @response_to_rule_breaking = obj.respond_to?(:call) ? obj : IGNORE
-    end
-  
-    private
-  
-    def prepare
-      interpreter.load(@rules)
-      interpreter.state = @initial
-    end
-  
-    def interpreter
-      @interpreter ||= Moory::Interpreter.new
-    end
-  
-    def method_missing(*args)
-      protected?(*args) ? 
-        filter_first(*args) : 
-        forward(*args)
-    end
-  
-    def protected?(*args)
-      interpreter.alphabet.include?(args.first.to_s)
-    end
-  
-    def filter_first(*args)
-      interpreter.putm(args.first.to_s) ? 
-        forward(*args) : 
-        response_to_rule_breaking.call(*args)
-    end
-  
-    def forward(*args)
-      @protege.send(*args)
-    end
-  end
-end