mediawiki-butt 0.9.0 → 0.10.0

data/lib/mediawiki/query/lists/backlinks.rb

@@ -0,0 +1,145 @@
+module MediaWiki
+  module Query
+    module Lists
+      module Backlinks
+        # Gets an array of backlinks to a given title, like
+        #   Special:WhatLinksHere.
+        # @param title [String] The page to get the backlinks of.
+        # @param limit [Int] The maximum number of pages to get. Defaults to
+        #   500, and cannot be greater than that unless the user is a bot. If
+        #   the user is a bot, the limit cannot be greater than 5000.
+        # @see https://www.mediawiki.org/wiki/API:Backlinks MediaWiki Backlinks
+        #   API Docs
+        # @since 0.1.0
+        # @return [Array<String>] All backlinks until the limit
+        def what_links_here(title, limit = 500)
+          params = {
+            action: 'query',
+            list: 'backlinks',
+            bltitle: title,
+            bllimit: get_limited(limit)
+          }
+
+          ret = []
+          response = post(params)
+          response['query']['backlinks'].each { |bl| ret << bl['title'] }
+
+          ret
+        end
+
+        # Gets interwiki backlinks by the prefix and title.
+        # @param prefix [String] The wiki prefix, e.g., "mcw".
+        # @param title [String] The title of the page on that wiki.
+        # @param limit [Int] See #what_links_here.
+        # @see https://www.mediawiki.org/wiki/API:Iwbacklinks MediaWiki
+        #   Iwbacklinks API Docs
+        # @since 0.10.0
+        # @return [Array<String>] All interwiki backlinking page titles.
+        def get_interwiki_backlinks(prefix = nil, title = nil, limit = 500)
+          params = {
+            action: 'query',
+            list: 'iwbacklinks',
+            iwbllimit: get_limited(limit)
+          }
+          params[:iwblprefix] = prefix unless prefix.nil?
+          params[:iwbltitle] = title unless title.nil?
+
+          ret = []
+          response = post(params)
+          response['query']['iwbacklinks'].each { |bl| ret << bl['title'] }
+
+          ret
+        end
+
+        # Gets language backlinks by the language and title.
+        # @param language [String] The language code
+        # @param title [String] The page title.
+        # @param limit [Int] See {#what_links_here}
+        # @see https://www.mediawiki.org/wiki/API:Langlinks MediaWiki Langlinks
+        #   API Docs
+        # @since 0.10.0
+        # @return [Array<String>] All pages that link to the language links.
+        def get_language_backlinks(language = nil, title = nil, limit = 500)
+          language.downcase! if language.match(/[^A-Z]*/)[0].size == 0
+          params = {
+            action: 'query',
+            list: 'langbacklinks',
+            lbltitle: get_limited(limit)
+          }
+          params[:lbllang] = language unless language.nil?
+          params[:lbltitle] = title unless title.nil?
+
+          ret = []
+          response = post(params)
+          response['query']['langbacklinks'].each { |bl| ret << bl['title'] }
+
+          ret
+        end
+
+        # Gets image backlinks, or the pages that use a given image.
+        # @param title [String] The image.
+        # @param list_redirects [Nil/Boolean] Set to nil to list redirects and
+        #   non-redirects. Set to true to only list redirects. Set to false to
+        #   only list non-redirects.
+        # @param thru_redirect [Boolean] Whether to list pages that link to a
+        #   redirect of the image.
+        # @param limit [Int] See {#what_links_here}
+        # @see https://www.mediawiki.org/wiki/API:Imageusage MediaWiki
+        #   Imageusage API Docs
+        # @since 0.10.0
+        # @return [Array<String>] All page titles that fit the requirements.
+        def get_image_backlinks(title, list_redirects = nil, thru_redir = false,
+                                limit = 500)
+          params = {
+            action: 'query',
+            list: 'imageusage',
+            iutitle: title,
+            iulimit: get_limited(limit)
+          }
+
+          params[:iufilterredir] = list_redirects.nil? ? 'all' : list_redirects
+          params[:iuredirect] = '1' if thru_redir
+
+          response = post(params)
+          ret = []
+          response['query']['imageusage'].each { |bl| ret << bl['title'] }
+
+          ret
+        end
+
+        # Gets all external link page titles.
+        # @param url [String] The URL to get backlinks for.
+        # @param limit [Int] See {#what_links_here}
+        # @see https://www.mediawiki.org/wiki/API:Exturlusage MediaWiki
+        #   Exturlusage API Docs
+        # @since 0.10.0
+        # @return [Array<String>] All pages that link to the given URL.
+        # @return [Array<Hash>] All pages that link to any external links.
+        def get_url_backlinks(url = nil, limit = 500)
+          params = {
+            action: 'query',
+            list: 'exturlusage',
+            eulimit: get_limited(limit)
+          }
+          params[:euquery] = url unless url.nil?
+
+          response = post(params)
+          ret = []
+          response['query']['exturlusage'].each do |bl|
+            if url.nil?
+              hash = {
+                url: bl['url'],
+                title: bl['title']
+              }
+              ret << hash
+            else
+              ret << bl['title']
+            end
+          end
+
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki/query/lists/categories.rb

