gamefic 1.7.0 → 2.1.0

data/lib/gamefic/query.rb

@@ -1,18 +1,15 @@
-#require 'gamefic/keywords'
-
-module Gamefic
-
-  module Query
-    autoload :Base, 'gamefic/query/base'
-    autoload :Children, 'gamefic/query/children'
-    autoload :Descendants, 'gamefic/query/descendants'
-    autoload :External, 'gamefic/query/external'
-    autoload :Family, 'gamefic/query/family'
-    autoload :Itself, 'gamefic/query/itself'
-    autoload :Matches, 'gamefic/query/matches'
-    autoload :Parent, 'gamefic/query/parent'
-    autoload :Siblings, 'gamefic/query/siblings'
-    autoload :Text, 'gamefic/query/text'
-  end
-
-end
+module Gamefic
+  module Query
+    autoload :Base, 'gamefic/query/base'
+    autoload :Children, 'gamefic/query/children'
+    autoload :Descendants, 'gamefic/query/descendants'
+    autoload :External, 'gamefic/query/external'
+    autoload :Family, 'gamefic/query/family'
+    autoload :Tree, 'gamefic/query/tree'
+    autoload :Itself, 'gamefic/query/itself'
+    autoload :Matches, 'gamefic/query/matches'
+    autoload :Parent, 'gamefic/query/parent'
+    autoload :Siblings, 'gamefic/query/siblings'
+    autoload :Text, 'gamefic/query/text'
+  end
+end

data/lib/gamefic/query/base.rb

@@ -9,6 +9,13 @@ module Gamefic
         @arguments = args
       end
 
+      # Determine whether the query allows ambiguous entity references.
+      # If false, actions that use this query will only be valid if the token
+      # passed into it resolves to a single entity. If true, actions will
+      # accept an array of matching entities instead.
+      # Queries are not ambiguous by default (ambiguous? == false).
+      #
+      # @return [Boolean]
       def ambiguous?
         false
       end
@@ -36,8 +43,8 @@ module Gamefic
           return Matches.new(drill, token, '') unless drill.length != 1
           return Matches.new([], '', token)
         end
-        result = available.select{ |e| e.match?(token) }
-        result = available.select{ |e| e.match?(token, fuzzy: true) } if result.empty?
+        result = available.select{ |e| e.specified?(token) }
+        result = available.select{ |e| e.specified?(token, fuzzy: true) } if result.empty?
         result.keep_if{ |e| accept? e }
         Matches.new(result, (result.empty? ? '' : token), (result.empty? ? token : ''))
       end
@@ -48,22 +55,18 @@ module Gamefic
         result.include?(object)
       end
 
+      # A ranking of how precise the query's arguments are.
+      #
+      # Query precision is a factor in calculating Action#rank.
+      #
+      # @return [Integer]
       def precision
         if @precision.nil?
           @precision = 1
           arguments.each { |a|
-            #if a.kind_of?(Symbol) or a.kind_of?(Regexp)
-            #  @precision += 1
-            #elsif a.kind_of?(Class)
-            #  @precision += (count_superclasses(a) * 100)
-            #elsif a.kind_of?(Module)
-            #  @precision += 10
-            #elsif a.kind_of?(Object)
-            #  @precision += 1000
-            #end
-            if a.kind_of?(Class)
+            if a.is_a?(Class)
               @precision += 100
-            elsif a.kind_of?(Gamefic::Entity)
+            elsif a.is_a?(Gamefic::Entity)
               @precision += 1000
             end
           }
@@ -71,52 +74,63 @@ module Gamefic
         end
         @precision
       end
-
-      def rank
-        precision
-      end
+      alias rank precision
 
       def signature
-        "#{self.class.to_s.downcase}(#{@arguments.join(',')})"
+        "#{self.class.to_s.split('::').last.downcase}(#{simplify_arguments.join(', ')})"
       end
 
+      # Determine whether the specified entity passes the query's arguments.
+      #
+      # @return [Boolean]
       def accept?(entity)
         result = true
-        arguments.each { |a|
-          if a.kind_of?(Symbol)
-            result = (entity.send(a) != false)
-          elsif a.kind_of?(Regexp)
-            result = (!entity.to_s.match(a).nil?)
-          elsif a.is_a?(Module) or a.is_a?(Class)
-            result = (entity.is_a?(a))
+        arguments.each do |a|
+          result = if a.is_a?(Symbol)
+            (entity.send(a) != false)
+          elsif a.is_a?(Regexp)
+            !entity.to_s.match(a).nil?
+          elsif a.is_a?(Module) || a.is_a?(Class)
+            entity.is_a?(a)
           else
-            result = (entity == a)
+            (entity == a)
           end
           break if result == false
-        }
+        end
         result
       end
 
       protected
