rwikibot 1.0.10 → 2.0.0

data/CHANGELOG

@@ -1,5 +1,33 @@
 RWikiBot ChangeLog   
 
+2.0 ** BREAKING RELEASE** - this will break pretty all 1.X bots. 
+	- It's smart enough now to handle query-continues! As such, there's a new dependency - deep_merge. Get it - it's in gem. 
+	- Made a Page class. now, instead of bot.delete_page(title...), you do page.delete
+	- Got rid of the stupid Result class. That was a terrible decision. 
+	- edit_page is now save. Part of the Page/class concept
+	- Changed user-agent to bot/RWikiBot/2.0
+	- page_exists has been replaced with the page attribute "missing" - this aligns with MW's behavior
+	- Removed redirects since it doesn't matter anymore now that the API is solidified
+	- Removed image_embdedded_in since it's defunct
+	- Removed revisions due to limited functionality
+	- Removed pageid_to_title because the API is smart enough to not require conversion
+	- Made the utilities all private because utilities don't need to be public
+	- Shortened up the code considerably by retuning make_request when I can
+	- Moved make_request and it's new friend raw_call to utilities because they are.
+	- Removed normalize since I can get the "missing" attribute when creating a page, and that's good 'nuff
+
+1.2 
+	- Added edit functionality to complete the API
+	- Played catchup with a whole lot of methods
+
+1.1
+	- Switched from YAML to XML for a handful of reasons, most of which being poorly formatted YAML errors in API
+	- Disabled cookies from login since they're terrible and hard to maintain and bad long term practice and the API supports it (you're welcome)
+	- Striked the "name" field and "prefix" field from initialize. Those were antiquated anyway. 
+	- Reordered the methods to align with documentation
+	- Changed User-Agent to bot-RWikiBot/1.1
+	- Refined error handling (sorta)	
+
 1.0.10
 	- Changed a get back to post since the bug wasn't with me. 
 

data/README

@@ -1,3 +1,17 @@
-This is RWikiBot 1.0. 
+This is RWikiBot 2.0
 
-This is a test README file.
+For the most up-to-date information on RWikiBot, how to use it, and why it's amazing, please visit:
+http://www.rwikibot.net
+
+New in 2.0 (highlights)
+	- It's smart enough now to handle query-continues! As such, there's a new dependency - deep_merge. Get it - it's in gem. 
+	- Made a Page class. now, instead of bot.delete_page(title...), you do page.delete
+	- Got rid of the stupid Result class. That was a terrible decision. 
+	- edit_page is now save. Part of the Page/class concept
+	- Changed user-agent to bot/RWikiBot/2.0
+	
+For more, see the the CHANGELOG.
+
+Author:: Eddie Roger (mailto:eddieroger@nospam@gmail.com) http://www.eddieroger.com
+Copyright:: Copyright (c) 2008 Eddie Roger
+License:: GNU/GPL 2.0

data/lib/errors.rb

@@ -0,0 +1,14 @@
+module RWBErrors
+  class LoginError < StandardError
+  end
+
+  class RWikiBotError < StandardError
+  end
+
+  class VersionTooLowError < StandardError
+  end
+  
+  class NotLoggedInError < StandardError
+  end
+  
+end

data/lib/pages.rb