@@ -0,0 +1,65 @@
+module MediaWiki
+  module Query
+    module Lists
+      module Categories
+        # Returns an array of all page titles that belong to a given category.
+        #   By default, it will only get the pages. Files and subcategories can
+        #   be gotten through {#get_subcategories} and {#get_files_in_category}
+        #   or setting the type parameter.
+        # @param category [String] The category title. It can include
+        #   "Category:", or not, it doesn't really matter because we will add it
+        #   if it is missing.
+        # @param limit [Int] The maximum number of members to get. Defaults to
+        #   500, and cannot be greater than that unless the user is a bot.
+        #   If the user is a bot, the limit cannot be greater than 5000.
+        # @param type [String] The type of stuff to get. There are 3 valid
+        #   values: page, file, and subcat. Separate these with a pipe
+        #   character, e.g., 'page|file|subcat'.
+        # @see https://www.mediawiki.org/wiki/API:Categorymembers MediaWiki
+        #   Category Members API Docs
+        # @since 0.1.0
+        # @return [Array] All category members until the limit
+        def get_category_members(category, limit = 500, type = 'page')
+          params = {
+            action: 'query',
+            list: 'categorymembers',
+            cmprop: 'title',
+            cmlimit: get_limited(limit),
+            cmtype: type
+          }
+
+          if category =~ /[Cc]ategory\:/
+            params[:cmtitle] = category
+          else
+            params[:cmtitle] = "Category:#{category}"
+          end
+          ret = []
+          response = post(params)
+          response['query']['categorymembers'].each { |cm| ret << cm['title'] }
+
+          ret
+        end
+
+        # Gets the subcategories of a given category.
+        # @param category [String] See {#get_category_members}
+        # @param limit [Int] See {#get_category_members}
+        # @see {#get_category_members}
+        # @since 0.9.0
+        # @return [Array<String>] All subcategories.
+        def get_subcategories(category, limit = 500)
+          get_category_members(category, limit, 'subcat')
+        end
+
+        # Gets all of the files in a given category.
+        # @param category [String] See {#get_category_members}
+        # @param limit [Int] See {#get_category_members}
+        # @see {#get_category_members}
+        # @since 0.9.0
+        # @return [Array<String>] All files in the category.
+        def get_files_in_category(category, limit = 500)
+          get_category_members(category, limit, 'file')
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki/query/lists/lists.rb

@@ -0,0 +1,25 @@
+require_relative '../../constants'
+require_relative '../query'
+require_relative 'backlinks'
+require_relative 'categories'
+require_relative 'all'
+require_relative 'search'
+require_relative 'miscellaneous'
+require_relative 'log/log'
+require_relative 'recent_changes'
+require_relative 'querypage'
+
+module MediaWiki
+  module Query
+    module Lists
+      include MediaWiki::Query::Lists::Backlinks
+      include MediaWiki::Query::Lists::Categories
+      include MediaWiki::Query::Lists::All
+      include MediaWiki::Query::Lists::Search
+      include MediaWiki::Query::Lists::Miscellaneous
+      include MediaWiki::Query::Lists::Log
+      include MediaWiki::Query::Lists::RecentChanges
+      include MediaWiki::Query::Lists::QueryPage
+    end
+  end
+end

