mediawiki-gateway 0.6.2 → 1.0.0.rc1

data/samples/get_page.rb

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Sample script for fetching a page's current contents in Wiki markup
-#
-require './lib/media_wiki'
-
-config = MediaWiki::Config.new ARGV 
-config.abort("Name of article is mandatory.") unless config.article
-
-mw = MediaWiki::Gateway.new(config.url, { :loglevel => Logger::DEBUG } )
-puts mw.get(config.article)

data/samples/import_xml.rb

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Import a MediaWiki XML dump 
-#
-require './lib/media_wiki'
-
-if ARGV.length < 3
-  raise "Syntax: import_xml.rb <host> <username> <password> <file>"
-end
-
-mw = MediaWiki::Gateway.new(ARGV[0], Logger::DEBUG)
-mw.login(ARGV[1], ARGV[2])
-mw.import(ARGV[3])
-

data/samples/run_fake_media_wiki.rb

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-# Helper script for running a live FakeMediaWiki instance instead of just shamracking it.
-require 'rubygems'
-require 'sinatra/base'
-require 'spec/fake_media_wiki/app'
-
-FakeMediaWiki::App.run! :host => 'localhost', :port => 9090
-

data/samples/search_content.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Sample script for searching page contents in a Wiki
-#
-require './lib/media_wiki'
-
-config = MediaWiki::Config.new ARGV 
-config.abort("Please specify search key as article name (-a)") unless config.article
-
-mw = MediaWiki::Gateway.new(config.url, { :loglevel => Logger::DEBUG } )
-mw.login(config.user, config.pw)
-puts mw.search(config.article, nil, 50)

data/samples/semantic_query.rb

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Sample script for querying Semantic MediaWiki data
-#
-
-require './lib/media_wiki'
-
-mw = MediaWiki::Gateway.new(ARGV[0])
-
-params = []
-i = 2
-until i == ARGV.length
-	params << ARGV[i]
-	i += 1
-end
-
-puts mw.semantic_query(ARGV[1], params)

data/samples/upload_commons.rb

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Sample script for uploading files to Mediawiki Commons (interactive)
-
-require './lib/media_wiki'
-
-config = MediaWiki::Config.new(ARGV, "upload")
-file = ARGV[0]
-config.abort("Name of file to upload is mandatory.") unless file
-
-mw = MediaWiki::Gateway.new(config.url)
-mw.login(config.user, config.pw)
-
-puts "Login successful."
-puts "Description of file:"
-desc = STDIN.gets.chomp
-puts "Date of file:"
-date = STDIN.gets.chomp
-puts "Target filename: (leave blank to use existing name)"
-target = STDIN.gets.chomp
-target = config.target if target.empty? 
-puts "Categories, separated by commas:"
-cats = STDIN.gets.chomp.split(",")
-cats = "[[Category:" + cats.join("]]\n[[Category:") + "]]" unless cats.empty?
-
-template = <<-TEMPLATE
-== Summary ==
-{{Information
-|Description={{en|1=%DESC%}}
-|Source={{own}}
-|Author=[[User:%USER%|%USER%]]
-|Date=%DATE%
-|Permission=
-|other_versions=
-}}
-
-== Licensing ==
-{{self|cc-by-sa-3.0|GFDL}}
-
-%CATS%
-TEMPLATE
-desc = template.gsub('%USER%', config.user).gsub('%DESC%', desc).gsub('%DATE%', date).gsub('%CATS%', cats)
-puts "Uploading #{file} to #{target}..."
-mw.upload(file, {:target => target, :description => desc, :summary => "Uploaded by MediaWiki::Gateway"})
-puts "Done."

data/samples/upload_file.rb

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Sample script for fetching a page's current contents in Wiki markup
-#
-require './lib/media_wiki'
-
-config = MediaWiki::Config.new(ARGV, "upload")
-config.abort("Name of file to upload is mandatory.") unless ARGV[0]
-
-mw = MediaWiki::Gateway.new(config.url, { :loglevel => Logger::DEBUG } )
-mw.login(config.user, config.pw)
-mw.upload(ARGV[0], {:target => config.target, :description => config.desc, :summary => config.summary})
-

data/spec/fake_media_wiki/api_pages.rb