@@ -0,0 +1,206 @@
+## This class defines a MediaWiki page. Think of it like this: the bot handles site related stuff, but to take action on a page, you need a page object.
+require 'rwikibot'
+require 'errors'
+
+module Pages
+  include RWBErrors
+
+  class Page
+    attr_reader :title, :namespace, :new, :length, :counter, :lastrevid
+
+    # Creates a new Page object.
+    def initialize(bot, title='')
+      @bot = bot
+
+      # Get page attributes
+      info = info(title)
+
+      @title      = info['title']
+      @namespace  = info['ns']
+      @new        = info.has_key?('new')
+      @length     = info['length']
+      @counter    = info ['counter']
+      @lastrevid  = info['lastrevid']
+      @missing    = info.has_key?('missing')
+
+    end
+
+    # This will get only the content of the article. It is a modification of revisions to specifically pull the content. I thought it would be useful.
+    def content(options = nil)
+
+      post_me = {'prop' => 'revisions', 'titles' => @title, 'rvprop' => 'content'}
+
+      # Handle any additional options
+      if options != nil
+        options.each_pair do |key, value|
+          post_me[key] = value
+        end
+      end
+
+      # Make the request. Becuase we care.
+      revisions_result = @bot.make_request('query', post_me )
+      return revisions_result.fetch('pages').fetch('page').fetch('revisions').fetch('rev')
+    end
+
+    # If you have to ask what this method does, don't use it. Seriously, use with caution - this method does not have a confirmation step, and deleted (while restorable) are immediate.
+    #
+    def delete(reason="Deleted by RWikiBot")
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,12)
+      raise RWBErrors::NotLoggedInError unless @bot.logged_in?
+
+      post_me = {
+        'title'     => @title ,
+        'token'     => get_token('delete') ,
+        'reason'    => reason
+      }
+
+      return delete_result = @bot.make_request('delete',post_me)
+    end
+
+    # This method fetches any article that links to the article given in 'title'. Returned in alphabetical order.
+    def backlinks (titles, options = nil)
+      raise VersionTooLowError unless meets_version_requirement(1,9)
+
+      # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
+      post_me = {'list' => 'backlinks', 'titles' => "#{title}" }
+
+
+      if options != nil
+        options.each_pair do |key, value|
+          post_me[key] = value
+        end
+      end
+
+      #make the request
+      backlinks_result = make_request('query', post_me)
+
+      if backlinks_result.success?
+        return backlinks_result.get_result.fetch('backlinks')
+      else
+        return backlinks_result.get_message
+      end
+    end
+
+    # This method pulls any page that includes the template requested. Please note - the template must be the full name, like "Template:Disputed" or "Template:Awesome".
+    def embedded_in (options = nil)
+      raise VersionTooLowError unless @bot.meets_version_requirement(1,9)
+
+      # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
+      post_me = {'list' => 'embeddedin', 'eititle' => @title }
+
+      if options != nil
+        options.each_pair do |key, value|
+          post_me[key] = value
+        end
+      end
+
+      #make the request
+      embeddedin_result = @bot.make_request('query', post_me)
+      return embeddedin_result.fetch('embeddedin').fetch('ei')
+    end
+
+    # I decided to split this up since I wanted to normalize the bot framework as much as possible, or in other words, make it as easy to use as possible. I think the sacrifice of more methods is worth having more English looking code. Its the Ruby way.
+    # Info will return information about the page, from namespace to normalized title, last touched, etc.
+    def info  (titles)
+      # Basic quqery info
+      post_me = {"prop" => "info", 'titles' => titles}
+
+      # Make the request
+      info_result = @bot.make_request('query', post_me)
+
+      return info_result.fetch('pages').fetch('page')
+    end
+
+    # This method will let you move a page from one name to another. A move token is required for this to work. Keep that in mind. (get_token much?)
+    def move(to, reason, movetalk = true, noredirect = false)
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,12)
+      raise RWBErrors::NotLoggedInError unless @bot.logged_in?
+
+      post_me = {
+        'from'    => @title ,
+        'to'      => "#{to}" ,
+        'token'   => get_token('move') ,
+        'reason'  => "#{reason}" ,
+      }
+
+      # These ifs are necessary because they should only be part of post_me if the passed vars are true (which they are by default)
+      if movetalk
+        post_me['movetalk'] = ''
+      end
+      if noredirect
+        post_me['noredirect'] = ''
+      end
+
+      return @bot.make_request('move', post_me)
+    end
+
+    # Rollback does what it says - rolls back an article one version in the wiki. This is a function that requires not only a token, but a previous user.
+    def rollback (summary="", markbot=true)
+
+      temp_token = get_token("rollback") # special for rollback. Stupid rollback.
+      post_me = {
+        'title'     => @title,
+        'token'     => temp_token['token'],
+        'user'      => temp_token['user'],
+        'summary'   => summary
+      }
+
+      if markbot
+        post_me['markbot'] = ''
+      end
+
+      return @bot.make_request('rollback', post_me)
+    end
+
+    # This method is used to edit pages. Not much more to say about it. Be sure you're logged in and got a token (get_token). Options is an array (or hash) of extra values allowed by the API.
+    def save(content, summary = nil, options = nil)
+
+      post_me = {
+        'text' => "#{content}" ,
+        'token' => get_token("edit") ,
+        'title' => @title ,
+        # 'lgtoken' => @config['lgtoken'] ,
+        'summary' => "#{summary}" ,
+        'edittime' => Time.now.strftime("%Y%m%d%H%M%S") ,
+        # 'userid' => @config.fetch('lguserid') ,
+      }
+
+      if options.nil? == FALSE
+        options.each do |key, value|
+          post_me[key] = value
+        end
+      end
+      return @bot.make_request('edit', post_me).fetch('result')
+    end
+
+    private
+    # This method should universally return tokens, just give title and type. You will receive a token string (suitable for use in other methods), so plan accordingly.
+    # Use an edit token for both editing and creating articles (edit_article, create_article). For rollback, more than just a token is required. So, for token=rollback, you get a hash of token|user. Just the way it goes.
+    def get_token(intoken)
+      if intoken.downcase == 'rollback'
+        #specific to rollback
+        post_me = {
+          'prop'    => 'revisions' ,
+          'rvtoken' => intoken ,
+          'titles'  => @title
+        }
+      else
+        post_me = {
+          'prop'    => 'info',
+          'intoken' => intoken,
+          'titles'  => @title
+        }
+      end
+      raw_token = @bot.make_request('query', post_me)
+
+      if intoken.downcase == 'rollback'
+        # Damn this decision to make rollback special!. Wasn't mine, I just have to live by it.
+        token2 = raw_token.fetch('pages').fetch('page').fetch('revisions').fetch('rev')
+        return {'token' => token2.fetch('rollbacktoken') , 'user' => token2.fetch('user')}
+      else
+        return raw_token.fetch('pages').fetch('page').fetch("#{intoken}token")
+      end
+    end
+  end #class
+
+end #module

data/lib/rwikibot.rb

@@ -1,674 +1,195 @@
-# RWikiBot 0.1
-# 
-# This is a framework upon which to create MediaWiki Bots. It provides a set of methods to acccess MediaWiki's API and return information in 
+# This is a framework upon which to create MediaWiki Bots. It provides a set of methods to acccess MediaWiki's API and return information in
 # various forms, depending on the type of information returned. By abstracting these methods into a Bot object, cleaner script code can be
-# written later. Furthermore, it facilitates the updating of the API without breaking old bots. Last, but not least, its good to abstract. 
-# 
-# Configuration options are kept in config.yaml and processed on bot creation. I have worked really hard to make sure this file doesn't need editing, 
-# so please don't make changes here, and email me if you find something that I missed.
-# 
-# Author:: Edwin Sidney Roger (mailto:eddieroger@gmail.com)
-# Copyright:: Copyright (c) 2007 Edwin Sidney Roger
+# written later. Furthermore, it facilitates the updating of the API without breaking old bots. Last, but not least, its good to abstract. #
+#
+# Author:: Eddie Roger (mailto:eddieroger@gmail.com)
+# Copyright:: Copyright (c) 2008 Eddie Roger
 # License:: GNU/GPL 2.0
+
+# ruby requires
 require 'net/http'
 require 'uri'
-require 'yaml'
 require 'cgi'
-require 'logger'
 
+# my requires
+require 'errors'
+require 'utilities'
+require 'pages'
+
+# gem requires
+require 'xmlsimple'
+require 'deep_merge' # New in 2.0!
 
 #This is the main bot object. The goal is to represent every API method in some form here, and then write seperate, cleaner scripts in individual bot files utilizing this framework. Basically, this is an include at best.
 class RWikiBot
 
+  include RWBErrors
+  include RWBUtilities
+  include Pages
   
-  attr_accessor :http, :config, :botname
-  
-  # New bots hope for three attributes, but require none. The first is simply the name of the bot for logging purposes. The second is the debug level constant, and third is the logfile.
-  #
-  # Example: bot = RWikiBot.new("My Neat Bot", Logger::DEBUG, "./rwikibot.log")
-  def initialize ( name = "TestBot", username = 'RWikiBot', password = 'rwikibot', domain = 'en', api_path = 'http://localhost:8888/wiki/api.php', wikicookieprefix = 'wikidb_wiki')
+  attr_reader :config
 
-    @botname = name
+  def initialize ( username = 'rwikibot', password = '', api_path = 'http://www.rwikibot.net/wiki/api.php', domain = '', login=false)
     @config = Hash.new