data/lib/mediawiki/query/lists/log/block.rb

@@ -0,0 +1,83 @@
+require_relative '../../../constants'
+
+module MediaWiki
+  module Query
+    module Lists
+      module Log
+        module Block
+          # Gets block/block logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   blocked, flags, duration, expiry, blocker, comment, timestamp.
+          def get_block_log(user = nil, title = nil, start = nil, stop = nil,
+                            limit = 500)
+            response = get_log('block/block', user, title, start, stop, limit)
+
+            ret = []
+            response['query']['logevents'].each do |log|
+              ret << get_blockblock(log)
+            end
+
+            ret
+          end
+
+          # Gets block/reblock logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   blocked, flags, duration, expiry, blocker, comment, timestamp.
+          def get_reblock_log(user = nil, title = nil, start = nil, stop = nil,
+                               limit = 500)
+            response = get_log('block/reblock', user, title, start, stop, limit)
+
+            ret = []
+            response['query']['logevents'].each do |log|
+              ret << get_blockreblock(log)
+            end
+
+            ret
+          end
+
+          # Gets block/unblock logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   blocked, blocker, comment, timestamp.
+          def get_unblock_log(user = nil, title = nil, start = nil, stop = nil,
+                               limit = 500)
+            response = get_log('block/unblock', user, title, start, stop, limit)
+
+            ret = []
+            response['query']['logevents'].each do |log|
+              ret << get_blockunblock(log)
+            end
+
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki/query/lists/log/delete.rb

@@ -0,0 +1,59 @@
+module MediaWiki
+  module Query
+    module Lists
+      module Log
+        # @todo delete/event
+        # @todo delete/revision
+        module Delete
+          # Gets delete/delete logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   title, user, comment, timestamp.
+          def get_delete_log(user = nil, title = nil, start = nil, stop = nil,
+                             limit = 500)
+            response = get_log('delete/delete', user, title, start, stop, limit)
+
+            ret = []
+            response['query']['logevents'].each do |log|
+              ret << get_general(log)
+            end
+
+            ret
+          end
+
+          # Gets delete/restore logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   title, user, comment, timestamp.
+          def get_deletion_restore_log(user = nil, title = nil, start = nil,
+                                       stop = nil, limit = 500)
+            resp = get_log('delete/restore', user, title, start, stop, limit)
+
+            ret = []
+            resp['query']['logevents'].each do |log|
+              ret << get_general(log)
+            end
+
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki/query/lists/log/import.rb

@@ -0,0 +1,57 @@
+module MediaWiki
+  module Query
+    module Lists
+      module Log
+        module Import
+          # Gets import/interwiki logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   title, user, comment, timestamp, count, interwiki_title.
+          def get_interwiki_import_log(user = nil, title = nil, start = nil,
+                                       stop = nil, limit = 500)
+            resp = get_log('import/interwiki', user, title, start, stop, limit)
+
+            ret = []
+            resp['query']['logevents'].each do |log|
+              ret << get_importinterwiki(log)
+            end
+
+            ret
+          end
+
+          # Gets import/upload logs.
+          # @param user [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param title [String] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param start [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param stop [DateTime] See {MediaWiki::Query::Lists::Log#get_log}
+          # @param limit [Int] See {MediaWiki::Query::Lists::Log#get_log}
+          # @see {MediaWiki::Query::Lists::Log#get_log}
+          # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki
+          #   Logevents API Docs
+          # @since 0.10.0
+          # @return [Array<Hash>] The events, containing the following keys: id,
+          #   title, user, timestamp, comment.
+          def get_upload_import_log(user = nil, title = nil, start = nil,
+                                    stop = nil, limit = 500)
+            resp = get_log('import/upload', user, title, start, stop, limit)
+
+            ret = []
+            resp['query']['logevents'].each do |log|
+              ret << get_importupload(log)
+            end
+
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki/query/lists/log/log.rb