@@ -1,135 +0,0 @@
-module FakeMediaWiki
-
-  class ApiPages
-
-    def initialize
-      @page_id = 0
-      @pages = {}
-      @namespaces = { "" => 0 }
-    end
-    
-    def add_namespace(id, prefix)
-      @namespaces[prefix] = id
-    end
-
-    def namespaces_by_prefix
-      @namespaces
-    end
-
-    def namespaces_by_id
-      @namespaces.invert
-    end
-  
-    def add(title, content, redirect=false)
-      @page_id += 1
-      dummy, prefix = title.split(":", 2).reverse
-      @pages[title] = {
-        :pageid => @page_id,
-        :namespace => namespaces_by_prefix[prefix || ""],
-        :title => title,
-        :content => content,
-        :redirect => redirect
-      }
-    end
-    
-    def get(title)
-      @pages[title]
-    end
-    
-    def list(prefix) 
-      @pages.select do |key, page|
-        key =~ /^#{prefix}/
-      end
-    end
-
-    def search(searchkey, namespaces)
-      raise FakeMediaWiki::ApiError.new("srparam-search", "empty search string is not allowed") if searchkey.empty?
-      @pages.select do |key, page|
-        page[:content] =~ /#{searchkey}/ and namespaces.include? page[:namespace].to_s
-      end
-    end
-    
-    def delete(title)
-      @pages.delete(title)
-    end
-
-    def undelete(title)
-      if @pages[title]
-        0
-      else
-        add(title, "Undeleted content")
-        1
-      end
-    end
-  end
-
-  class ApiToken
-    ADMIN_TOKEN   = "admin_token+\\"   unless const_defined?(:ADMIN_TOKEN)
-    REGULAR_TOKEN = "regular_token+\\" unless const_defined?(:REGULAR_TOKEN)
-    BLANK_TOKEN   = "+\\"              unless const_defined?(:BLANK_TOKEN)
-
-    def initialize(params)
-      @token_str = params[:token]
-      @token_in = params[:intoken]
-    end
-    
-    def set_type(type)
-      @token_in = type
-    end
-    
-    def validate
-      unless @token_str
-        raise FakeMediaWiki::ApiError.new("notoken", "The token parameter must be set")
-      end
-    end
-
-    def validate_admin
-      validate
-      if @token_str != ADMIN_TOKEN
-        raise FakeMediaWiki::ApiError.new("badtoken", "Invalid token")
-      end
-    end
-    
-    def request(user)
-      @user = user
-      respond_to?(requested_token_type) ? send(requested_token_type) : nil
-    end
-       
-    def requested_token_type
-      "#{@token_in}token".to_sym
-    end
-
-    def importtoken
-      if @user && @user[:is_admin]
-        ADMIN_TOKEN
-      else
-        nil
-      end
-    end
-    alias_method :deletetoken, :importtoken
-    alias_method :undeletetoken, :importtoken
-    alias_method :userrightstoken, :importtoken
-    alias_method :createusertoken, :importtoken
-    
-    def edittoken
-      if @user
-        REGULAR_TOKEN
-      else
-        BLANK_TOKEN
-      end
-    end
-    alias_method :optionstoken, :edittoken
-  end
-
-  class ApiError < StandardError
-    
-    attr_reader :code, :message
-
-    def initialize(code, message)
-      @code = code
-      @message = message
-    end
-
-  end
-  
-end

data/spec/fake_media_wiki/app.rb