-    
-    #We log. Log4r in the house. 
-    ##@wikibotlogger = Logger.new('rwikibot.log')
-    
-    #INFO level is nice. I like it as production default because I like log files. Feel free to change. It will change once config loaded
-    ##@wikibotlogger.level = Logger::DEBUG
-    ###@wikibotlogger.info "New RWikiBot created. My name is #{@botname}"
-    
+
     # This had to come back since I was having config loading issues when being called from MediaWiki
     @config['username'] = username
     @config['password'] = password
-    @config['domain'] = domain
     @config['api_path'] = api_path
-    @config['wikicookieprefix'] = wikicookieprefix
-    
+    @config['domain']   = domain
+    @config['cookies']	= ""
     @config['logged_in'] = FALSE
     @config['uri'] = URI.parse(@config.fetch('api_path'))
-    
-    ##change - make an HTTP object here for use later, now that we have config
-    @http = Net::HTTP.new(@config.fetch('uri').host, @config.fetch('uri').port)
-    ###@wikibotlogger.debug("INIT - Created HTTP object. Result is: #{@http}}")
 
-    @config['cookie'] = nil
+    # This has to be last methinks
+    @config['api_version'] = version.to_f
+
+    if login
+      login
+    end
+
   end
 
-  # Login
-  #
-  # This is the method that will allow the bot to log in to the wiki. Its not always necessary, but bots need to log in to save changes or retrieve watchlists. 
-  #
-  # No variables are accepted and the username/password are stored in config.yaml. 
+  # This is the method that will allow the bot to log in to the wiki. Its not always necessary, but bots need to log in to save changes or retrieve watchlists.
   def login
-    
-    ###@wikibotlogger.debug("LOGIN - Preparing login information...")
+    raise VersionTooLowError unless meets_version_requirement(0,0)
+
     post_me = {'lgname'=>@config.fetch('username'),'lgpassword'=>@config.fetch('password')}
     if @config.has_key?('domain') && (@config.fetch('domain') != nil)
       post_me['lgdomain'] = @config.fetch('domain')
     end
-    
-    ###@wikibotlogger.debug("LOGIN - Asking make_request to perform login...")
+
+    #Calling make_request to actually log in
     login_result = make_request('login', post_me)
-    ##@wikibotlogger.debug("LOGIN - We should have a result of type login now.")
-    
-    ##@wikibotlogger.debug("LOGIN - login_result received. Result is: #{login_result.fetch('result')}")
-    
+
     # Now we need to changed some @config stuff, specifically that we're logged in and the variables of that
     # This will also change the make_request, but I'll comment there
-    if login_result.fetch('result') == "Success"
+    if login_result['result'] == "Success"
       # All lg variables are directly from API and stored in config that way
-      ##@wikibotlogger.info("LOGIN - Login successful. Wiki user is: #{login_result.fetch('lgusername')}")
-      @config['logged_in'] = TRUE
-      @config['lgusername'] = login_result.fetch('lgusername')
-      @config['lguserid'] = login_result.fetch('lguserid')
-      @config['lgtoken'] = login_result.fetch('lgtoken') 
-      ##@wikibotlogger.debug("LOGIN - MediwWiki API variables stored in @config")
-      return TRUE
-    else 
-      ##@wikibotlogger.error("LOGIN - Login Error. Wiki API said: #{login_result.fetch('result')}")
-      return FALSE
-    end
-    
-  end
-  
-  # Watchlist
-  #
-  # This method will get the watchlist for the bot's MediaWiki username. This is really onlu useful if you want the bot to watch a specific list of pages, and would require the bot maintainer to login to the wiki as the bot to set the watchlist. 
-  #
-  # INPUT:: Options is a hash of API allowed fields that will be passed.
-  #
-  # OUTPUT:: Returns an array of hashes.
-  def watchlist (options=nil)
-    # Get the bot's watchlist
-    ##@wikibotlogger.debug("WATCHLIST - Preparing request information...")
-    post_me = {'list'=>'watchlist'}
-    
-    if options != nil
-      options.each do |key, value|
-        post_me[key] = value
-      end
-    end
-    
-    # Make the request
-    ##@wikibotlogger.debug "WATCHLIST - Asking make_request to get watchlist..."
-    watchlist_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "WATCHLIST - We should have a result of type query now."
-    
-    #Process into a Hash for return
-    ##@wikibotlogger.debug "WATCHLIST - Processing result..."
-    return watchlist_result.fetch('watchlist')
-    
-  end
-  
-  # Query
-  #
-  # This method will return Wiki-wide recent changes, almost as if looking at the Special page Recent Changes. But, in this format, a bot can handle it. Also we're using the API. And bots can't read.
-  # 
-  # INPUT:: A hash of API-allowed keys and values. Default is same as API default.
-  # PARAMETERS:: letype (flt), lefrom (paging timestamp), leto (flt), ledirection (dflt=older), leuser (flt), letitle (flt), lelimit (dflt=10, max=500/5000)
-  # OUTPUT:: An array of hashes.
-  def recent_changes (options=nil)
-    
-    # This will allow any given bot to get recent changes. Then act on it. But that's another method
-    # TODO - Persistent timestamp storage
-    
-    ##@wikibotlogger.debug("RECENT CHANGES - Preparing request information...")
-    post_me = {"list" => "recentchanges", 'rclimit' => '5000'}
-    if options != nil
-      options.each do |key, value|
-        post_me[key] = value
-      end
-    end
-    
-    # Make the request
-    ##@wikibotlogger.debug "RECENT CHANGES - Asking make_request to get recentchanges..."
-    recentchanges_result = make_request('query' , post_me)
-    ##@wikibotlogger.debug "RECENT CHANGES - We should have a result of type query now."
-    
-    # Figure out what to do now. Process, I'd think
-    ##@wikibotlogger.debug "RECENT CHANGES - Processing result..."
-    
-    return recentchanges_result.fetch('recentchanges')
-    
-  end
-  
-  # List
-  #
-  # This will reutrn a list of the most recent log events. Useful for bots who want to validate log events, or even just a notify bot that checks for events and sends them off. 
-  #
-  # INPUT:: A hash of API-allowed keys and values. Default is same as API default.
-  #
-  # OUTPUT:: An array of hashes containing log events.
-  def log_events (options = nil)
-    
-    ##@wikibotlogger.debug "LOG EVENTS - Preparing request information..."
-    
-    # Make the request
-    post_me = {"list" => "logevents"}
-    
-    if options != nil
-      ##@wikibotlogger.debug("LOG EVENTS - Additional options added by requestor. Adding to post_me...")
-      options.each_pair do |key, value|
-        post_me[key] = value
-        ##@wikibotlogger.debug "LOG EVENTS - Added #{post_me[key]}"
-      end
-      ##@wikibotlogger.debug("LOG EVENTS - No more additional options. Moving on...")
-    end
-    
-    #Make the request!
-    ##@wikibotlogger.debug "LOG EVENTS = Asking make_request to get logevents"
-    logevents_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "LOG EVENTS - We should have a result of type logevents now."
-    
-    # Process results
-    ##@wikibotlogger.debug "LOG EVENTS - Processing result..."
-    
-    
-    return logevents_result.fetch('logevents')
+      @config['logged_in'] 		  = TRUE
+      @config['lgusername'] 	  = login_result.fetch('lgusername')
+      @config['lguserid'] 		  = login_result.fetch('lguserid')
+      @config['lgtoken'] 		    = login_result.fetch('lgtoken')
+      @config['_session']       = login_result.fetch('sessionid')
+      @config['cookieprefix'] 	= login_result.fetch('cookieprefix')
+      # puts "You are now logged in as: #{@config['lgusername']}"
+      return true
+    else
+      # puts "Error logging in. Error was: "
+      raise LoginError, "#{login_result['result']}: #{login_result['details']}"
 