@@ -0,0 +1,372 @@
+require_relative '../../../constants'
+require_relative 'block'
+require_relative 'delete'
+require_relative 'import'
+require_relative 'merge'
+require_relative 'move'
+require_relative 'newusers'
+require_relative 'patrol'
+require_relative 'protect'
+require_relative 'rights'
+require_relative 'upload'
+
+module MediaWiki
+  module Query
+    module Lists
+      module Log
+        include MediaWiki::Query::Lists::Log::Block
+        include MediaWiki::Query::Lists::Log::Delete
+        include MediaWiki::Query::Lists::Log::Import
+        include MediaWiki::Query::Lists::Log::Merge
+        include MediaWiki::Query::Lists::Log::Move
+        include MediaWiki::Query::Lists::Log::NewUsers
+        include MediaWiki::Query::Lists::Log::Patrol
+        include MediaWiki::Query::Lists::Log::Protect
+        include MediaWiki::Query::Lists::Log::Rights
+        include MediaWiki::Query::Lists::Log::Upload
+
+        # Gets the general log as seen in Special:Log. Since not every single
+        #   log type possible can be supported, non-default MW logs will be
+        #   represented exactly as provided by the API, with the :skipped key
+        #   as true.
+        # @param user [String] See {#get_log}
+        # @param title [String] See {#get_log}
+        # @param start [DateTime] See {#get_log}
+        # @param stop [DateTime] See {#get_log}
+        # @param limit [Int] See {#get_log}
+        # @see {#get_log}
+        # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki Logevents
+        #   API Docs
+        # @since 0.10.0
+        # @return [Array<Hash>] All the log events.
+        def get_overall_log(user = nil, title = nil, start = nil, stop = nil,
+                            limit = 500)
+          time_format = MediaWiki::Constants::TIME_FORMAT
+          params = {
+            action: 'query',
+            list: 'logevents',
+            lelimit: get_limited(limit)
+          }
+          params[:leuser] = user unless user.nil?
+          params[:letitle] = title unless title.nil?
+          params[:lestart] = start.strftime(time_format) unless start.nil?
+          params[:leend] = stop.strftime(time_format) unless stop.nil?
+          response = post(params)
+
+          ret = []
+          response['query']['logevents'].each do |log|
+            case log['type']
+            when 'block'
+              case log['action']
+              when 'block'
+                hash = get_blockblock(log)
+              when 'unblock'
+                hash = get_blockunblock(log)
+              when 'reblock'
+                hash = get_blockreblock(log)
+              end
+            when 'delete'
+              case log['action']
+              when 'delete', 'restore'
+                hash = get_deletedelete(log)
+              end
+            when 'import'
+              case log['action']
+              when 'interwiki'
+                hash = get_importinterwiki(log)
+              when 'upload'
+                hash = get_importupload(log)
+              end
+            when 'merge'
+              case log['action']
+              when 'merge'
+                hash = get_mergemerge(log)
+              end
+            when 'move'
+              case log['action']
+              when 'move', 'move_redir'
+                hash = get_move(log)
+              end
+            when 'newusers'
+              case log['action']
+              when 'autocreate', 'create', 'create2'
+                hash = get_user(log)
+              end
+            when 'patrol'
+              case log['action']
+              when 'patrol'
+                hash = get_patrol(log)
+              end
+            when 'protect'
+              case log['action']
+              when 'modify', 'protect'
+                hash = get_protect(log)
+              when 'move_prot'
+                hash = get_protectmoveprot(log)
+              when 'unprotect'
+                hash = get_protectunprotect(log)
+              end
+            when 'rights'
+              case log['action']
+              when 'autopromote'
+                hash = get_rightsautopromote(log)
+              when 'rights'
+                hash = get_rightsrights(log)
+              end
+            when 'upload'
+              case log['action']
+              when 'overwrite', 'upload'
+                hash = get_upload(log)
+              end
+            end
+
+            hash = log if hash.nil?
+
+            type = "#{log['type']}/#{log['action']}"
+
+            hash[:type] = type
+            hash[:skipped] = false unless hash.key(:skipped)
+
+            ret << hash
+          end
+
+          ret
+        end
+
+        private
+
+        # Gets log events.
+        # @param action [String] The action, e.g., block/block.
+        # @param user [String] The user to filter by.
+        # @param title [String] The title to filter by.
+        # @param start [DateTime] Where to start the log events at.
+        # @param stop [DateTime] Where to end the log events.
+        # @param limit [Int] The limit, maximum 500 for users or 5000 for bots.
+        # @see https://www.mediawiki.org/wiki/API:Logevents MediaWiki Logevents
+        #   API Docs
+        # @since 0.10.0
+        # @return [JSON] The response json.
+        def get_log(action, user = nil, title = nil, start = nil, stop = nil,
+                    limit = 500)
+          params = {
+            action: 'query',
+            list: 'logevents',
+            leaction: action,
+            lelimit: get_limited(limit)
+          }
+          params[:leuser] = user unless user.nil?
+          params[:letitle] = title unless title.nil?
+          params[:lestart] = start.strftime(MediaWiki::Constants::TIME_FORMAT) unless start.nil?
+          params[:leend] = stop.strftime(MediaWiki::Constants::TIME_FORMAT) unless stop.nil?
+          post(params)
+        end
+
+        def get_block(log)
+          {
+            id: log['logid'],
+            blocked: log['title'],
+            flags: log['block']['flags'],
+            duration: log['block']['duration'],
+            expiry: DateTime.strptime(log['block']['expiry'],
+                                      MediaWiki::Constants::TIME_FORMAT),
+            blocker: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_unblock(log)
+          {
+            id: log['logid'],
+            blocked: log['title'],
+            blocker: log['user'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT),
+            comment: log['comment']
+          }
+        end
+
+        def get_importinterwiki(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT),
+            count: log['params']['count'],
+            interwiki_title: log['params']['interwiki_title']
+          }
+        end
+
+        def get_general(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT),
+            comment: log['comment']
+          }
+        end
+
+        def get_merge(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            comment: log['comment'],
+            destination_title: log['params']['dest_title'],
+            mergepoint: DateTime.strptime(log['params']['mergepoint'],
+                                          MediaWiki::Constants::TIME_FORMAT),
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_move(log)
+          hash = {
+            id: log['logid'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+
+          if log.key?('actionhidden')
+            hash[:hidden] = true
+            hash[:title] = nil
+            hash[:comment] = nil
+            hash[:suppressedredirect] = log.key('suppressed')
+          else
+            hash[:title] = log['title']
+            hash[:new_title] = log['move']['new_title']
+            hash[:user] = log['user']
+            hash[:comment] = log['comment']
+
+            hash[:suppressedredirect] = log['move'].key?('suppressedredirect')
+          end
+
+          hash
+        end
+
+        def get_user(log)
+          {
+            id: log['logid'],
+            new_user: log['title'],
+            user: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_patrol(log)
+          hash = {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            comment: log['comment'],
+            current_revision: log['patrol']['cur'],
+            previous_revision: log['patrol']['prev'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+          auto = log['patrol']['auto']
+          hash[:automatic] = auto == 1
+
+          hash
+        end
+
+        def get_protect(log)
+          time_format = MediaWiki::Constants::TIME_FORMAT
+          hash = {
+            id: log['logid'],
+            title: log['title'],
+            description: log['params']['description'],
+            user: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'], time_format)
+          }
+
+          hash[:details] = []
+
+          log['params']['detail'].each do |detail|
+            details_hash = {
+              type: detail['type'],
+              level: detail['level']
+            }
+            expire = detail['expiry']
+            if expire != 'infinite'
+              details_hash[:expiry] = DateTime.strptime(expire, time_format)
+            end
+            hash[:details] << detail_hash
+          end
+
+          hash
+        end
+
+        def get_protectmoveprot(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            old_title: log['params']['oldtitle_title'],
+            user: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_protectunprotect(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_rightsautopromote(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            new_rights: log['rights']['new'].split(', '),
+            old_rights: log['rights']['old'].split(', '),
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_rightsrights(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            to: log['title'],
+            from: log['user'],
+            new_rights: log['rights']['new'].split(', '),
+            old_rights: log['rights']['old'].split(', '),
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+
+        def get_upload(log)
+          {
+            id: log['logid'],
+            title: log['title'],
+            user: log['user'],
+            sha: log['img_sha1'],
+            comment: log['comment'],
+            timestamp: DateTime.strptime(log['timestamp'],
+                                         MediaWiki::Constants::TIME_FORMAT)
+          }
+        end
+      end
+    end
+  end
+end