pangdudu-rwikibot 2.0.6.1

data/CHANGELOG

@@ -0,0 +1,93 @@
+RWikiBot ChangeLog  
+
+2.0.5
+	- Apparently meets_version_requirement was wrong. Not no more. 
+
+2.0.4
+	- I get it - I just suck at keeping versions consistent. And Github requires incremental gemspecs.
+
+2.0.3
+	- Removed an extra puts. Oops.
+	- Added Page::protect
+	- Reimplemented meets_version_requirement and references to it
+	
+2.0.2
+	- Random little changes. Forgot to document. Sorry. 
+	
+2.0.1 
+	- Changing gemspec so MAYBE it will be included in github gems.
+
+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.  
+
+1.0.9
+  - Disabled Logging because of permission errors on writing log files as a MediaWiki extension
+
+1.0.8
+  - Switched BACK to initialize-time config since calling from a hook didn't play with the files right, I think
+
+1.0.7
+  - Added PAGEID_TO_TITLE
+  - Turned Logger level up to INFO-  sorry for forgetting that :-)
+
+1.0.6
+  - Added VERSION
+  - Removed some _more_ debugging code
+  - Fixed login code to send back tokens and things, thereby fixing login altogether. Bots are now welcome!
+
+1.0.5
+  - Added parameters for queries to the rdoc - save MediaWiki some bandwidth
+  - Added BACKLINKS, PAGE_EXISTS?, EMBEDDED_IN, IMAGE_EMBEDDED_IN
+  - Fixed a bug in ALL_PAGES, where it wasn't really sending the options hash as part of the request. Oops.  
+  - Removed some debug puts
+  - Premiered the RWikiBot logo. Not in the source, but it exists now.
+  
+1.0.4
+  - Changed config.yaml to sample-config.yaml
+  - Had rake include the sample-config.yaml file
+  - Fixed broken cookie code to ask for wikicookieprefix, which is usually dbname+tableprefix
+
+1.0.3
+  - Bugfix in config file
+
+1.0.2
+  - Changed initialize to ask for a configuration to use, defaulting to 'default'
+  - Modified config.yaml to prompt for wikidbprefix, which is the cookie identifier.  
+  - PATCH: Changed bake to search use wikidbprefix in cookie name.  
+
+1.0.1
+  - Added very basic error handing around the MAKE_REQUEST method since MediaWiki returns invalid YAML  
+  - Fixed login method to accept domain value
+  - Check for domain being present and set in config.yaml
+  - Added redirect? method to return true/false if title is a redirect page
+  - Changed from "framework" to "library"
+
+1.0.0 - Initial Version

data/README.textile

