gamefic 3.4.0 → 3.6.0

data/lib/gamefic/query/base.rb

@@ -13,25 +13,23 @@ module Gamefic
       # @return [Boolean]
       attr_reader :ambiguous
 
+      attr_accessor :narrative
+
       # @raise [ArgumentError] if any of the arguments are nil
       #
       # @param arguments [Array<Object>]
       # @param ambiguous [Boolean]
-      def initialize *arguments, ambiguous: false
+      # @param name [String]
+      def initialize *arguments, ambiguous: false, name: self.class.to_s
         raise ArgumentError, "nil argument in query" if arguments.any?(&:nil?)
 
         @arguments = arguments
         @ambiguous = ambiguous
+        @name = name
       end
 
       # Get a query result for a given subject and token.
       #
-      # @note This method is retained as a convenience for authors. Narratives
-      #   should use Composer to build commands, as it provides more precise
-      #   matching of tokens to valid response arguments. Authors can use
-      #   #query to find entities that match a token regardless of whether the
-      #   result matches an available response.
-      #
       # @example
       #   respond :reds do |actor|
       #     reds = available(ambiguous: true).query(actor, 'red').match
@@ -41,19 +39,44 @@ module Gamefic
       # @param subject [Gamefic::Entity]
       # @param token [String]
       # @return [Result]
-      def query(_subject, _token)
-        raise "#query not implemented for #{self.class}"
+      def query(subject, token)
+        first_pass = Scanner.scan(span(subject), token)
+        if ambiguous?
+          ambiguous_result(first_pass.filter(*normalized_arguments))
+        elsif first_pass.match.one?
+          unambiguous_result(first_pass.filter(*normalized_arguments))
+        else
+          unambiguous_result(first_pass)
+        end
+      end
+      alias filter query
+
+      # Get an array of entities that match the arguments from the context of
+      # the subject.
+      #
+      # @param subject [Entity]
+      # @return [Array<Entity>]
+      def select subject
+        span(subject).that_are(*normalized_arguments)
       end
 
-      # Get an array of entities that match the query from the context of the
-      # subject.
+      # Get an array of entities that are candidates for selection from the
+      # context of the subject. These are the entities that #select will
+      # filter through query's arguments.
+      #
+      # Subclasses should override this method.
       #
       # @param subject [Entity]
       # @return [Array<Entity>]
-      def select _subject
-        raise "#select not implemented for #{self.class}"
+      def span _subject
+        []
       end
 
+      # True if the object is selectable by the subject.
+      #
+      # @param subject [Entity]
+      # @param object [Array<Entity>, Entity]
+      # @return [Boolean]
       def accept?(subject, object)
         available = select(subject)
         if ambiguous?
@@ -72,12 +95,20 @@ module Gamefic
         @ambiguous
       end
 
+      def name
+        @name || self.class.to_s
+      end
+
+      def inspect
+        "##{ambiguous? ? '*' : ''}#{name}(#{normalized_arguments.map(&:inspect).join(', ')})"
+      end
+
       private
 
       def calculate_precision
-        @arguments.sum(@ambiguous ? -1000 : 0) do |arg|
+        normalized_arguments.sum(@ambiguous ? -1000 : 0) do |arg|
           case arg
-          when Entity, Scriptable::Proxy::Agent
+          when Entity, Proxy, Proxy::Base
             1000
           when Class, Module
             class_depth(arg) * 100
@@ -107,7 +138,22 @@ module Gamefic
       def unambiguous_result scan
         return Result.new(nil, scan.token) unless scan.matched.one?
 
-        Result.new(scan.matched.first, scan.remainder)
+        Result.new(scan.matched.first, scan.remainder, scan.strictness)
+      end
+
+      def normalized_arguments
+        @normalized_arguments ||= arguments.map do |arg|
+          case arg
+          when Proxy, Proxy::Base
+            arg.fetch(narrative)
+          when String
+            proc do |entity|
+              arg.keywords.all? { |word| entity.keywords.include?(word) }
+            end
+          else
+            arg
+          end
+        end
       end
     end
   end

data/lib/gamefic/query/general.rb

@@ -14,22 +14,13 @@ module Gamefic
       # @param entities [Array, Proc]
       # @param arguments [Array<Object>]
       # @param ambiguous [Boolean]