+    end #if
   end
-  
-  # Query
-  #
-  # This will return any redirects from an article title so that you know where it ends. Useful to check for redirects, but mostly here for completeness of the framework.
-  #
-  # INPUT:: A string of pipe-delimited titles ('Apple|Baseball|Car port'), and an optional hash of API acceptable values.
-  # OUTPUT:: An array of redirects.
-  def redirects (title, options = nil)
-    
-    # Prepare the request
-    ##@wikibotlogger.debug "REDIRECTS - Preparing request information..."
-    post_me = {'titles' => title, 'redirects'=>'', 'prop' => 'info'}
-    
-    if options != nil
-      ##@wikibotlogger.debug("REDIRECTS - Additional options added by requestor. Adding to post_me...")
-      options.each_pair do |key, value|
-        post_me[key] = value
-        ##@wikibotlogger.debug "REDIRECTS - Added #{post_me[key]}"
-      end
-      ##@wikibotlogger.debug("REDIRECTS - No more additional options. Moving on...")
-    end
-    
-    #Make the request
-    ##@wikibotlogger.debug "REDIRECTS - Asking make_request find redirects..."
-    redirects_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "REDIRECTS - We should have a result now..."
-  
-    ##@wikibotlogger.debug "REDIRECTS - Processing result..."
-    
-    
-    return redirects_result.fetch('pages')
-  
-  end
-  
-  
-  # Query
-  #
-  # This is a lot like REDIRECTS method, except its just a true/false to validate whether or not an article is a redirect. We could write the logic into the final bot app, but we're awesome and we include a quicky method.
-  #
-  # INPUT:: Title (please, just one!)
-  # OUTPUT:: True/False
-  def redirect? (title)
-    
-    # Prepare the request
-    ##@wikibotlogger.debug "REDIRECT? - Preparing request information..."
-    post_me = {'titles' => title, 'redirects'=>'', 'prop' => 'info'}
-    
-    
-    #Make the request
-    ##@wikibotlogger.debug "REDIRECT? - Asking make_request find redirects..."
-    redirects_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "REDIRECT? - We should have a result now..."
-  
-    ##@wikibotlogger.debug "REDIRECT? - Processing result..."
-    
-    
-    return redirects_result.has_key?('redirects')
-    
-  end
-  
-  
-  # Query
-  #
-  # This little ditty returns a normalized version of the title passed to it. It is super useful because it will normalize an otherise poorly entered title, but most importantly it will let us know if an article exists or not by if it is able to normalize. 
-  #
-  # INPUT:: Titles, either singular or pipe-delimited.
-  # OUTPUT:: An array of normalized hashes.
-  def normalize (title)
-    
-    # Prepare the request
-    ##@wikibotlogger.debug "NORMALIZE - Preparing request information..."
-    post_me = {'titles' => title}
-    
-    #Make the request
-    ##@wikibotlogger.debug "NORMALIZE - Asking make_request to normalize titles..."
-    normalized_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "NORMALIZE - We should have a result now..."
-  
-    ##@wikibotlogger.debug "NORMALIZE - Processing result..."
-    
-    
-    return normalized_result.fetch('pages')
-  
+
+  # Use Page to create a new page object that you can then manipulate. You could create a page on it's own, but if you do, be _sure_ to pass your bot along with the title, otherwise you won't get access to the super-fun make_request object that is pretty much required.
+  def Page(title='')
+    return Page.new(self, title)
   end
 
-  # List
-  #
   # This will return a list of all pages in a given namespace. It returns a list of pages in with the normalized title and page ID, suitable for usage elsewhere. Accepts all parameters from the API in Hash form.
-  # Default is namespace => 0, which is just plain pages. Nothing 'special'. 
-  # Also note that if the username the Bot uses is not of type Bot in the Wiki, you will be limited to 50 articles. Also log in, or you get an error.
-  #
-  # INPUT:: A hash of API-allowed keys and values. Default is same as API default.
-  # PARAMETERS:: apfrom (paging), apnamespace (dflt=0), apredirect (flt), aplimit (dflt=10, max=500/5000)
-  # OUTPUT:: An array of hashes with information about the pages. 
+  # Default is namespace => 0, which is just plain pages. Nothing 'special'.
   def all_pages (options = nil)
-    
+    raise VersionTooLowError unless meets_version_requirement(1,9)
     # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
     ##@wikibotlogger.debug "ALL PAGES - Preparing request information..."
     post_me = {'list' => 'allpages', 'apnamespace' => '0', 'aplimit' => '5000'}
-    
-    
+
+
     if options != nil
-      ##@wikibotlogger.debug("ALL PAGES - Additional options added by requestor. Adding to post_me...")
       options.each_pair do |key, value|
         post_me[key] = value
-        ##@wikibotlogger.debug "ALL PAGES - Added #{post_me[key]}"
       end
-      ##@wikibotlogger.debug("ALL PAGES - No more additional options. Moving on...")
     end
-    
+
     #make the request
-    ##@wikibotlogger.debug "ALL PAGES - Asking make_request to get all pages..."
     allpages_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "ALL PAGES - We should have a result now..."
-    
-    return allpages_result.fetch('allpages')
-    
+    allpages_result.fetch('allpages')['p']
   end
 
