Olib 0.1.2 → 2.0.0.pre.rc.1

data/lib/Olib/version.rb

@@ -1,3 +1,3 @@
 module Olib
-  VERSION = "0.1.2"
+  VERSION = "2.0.0-rc.1"
 end

data/lib/Olib/xml.rb

@@ -0,0 +1,43 @@
+##
+## XML utils
+##
+module XML
+  def self.xml_on
+    Script.current.want_downstream_xml = true
+  end
+
+  def self.xml_off
+    Script.current.want_downstream_xml = false
+  end
+
+  def self.tap
+    xml_on
+    result = yield
+    xml_off
+    result
+  end
+
+  def self.cmd(cmd)
+    XML.tap do 
+      fput(cmd)
+      while line = get
+        yield(line)
+      end
+    end
+  end
+
+  def self.lines(**opts, &block)
+    XML.tap do 
+      while line = get
+        result = block.call(line)
+        break if result == :halt
+      end
+    end
+  end
+
+  def self.match(cmd, patt, timeout: 5)
+    XML.tap do
+      dothistimeout(cmd, timeout, patt)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: Olib
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 2.0.0.pre.rc.1
 platform: ruby
 authors:
 - Ondreian Shamsiel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2018-01-04 00:00:00.000000000 Z
 dependencies: []
 description: Useful Lich extensions for Gemstone IV including hostile creature management,
   group management, syntactically pleasing movement, locker management, etc
@@ -32,16 +32,27 @@ files:
 - lib/Olib/character/stance.rb
 - lib/Olib/combat/creature.rb
 - lib/Olib/combat/creatures.rb
+- lib/Olib/core/action.rb
 - lib/Olib/core/container.rb
+- lib/Olib/core/containers.rb
 - lib/Olib/core/errors.rb
-- lib/Olib/core/extender.rb
+- lib/Olib/core/exist.rb
 - lib/Olib/core/item.rb
+- lib/Olib/core/kinds.rb
+- lib/Olib/core/rummage.rb
+- lib/Olib/core/transaction.rb
 - lib/Olib/core/use.rb
 - lib/Olib/core/utils.rb
+- lib/Olib/core/verbs.rb
 - lib/Olib/dictionary/dictionary.rb
+- lib/Olib/ext/hash.rb
+- lib/Olib/ext/matchdata.rb
+- lib/Olib/ext/string.rb
+- lib/Olib/ext/symbol.rb
 - lib/Olib/go2.rb
-- lib/Olib/interface/queryable.rb
-- lib/Olib/npcs.rb
+- lib/Olib/loot.rb
+- lib/Olib/npcs/npc.rb
+- lib/Olib/npcs/npcs.rb
 - lib/Olib/objects/box.rb
 - lib/Olib/objects/clothing.rb
 - lib/Olib/objects/herb.rb
@@ -51,16 +62,18 @@ files:
 - lib/Olib/objects/scroll.rb
 - lib/Olib/objects/uncommon.rb
 - lib/Olib/objects/wand.rb
-- lib/Olib/pattern.rb
+- lib/Olib/pattern_matching/any.rb
+- lib/Olib/pattern_matching/err.rb
+- lib/Olib/pattern_matching/ok.rb
+- lib/Olib/pattern_matching/outcome.rb
+- lib/Olib/pattern_matching/pattern_matching.rb
+- lib/Olib/pattern_matching/result.rb
+- lib/Olib/pattern_matching/rill.rb
+- lib/Olib/pattern_matching/where.rb
 - lib/Olib/shops.rb
-- lib/Olib/storage/app_data.rb
 - lib/Olib/supervisor/supervisor.rb
-- lib/Olib/try/try.rb
-- lib/Olib/utils/cli.rb
-- lib/Olib/utils/help_menu.rb
-- lib/Olib/utils/monsterbold.rb
-- lib/Olib/utils/vbulletin.rb
 - lib/Olib/version.rb
+- lib/Olib/xml.rb
 homepage: https://github.com/ondreian/Olib
 licenses:
 - MIT
@@ -76,12 +89,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Useful Lich extensions for Gemstone IV

data/lib/Olib/core/extender.rb

@@ -1,29 +0,0 @@
-# TODO:
-# this should be refactored to use a mixin pattern
-module Olib
-  class Gameobj_Extender
-    attr_accessor :type
-    def initialize(item)
-      self.__extend__(item)
-      @type = item.type
-    end
-
-    # This copies GameObj data to attributes so we can employ it for scripting
-    def __extend__(item)
-      item.instance_variables.each { |var|
-        s = var.to_s.sub('@', '')
-        (class << self; self end).class_eval do; attr_accessor "#{s}"; end
-        instance_variable_set "#{var}", item.send(s)
-      }
-    end
-
-    def echo
-      respond self
-      self
-    end
-
-    def at
-      fput "look at ##{@id}"
-    end
-  end
-end

data/lib/Olib/interface/queryable.rb