@@ -1,360 +0,0 @@
-require 'rubygems'
-require 'sinatra/base'
-require_relative 'api_pages'
-require_relative 'query_handling'
-
-# A simple Rack app that stubs out a web service, for testing.
-
-module FakeMediaWiki
-
-  class App < Sinatra::Base
-
-    set :show_exceptions, false
-    set :environment, :development
-
-    def initialize
-      reset
-      super
-    end
-
-    def reset
-      @sequence_id = 0
-
-      @users = {}
-      add_user('atlasmw', 'wombat', 'local', true)
-      add_user('nonadmin', 'sekrit', 'local', false)
-      add_user('ldapuser', 'ldappass', 'ldapdomain', false)
-
-      @pages = ApiPages.new
-      @pages.add('Main Page', 'Content')
-      @pages.add('Main 2', 'Content')
-      @pages.add('Empty', '')
-      @pages.add('Level/Level/Index', '{{#include:Foo}} {{#include:Bar}}')
-      @pages.add_namespace(100, "Book")
-      @pages.add('Book:Italy', 'Introduction')
-      @pages.add_namespace(200, "Sandbox")
-      @pages.add('Foopage', 'Content')
-      @pages.add('Redirect', '#REDIRECT', true)
-
-      @extensions = { 'FooExtension' => 'r1', 'BarExtension' => 'r2', 'Semantic MediaWiki' => '1.5' }
-
-      @logged_in_users = []
-    end
-
-    def next_id
-      @sequence_id += 1
-    end
-
-    def add_user(username, password, domain, is_admin)
-      @users[username] = {
-        :userid => next_id,
-        :username => username,
-        :password => password,
-        :domain => domain,
-        :is_admin => is_admin
-      }
-    end
-
-    def logged_in(username)
-      @logged_in_users.include?(username)
-    end
-
-    get "/w/api.php" do
-      handle_request if params[:action] == 'query'
-    end
-
-    post "/w/api.php" do
-      handle_request
-    end
-
-    def handle_request
-      begin
-        halt(503, "Maxlag exceeded") if params[:maxlag].to_i < 0
-
-        @token = ApiToken.new(params)
-        action = params[:action]
-        if respond_to?(action)
-          content_type "application/xml"
-          return send(action)
-        end
-
-        halt(404, "Page not found")
-      rescue FakeMediaWiki::ApiError => e
-        return api_error_response(e.code, e.message)
-      end
-    end
-
-    def import
-      @token.validate_admin
-
-      api_response do |_|
-        _.import do
-          _.page(nil, :title => "Main Page", :ns => 0, :revisions => 0)
-          _.page(nil, :title => "Template:Header", :ns => 10, :revisions => 1)
-        end
-      end
-    end
-
-    def validate_page_overwrite(current_page)
-      if current_page && params[:createonly]
-        raise FakeMediaWiki::ApiError.new("articleexists", "The article you tried to create has been created already")
-      end
-    end
-
-    def edit
-      @token.validate
-
-      title = params[:title]
-      current_page = @pages.get(title)
-      validate_page_overwrite(current_page)
-
-      new_page = @pages.add(title, params[:text])
-      page_info = {:result => "Success", :pageid => new_page[:pageid], :title => new_page[:title], :newrevid => new_page[:pageid]}
-      if current_page
-        page_info.merge!(:oldrevid => current_page[:pageid])
-      else
-        page_info.merge!(:new => "", :oldrevid => 0)
-      end
-
-      api_response do |_|
-        _.edit(nil, page_info)
-      end
-    end
-
-    def delete
-      @token.validate_admin
-
-      title = params[:title]
-      raise FakeMediaWiki::ApiError.new("missingtitle", "The page you requested doesn't exist") unless @pages.get(title)
-      @pages.delete(title)
-
-      api_response do |_|
-        _.delete(nil, {:title => title, :reason => "Default reason"})
-      end
-    end
-
-    def undelete
-      @token.validate_admin
-
-      title = params[:title]
-      revisions = @pages.undelete(title)
-      api_response do |_|
-        _.undelete(nil, {:title => title, :revisions => revisions})
-      end
-    end
-
-    def upload
-      @token.validate
-
-      filename = params[:filename]
-      @pages.add(filename, params[:file])
-      api_response do |_|
-        _.upload(nil, {:filename => filename, :result => "Success"})
-      end
-    end
-
-    def parse
-      page = @pages.get(params[:page])
-      api_response do |_|
-        _.parse({ :revid => page ?  page[:pageid] : 0}) do
-          if params[:page] == "Foopage"
-            _.text('Sample <B>HTML</B> content.' \
-              '<img width="150" height="150" class="thumbimage" src="http://upload.wikimedia.org/foo/Ruby_logo.svg" alt="Ruby logo.svg"/>' \
-              '<span class="editsection">[<a title="Edit section: Nomenclature" href="/w/index.php?title=Seat_of_local_government&amp;action=edit&amp;section=1">edit</a>]</span>' \
-              '<a title="Interpreted language" href="/wiki/Interpreted_language">interpreted language</a>'
-            )
-          else
-            _.text('Sample <B>HTML</B> content.')
-          end
-        end
-      end
-    end
-
-    include QueryHandling
-
-    def api_response(api_attr = {}, &block)
-      builder do |_|
-        if block_given?
-          _.api(api_attr, &block)
-        else
-          _.api(api_attr)
-        end
-      end
-    end
-
-    def api_error_response(code, info)
-      api_response do |_|
-        _.error(nil,
-                :code => code,
-                :info => info)
-      end
-    end
-
-    def query_pages
-      api_response do |_|
-        _.query do
-          _.pages do
-            requested_page_titles.each do |title|
-              yield(_, title, @pages.get(title))
-            end
-          end
-        end
-      end
-    end
-
-    def get_info
-      query_pages do |_, title, page|
-        attributes = { :title => title, :ns => '0'}
-        if page.nil?
-          attributes[:missing] = ""
-        else
-          attributes[:redirect] = "" if page[:redirect]
-        end
-        _.page(nil, attributes)
-      end
-    end
-
-    def get_revisions
-      query_pages do |_, title, page|
-        if page.nil?
-          _.page(nil, { :title => title, :ns => '0', :missing => "" })
-        else
-          page = page.dup
-          content = page.delete(:content)
-          _.page(page.merge({ :ns => 0 })) do
-            _.revisions do
-              _.rev(content)
-            end
-          end
-        end
-      end
-    end
-
-    def user
-      username = request.cookies['login']
-      @users[username] if logged_in(username)
-    end
-
-    def requested_page_titles
-      params[:titles].split("|")
-    end
-
-    def tokens
-      @token.request(user)
-
-      api_response do |_|
-        _.tokens(:optionstoken => @token.optionstoken)
-      end
-    end
-
-    def get_token
-      token_str = @token.request(user)
-      query_pages do |_, title, page|
-        page = page ? page.dup : {}
-        page[params[:intoken] + "token"] = token_str if token_str
-        _.page(nil, page.merge({ :ns => 0 }))
-      end
-    end
-
-    def get_undelete_token
-      @token.set_type 'undelete'
-      token_str = @token.request(user)
-      api_response do |_|
-        _.query do
-          _.deletedrevs do
-            requested_page_titles.select {|title| ! @pages.get(title) }.each do |title|
-              _.page(nil, { :title => title, :token => token_str })
-            end
-          end
-        end
-      end
-    end
-
-    def get_userrights_token(username)
-      @token.set_type 'userrights'
-      token_str = @token.request(user)
-
-      user_to_manage = @users[username]
-
-      if user_to_manage
-        api_response do |_|
-          _.query do
-            _.users do
-              _.user(nil, { :name => user_to_manage[:username], :userrightstoken => token_str })
-            end
-          end
-        end
-      else
-        api_response do |_|
-          _.error(nil, { :code => 'nosuchuser', :info => "The user '#{params[:ususer].to_s}' does not exist"} )
-        end
-      end
-    end
-
-    def login
-      user = @users[params[:lgname]]
-      if user and user[:domain] == params[:lgdomain]
-        if params[:lgpassword] == user[:password]
-          @logged_in_users << user[:username]
-          response.set_cookie('login', user[:username])
-          result = { :result => "Success", :lguserid => "1", :lgusername => "Atlasmw"}
-        else
-          result = { :result => "WrongPass" }
-        end
-      else
-        result = { :result => "NotExists" }
-      end
-
-      api_response do |_|
-        _.login(nil, result)
-      end
-    end
-
-    def createaccount
-      api_response do |_|
-        @token.request(user)
-
-        if params[:token].present?
-          @token.validate_admin
-          add_user(params[:name], params[:password], 'local', false)
-          _.createaccount(:token => @token.createusertoken, :userid => @users.length, :username => params[:name], :result => 'success')
-        else
-          _.createaccount(:token => @token.createusertoken, :result => 'needtoken')
-        end
-      end
-    end
-
-    def options
-      api_response(:options => 'success')
-    end
-
-    def userrights
-      api_response do |_|
-        _.userrights({:user => params[:user]}) do
-          _.removed do
-            params[:remove].split('|').each do |removed_group|
-              _.group(removed_group)
-            end
-          end
-          _.added do
-            params[:add].split('|').each do |added_group|
-              _.group(added_group)
-            end
-          end
-        end
-      end
-    end
-
-  end
-
-  class WikiPage
-
-    def initialize(options={})
-      options.each { |k, v| send("#{k}=", v) }
-    end
-
-    attr_accessor :content, :author
-
-  end
-
-end