-  # List
-  #
-  # This method fetches any article that links to the article given in 'title'. Returned in alphabetical order.
-  # 
-  # INPUT:: A normalized article title or titles (pipe delimited), and a hash of API-allowed keys and values. Default is same as API default.
-  # PARAMETERS:: blfrom (paging), blnamespace (flt), blredirect (flt), bllimit (dflt=10, max=500/5000)
-  # OUTPUT:: An array of hashes with backlinked articles. 
-  def backlinks (titles, options = nil)
-    
-    # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
-    ##@wikibotlogger.debug "BACKLINKS - Preparing request information..."
-    post_me = {'list' => 'backlinks', 'titles' => "#{title}" }
-     
-    
+  # This method will get the watchlist for the bot's MediaWiki username. This is really onlu useful if you want the bot to watch a specific list of pages, and would require the bot maintainer to login to the wiki as the bot to set the watchlist.
+  def watchlist (options=nil)
+    raise VersionTooLowError unless meets_version_requirement(1,10)
+    raise NotLoggedInError unless logged_in?
+
+    # Get the bot's watchlist
+    post_me = {'list'=>'watchlist'}
+
     if options != nil
-      ##@wikibotlogger.debug("BACKLINKS - Additional options added by requestor. Adding to post_me...")
-      options.each_pair do |key, value|
+      options.each do |key, value|
         post_me[key] = value
-        ##@wikibotlogger.debug "BACKLINKS - Added #{post_me[key]}"
       end
-      ##@wikibotlogger.debug("BACKLINKS - No more additional options. Moving on...")
     end
-    
-    #make the request
-    ##@wikibotlogger.debug "BACKLINKS - Asking make_request to get backlinks..."
-    backlinks_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "BACKLINKS - We should have a result now..."
-    return backlinks_result.fetch('backlinks')
-    
+
+    # Make the request
+    return make_request('query', post_me).fetch('watchlist').fetch('item')
   end
-  
-  # List
-  #
-  # This method pulls any page that includes the template requested. Please note - the template must be the full name, like "Template:Disputed" or "Template:Awesome". Just one, please.
-  # 
-  # INPUT:: A normalized template title, and a hash of API-allowed keys and values. Default is same as API default.
-  # PARAMETERS:: eifrom (paging), einamespace (flt), eiredirect (flt), eilimit (dflt=10, max=500/5000)
-  # OUTPUT:: An array of hashes with articles using said template. 
-  def embedded_in (title, options = nil)
-    
-    # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
-    ##@wikibotlogger.debug "EMBEDDED IN - Preparing request information..."
-    post_me = {'list' => 'embeddedin', 'titles' => "#{title}" }
-     
-    
+
+  # This method will return Wiki-wide recent changes, almost as if looking at the Special page Recent Changes. But, in this format, a bot can handle it. Also we're using the API. And bots can't read.
+  def recent_changes (options=nil)
+    raise VersionTooLowError unless meets_version_requirement(1,10)
+
+    post_me = {"list" => "recentchanges", 'rclimit' => '5000'}
     if options != nil
-      ##@wikibotlogger.debug("EMBEDDED IN - Additional options added by requestor. Adding to post_me...")
-      options.each_pair do |key, value|
+      options.each do |key, value|
         post_me[key] = value
-        ##@wikibotlogger.debug "EMBEDDED IN - Added #{post_me[key]}"
       end
-      ##@wikibotlogger.debug("EMBEDDED IN - No more additional options. Moving on...")
     end
-    
-    #make the request
-    ##@wikibotlogger.debug "EMBEDDED IN - Asking make_request to get backlinks..."
-    embeddedin_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "EMBEDDED IN - We should have a result now..."
-    return embeddedin_result.fetch('embeddedin')
-    
-  end
-  
-  # List
-  #
-  # A whole lot like EMBEDDED_IN, except this bad boy has the job of handling Image: instead of Template:. I guess bots may want to watch images. Its really for completeness. But, people do do things with pictures. Maybe it handles Media: as well, but no promisesses.
-  # 
-  # INPUT:: A normalized image title, and a hash of API-allowed keys and values. Default is same as API default.
-  # PARAMETERS:: iefrom (paging), ienamespace (flt), ielimit (dflt=10, max=500/5000)
-  # OUTPUT:: An array of hashes with images page links
-  # def image_embedded_in (title, options = nil) :nodoc:
-  #   
-  #   # This will get all pages. Limits vary based on user rights of the Bot. Set to bot.
-  #   ##@wikibotlogger.debug "IMAGE EMBEDDED IN - Preparing request information..."
-  #   post_me = {'list' => 'embeddedin', 'titles' => "#{title}" }
-  #    
-  #   
-  #   if options != nil
-  #     ##@wikibotlogger.debug("IMAGE EMBEDDED IN - Additional options added by requestor. Adding to post_me...")
-  #     options.each_pair do |key, value|
-  #       post_me[key] = value
-  #       ##@wikibotlogger.debug "IMAGE EMBEDDED IN - Added #{post_me[key]}"
-  #     end
-  #     ##@wikibotlogger.debug("IMAGE EMBEDDED IN - No more additional options. Moving on...")
-  #   end
-  #   
-  #   #make the request
-  #   ##@wikibotlogger.debug "IMAGE EMBEDDED IN - Asking make_request to get backlinks..."
-  #   imageembeddedin_result = make_request('query', post_me)
-  #   ##@wikibotlogger.debug "IMAGE EMBEDDED IN - We should have a result now..."
-  #   return imageembeddedin_result.fetch('embeddedin')
-  #   
-  # end
-    
-  # Prop = Info
-  #
-  # I decided to split this up since I wanted to normalize the bot framework as much as possible, or in other words, make it as easy to use as possible. I think the sacrifice of more methods is worth having more English looking code. Its the Ruby way. 
-  # Info will return information about the page, from namespace to normalized title, last touched, etc. 
-  #
-  # INPUT:: This method only takes titles, but will accept a pipe-delimited string. Ex: "Apple|Baseball|Horse|Main Page"
-  # 
-  # OUTPUT:: An array of hashes.
-  def info (titles)
-    
-    # Basic quqery info
-    ##@wikibotlogger.debug "INFO - Preparing the query..."
-    post_me = {"prop" => "info", 'titles' => titles}
-    
+
     # Make the request
-    ##@wikibotlogger.debug "INFO - Asking make_request to get info"
-    info_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "INFO - We should have a result set now..."
-    
-    # Result processing
-    ##@wikibotlogger.debug "INFO - Preparing results..."
-    
-    return info_result.fetch('pages')
-  
+    return make_request('query' , post_me).fetch('recentchanges').fetch('rc')
   end