-      def initialize entities, *arguments, ambiguous: false
-        super(*arguments, ambiguous: ambiguous)
+      def initialize entities, *arguments, ambiguous: false, name: nil
+        super(*arguments, ambiguous: ambiguous, name: name)
         @entities = entities
       end
 
-      def select subject
-        available_entities(subject).that_are(*@arguments)
-      end
-
-      def query subject, token
-        filtered = available_entities(subject).that_are(*@arguments)
-        return Result.new(token, nil) if filtered.include?(token)
-
-        scan = Scanner.scan(filtered, token)
-
-        ambiguous? ? ambiguous_result(scan) : unambiguous_result(scan)
+      def span subject
+        available_entities(subject)
       end
 
       private
@@ -37,9 +28,9 @@ module Gamefic
       def available_entities(subject)
         if @entities.is_a?(Proc)
           if @entities.arity.zero?
-            @entities.call
+            Stage.run narrative, &@entities
           else
-            @entities.call(subject)
+            Stage.run narrative, subject, &@entities
           end
         else
           @entities

data/lib/gamefic/query/result.rb

@@ -11,9 +11,12 @@ module Gamefic
       # @return [String]
       attr_reader :remainder
 
-      def initialize match, remainder
+      attr_reader :strictness
+
+      def initialize match, remainder, strictness = 0
         @match = match
         @remainder = remainder
+        @strictness = strictness
       end
     end
   end

data/lib/gamefic/query/scoped.rb

@@ -10,36 +10,18 @@ module Gamefic
       attr_reader :scope
 
       # @param scope [Class<Gamefic::Scope::Base>]
-      def initialize scope, *arguments, ambiguous: false
-        super(*arguments, ambiguous: ambiguous)
+      def initialize scope, *arguments, ambiguous: false, name: nil
+        super(*arguments, ambiguous: ambiguous, name: name)
         @scope = scope
       end
 
-      def select(subject)
+      def span(subject)
         @scope.matches(subject)
-              .that_are(*@arguments)
-      end
-
-      # @return [Result]
-      def query(subject, token)
-        available = @scope.matches(subject)
-                          .that_are(*@arguments)
-        return Result.new(token, nil) if available.include?(token)
-
-        scan = Scanner.scan(available, token)
-
-        return ambiguous_result(scan) if ambiguous?
-
-        unambiguous_result(scan)
       end
 
       def precision
         @precision ||= @scope.precision + calculate_precision
       end
-
-      def ambiguous?
-        @ambiguous
-      end
     end
   end
 end

data/lib/gamefic/query/text.rb

@@ -4,16 +4,21 @@ module Gamefic
   module Query
     # A special query that handles text instead of entities.
     #
-    class Text
+    class Text < Base
       # @param argument [String, Regexp]
-      def initialize argument = /.*/
-        @argument = argument
-        validate
+      # @param name [String, nil]
+      def initialize argument = /.*/, name: self.class.name
+        super(argument, name: name)
+        validate_argument
+      end
+
+      def argument
+        arguments.first
       end
 
       # @return [String, Regexp]
       def select(_subject)
-        @argument
+        argument
       end
 
       def query _subject, token
@@ -23,6 +28,7 @@ module Gamefic
           Result.new(nil, token)
         end
       end
+      alias filter query
 
       def precision
         0
@@ -32,25 +38,21 @@ module Gamefic
         match? argument
       end
 
-      def ambiguous?
-        true
-      end
-
       private
 
       def match? token
-        return false unless token.is_a?(String)
+        return false unless token.is_a?(String) && !token.empty?
 
-        case @argument
+        case argument
         when Regexp
-          token =~ @argument
+          token =~ argument
         else
-          token == @argument
+          token == argument
         end
       end
 
-      def validate
-        return if @argument.is_a?(String) || @argument.is_a?(Regexp)
+      def validate_argument
+        return if argument.is_a?(String) || argument.is_a?(Regexp)
 
         raise ArgumentError, 'Invalid text query argument'
       end

data/lib/gamefic/query.rb

@@ -2,6 +2,7 @@
 
 require 'gamefic/query/base'
 require 'gamefic/query/general'
+require 'gamefic/query/abstract'
 require 'gamefic/query/scoped'
 require 'gamefic/query/text'
 require 'gamefic/query/result'

data/lib/gamefic/response.rb

@@ -8,19 +8,18 @@ module Gamefic
     # @return [Symbol]
     attr_reader :verb
 
-    # @return [Array<Query::Base>]
+    # @return [Array<Query::Base, Query::Text>]
     attr_reader :queries
 
     # @param verb [Symbol]
     # @param narrative [Narrative]