-      
-      # Return an array of the entity's children. If the child is neighborly,
+
+      # Return an array of the entity's children. If the child is accessible,
       # recursively append its children.
       # The result will NOT include the original entity itself.
       #
       # @return [Array<Object>]
       def subquery_accessible entity
+        return [] if entity.nil?
         result = []
         if entity.accessible?
-          entity.children.each { |c|
+          entity.children.each do |c|
             result.push c
             result.concat subquery_accessible(c)
-          }
+          end
         end
         result
       end
 
       private
 
+      def simplify_arguments
+        arguments.map do |a|
+          if a.is_a?(Class) || a.is_a?(Object)
+            a.to_s.split('::').last.downcase
+          else
+            a.to_s.downcase
+          end
+        end
+      end
+
       def nested?(token)
         !token.match(NEST_REGEXP).nil?
       end
@@ -124,13 +138,12 @@ module Gamefic
       def denest(objects, token)
         parts = token.split(NEST_REGEXP)
         current = parts.pop
-        last_result = objects.select{ |e| e.match?(current) }
-        last_result = objects.select{ |e| e.match?(current, fuzzy: true) } if last_result.empty?
-        result = last_result
-        while parts.length > 0
+        last_result = objects.select { |e| e.specified?(current) }
+        last_result = objects.select { |e| e.specified?(current, fuzzy: true) } if last_result.empty?
+        until parts.empty?
           current = "#{parts.last} #{current}"
-          result = last_result.select{ |e| e.match?(current) }
-          result = last_result.select{ |e| e.match?(current, fuzzy: true) } if result.empty?
+          result = last_result.select { |e| e.specified?(current) }
+          result = last_result.select { |e| e.specified?(current, fuzzy: true) } if result.empty?
           break if result.empty?
           parts.pop
           last_result = result

data/lib/gamefic/query/descendants.rb

@@ -5,9 +5,9 @@ module Gamefic
         result = []
         children = super
         result.concat children
-        children.each { |c|
+        children.each do |c|
           result.concat subquery_accessible(c)
-        }
+        end
         result
       end
     end

data/lib/gamefic/query/external.rb

@@ -1,14 +1,18 @@
-module Gamefic
-  module Query
-    class External < Base
-      def initialize objects, *args
-        super(*args)
-        @objects = objects
-      end
-      
-      def context_from subject
-        @objects
-      end
-    end
-  end
-end
+module Gamefic
+  module Query
+    class External < Base
+      def initialize objects, *args
+        super(*args)
+        @objects = objects
+      end
+
+      def context_from subject
+        @objects
+      end
+
+      def accept?(entity)
+        @objects.include?(entity) && super(entity)
+      end
+    end
+  end
+end

data/lib/gamefic/query/family.rb

@@ -1,15 +1,11 @@
 module Gamefic
   module Query
+    # Query to retrieve the subject's siblings and all accessible descendants.
+    #
     class Family < Base
       def context_from(subject)
         result = []
