Olib 0.1.2 → 2.0.0.pre.rc.1

data/lib/Olib/loot.rb

@@ -0,0 +1,44 @@
+class Loot
+  include Enumerable
+
+  ALL = -> item { true }
+
+  attr_reader :predicate
+
+  def initialize(&predicate)
+    @predicate = predicate
+  end
+
+  def each()    
+    GameObj.loot.to_a.map do |obj| Item.new(obj) end
+      .reject(&Where[noun: "disk"])
+      .select(&@predicate)
+      .each do |item| yield(item) end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    to_a.respond_to?(method) or super
+  end
+
+  def method_missing(method, *args)
+    if to_a.respond_to?(method)
+      to_a.send(method, *args)
+    else
+      super(method, *args)
+    end
+  end
+
+
+  def self.method_missing(method, *args, &block)
+    if respond_to?(method)
+      Loot.new.send(method, *args, &block)
+    else
+      super(method, *args, &block)
+    end
+  end
+
+  def self.respond_to?(method)
+    return super(method) unless Loot.new.respond_to?(method)
+    return true
+  end
+end

data/lib/Olib/npcs/npc.rb

@@ -0,0 +1,4 @@
+require "Olib/core/exist"
+
+class NPC < Exist
+end

data/lib/Olib/npcs/npcs.rb

@@ -0,0 +1,45 @@
+require "Olib/npcs/npc"
+# a collection for managing all of the npcs in a room
+
+class NPCS
+  include Enumerable
+
+  ALL = -> npc { true }
+
+  attr_reader :predicate
+
+  def initialize(&predicate)
+    @predicate = predicate
+  end
+
+  def each()    
+    GameObj.npcs.to_a.map do |obj| NPC.new(obj) end
+      .select(&@predicate)
+      .each do |npc| yield(npc) unless npc.tags.include?(:aggressive) end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    to_a.respond_to?(method) or super
+  end
+
+  def method_missing(method, *args)
+    if to_a.respond_to?(method)
+      to_a.send(method, *args)
+    else
+      super(method, *args)
+    end
+  end
+
+  def self.method_missing(method, *args, &block)
+    if respond_to?(method)
+      NPCS.new.send(method, *args, &block)
+    else
+      super(method, *args, &block)
+    end
+  end
+
+  def self.respond_to?(method)
+    return super(method) unless NPCS.new.respond_to?(method)
+    return true
+  end
+end

data/lib/Olib/objects/box.rb

@@ -1,3 +1,3 @@
 
-class Box < Olib::Item
+class Box < Item
 end

data/lib/Olib/objects/clothing.rb

@@ -1,2 +1,2 @@
-class Clothing < Olib::Item
+class Clothing < Item
 end

data/lib/Olib/objects/herb.rb

@@ -1,2 +1,2 @@
-class Herb < Olib::Item
+class Herb < Item
 end

data/lib/Olib/objects/jewel.rb

@@ -1,18 +1,18 @@
 # Class to interact with gems
 # overwriting Gem is a bad idea
-class Jewel < Olib::Item
+class Jewel < Item
   attr_accessor :quality, :value
   
   def appraise
-    result = dothistimeout "appraise ##{@id}", 3, /#{Olib::Dictionary.gems[:appraise].values.join('|')}/
+    result = dothistimeout "appraise ##{@id}", 3, /#{Dictionary.gems[:appraise].values.join('|')}/
     case result
-      when Olib::Dictionary.gems[:appraise][:gemshop]
+      when Dictionary.gems[:appraise][:gemshop]
         # handle gemshop appraisal
         @value = $1.to_i
-      when Olib::Dictionary.gems[:appraise][:player]
+      when Dictionary.gems[:appraise][:player]
         @value = $3.to_i
         @quality = $2
-      when Olib::Dictionary.gems[:appraise][:failure]
+      when Dictionary.gems[:appraise][:failure]
         waitrt?
         self.appraise
       else
@@ -22,11 +22,11 @@ class Jewel < Olib::Item
   end
 
   def normalized_name
-    Olib::Dictionary.gems[:singularize].call(@name)
+    Dictionary.gems[:singularize].call(@name)
   end
   
   def sell
     result = take