-    # @param queries [Array<Query::Base>]
+    # @param args [Array<Object>]
     # @param meta [Boolean]
     # @param block [Proc]
-    def initialize verb, narrative, *queries, meta: false, &block
+    def initialize verb, narrative, *args, meta: false, &block
       @verb = verb
-      @queries = map_queryable_objects(queries)
+      @queries = map_queries(args, narrative)
       @meta = meta
-      @block = block
       @callback = Callback.new(narrative, block)
     end
 
@@ -57,53 +56,95 @@ module Gamefic
     # @param actor [Active]
     # @param command [Command]
     def accept? actor, command
-      return false if command.verb != verb || command.arguments.length != queries.length
-
-      queries.each_with_index do |query, idx|
-        return false unless query.accept?(actor, command.arguments[idx])
-      end
-
-      true
+      command.verb == verb &&
+        command.arguments.length == queries.length &&
+        queries.zip(command.arguments).all? { |query, argument| query.accept?(actor, argument) }
     end
 
     def execute *args
-      @callback.run *args
+      @callback.run(*args)
     end
 
     def precision
       @precision ||= calculate_precision
     end
 
+    # Turn an actor and an expression into a command by matching the
+    # expression's tokens to queries. Return nil if the expression
+    # could not be matched.
+    #
+    # @param actor [Actor]
+    # @param expression [Expression]
+    # @return [Command, nil]
+    def to_command actor, expression
+      return log_and_discard unless expression.verb == verb && expression.tokens.length <= queries.length
+
+      results = filter(actor, expression)
+      return log_and_discard unless results
+
+      Gamefic.logger.info "Accepted #{inspect}"
+      Command.new(
+        verb,
+        results.map(&:match),
+        results.sum(&:strictness),
+        precision
+      )
+    end
+
+    def inspect
+      "#<#{self.class} #{([verb] + queries).map(&:inspect).join(', ')}>"
+    end
+
     private
 
+    def log_and_discard
+      Gamefic.logger.info "Discarded #{inspect}"
+      nil
+    end
+
+    def filter actor, expression
+      remainder = ''
+      result = queries.zip(expression.tokens)
+                      .map do |query, token|
+                        token = "#{remainder} #{token}".strip
+                        result = query.filter(actor, token)
+                        return nil unless result.match
+
+                        remainder = result.remainder
+                        result
+                      end
+      result if remainder.empty?
+    end
+
     def generate_default_syntax
-      user_friendly = verb.to_s.gsub(/_/, ' ')
-      args = []
-      used_names = []
-      queries.each do |_c|
-        num = 1
-        new_name = ":var"
-        while used_names.include? new_name
-          num += 1
-          new_name = ":var#{num}"
-        end
-        used_names.push new_name
-        user_friendly += " #{new_name}"
-        args.push new_name
-      end
-      Syntax.new(user_friendly.strip, "#{verb} #{args.join(' ')}".strip)
+      args = queries.length.times.map { |num| num.zero? ? ':var' : ":var#{num + 1}" }
+      tmpl = "#{verb} #{args.join(' ')}".strip
+      Syntax.new(tmpl.gsub('_', ' '), tmpl)
     end
 
     def calculate_precision
-      total = 0
-      queries.each { |q| total += q.precision }
-      total -= 1000 if verb.nil?
+      total = queries.sum(&:precision)
+      total -= 1000 unless verb
       total
     end
 
-    def map_queryable_objects queries
-      # @todo Considering moving mapping from Actions to here
-      queries
+    def map_queries args, narrative
+      args.map do |arg|
+        select_query(arg, narrative).tap { |qry| qry.narrative = narrative }
+      end
+    end
+
+    def select_query arg, narrative
+      case arg
+      when Entity, Class, Module, Proc, Proxy, Proxy::Base
+        narrative.available(arg)
+      when String, Regexp
+        narrative.plaintext(arg)
+      when Query::Base, Query::Text
+        arg
+      else
+        raise ArgumentError, "invalid argument in response: #{arg.inspect}"
+      end
     end
   end
 end

