rwikibot 1.0.0

data/README

@@ -0,0 +1,3 @@
+This is RWikiBot 1.0. 
+
+This is a test README file.

data/config.yaml

@@ -0,0 +1,5 @@
+:source:use: 'default'
+:source:default:
+    username: "RWikiBot"
+    password: "rwikibot"
+    api_path: "http://localhost:8888/wiki/api.php"

data/lib/rwikibot.rb

@@ -0,0 +1,470 @@
+# 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 
+# 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
+# License:: GNU/GPL 2.0
+require 'net/http'
+require 'uri'
+require 'yaml'
+require 'cgi'
+require 'logger'
+
+
+#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
+
+  
+  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 = "Unnamed Bot", debuglevel = Logger::INFO, log_location = "./rwikibot.log" )
+    
+    @botname = name
+    
+    #We log. Log4r in the house. 
+    @wikibotlogger = Logger.new('rwikibot.log')
+    # @wikibotlogger.outputters = FileOutputter.new('f1', :filename => log_location, :trunc => false)
+    
+    #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 = debuglevel
+    @wikibotlogger.info "New RWikiBot created. My name is #{@botname}"
+    
+    # Load the configuration!! (saved the file based, because I liked it too much.)
+    @wikibotlogger.debug "Loading configuration..."
+    config_file = YAML.load_file('config.yaml')
+    use_config = config_file.fetch('use') #tricky, tricky
+    @wikibotlogger.debug "Config loaded. Using settings: #{use_config}"
+    
+    #now, the hash that will hold the config options
+    @config = config_file.fetch(use_config)
+    @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
+  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. 
+  def login
+    
+    @wikibotlogger.debug("LOGIN - Preparing login information...")
+    post_me = {'lgname'=>@config.fetch('username'),'lgpassword'=>@config.fetch('password')}
+    
+    @wikibotlogger.debug("LOGIN - Asking make_request to perform login...")
+    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"
+      # 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.
+  #
+  # 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"}
+    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')
+
+  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 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')
+  
+  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.
+  # 
+  # OUTPUT:: An array of hashes with information about the pages. 
+  def all_pages (options = nil)
+    
+    # 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'}
+    
+    #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..."    
+    
+    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
+    
+    return allpages_result.fetch('allpages')
+    
+  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')
+  
+  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
+    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')
+    
+  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.
+  def site_info (siprop = 'general')
+    
+    @wikibotlogger.debug "SITE INFO - Preparing request information..."
+    
+    # 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
+    end
+    
+    puts "Deleted #{count} items."
+    
+    return array
+  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)
+      
+    #Housekeeping. We need to add format and action to the request hash
+    post_this['format'] = 'yaml'
+    post_this['action'] = action
+    
+    #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..."
+    resp = @http.post( @config.fetch('uri').path , post_string ,  {'User-agent' => 'RWikiBot/0.1','Cookie' => bake(@config.fetch('cookie'))})
+    @wikibotlogger.info "MAKE REQUEST - Response: "
+    @wikibotlogger.info 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']
+      @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
+    
+  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
+    # wikidb_wiki_UserID wikidb_wiki_UserName wikidb_wiki_Token
+    
+    if cookie != nil
+      return "#{dough.fetch('wikidb_wiki_UserID')}; #{dough.fetch('wikidb_wiki_UserName')}; #{dough.fetch('wikidb_wiki_Token')}"
+    else
+      return ""
+    end
+    
+    # No shit, this took me almost a week to figure it out
+  end
+  
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: rwikibot
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-02-25 00:00:00 -06:00
+summary: A framework 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: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Eddie Roger
+files: 
+- lib/rwikibot.rb
+- README
+- config.yaml
+test_files: []
+
+rdoc_options: 
+- --inline-source
+extra_rdoc_files: 
+- README
+- config.yaml
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+