class Gamefic::Query::Base


and integers.
Most queries return entities, but there are also queries for plain text
a response callback.
Each query matches a command token to an object that can be passed into
A base class for entity-based queries that can be applied to responses.

def self.plain 

def self.plain
  @plain ||= new
end

def self.span(subject) 

def self.span(subject)
  plain.span(subject)
end

def accept?(subject, object)

Returns:
  • (Boolean) -

Parameters:
  • object (Entity) --
  • subject (Entity) -- 
def accept?(subject, object)
  select(subject).include?(object)
end

def bind(narrative) 

def bind(narrative)
  clone.tap do |query|
    query.instance_exec do
      @arguments = narrative.unproxy(@arguments)
    end
  end
end

def calculate_precision 

def calculate_precision
  arguments.sum(0) do |arg|
    case arg
    when Entity, Proxy::Base
      1000
    when Class, Module
      class_depth(arg) * 100
    else
      1
    end
  end
end

def class_depth(klass) 

def class_depth(klass)
  return 1 unless klass.is_a?(Class)
  depth = 1
  sup = klass
  depth += 1 while (sup = sup.superclass)
  depth
end

def filter(subject, token)

Returns:
  • (Result) -

Parameters:
  • token (String) --
  • subject (Gamefic::Entity) -- 
def filter(subject, token)
  scan = Scanner.scan(select(subject), token)
  return Result.new(nil, scan.token) unless scan.matched.one?
  Result.new(scan.matched.first, scan.remainder, scan.strictness)
end

def initialize *arguments, name: self.class.to_s

Parameters:
  • name (String) --
  • arguments (Array) --
    Raises:
    • (ArgumentError) - if any of the arguments are nil 
    def initialize *arguments, name: self.class.to_s
  raise ArgumentError, "nil argument in query" if arguments.any?(&:nil?)
  @arguments = arguments
  @name = name
end

    def inspect 

    def inspect
  "#{name}(#{arguments.map(&:inspect).join(', ')})"
end

    def name 

    def name
  @name || self.class.to_s
end

    def precision

    Returns:
    • (::Integer) - 
    def precision
  @precision ||= calculate_precision
end

    def select(subject)

    Returns:
    • (Array) -

    Parameters:
    • subject (Entity) -- 
    def select(subject)
  span(subject).that_are(*arguments)
end

    def span(_subject)

    Returns:
    • (Array) -

    Parameters:
    • subject (Entity) -- 
    def span(_subject)
  []
end