gamefic 1.5.1 → 1.6.0

data/lib/gamefic/plot/theater.rb

@@ -0,0 +1,73 @@
+module Gamefic
+
+  module Plot::Theater
+    # Execute a block of code in a subset of the object's scope. An object's
+    # stage is an isolated namespace that has its own instance variables and
+    # access to its owner's public methods.
+    #
+    # There are two ways to execute code on the stage. It will accept either a
+    # string of code with an optional file name and line number, or a proc
+    # with optional arguments. See module_eval and module_exec for more
+    # information.
+    #
+    # @example Evaluate a string of code
+    #   stage "puts 'Hello'"
+    #
+    # @example Evaluate a string of code with a file name and line number
+    #   stage "puts 'Hello'", "file.rb", 1
+    #
+    # @example Execute a block of code
+    #   stage {
+    #     puts 'Hello'
+    #   }
+    #
+    # @example Execute a block of code with arguments
+    #   stage 'hello' { |message|
+    #     puts message # <- prints 'hello'
+    #   }
+    #
+    # @example Use an instance variable
+    #   stage "@message = 'hello'"
+    #   stage "puts @message" # <- prints 'hello'
+    #
+    # @return [Object] The value returned by the executed code
+    def stage *args, &block
+      if block.nil?
+        theater.module_eval *args
+      else
+        theater.module_exec *args, &block
+      end
+    end
+
+    # The module that acts as an isolated namespace for staged code.
+    #
+    # @return [Module]
+    def theater
+      return @theater unless @theater.nil?
+      instance = self
+
+      @theater = Module.new do
+        define_singleton_method :method_missing do |symbol, *args, &block|
+          instance.public_send :public_send, symbol, *args, &block
+        end
+
+        define_singleton_method :stage do |*args|
+          raise NoMethodError.new("The stage method is not available from inside staged scripts")
+        end
+
+        define_singleton_method :to_s do
+          "[Theater]"
+        end
+      end
+
+      # HACK: Include the theater module in Object so that classes and modules
+      # defined in scripts are accessible from procs passed to the stage.
+      Object.class_exec(@theater) do |t|
+        include t
+      end
+      
+      @theater
+    end
+  end
+
+end

data/lib/gamefic/query.rb

@@ -1,30 +1,17 @@
-require 'gamefic/keywords'
+#require 'gamefic/keywords'
 
 module Gamefic
 
   module Query
     autoload :Base, 'gamefic/query/base'
-    autoload :Text, 'gamefic/query/text'
-    autoload :Expression, 'gamefic/query/expression'
-    autoload :Self, 'gamefic/query/self'
-    autoload :Parent, 'gamefic/query/parent'
     autoload :Children, 'gamefic/query/children'
-    autoload :ManyChildren, 'gamefic/query/many_children'
-    autoload :AmbiguousChildren, 'gamefic/query/ambiguous_children'
-    autoload :PluralChildren, 'gamefic/query/plural_children'
-    autoload :Siblings, 'gamefic/query/siblings'
+    autoload :Descendants, 'gamefic/query/descendants'
     autoload :Family, 'gamefic/query/family'
+    autoload :Itself, 'gamefic/query/itself'
     autoload :Matches, 'gamefic/query/matches'
-    
-    def self.allow_plurals?
-      if @allow_plurals.nil?
-        @allow_plurals = true
-      end
-      @allow_plurals
-    end
-    def self.allow_plurals= boolean
-      @allow_plurals = boolean
-    end
+    autoload :Parent, 'gamefic/query/parent'
+    autoload :Siblings, 'gamefic/query/siblings'
+    autoload :Text, 'gamefic/query/text'
   end
 
 end

data/lib/gamefic/query/base.rb

@@ -1,266 +1,147 @@
-module Gamefic::Query
-  class Base
-    @@ignored_words = ['a', 'an', 'the', 'and', ',']
-    @@subquery_prepositions = ['in', 'on', 'of', 'inside', 'from']
-    # Include is necessary here due to a strange namespace
-    # resolution bug when interpreting gfic files
-    include Gamefic
-    attr_accessor :arguments
-    def initialize *arguments
-      test_arguments arguments
-      @optional = false
-      if arguments.include?(:optional)
-        @optional = true
-        arguments.delete :optional
+module Gamefic
+  module Query
+    class Base
+      NEST_REGEXP = / in | on | of | from | inside /
+
+      attr_reader :arguments
+
+      def initialize *args
+        @arguments = args
       end