-  
-  # Prop - Revisions
-  #
-  # This is the main way of accessing content and page specific information from the wiki. It has multiple uses as described in the API, Its also considerably more complex than the other methods. Enjoy it.
-  # A final note - I'd really be familiar with this method in the API since I've spent a lot of time trying to figure it out myself.
-  #
-  # Please be sure to add the RVPROP key at least, otherwise you'll just get the basic information of revid, oldid and pageid. Boring.
-  #
-  # INPUT:: A string of article titles (pipe-delimited), and a hash of API-allowed keys and values. Default is same as API default.
-  #
-  # OUTPUT:: An array of hashes. 
-  def revisions(titles, options = nil)
-    
-    # Prepare the request! Notify the logger!
-    ##@wikibotlogger.debug "REVISIONS - Preparing the requeset..."
-    post_me = {'prop' => 'revisions', 'titles' => titles}
-    
-    # Handle any additional options
+
+  # This will reutrn a list of the most recent log events. Useful for bots who want to validate log events, or even just a notify bot that checks for events and sends them off.
+  def log_events (options = nil)
+    raise VersionTooLowError unless meets_version_requirement(1,11)
+    post_me = {"list" => "logevents"}
+
     if options != nil
-      ##@wikibotlogger.debug("REVISIONS - Additional options added by requestor. Adding to post_me...")
       options.each_pair do |key, value|
         post_me[key] = value
-        ##@wikibotlogger.debug "REVISIONS - Added #{post_me[key]}"
       end
-      ##@wikibotlogger.debug("REVISIONS - No more additional options. Moving on...")
     end
-    
-    # Make the request. Becuase we care.
-    ##@wikibotlogger.debug "REVISIONS - Asking make_request to get revision for articles(s) #{titles}"
-    revisions_result = make_request('query', post_me )
-    ##@wikibotlogger.debug "REVISIONS - We should have a result now..."
-    
-    #Process the results
-    ##@wikibotlogger.debug "REVISIONS - Preparing results..."
-    
-    return revisions_result.fetch('pages')
-    
+
+    #Make the request!
+    return make_request('query', post_me).fetch('logevents').fetch('item')
   end
-  
-  # Meta
-  #
-  # This is the only meta method. It will return site information. I chose not to allow it to specify, and it will only return all known properties. 
-  # api.php?action=query&meta=siteinfo&siprop=general|namespaces
-  #
-  # INPUT:: siprop is either 'general' or 'namespaces'. 
-  #
-  # OUTPUT:: A hash of values about site information.
+
+  # This is the only meta method. It will return site information. I chose not to allow it to specify, and it will only return all known properties.
   def site_info (siprop = 'general')
-    
-    ##@wikibotlogger.debug "SITE INFO - Preparing request information..."
-    
+    raise VersionTooLowError unless meets_version_requirement(1,9)
     # Make the request
     post_me = {"meta" => "siteinfo" , "siprop" => siprop}
-    
-    
+
     #Make the request!
-    ##@wikibotlogger.debug "SITE INFO - Asking make_request to get site info"
     siteinfo_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "SITE INFO - We should have a result of type site info now."
-    
-    # Process results
-    ##@wikibotlogger.debug "SITE INFO - Processing result..."
-    
+
     if siprop == 'general'
       return siteinfo_result.fetch('general')
     else
-      return siteinfo_result.fetch('namespaces')
-    end
-    
-  end
-  
-  # The point of this method is to iterate through an array of hashes, which most of the other methods return, and remove multiple instances of the same wiki page. We're more than often only concerned with the most recent revision, so we'll delete old ones. 
-  #
-  # Hashes don't respond to the the Array.uniq method. So this is the same-ish
-  # INPUT:: An array of hashes. 
-  # OUTPUT:: An array of hashes that are unique. 
-  def make_unique(array)
-    
-    test_array = array
-    count = 0
-  
-    # First, let's make one big loop to go through each item in the array. 
-    array.reverse.each do |current_item|
-      
-      # Now, let's loop double time. 
-      test_array.each do |test_item|
-        
-        # Some comparisons...
-        if (current_item.fetch('title') == test_item.fetch('title') && current_item.fetch('revid') > test_item.fetch('revid') )
-          
-          # At this point, current is the same article as test, and current is newer. Delete test
-          array.delete(test_item)
-          count += 1
-          
-        end
-      end
+      return siteinfo_result.fetch('namespaces').fetch('ns')
     end
-    
-    puts "Deleted #{count} items."
-    
-    return array
-  end
-  
-  # This is a little something I cooked up because it seems like a totally logical thing for bots to want to do. Basically, you feed it a page title - any you want (that's the point) - and it returns TRUE or FALSE if the page exists inside the wiki. Technically, it pulls an attribute "missing", and in its presense, reports TRUE since the page is fake.
-  # That's something a bot would want to do, right?
-  #
-  # INPUT:: A title. Just one! 
-  #
-  # OUTPUT:: TRUE/FALSE, depending on which is correct
-  def page_exists? (title)
-    
-    # Prepare the request
-    ##@wikibotlogger.debug "PAGE EXISTS? - Preparing request information..."
-    post_me = {'titles' => title}
-    
-    #Make the request
-    ##@wikibotlogger.debug "PAGE EXISTS? - Asking make_request to verify page existence..."
-    page_exists_result = make_request('query', post_me)
-    ##@wikibotlogger.debug "PAGE EXISTS? - We should have a result now..."
-  
-    ##@wikibotlogger.debug "PAGE EXISTS? - Processing result..."
-    
-    
-    if page_exists_result.fetch('pages')[0].has_key?('missing')
-      ##@wikibotlogger.debug "PAGE EXISTS? - The page #{title} does NOT exist. Sorry."
-      return false
-    else
-      ##@wikibotlogger.debug "PAGE EXISTS? - The page #{title} DOES exist. You lucky, lucky bot."
-      return true
-    end
-    
-  end
-  
-  # This method will return the version of the MediaWiki server. This is done by parsing the version number from the generator attribute of the the site_info method. Useful? Yes - maybe yout bot is only compatible with MediaWiki 1.9.0 depending on what methods you use. I like it, anwyay.
-  #
-  # INPUT:: None
-  #
-  # OUTPUT:: Version number
-  def version
-    # Almost TOO simple... 
-    return site_info.fetch('generator').split(' ')[1]
   end