@@ -0,0 +1,31 @@
+h1=(). This is "RWikiBot":rwb 2.0
+
+h2. Welcome.
+
+Thanks for checking out RWikiBot. For me, this is heavily a labor of love, so I hope you find it as useful as I do. And, if you find new or useful patches or requests, please send them my way! For the most update-to-date information on "RWikiBot":rwb check out the "site":rwb.
+
+h2. Installation
+
+Want it? Come get it! RWikiBot is available as a gem from RubyForge or Github. 
+
+For the RubyForge gem, just type @gem install rwikibot@.
+
+For the Github gem (which is probably more recent), then do this: 
+# @gem sources -a http://gems.github.com@ (you only have to do this once)
+# @sudo gem install pangdudu-rwikibot@
+
+h2. What's New? (highlights - see CHANGELOG for more)
+
+  * 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
+
+h2. The Boring Stuff. 
+
+Author: Eddie Roger ("eddieroger@gmail.com":mailto:eddieroger@gmail.com)  "eddieroger.com":http://www.eddieroger.com <br/>
+Copyright: Copyright (c) 2009 Eddie Roger <br/>
+License: GNU/GPL 2.0
+
+[rwb]http://www.rwikibot.net

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+
+Gem::manage_gems
+
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+PKG_NAME           = 'rwikibot'
+PKG_VERSION        = '2.0.0'
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'rwikibot'
+RUBY_FORGE_USER    = 'eddieroger'
+
+spec = Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.name = PKG_NAME
+	s.version = PKG_VERSION
+	s.author = "Eddie Roger"
+	s.email = "eddieroger @nospam@ gmail.com"
+	s.summary = "A library for creating MediaWiki bots."
+	s.homepage = "http://www.rwikibot.net"
+	s.rubyforge_project = 'RWikiBot'
+	s.files = FileList['lib/*.rb', 'test/*'].to_a
+	s.require_path = "lib"
+  s.test_files = Dir.glob('tests/*.rb')
+	s.has_rdoc = 'true'
+	s.rdoc_options = ['--inline-source --force-update']
+	s.extra_rdoc_files = ["README", "CHANGELOG"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+	pkg.need_tar = true
+end
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "#{PKG_NAME} -- the best way to create MediaWiki bots in Ruby"
+  rdoc.options << "--inline-source"
+  rdoc.rdoc_files.include('README', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => "pkg/#{spec.name}-#{spec.version}.gem" do
+	puts "generated latest version"
+end

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,216 @@
+## 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, :missing
+
+    # Creates a new Page object.
+    def initialize(bot, title='')
+      @bot = bot
+      #puts @bot.config
+      
+      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
+    
+    # I used to have an exists method (page_exists), but I got rid of it in 2.0, but I'm bringing it back. 
+    def exists?
+      if @missing
+        return false
+      else
+        return true
+      end
+    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'}
+
+      post_me.merge!(options) if options
+
+      revisions_result = @bot.make_request('query', post_me )
+      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
+      }
+
+      @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)
+
+      post_me = {'list' => 'backlinks', 'titles' => "#{title}" }
+
+      post_me.merge!(options) if options
+
+      backlinks_result = make_request('query', post_me)
+
+      backlinks_result.success? ?
+        backlinks_result.get_result.fetch('backlinks') :
+        backlinks_result.get_message
+    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 }
+
+      post_me.merge!(options) if options
+
+      embeddedin_result = @bot.make_request('query', post_me)
+      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)
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,9)
+      
+      post_me = {"prop" => "info", 'titles' => titles}
+      info_result = @bot.make_request('query', post_me)
+      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)
+      post_me['movetalk']   = '' if movetalk
+      post_me['noredirect'] = '' if noredirect
+
+      @bot.make_request('move', post_me)
+    end # move
+    
+    # This method is used to protect (and unprotect!) pages. See the API for 
+    # possible values. By default, it will lock a page to require sysop level 
+    # privledge and never expire. 
+    def protect(protections='edit=sysop', expiry='infinite', reason='', cascade=true)
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,12)
+      raise RWBErrors::NotLoggedInError unless @bot.logged_in?
+
+      post_me = {
+        'title'         => @title ,
+        'token'         => get_token('protect') ,
+        'protections'   => protections ,
+        'expiry'        => expiry ,
+        'reason'        => reason ,
+      }
+      
+      post_me['cascade'] = '' if cascade
+      @bot.make_request('protect', post_me)
+    end # protect
+
+    # 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)
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,12)
+      raise RWBErrors::NotLoggedInError unless @bot.logged_in?
+
+      temp_token = get_token("rollback") # special for rollback. Stupid rollback.
+      post_me = {
+        'title'     => @title,
+        'token'     => temp_token['token'],
+        'user'      => temp_token['user'],
+        'summary'   => summary
+      }
+
+      post_me['markbot'] = '' if markbots
+      @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)
+      raise RWBErrors::VersionTooLowError unless @bot.meets_version_requirement(1,13)
+      raise RWBErrors::NotLoggedInError unless @bot.logged_in?
+
+      post_me = {
+        'text'     => "#{content}" ,
+        'token'    => get_token("edit") ,
+        'title'    => @title ,
+        'summary'  => "#{summary}" ,
+        'edittime' => Time.now.strftime("%Y%m%d%H%M%S") ,
+      }
+
+      post_me.merge!(options) if options
+
+      @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')
+        {'token' => token2.fetch('rollbacktoken') , 'user' => token2.fetch('user')}
+      else
+        raw_token.fetch('pages').fetch('page').fetch("#{intoken}token")
+      end
+    end
+  end
+end

data/lib/rwikibot.rb