@@ -1,50 +0,0 @@
-module Interface
-  class Queryable
-    def self.fetch
-      []
-    end
-
-    def self.each(&block)
-      fetch.each &block
-    end
-
-    def self.map(&block)
-      fetch.map &block
-    end
-
-    def self.find(&block)
-      fetch.find &block
-    end
-
-    def self.sort(&block)
-      fetch.sort &block
-    end
-
-    def self.select(&block)
-      fetch.select &block
-    end
-
-    def self.reject(&block)
-      fetch.reject &block
-    end
-
-    def self.where(**conds)
-    end
-
-    def self.first
-      fetch.first
-    end
-
-    def self.sample(n = 1)
-      fetch.sample n
-    end
-
-    def self.empty?
-      (fetch || []).empty?
-    end
-
-    def self.size
-      fetch.size
-    end
-  end
-end

data/lib/Olib/npcs.rb

@@ -1,5 +0,0 @@
-class NPCS
-  def self.[](query)
-    GameObj.npcs.select { |npc| npc.name =~ /#{query}/ }
-  end
-end

data/lib/Olib/pattern.rb

@@ -1,34 +0,0 @@
-##
-## @brief      pattern matching for Ruby
-##
-class Pattern
-  attr_accessor :cases
-
-  def initialize(cases)
-    @cases = cases
-  end
-
-  def match(str)
-    found = @cases.each_pair.find do |exp, handler|
-      str =~ exp
-    end
-
-    if !found
-      raise Exception.new [
-        "Error: inexhaustive pattern",
-        "counterexample: #{str}",
-      ].join("\n")
-    end
-
-    exp, handler = found
-
-    handler.call exp.match(str).to_struct
-  end
-
-  def to_proc
-    patt = self
-    Proc.new do |str|
-      patt.match str
-    end
-  end
-end

data/lib/Olib/storage/app_data.rb

@@ -1,32 +0,0 @@
-require 'fileutils'
-
-module Olib
-  class App
-    FOLDER  = ".olib"
-    APP_DIR = File.join Dir.home, FOLDER
-    ##
-    ## setup app dir
-    ##
-    FileUtils.mkdir_p APP_DIR
-
-    def self.app_file(path)
-      File.join APP_DIR, path
-    end
-
-    def self.open(file)
-      File.open(app_file(file), 'a', &block)
-    end
-
-    def self.write_json(file, data)
-      open(file) do |f|
-        JSON.dump(data)
-      end
-    end
-
-    def self.read(file, &block)
-      open(file) do |file|
-        yield
-      end
-    end
-  end
-end

data/lib/Olib/try/try.rb

@@ -1,58 +0,0 @@
-class Try
-  attr_accessor :result, :task
-  
-  def self.of(&task)
-    Proc.new do 
-      Try.new task
-    end
-  end
-
-  def initialize(&task)
-    @task = task
-    run!
-  end
-
-  private def run!
-    begin
-      result = @task.call
-      # handle recursives
-      if result.is_a?(Try)
-        @result = result.result
-      else
-        @result = result
-      end
-    rescue Exception => e
-      @result = e
-    end
-  end
-
-  def failed?
-    @result.class.ancestors.include? Exception
-  end
-
-  def success?
-    !failed?
-  end
-
-  def recover
-    Try.new { yield @result } if failed?
-  end
-
-  def then
-    Try.new { yield @result } if success?
-  end
-
-  def match?(exp)
-    if failed?
-      @result.message.match(exp)
-    elsif @result.respond_to?(:match)
-      @result.match(exp)
-    else
-      raise Exception.new "cannot match class #{@result.class}"
-    end
-  end
-end
-
-def try(&block)
-  Try.new &block
-end

data/lib/Olib/utils/cli.rb

@@ -1,81 +0,0 @@
-module Olib
-  class ScriptVars
-    attr_accessor :opts
-    def initialize
-      opts          = {}
-      opts[:flags]  = {}
-      return opts if Script.current.vars.empty?
-      list          = Script.current.vars.map(&:downcase).last(Script.current.vars.length-1)
-      
-      unless list.first.start_with?('--')
-        opts[:cmd]   = list.shift
-      end
-
-      # iterate over list for flag values
-      flags = list.compact.join(' ').split('--')
-      flags.shift
-      flags.each { |flag|
-        segments  = flag.split(' ')
-        name      =  symbolize(segments.shift)
-        opts[:flags][name] = true 
-        if !segments.empty?
-          value = segments.join(' ').strip
-          if value =~ /[\d]+/
-            value = value.to_i
-          end
-          opts[:flags][name] = value
-        end
-      }
-
-      @opts = opts
-      self
-    end
-
-    def cmd
-      @opts[:cmd]
-    end
-
-    def empty?(flag)
-      opts[:flags][flag].class == TrueClass || opts[:flags][flag].class == NilClass
-    end
-
-    def cmd?(action)
-      cmd == action
-    end
-
-    def symbolize(flag)
-      flag.gsub('--', '').gsub('-', '_').to_sym
-    end
-
-    def help?
-      cmd =~ /help/
-    end
-
-    def flags
-      opts[:flags].keys
-    end
-
-    def to_s
-      @opts.to_s
-    end
-
-    def flag
-      self
-    end
-
-    def flag?(f)
-      opts[:flags][ symbolize(f) ]
-    end
-
-    def method_missing(arg1, arg2=nil)
-      @opts[:flags][arg1]
-    end
-
-  end
-end
-
-module Olib
-  def Olib.CLI
-    Olib::ScriptVars.new
-  end
-end

data/lib/Olib/utils/help_menu.rb

@@ -1,166 +0,0 @@
-module Olib
-  class HelpMenu
-    attr_accessor :script, :cmds, :last_added, :flags, :title, :padding, :cols, :max_column_width
-
-    def initialize
-      @script = $lich_char+Olib.script.to_s
-      @cmds                = {}
-      @flags               = {}
-      @padding             = 5
-      @max_column_width    = Vars.max_column_width.to_i || 100
-      @title  = "#{@script} help menu".upcase
-      self
-    end
-
-    def flag(flag, info)
-      if @last_added
-        @cmds[@last_added][:flags][flag] = info
-      else
-        @flags[flag] = info
-      end
-        
-      self
-    end
-
-    def pad
-      [''] * @padding * ' '
-    end
-
-    def cmd(cmd, info)
-      @last_added         = cmd
-      @cmds[cmd]          = {}
-      @cmds[cmd][:info]   = info
-      @cmds[cmd][:flags]  = {}
-      self
-    end
-
-    def width
-      return @cols if @cols
-      
-      @cols        = {}
-      @cols[:one]  = @script.length+padding
-
-      # global flags and commands
-      @cols[:two]  = @flags
-        .keys
-        .concat(@cmds.keys)
-        .map(&:strip)
-        .sort_by(&:length).last.length+padding
-
-      # flags
-      @cols[:three] = @cmds
-        .keys
-        .map { |cmd| @cmds[cmd][:flags].keys }
-        .flatten
-        .map(&:strip)
-        .sort_by(&:length).last.length+padding
-
-      # help text
-      @cols[:four] = @max_column_width+padding
-
-      @cols[:total] = @cols.values.reduce(&:+)
-
-      @cols
-    end
-
-    def center(str)
-      "%#{width.values.reduce(&:+)/3-str.length}s\n" % str
-    end
-
-    # offset the entire array of eles by n number of blank strings
-    def offset(n, *eles)
-      row *(eles.unshift *[''] * n)
-    end
-
-    def row(*columns)
-      "%#{width[:one]}s %#{width[:two]}s#{pad}%-#{width[:three]}s#{pad}%-#{width[:four]}s\n" % columns.map(&:strip)
-      #row2 *columns
-    end
-
-    def bar
-      "|\n".rjust(width[:total]+10,"-")
-    end
-
-    def n
-      "\n"
-    end
-
-    def chunker(content)
-      rows = ['']
-
-      content.split.each { |chunk|
-        if rows.last.length + chunk.length > @max_column_width then rows.push chunk else rows.last.concat " "+chunk end
-      }
-
-      rows
-    end
-
-    def write
-      m = []
-      m.push bar
-      m.push n
-      m.push "#{@title}:"
-      m.push n
-      m.push n
-      m.push bar
-      unless @flags.keys.empty?
-        m.push *["global flags:", "", "", ""].map(&:upcase)
-        m.push bar
-        @flags.each { |flag, info|
-          if info.length > @max_column_width
-            chunks = chunker info
-            m.push row( @script, '', '--'+flag, chunks.shift )
-            chunks.each { |chunk| m.push offset 3, chunk }
-            m.push n
-          else
-            m.push row(@script, '', '--'+flag, info)
-            m.push n
-          end
-          
-        }
-      end
-      m.push n
-      unless @cmds.keys.empty?
-        m.push bar
-        m.push row *['', "| cmd", "| flag", "| info"].map(&:upcase)
-        m.push bar
-        @cmds.keys.each { |cmd|
-          # add top level command
-          m.push n
-          if @cmds[cmd][:info].length > @max_column_width
-            chunks = chunker @cmds[cmd][:info]
-            m.push row(@script, cmd, '', chunks.shift)
-            chunks.each { |chunk| m.push offset 3, chunk }
-            m.push n
-          else
-            m.push row(@script, cmd, '', @cmds[cmd][:info])
-            m.push n
-          end
-
-          # add flags for command
-          @cmds[cmd][:flags].keys.each {|flag|
-            if @cmds[cmd][:flags][flag].length > @max_column_width
-              chunks = chunker @cmds[cmd][:flags][flag]
-              m.push row( @script, cmd, '--'+flag, chunks.shift )
-              chunks.each { |chunk| m.push offset 3, chunk }
-              m.push n
-            else
-              m.push row(@script, cmd, '--'+flag, @cmds[cmd][:flags][flag] )
-              m.push n
-            end
-          }
-
-        }
-        m.push bar
-        m.push n
-      end
-      respond m.join('')
-    end
-  end
-end
-
-
-
-
-
-