-  
-  # This method turns a pageid into a title. Why? Because I've written the rest of the methods title-centric, and I want to keep it that way. But, sometiumes you get a list of ids and not titles, and we have to do something about that.
-  #
-  # INPUT:: PageID - just one!
-  # OUTPUT:: A title in string form. 
-  def pageid_to_title(id)
-    
-      # Prepare the request! Notify the logger!
-      ##@wikibotlogger.debug "PAGEID TO TITLE - Preparing the requeset..."
-      post_me = {'prop' => 'info', 'pageids' => id}
-
-      # Make the request. Becuase we care.
-      ##@wikibotlogger.debug "PAGEID TO TITLE - Asking make_request to get revision for pageid #{id}"
-      id_result = make_request('query', post_me )
-      ##@wikibotlogger.debug "PAGEID TO TITLE - We should have a result now..."
-
-      #Process the results
-      ##@wikibotlogger.debug "PAGEID TO TITLE - Preparing results..."
-
-      return id_result.fetch('pages')[0].fetch('title')
 
+  # Get information about the current user
+  def user_info (uiprop = nil)
+    raise VersionTooLowError unless meets_version_requirement(1,11)
+    # Make the request
+    post_me = {"meta" => "userinfo" }
+    post_me['uiprop'] =  uiprop unless uiprop.nil?
+
+    return make_request('query',post_me).fetch('userinfo')
   end
-  
-  
-  private 
-  
-  # Make Request is a method that actually handles making the request to the API. Since the API is somewhat standardized, this method is able to accept the action and a hash of variables, and it handles all the fun things MediaWiki likes to be weird over, like cookies and limits and actions. Its very solid, but I didn't want it public because it also does some post processing, and that's not very OO. 
-  def make_request (action, post_this)
-    
-    # Now, we do error handling. We're big like that.
-    begin
-     
-      #Housekeeping. We need to add format and action to the request hash
-      post_this['format'] = 'yaml'
-      post_this['action'] = action
-      if @config.fetch('logged_in')
-        post_this['lgusername'] = @config.fetch('lgusername')
-        post_this['lgtoken'] = @config.fetch('lgtoken')
-        post_this['lguserid'] = @config.fetch('lguserid')
-      end
-    
-      #change - preparing a POST string instead of hash. 
-      post_string = ''
-      post_this.each_pair do |key, value|
-        post_string << "#{key}=#{value}&"
-      end
-      ##@wikibotlogger.info("MAKE REQUEST - Post String is: #{post_string}")
-      ##@wikibotlogger.debug "MAKE REQUEST - Sending request to: #{@config.fetch('uri')}"
-    
-      #Send the actual request    
-      ##@wikibotlogger.debug "MAKE REQUEST - Sending request..."
-      #'User-agent' => 'RWikiBot/0.1'     
-			# This is working agian. There was a bug in Ruby 1.8.4
-      resp = @http.post( @config.fetch('uri').path , post_string ,  {'User-agent'=>'RWikiBot/1.0', 'Cookie' => bake(@config.fetch('cookie')) } ) #
-      #resp = @http.get( "/wiki/api.php?#{post_string}" ,  {'User-agent'=>'RWikiBot/1.0', 'Cookie' => bake(@config.fetch('cookie')) } ) #
-      ##@wikibotlogger.debug "MAKE REQUEST - Response: "
-      ##@wikibotlogger.debug resp.body
-      ##@wikibotlogger.debug "MAKE REQUEST - End Response "
-      result = YAML.load(resp.body)
-    
-      #Process response
-      ##@wikibotlogger.debug "MAKE REQUEST - Response received. Processing..."
-      return_result = result.fetch(action)
-    
-      # A small check to make sure we don't need to save cookie data. Because usually, we don't
-      if @config.fetch('logged_in') == FALSE
-        @config['cookie'] = resp.header['set-cookie'] if @config.fetch('cookie').nil?
-        ##@wikibotlogger.debug "MAKE REQUEST - Received login cookie. Cookie is: #{resp.header['set-cookie']}"
-      end
-    
-      #Return the response
-      ##@wikibotlogger.debug "MAKE REQUEST - Response cleaned. Returning result."
-      return return_result
-    
-    # The short form is that the API's error message causes an ArgumentError, so we gotta handle that. I notified  MediaWiki
-    rescue ArgumentError
-      ##@wikibotlogger.error "MAKE REQUEST - The request has failed."
-      ##@wikibotlogger.error "MAKE REQUEST - Error is: #{$!}"
-      
-      raise ArgumentError, "Problem processing returned YAML result"
-    end
-  end
-  
-  # For some odd reason, MediaWiki sends back three cookies the first time you establis a session. For some even more odd, Net::HTTP doesn't treat the set-cookie headers individually the way that normal borowsers do. So, I have this processing method to handle cookie logic - when to send, when to set, etc. And it bakes cookies. Get it? Bake.
-  def bake(cookie)
-    
-    # Make some dough. Let CGI parse set-cookie, since there's multiple set-cookies and this is hard
-    dough = CGI::Cookie::parse(cookie) 
-    
-    # Take the dough and get my three elements out
-    
-    if @config.fetch('logged_in') == TRUE
-      ##@wikibotlogger.debug "BAKE - Baking a cookie... Smells like wiki."
-      # return "#{dough.fetch(@config.fetch('wikicookieprefix')+'UserID')}; #{dough.fetch(@config.fetch('wikicookieprefix')+'UserName')}; #{dough.fetch(@config.fetch('wikicookieprefix')+'Token')}"
-      return "#{dough.fetch('wikidb_UserID')}; #{dough.fetch('wikidb_UserName')}; #{dough.fetch('wikidb_Token')}"
-     
-    else
-      ##@wikibotlogger.debug "BAKE - No cookies to bake this time."
-      return ""
+
+end
+
+# I'm never happy with good enough, and when it comes to my hashes, I like to see the members of it. So I changed the hash to_s. Overriding method makes me happy. 
+class Hash
+  def to_s
+    out = "{"
+    self.each do |key, value|
+      out += "#{key} => #{value},"
     end
-    
-    # No shit, this took me almost a week to figure it out
+    out = out.chop
+    out += "}"
   end
-  
-end
+end

data/lib/utilities.rb