-        top = subject.parent
-        unless top.nil?
-          #until top.parent.nil?
-          #  top = top.parent
-          #end
-          result.concat subquery_accessible(top)
-        end
+        result.concat subquery_accessible(subject.parent)
         result.delete subject
         subject.children.each { |c|
           result.push c

data/lib/gamefic/query/matches.rb

@@ -1,67 +1,75 @@
-module Gamefic
-  module Query
-    class Matches
-      attr_accessor :objects, :matching, :remaining
-
-      def initialize objects, matching, remaining
-        @objects = objects
-        @matching = matching
-        @remaining = remaining
-      end
-
-      def self.execute objects, description, continued: false
-        if continued
-          match_with_remainder objects, description
-        else
-          match_without_remainder objects, description
-        end
-      end
-
-      class << self
-        private
-
-        def match_without_remainder objects, description
-          matches = objects.select{ |e| e.match?(description) }
-          if matches.empty?
-            matching = ''
-            remaining = description
-          else
-            matching = description
-            remaining = ''
-          end
-          Matches.new(matches, matching, remaining)
-        end
-
-        def match_with_remainder objects, description
-          matching_objects = objects
-          matching_text = []
-          words = description.split(Matchable::SPLIT_REGEXP)
-          i = 0
-          #cursor = []
-          words.each { |w|
-            cursor = inner_match matching_objects, words, matching_text, i, w
-            break if cursor.empty? or (cursor & matching_objects).empty?
-            matching_objects = (cursor & matching_objects)
-            i += 1
-          }
-          objects = matching_objects
-          matching = matching_text.uniq.join(' ')
-          remaining = words[i..-1].join(' ')
-          m = Matches.new(objects, matching, remaining)
-          m
-        end
-
-        def inner_match matching_objects, words, matching_text, i, w
-          cursor = []
-          matching_objects.each { |o|
-            if o.match?(words[0..i].join(' '), fuzzy: true)
-              cursor.push o
-              matching_text.push w
-            end
-          }
-          cursor
-        end
-      end
-    end
-  end
-end
+module Gamefic
+  module Query
+    class Matches
+      # The resolved tokens
+      # @return [Array<Object>]
+      attr_reader :objects
+
+      # The matching string
+      # @return [String]
+      attr_reader :matching
+
+      # The remaining (unmatched) string
+      # @return [String]
+      attr_reader :remaining
+
+      def initialize objects, matching, remaining
+        @objects = objects
+        @matching = matching
+        @remaining = remaining
+      end
+
+      def self.execute objects, description, continued: false
+        if continued
+          match_with_remainder objects, description
+        else
+          match_without_remainder objects, description
+        end
+      end
+
+      class << self
+        private
+
+        def match_without_remainder objects, description
+          matches = objects.select{ |e| e.specified?(description) }
+          if matches.empty?
+            matching = ''
+            remaining = description
+          else
+            matching = description
+            remaining = ''
+          end
+          Matches.new(matches, matching, remaining)
+        end
+
+        def match_with_remainder objects, description
+          matching_objects = objects
+          matching_text = []
+          words = description.split(Keywords::SPLIT_REGEXP)
+          i = 0
+          words.each { |w|
+            cursor = inner_match matching_objects, words, matching_text, i, w
+            break if cursor.empty? or (cursor & matching_objects).empty?
+            matching_objects = (cursor & matching_objects)
+            i += 1
+          }
+          objects = matching_objects
+          matching = matching_text.uniq.join(' ')
+          remaining = words[i..-1].join(' ')
+          Matches.new(objects, matching, remaining)
+        end
+
+        def inner_match matching_objects, words, matching_text, i, w
+          cursor = []
+          matching_objects.each { |o|
+            if o.specified?(words[0..i].join(' '), fuzzy: true)
+              cursor.push o
+              matching_text.push w
+            end
+          }
+          cursor
+        end
+      end
+    end
+  end
+end

data/lib/gamefic/query/text.rb

@@ -2,15 +2,17 @@ module Gamefic
   module Query
     class Text < Base
       def initialize *arguments
-        arguments.each { |a|
-          if (a.kind_of?(Symbol) or a.kind_of?(String)) and !a.to_s.end_with?('?')
+        arguments.each do |a|
+          if (a.kind_of?(Symbol) || a.kind_of?(String)) && !a.to_s.end_with?('?')
             raise ArgumentError.new("Text query arguments can only be boolean method names (:method?) or regular expressions")
           end
-        }
+        end
         super
       end
-      def resolve(subject, token, continued: false)
-        parts = token.split(Matchable::SPLIT_REGEXP)
+
+      def resolve _subject, token, continued: false
+        return Matches.new([], '', token) unless accept?(token)
+        parts = token.split(Keywords::SPLIT_REGEXP)
         cursor = []
         matches = []
         i = 0
@@ -21,20 +23,18 @@ module Gamefic
         }
         if continued
           Matches.new([matches.join(' ')], matches.join(' '), parts[i..-1].join(' '))
+        elsif matches.length == parts.length
+          Matches.new([matches.join(' ')], matches.join(' '), '')
         else
-          if matches.length == parts.length
-            Matches.new([matches.join(' ')], matches.join(' '), '')
-          else
-            Matches.new([], '', parts.join(' '))
-          end
+          Matches.new([], '', parts.join(' '))
         end
       end
 
-      def include?(subject, token)
+      def include? _subject, token
         accept?(token)
       end
 
-      def accept?(entity)
+      def accept? entity
         return false unless entity.kind_of?(String) and !entity.empty?
         super
       end