-      @arguments = arguments
-      @match_hash = Hash.new
-    end
-    # Check whether the query allows ambiguous matches.
-    # If allowed, this query's 
-    def allow_ambiguous?
-      false
-    end
-    def allow_many?
-      false
-    end
-    def last_match_for(subject)
-      @match_hash[subject]
-    end
-    def optional?
-      @optional
-    end
-    def context_from(subject)
-      subject
-    end
-    def validate(subject, object)
-      arr = context_from(subject)
-      @arguments.each { |arg|
-        arr = arr.that_are(arg)
-      }
-      if (allow_many? or allow_ambiguous?)
-        if object.kind_of?(Array)
-          return (object & arr) == object
-        end
-        return false
-      elsif !object.kind_of?(Array)
-        return arr.include?(object)
+
+      def ambiguous?
+        false
       end
-      return false
-    end
-    # @return [Array]
-    def execute(subject, description)
-      if (allow_many? or allow_ambiguous?) and !Query.allow_plurals?
-        return Matches.new([], '', description)
+
+      # Subclasses should override this method with the logic required to collect
+      # all entities that exist in the query's context.
+      #
+      # @return [Array<Object>]
+      def context_from(subject)
+        []
       end
-      if !allow_ambiguous?
-        if allow_many? and !description.include?(',') and !description.downcase.include?(' and ')
-          return Matches.new([], '', description)
+
+      # Get an array of objects that exist in the subject's context and match
+      # the provided token.
+      #
+      def resolve(subject, token, continued: false)
+        available = context_from(subject)
+        return Matches.new([], '', token) if available.empty?
+        if continued
+          return Matches.execute(available, token, continued: continued)
+        elsif nested?(token)
+          drill = denest(available, token)
+          drill.keep_if{ |e| accept?(e) }
+          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.keep_if{ |e| accept? e }
+        Matches.new(result, (result.empty? ? '' : token), (result.empty? ? token : ''))
       end
-      array = context_from(subject)
-      matches = self.match(description, array)
-      objects = matches.objects
-      matches = Matches.new(objects, matches.matching_text, matches.remainder)
-      if objects.length == 0 and matches.remainder == "it" and subject.respond_to?(:last_object)
-        if !subject.last_object.nil?
-          obj = subject.last_object
-          if validate(subject, obj)
-            matches = Matches.new([obj], "it", "")
-          end
-        end
+
+      def include?(subject, object)
+        return false unless accept?(object)
+        result = context_from(subject)
+        result.include?(object)
       end
-      @match_hash[subject] = matches
-      matches
-    end
-    def base_specificity
-      0
-    end
-    def specificity
-      if @specificity == nil
-        @specificity = base_specificity
-        magnitude = 1
-        @arguments.each { |item|
-          if item.kind_of?(Entity)
-            @specificity += (magnitude * 10)
-            item = item.class
-          end
-          if item.kind_of?(Class)
-            s = item
-            while s != nil
-              @specificity += magnitude
-              s = s.superclass
+
+      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
+          }
+          @precision
+        end
+        @precision
+      end
+
+      def rank
+        precision
+      end
+
+      def signature
+        "#{self.class.to_s.downcase}(#{@arguments.join(',')})"
+      end
+
+      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))
           else
-            @specificity += magnitude
+            result = (entity == a)
           end
+          break if result == false
         }
-        if allow_many?
-          # HACK Ridiculously high magic number to force queries that return
-          # arrays to take precedence over everything
-          @specificity = @specificity * 10
-        end
+        result
       end