@@ -0,0 +1,171 @@
+# 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. #
+#
+# 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 'cgi'
+
+# 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_reader :config
+
+  def initialize(username='rwikibot', password='', api_path='http://www.rwikibot.net/wiki/api.php', domain='', login=false)
+    @config = Hash.new
+
+    @config = {
+     'username'  => username,
+     'password'  => password,
+     'api_path'  => api_path,
+     'domain'    => domain,
+     'cookies'   => "",
+     'logged_in' => false,
+     'uri'       => URI.parse(api_path)
+    }
+
+    @config['api_version'] = version.to_f
+
+    if login
+      login
+    end
+  end
+
+  # 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
+    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
+
+    login_result = make_request('login', post_me)
+
+    # 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['result'] == "Success"
+      # All lg variables are directly from API and stored in config that way
+      @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')
+
+      true
+    else
+      # puts "Error logging in. Error was: "
+      raise LoginError, "#{login_result['result']}: #{login_result['details']}"
+    end
+  end
+
+  # 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='')
+    Page.new(self, title)
+  end
+
+  # 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'.
+  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.
+    post_me = {'list' => 'allpages', 'apnamespace' => '0', 'aplimit' => '5000'}
+    post_me.merge!(options) if options
+    allpages_result = make_request('query', post_me)
+    allpages_result.fetch('allpages')['p']
+  end
+
+  # 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?
+    post_me = {'list'=>'watchlist'}
+    post_me.merge!(options) if options
+    make_request('query', post_me).fetch('watchlist').fetch('item')
+  end
+
+  # 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'}
+    post_me.merge!(options) if options
+    make_request('query' , post_me).fetch('recentchanges').fetch('rc')
+  end
+
+  # 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"}
+    post_me.merge!(options) if options
+    make_request('query', post_me).fetch('logevents').fetch('item')
+  end
+
+  # 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')
+    #raise VersionTooLowError unless meets_version_requirement(1,9)
+    post_me = {"meta" => "siteinfo" , "siprop" => siprop}
+    siteinfo_result = make_request('query', post_me)
+    siprop == 'general' ?
+      siteinfo_result.fetch('general') :
+      siteinfo_result.fetch('namespaces').fetch('ns')
+  end
+
+  # Get information about the current user
+  def user_info(uiprop=nil)
+    raise VersionTooLowError unless meets_version_requirement(1,11)
+    post_me = {"meta" => "userinfo" }
+    post_me['uiprop'] =  uiprop unless uiprop.nil?
+
+    make_request('query',post_me).fetch('userinfo')
+  end
+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
+    out = out.chop
+    out += "}"
+  end
+end

data/lib/utilities.rb

@@ -0,0 +1,119 @@
+module RWBUtilities
+
+
+  def meets_version_requirement(maj, min)
+    major, minor = @config['api_version'].to_s.split('.')
+#    puts "#{major} > #{maj}"
+    if ( major.to_i > maj.to_i ) || ( (major.to_i == maj.to_i) && (minor.to_i >= min.to_i) )
+      return true
+    else 
+      return false
+    end
+  end # meets_version_requirement
+
+  # 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)
+    (result['result'] == "Success") && result.has_key?("redirects")
+  end
+
+  # A quick (and public) method of checking whether or not we're logged in, since I don't want @config exposed
+  def logged_in?
+    @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
+
+    array.reverse.each do |current_item|
+      test_array.each do |test_item|
+        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
+
+    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
+    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)
+    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
+
+    r
+  end
+
+  # 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 })
+
+    if return_result.has_key?('error')
+      raise RWikiBotError, "#{return_result.fetch('error').fetch('code').capitalize}: #{return_result.fetch('error').fetch('info')}"
+    end
+
+    if !post_this.keys.any?{|k| k.include?('limit')} && 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_result, post_this]
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: pangdudu-rwikibot
+version: !ruby/object:Gem::Version 
+  version: 2.0.6.1
+platform: ruby
+authors: 
+- Eddie Roger
+- pangdudu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: deep_merge
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: A Ruby framework for creating MediaWiki robots.
+email: pangdudu@github
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- CHANGELOG
+- README.textile
+- Rakefile
+- lib/rwikibot.rb
+- lib/pages.rb
+- lib/errors.rb
+- lib/utilities.rb
+has_rdoc: true
+homepage: http://rwikibot.net/wiki
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- --inline-source
+- --force-update
+- README.textile
+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: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Creates an abstraction layer between MediaWiki API and Ruby.
+test_files: []
+