-    fput "sell ##{@id}" if result =~ Olib::Dictionary.get[:success]
+    fput "sell ##{@id}" if result =~ Dictionary.get[:success]
   end
 end

data/lib/Olib/objects/jewelry.rb

@@ -1,4 +1,4 @@
-class Jewelry < Olib::Item
+class Jewelry < Item
   HEIRLOOM = /are the initials ([A-Z]{2})./
 
   attr_accessor :heirloom

data/lib/Olib/objects/scroll.rb

@@ -1,4 +1,4 @@
-class Scroll < Olib::Item
+class Scroll < Item
   @@whitelist = [ 
     101, 102, 103, 107, 116, 120, 
     202, 211, 215, 219,

data/lib/Olib/objects/uncommon.rb

@@ -1,2 +1,2 @@
-class Uncommon < Olib::Item
+class Uncommon < Item
 end

data/lib/Olib/objects/wand.rb

@@ -1,2 +1,2 @@
-class Wand < Olib::Item
+class Wand < Item
 end

data/lib/Olib/pattern_matching/any.rb

@@ -0,0 +1,11 @@
+require "Olib/pattern_matching/result"
+
+class Any < Result
+  def self.===(*args)
+    true
+  end
+
+  def ===(other)
+    true
+  end
+end

data/lib/Olib/pattern_matching/err.rb

@@ -0,0 +1,4 @@
+require "Olib/pattern_matching/result"
+
+class Err < Result
+end

data/lib/Olib/pattern_matching/ok.rb

@@ -0,0 +1,4 @@
+require "Olib/pattern_matching/result"
+
+class Ok < Result
+end

data/lib/Olib/pattern_matching/outcome.rb

@@ -0,0 +1,35 @@
+require "Olib/ext/matchdata"
+
+class Outcome
+  HANDLEBARS = %r[{{(?<var>.*?)}}]
+
+  def self.union(outcomes, **vars)
+    Regexp.union(outcomes.map do |outcome| outcome.prepare(**vars) end)
+  end
+
+  def self.prepare(template, vars)
+    template.gsub(HANDLEBARS) do |name|
+      name = name.match(HANDLEBARS).to_struct.var.to_sym
+      if vars.respond_to?(name)  
+        vars.send(name) 
+      elsif vars.respond_to?(:fetch) 
+        vars.fetch(name)
+      elsif vars.respond_to?(:[])
+        vars[name]
+      else
+        raise Exception.new "could not serialize var: #{name} of #{vars.class.name} in Outcome"
+      end
+    end
+  end
+
+  attr_reader :template
+
+  def initialize(template)
+    @template = template
+  end
+  
+  def prepare(vars)
+    return @template if @template.is_a?(Regexp)
+    %r[#{Outcome.prepare(@template, vars)}]
+  end
+end

data/lib/Olib/pattern_matching/pattern_matching.rb

@@ -0,0 +1,5 @@
+require "Olib/pattern_matching/err"
+require "Olib/pattern_matching/ok"
+require "Olib/pattern_matching/result"
+require "Olib/pattern_matching/where"
+include Result::Constructors

data/lib/Olib/pattern_matching/result.rb

@@ -0,0 +1,80 @@
+class Result
+  def self.included(ctx)
+    ctx.include(Result::Constructors)
+    ctx.extend(Result:Constructors)
+  end
+
+  def self.of(); -> val { self.new(val); }; end
+  class << self; alias :[] :new; end
+
+  def self.compare(this, other)
+    return _match_class(this, other)  if other.is_a?(Class)
+    return _match_result(this, other) if this.is_a?(Result) and other.is_a?(Result)
+    return _compare_object_shape(this.val, other) if this.val.is_a?(Object) and other.is_a?(Hash)
+    return _compare_object_shape(other, this.val) if this.val.is_a?(Hash) and other.is_a?(Object)
+    return _compare_values(this.val, other)
+  end
+
+  def self._match_class(this, other)
+    return this.is_a?(other) if [Err, Ok].include?(other)
+    this.val.is_a?(other)
+  end
+
+  def self._compare_values(left, right)
+    left == Any || right == Any || left === right
+  end
+
+  def self._compare_object_shape(this, expected)
+    fail "expected Shape(#{expected.inspect}) must be a Hash" unless expected.is_a?(Hash)
+    ## fail fast when not possible to be true
+    return false if this.is_a?(Hash) and expected.size > this.size
+    ## compare all keys
+    expected.all? do |k, v|
+      if this.respond_to?(k.to_sym)
+        _compare_values(v, this.send(k.to_sym))
+      elsif this.respond_to?(:[])
+        _compare_values(v, this[k.to_s]) or _compare_values(v, this[k.to_sym])
+      else
+        false
+      end
+    end
+  end
+
+  def self._match_result(this, other)
+    return false unless this.is_a?(other.class)
+    return _compare_object_shape(this.val, other.val) if this.val.is_a?(Object) and other.val.is_a?(Hash)
+    return _compare_values(this.val, other.val)
+  end
+
+  attr_reader :val
+
+  def initialize(val)
+    @val = val
+  end
+
+  def ==(other)
+    self.===(other)
+  end
+
+  def ===(other)
+    Result.compare(self, other)
+  end
+
+  def to_json(*args)
+    @val.to_json(*args)
+  end
+
+  def to_proc
+    -> other { Result.compare(self, other) }
+  end
+
+  module Constructors
+    def Ok(*args)
+      Ok[*args]
+    end
+
+    def Err(*args)
+      Err[*args]
+    end
+  end
+end

data/lib/Olib/pattern_matching/rill.rb

@@ -0,0 +1,43 @@
+require "Olib/xml"
+require "Olib/pattern_matching/outcome"
+require "Olib/ext/matchdata"
+
+class Rill
+  PROMPT = /<prompt/
+
+  include Enumerable
+  attr_reader :close, :start, :mode
+
+  def initialize(start: nil, close: PROMPT, mode: :xml)
+    fail "Rill.new() requires :start argument" if start.nil?
+    @mode    = mode
+    @close   = Outcome.new(close)
+    @start   = Outcome.new(start)
+  end
+
+  def capture(obj, command_template)
+    return capture_xml(obj, command_template) if mode.eql?(:xml)
+    fail "non-XML mode not implemented yet"
+  end
+
+  def capture_xml(obj, command_template)
+    begin_pattern = @start.prepare(obj)
+    end_pattern   = @close.prepare(obj)
+    command       = Outcome.prepare(command_template, obj)
+    state         = :start
+    lines         = []
+    matches       = {}
+    XML.cmd(command) do |line|
+      state = :open  if line.match(begin_pattern)
+      lines  << line if state.eql?(:open)
+      if (result = (line.match(begin_pattern) || line.match(end_pattern)))
+        matches.merge!(result.to_h)
+      end
+      return [matches, lines] if (line.match(end_pattern) and state.eql?(:open))
+    end
+  end
+
+  def each(&block)
+    @lines.each(&block)
+  end
+end

data/lib/Olib/pattern_matching/where.rb

@@ -0,0 +1,4 @@
+require "Olib/pattern_matching/result"
+
+class Where < Result
+end

data/lib/Olib/shops.rb

@@ -1,177 +1,169 @@
-module Olib
-  module Shop
+require "Olib/core/exist"
 
-    @@containers = []
+module Shop
 
-    def Shop.items
-      Shop.containers.map { |container| container.contents }.flatten
-    end
+  @@containers = []
+
+  def Shop.items
+    Shop.containers.map { |container| container.contents }.flatten
+  end
+
+  def Shop.containers
+    #fput "look"
+    @@containers = [
+      GameObj.loot, 
+      GameObj.room_desc
+    ]
+    .flatten
+    .compact
+    .select     { |container| !(container.name =~ /^([A-z][a-z]+ disk$)/)}
+    .map        { |container| Shop::Container.new(container)  }
+
+    @@containers
 
-    def Shop.containers
-      #fput "look"
-      @@containers = [
-        GameObj.loot, 
-        GameObj.room_desc
-      ]
-      .flatten
-      .compact
-      .select     { |container| !(container.name =~ /^([A-z][a-z]+ disk$)/)}
-      .map        { |container| Shop::Container.new(container)  }
+  end
+
+  def Shop.cache
+    @@containers
+  end
 
-      @@containers
+  class Container < Exist
+    attr_accessor :show, :nested, :containers, :id, :cache, :props
+
+    def to_s
+      info = {}
+      info[:name]     = @name
+      info[:noun]     = @noun
+      info[:props]    = @props
+      info[:cache]    = @cache
+      info.to_s
+    end
+    
+    def initialize(obj)
+      @cache = Hash.new
+      @props = Hash.new
+      super(obj)
+    end
 
+    def action(verb)
+      "#{verb} ##{@id}"
     end
 
-    def Shop.cache
-      @@containers
+    def look
+      self
     end
 
-    class Container < Olib::Gameobj_Extender
-      attr_accessor :show, :nested, :containers, :id, :cache, :props
-
-      def to_s
-        info = {}
-        info[:name]     = @name
-        info[:noun]     = @noun
-        info[:props]    = @props
-        info[:cache]    = @cache
-        info.to_s
-      end
+    # detect nested containers
+    def at
       
-      def initialize(obj)
-        @cache = Hash.new
-        @props = Hash.new
-        super(obj)
-      end
-
-      def action(verb)
-        "#{verb} ##{@id}"
-      end
-
-      def look
-        self
-      end
-
-      # detect nested containers
-      def at
+      Olib.wrap_stream(action 'look at') { |line|
         
-        Olib.wrap_stream(action 'look at') { |line|
-          
-          raise Olib::Errors::Mundane if line =~ /You see nothing unusual/
+        raise Errors::Mundane if line =~ /You see nothing unusual/
 
-          if line =~ /Looking at the (.*?), you see (?<nested>.*)/
-            @nested     = true
+        if line =~ /Looking at the (.*?), you see (?<nested>.*)/
+          @nested     = true
 
-            @containers = line.match(/Looking at the (.*?), you see (?<nested>.*)/)[:nested].scan(/<a exist="(?<id>.*?)" noun="(?<noun>.*?)">(?<name>.*?)<\/a>/).map {|matches| 
-              Container.new GameObj.new *matches
-            }
-            raise Olib::Errors::Prempt
-          end
-          
-        }
-
-        self
-      end
-
-      def nested?
-        @nested || false
-      end
-
-      def in
-        return self unless @id
-        Olib.wrap_stream(action 'look in') { |line|
-          raise Olib::Errors::Mundane if line=~ /^There is nothing in there|^That is closed|filled with a variety of garbage|Total items:/
-          raise Olib::Errors::Prempt  if line =~ /^In the (.*?) you see/
-        }
-        self
-      end
-
-      def on
-        return self unless @id
-        Olib.wrap_stream(action 'look on') { |line|
-          raise Olib::Errors::Mundane if line =~ /^There is nothing on there/
-          raise Olib::Errors::Prempt  if line =~ /^On the (.*?) you see/
-        }
-        self
-      end
-
-      def contents
-        look.in.on unless GameObj[@id].contents
-        GameObj[@id].contents.map {|i| Item.new(i).define('container', @id) }
-      end
-
-      def containers
-        @containers
-      end 
+          @containers = line.match(/Looking at the (.*?), you see (?<nested>.*)/)[:nested].scan(/<a exist="(?<id>.*?)" noun="(?<noun>.*?)">(?<name>.*?)<\/a>/).map {|matches| 
+            Container.new GameObj.new *matches
+          }
+          raise Errors::Prempt
+        end
+        
+      }
+
+      self
     end
+
+    def nested?
+      @nested || false
+    end
+
+    def in
+      return self unless @id
+      Olib.wrap_stream(action 'look in') { |line|
+        raise Errors::Mundane if line=~ /^There is nothing in there|^That is closed|filled with a variety of garbage|Total items:/
+        raise Errors::Prempt  if line =~ /^In the (.*?) you see/
+      }
+      self
+    end
+
+    def on
+      return self unless @id
+      Olib.wrap_stream(action 'look on') { |line|
+        raise Errors::Mundane if line =~ /^There is nothing on there/
+        raise Errors::Prempt  if line =~ /^On the (.*?) you see/
+      }
+      self
+    end
+
+    def contents
+      look.in.on unless GameObj[@id].contents
+      GameObj[@id].contents.map {|i| Item.new(i).define('container', @id) }
+    end
+
+    def containers
+      @containers
+    end 
+  end
+  
+  class Playershop
+    @@noncontainers = [ "wall", "ceiling", "permit", "floor", "helmet", "snowshoes",
+                    "candelabrum", "flowerpot", "Hearthstone", "bear", "candelabra",
+                    "sculpture", "anvil", "tapestry", "portrait", "Wehnimer", "spiderweb",
+                    "rug", "fountain", "longsword", "ship", "panel", "painting", "armor",
+                    "flowers", "head", "plate", "vase", "pillows", "mask", "skeleton", "fan",
+                    "flag", "statue", "mat", "plaque", "mandolin", "plant", "sign" ]
     
-    class Playershop
-      @@noncontainers = [ "wall", "ceiling", "permit", "floor", "helmet", "snowshoes",
-                      "candelabrum", "flowerpot", "Hearthstone", "bear", "candelabra",
-                      "sculpture", "anvil", "tapestry", "portrait", "Wehnimer", "spiderweb",
-                      "rug", "fountain", "longsword", "ship", "panel", "painting", "armor",
-                      "flowers", "head", "plate", "vase", "pillows", "mask", "skeleton", "fan",
-                      "flag", "statue", "mat", "plaque", "mandolin", "plant", "sign" ]
-      
-      def Playershop.containers
-        Shop.containers.reject { |container|
-          @@noncontainers.include? container.noun
-        }
-      end
-
-      def Playershop.balance
-        balance = 0
-        Olib.wrap_stream('shop withdraw') { |line|
-          next if line =~ /^Usage: SHOP WITHDRAW <amount>/
-          raise Olib::Errors::Prempt if line =~ /^You must be in your shop to do that.$/
-
-          if line =~ /Your shop's bank account is currently ([\d]+)/
-            balance = $1.to_i
-            raise Olib::Errors::Prempt
+    def Playershop.containers
+      Shop.containers.reject { |container|
+        @@noncontainers.include? container.noun
+      }
+    end
+
+    def Playershop.balance
+      balance = 0
+      Olib.wrap_stream('shop withdraw') { |line|
+        next if line =~ /^Usage: SHOP WITHDRAW <amount>/
+        raise Errors::Prempt if line =~ /^You must be in your shop to do that.$/
+
+        if line =~ /Your shop's bank account is currently ([\d]+)/
+          balance = $1.to_i
+          raise Errors::Prempt
+        end
+
+      }
+      return balance
+    end
+
+    def Playershop.where(conditions)        
+      Playershop.items.select { |item|
+        !conditions.keys.map { |key|
+          if conditions[key].class == Array
+            item.props[key].class == Array && !conditions[key].map { |ele| item.props[key].include? ele }.include?(false)
+          else
+            item.props[key] == conditions[key]
           end
+        }.include?(false)
+      }
+    end
 
-        }
-        return balance
-      end
-
-      def Playershop.where(conditions)        
-        Playershop.items.select { |item|
-          !conditions.keys.map { |key|
-            if conditions[key].class == Array
-              item.props[key].class == Array && !conditions[key].map { |ele| item.props[key].include? ele }.include?(false)
-            else
-              item.props[key] == conditions[key]
-            end
-          }.include?(false)
-        }
-      end
-
-      def Playershop.find_by_tags(*tags)
-        
-        Playershop.items.select { |item|
-          !tags.map {|tag| item.is?(tag) }.include? false
-        }
-      end
-
-      def Playershop.sign
-        Shop.containers.select { |container|
-          container.noun == 'sign'
-        }[0]
-      end
-
-      def Playershop.items
-        Playershop.containers.map { |container|
-          container.contents
-        }.flatten
-      end
+    def Playershop.find_by_tags(*tags)
+      
+      Playershop.items.select { |item|
+        !tags.map {|tag| item.is?(tag) }.include? false
+      }
     end
-  end
 
-  def Olib.Playershop
-    Olib::Shop::Playershop
-  end
+    def Playershop.sign
+      Shop.containers.select { |container|
+        container.noun == 'sign'
+      }[0]
+    end
 
-  def Olib.Shop
-    Olib::Shop
+    def Playershop.items
+      Playershop.containers.map { |container|
+        container.contents
+      }.flatten
+    end
   end
 end