-      @specificity
-    end
-    def signature
-      "#{self.class}(#{@arguments.join(',')})"
-    end
-    def test_arguments arguments
-      my_classes = [Gamefic::Entity]
-      my_objects = []
-      arguments.each { |a|
-        if a.kind_of?(Class) or a.kind_of?(Module)
-          my_classes.push a
-        elsif a.kind_of?(Gamefic::Entity)
-          my_objects.push a
-        elsif a.kind_of?(Symbol)
-          if my_classes.length == 0 and my_objects.length == 0
-            raise ArgumentError.new("Query signature requires at least one class, module, or object to accept a method symbol")
-          end
-          if my_classes.length > 0
-            responds = false
-            my_classes.each { |c|
-              if c.instance_methods.include?(a)
-                responds = true
-                break
-              end
-            }
-            if !responds
-              raise ArgumentError.new("Query signature does not have a target that responds to #{a}")
-            end
-          end
-          my_objects.each { |o|
-            if !o.respond_to?(a)
-              raise ArgumentError.new("Query signature contains object '#{o}' that does not respond to '#{a}'")
-            end
+
+      protected
+      
+      # Return an array of the entity's children. If the child is neighborly,
+      # recursively append its children.
+      # The result will NOT include the original entity itself.
+      #
+      # @return [Array<Object>]
+      def subquery_accessible entity
+        result = []
+        if entity.accessible?
+          entity.children.each { |c|
+            result.push c
+            result.concat subquery_accessible(c)
           }
-        else
-          raise ArgumentError.new("Invalid argument '#{a}' in query signature")
-        end
-      }
-    end
-    def match(description, array)
-      keywords = get_keywords(description)
-      array.each { |e|
-        if e.uid == keywords[0]
-          return Matches.new([e], keywords.shift, keywords.join(' '))
-        end
-      }
-      used = []
-      skipped = []
-      possibilities = array
-      at_least_one_match = false
-      while keywords.length > 0
-        next_word = keywords.shift
-        if @@subquery_prepositions.include?(next_word)
-          if !at_least_one_match
-            return Matches.new([], '', description)
-          end
-          so_far = keywords.join(' ')
-          in_matched = self.match(so_far, array)
-          if in_matched.objects.length > 0 and (in_matched.objects.length == 1 or in_matched.objects[0].kind_of?(Array))
-            # Subset matching should only consider the intersection of the
-            # original array and the matched object's children. This ensures
-            # that it won't erroneously match a child that was excluded from
-            # the original query.
-            parent = in_matched.objects.shift
-            subset = self.match(used.join(' '), (array & (parent.kind_of?(Array) ? parent[0].children : parent.children)))
-            if subset.objects.length == 1
-              if in_matched.objects.length == 0
-                return subset
-              else
-                return Matches.new([subset.objects] + in_matched.objects, subset.matching_text, subset.remainder)
-              end
-            end
-          end
-        end
-        used.push next_word
-        new_results = []
-        possibilities.each { |p|
-          words = Keywords.new(used.last)
-          if words.length > 0
-            matches = words.found_in(p.keywords, (allow_many? or allow_ambiguous?))
-            if matches > 0
-              new_results.push p
-            end
-          end
-        }
-        if new_results.length > 0
-          at_least_one_match = true
-          intersection = possibilities & new_results
-          if intersection.length == 0
-            skipped.push used.pop
-          else
-            skipped.clear
-            possibilities = intersection
-          end
-        elsif (next_word.downcase == 'and' or next_word == ',')
-          while keywords.first == ',' or keywords.first.downcase == 'and'
-            used.push keywords.shift
-          end
-          if allow_ambiguous?
-            # Ambiguous queries filter based on all keywords instead of
-            # building an array of specified entities
-            next
-          end
-          so_far = keywords.join(' ')
-          recursed = self.match(so_far, array)
-          if possibilities.length == 1 and !allow_ambiguous?
-            possibilities = [possibilities]
-          else
-            # Force lists of things to be uniquely identifying
-            return Matches.new([], '', description)
-          end
-          objects = recursed.objects.clone
-          while objects.length > 0
-            obj = objects.shift
-            if obj.kind_of?(Array)
-              possibilities.push obj
-            else
-              combined = [obj] + objects
-              possibilities.push combined
-              break
-            end
-          end
-          used += recursed.matching_text.split_words
-          skipped = recursed.remainder.split_words
-          keywords = []
-        else
-          # The first unignored word must have at least one match
-          if at_least_one_match and !@@ignored_words.include?(used.last)
-            keywords.unshift used.pop
-            return Matches.new(possibilities, used.join(' '), keywords.join(' '))
-          else
-            if !@@ignored_words.include?(used.last)
-              return Matches.new([], '', description)
-            end
-          end
         end
+        result
       end
-      if at_least_one_match and (used - @@ignored_words).length > 0
-        r = Matches.new(possibilities, used.join(' '), skipped.join(' '))
-        return r
-      else
-        return Matches.new([], '', description)
+
+      private
+
+      def count_superclasses cls
+        s = cls.superclass
+        c = 1
+        until s.nil? or s == Object or s == BasicObject
+          c += 1
+          s = s.superclass
+        end
+        c
       end
-    end
 
-    private
+      def nested?(token)
+        !token.match(NEST_REGEXP).nil?
+      end
 
-    def get_keywords text
-      if text.include?(',')
-        tmp = text.split(',', -1)
-        keywords = []
-        first = tmp.shift
-        keywords.push first.strip unless first.strip == ''
-        tmp.each { |t|
-          keywords.push ','
-          keywords += t.strip.split_words unless t.strip == ''
-        }
-        keywords.join(' ').split_words
-      else
-        text.split_words
+      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
+          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?
+          break if result.empty?
+          parts.pop
+          last_result = result
+        end
+        return [] if last_result.empty? or last_result.length > 1
+        return last_result if parts.empty?
+        denest(last_result[0].children, parts.join(' '))
       end
     end
   end