@@ -0,0 +1,127 @@
+## These methods aren't part of the API, so I'm moving them out. 
+## But they're still useful. Very. 
+
+module RWBUtilities
+  
+  private
+  
+  # is_redirect?
+  #
+  # Tests to see if a given page title is redirected to another page. Very Ruby.
+  def is_redirect? (title)
+    
+    post_me = {'titles' => title, 'redirects'=>'', 'prop' => 'info'}
+
+    result = make_request('query', post_me)
+    
+    if (result['result'] == "Success") && (result.has_key?("redirects"))
+      return true
+    else
+      return false
+    end
+  end
+  
+  # logged_in?
+  #
+  # A quick (and public) method of checking whether or not we're logged in, since I don't want @config exposed
+  #
+  # INPUT:: None
+  # OUTPUT:: boolean
+  def logged_in?
+    return @config['logged_in']
+  end
+  
+  # The point of this method is to iterate through an array of hashes, which most of the other methods return, and remove multiple instances of the same wiki page. We're more than often only concerned with the most recent revision, so we'll delete old ones. 
+  #
+  # Hashes don't respond to the the Array.uniq method. So this is the same-ish
+  def make_unique(array)
+    
+    test_array = array
+    count = 0
+  
+    # First, let's make one big loop to go through each item in the array. 
+    array.reverse.each do |current_item|
+      
+      # Now, let's loop double time. 
+      test_array.each do |test_item|
+        
+        # Some comparisons...
+        if (current_item.fetch('title') == test_item.fetch('title') && current_item.fetch('revid') > test_item.fetch('revid') )
+          
+          # At this point, current is the same article as test, and current is newer. Delete test
+          array.delete(test_item)
+          count += 1
+          
+        end
+      end
+    end
+    
+    return array
+  end
+  
+  # This method will return the version of the MediaWiki server. This is done by parsing the version number from the generator attribute of the the site_info method. Useful? Yes - maybe yout bot is only compatible with MediaWiki 1.9.0 depending on what methods you use. I like it, anwyay.
+  def version
+    # Almost TOO simple... 
+    return site_info.fetch('generator').split(' ')[1]
+  end
+  
+  # Make Request is a method that actually handles making the request to the API. Since the API is somewhat standardized, this method is able to accept the action and a hash of variables, and it handles all the fun things MediaWiki likes to be weird over, like cookies and limits and actions. Its very solid, but I didn't want it public because it also does some post processing, and that's not very OO.
+  def make_request (action, post_this)
+
+    #Housekeeping. We need to add format and action to the request hash
+    post_this['format'] = 'xml'
+    post_this['action'] = action
+
+    if (@config['logged_in'])
+      cookies = "#{@config['cookieprefix']}UserName=#{@config['lgusername']}; #{@config['cookieprefix']}UserID=#{@config['lguserid']}; #{@config['cookieprefix']}Token=#{@config['lgtoken']}; #{@config['cookieprefix']}_session=#{@config['_session']}"
+    else
+      cookies = ""
+    end
+
+    headers =  {
+      'User-agent'=>'bot-RWikiBot/2.0-rc1',
+      'Cookie' => cookies
+    }
+
+    r = Hash.new
+    until post_this.nil?
+      return_result, post_this = raw_call(headers, post_this)
+      r.deep_merge(return_result.fetch(action))
+    end
+
+    return r
+  end #make_request
+
+# Raw Call handles actually, physically talking to the wiki. It is broken out to handle query-continues where applicable. So, all the methods call make_request, and it calls raw_call until raw_call returns a nil post_this.
+  def raw_call(headers, post_this)
+    request = Net::HTTP::Post.new(@config.fetch('uri').path, headers)
+    request.set_form_data(post_this)
+    response = Net::HTTP.new(@config.fetch('uri').host, @config.fetch('uri').port).start {
+      |http| http.request(request)
+    }
+
+    # Extra cookie handling. Because editing will be based on session IDs and it generates a new one each time until you start responding. I doubt this will change.
+    if (response.header['set-cookie'] != nil)
+      @config['_session'] = response.header['set-cookie'].split("=")[1]
+    end
+
+    return_result = XmlSimple.xml_in(response.body, { 'ForceArray' => false })
+    # puts "==>>Result is: #{return_result}"
+
+    if return_result.has_key?('error')
+      raise RWikiBotError, "#{return_result.fetch('error').fetch('code').capitalize}: #{return_result.fetch('error').fetch('info')}"
+    end
+
+    if return_result.has_key?('query-continue')
+      return_result.fetch('query-continue').each do |key, value|
+        return_result.fetch('query-continue').fetch(key).each do |x,y|
+          post_this[x] = y
+        end
+      end
+    else
+      post_this = nil
+    end
+
+    return return_result, post_this
+  end #raw_call
+end

metadata

@@ -1,52 +1,59 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: rwikibot
 version: !ruby/object:Gem::Version 
-  version: 1.0.10
-date: 2007-05-29 00:00:00 -05:00
-summary: A library for creating MediaWiki bots.
-require_paths: 
-- lib
-email: eddieroger @nospam@ gmail.com
-homepage: 
-rubyforge_project: 
-description: 
-autorequire: rwikibot
-default_executable: 
-bindir: bin
-has_rdoc: "true"
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 2.0.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Eddie Roger
-files: 
-- lib/rwikibot.rb
-- test/rwikibot.log
-- sample-config.yaml
-- README
-- CHANGELOG
-test_files: []
+autorequire: 
+bindir: bin
+cert_chain: []
 
-rdoc_options: 
-- --inline-source
-extra_rdoc_files: 
-- README
-- CHANGELOG
-- sample-config.yaml
+date: 2008-12-29 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: eddieroger @nospam@ gmail.com
 executables: []
 
 extensions: []
 
+extra_rdoc_files: 
+- README
+- CHANGELOG
+files: 
+- lib/errors.rb
+- lib/pages.rb
+- lib/rwikibot.rb
+- lib/utilities.rb
+- README
+- CHANGELOG
+has_rdoc: "true"
+homepage: http://www.rwikibot.net
+post_install_message: 
+rdoc_options: 
+- --inline-source --force-update
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: RWikiBot
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A library for creating MediaWiki bots.
+test_files: []
 

data/sample-config.yaml

@@ -1,6 +0,0 @@
-default:
-    username: "RWikiBot"
-    password: "rwikibot"
-    domain: 'en'
-    api_path: "http://localhost:8888/wiki/api.php"
-    wikicookieprefix: 'wikidb_wiki_' #this is the MediaWiki default

data/test/rwikibot.log

@@ -1,3 +0,0 @@
-# Logfile created on Wed Mar 07 18:06:37 -0600 2007 by logger.rb/1.5.2.9
-I, [2007-03-07T18:06:37.367701 #19288]  INFO -- : New RWikiBot created. My name is Unnamed Bot
-D, [2007-03-07T18:06:37.367942 #19288] DEBUG -- : Loading configuration...