data/lib/gamefic/scanner/base.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # A base class for scanners that match tokens to entities.
+    #
+    class Base
+      # @return [Array<Entity>]
+      attr_reader :selection
+
+      # @return [String]
+      attr_reader :token
+
+      # @param selection [Array<Entity>]
+      # @param token [String]
+      def initialize selection, token
+        @selection = selection
+        @token = token
+      end
+
+      # @return [Result]
+      def scan
+        unmatched_result
+      end
+
+      # @param selection [Array<Entity>]
+      # @param token [String]
+      # @return [Result]
+      def self.scan selection, token
+        new(selection, token).scan
+      end
+
+      private
+
+      def unmatched_result
+        Result.unmatched(selection, token, self.class)
+      end
+
+      def matched_result matched, remainder
+        Result.new(selection, token, matched, remainder, self.class)
+      end
+    end
+  end
+end

data/lib/gamefic/scanner/fuzzy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # Fuzzy token matching.
+    #
+    # An entity will match a word in a fuzzy scan if it matches the beginning
+    # of one of the entity's keywords, e.g., `pen` is a fuzzy token match for
+    # the keyword `pencil`.
+    #
+    class Fuzzy < Strict
+      def match_word available, word
+        available.select { |obj| obj.keywords.any? { |wrd| wrd.start_with?(word) } }
+      end
+    end
+  end
+end

data/lib/gamefic/scanner/fuzzy_nesting.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # Fuzzy scanning for entities inside of other entities, e.g., `soc in draw`
+    # would match `sock in drawer`.
+    #
+    class FuzzyNesting < Nesting
+      def subprocessor
+        Fuzzy
+      end
+    end
+  end
+end

data/lib/gamefic/scanner/nesting.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # Strict scanning for entities inside of other entities, e.g., `sock inside drawer`.
+    #
+    class Nesting < Base
+      NEST_REGEXP = / in | on | of | from | inside | inside of | from inside | off | out | out of /.freeze
+
+      def subprocessor
+        Strict
+      end
+
+      def scan
+        return unmatched_result unless token =~ NEST_REGEXP
+
+        denest selection, token
+      end
+
+      private
+
+      def denest objects, token
+        near = objects
+        far = objects
+        parts = token.split(NEST_REGEXP)
+        until parts.empty?
+          current = parts.pop
+          last_result = subprocessor.scan(near, current)
+          last_result = subprocessor.scan(far, current) if last_result.matched.empty? && near != far
+          return unmatched_result if last_result.matched.empty? || last_result.matched.length > 1
+
+          near = last_result.matched.first.children & objects
+          far = last_result.matched.first.flatten & objects
+        end
+        last_result
+      end
+    end
+  end
+end

data/lib/gamefic/scanner/result.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # The result of an attempt to scan objects against a token in a Scanner. It
+    # provides an array of matching objects, the text that matched them, and the
+    # text that remains unmatched.
+    #
+    class Result
+      # The scanned objects
+      #
+      # @return [Array<Entity>, String, Regexp]
+      attr_reader :scanned
+
+      # The scanned token
+      #
+      # @return [String]
+      attr_reader :token
+
+      # The matched objects
+      #
+      # @return [Array<Entity>, String]
+      attr_reader :matched
+      alias match matched
+
+      # The remaining (unmatched) portion of the token
+      #
+      # @return [String]
+      attr_reader :remainder
+
+      attr_reader :processor
+
+      def initialize scanned, token, matched, remainder, processor
+        @scanned = scanned
+        @token = token
+        @matched = matched
+        @remainder = remainder
+        @processor = processor
+      end
+
+      def strictness
+        @strictness ||= Scanner.strictness(processor)
+      end
+
+      def filter *args
+        Scanner::Result.new(
+          scanned,
+          token,
+          match.that_are(*args),
+          remainder,
+          processor
+        )
+      end
+
+      def self.unmatched scanned, token, processor
+        new(scanned, token, [], token, processor)
+      end
+    end
+  end
+end

data/lib/gamefic/scanner/strict.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Scanner
+    # Strict token matching.
+    #
+    # An entity will only match a word in a strict scan if the entire word
+    # matches one of the entity's keywords.
+    #
+    class Strict < Base
+      # @return [Result]
+      def scan
+        words = token.keywords
+        available = selection.clone
+        filtered = []
+        words.each_with_index do |word, idx|
+          tested = match_word(available, word)
+          return matched_result(filtered, words[idx..].join(' ')) if tested.empty?
+
+          filtered = tested
+          available = filtered
+        end
+        matched_result filtered, ''
+      end
+
+      def match_word available, word
+        available.select { |obj| obj.keywords.include?(word) }
+      end
+    end
+  end
+end