Class: MediawikiApi::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/mediawiki_api/client.rb

Overview

high level client for MediaWiki

Constant Summary collapse

FORMAT =
'json'

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(url, log = false) ⇒ Client

Returns a new instance of Client


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# File 'lib/mediawiki_api/client.rb', line 19

def initialize(url, log = false)
  @cookies = HTTP::CookieJar.new

  @conn = Faraday.new(url: url) do |faraday|
    faraday.request :multipart
    faraday.request :url_encoded
    faraday.response :logger if log
    faraday.use :cookie_jar, jar: @cookies
    faraday.use FaradayMiddleware::FollowRedirects
    faraday.adapter Faraday.default_adapter
  end

  @logged_in = false
  @tokens = {}
end

Instance Attribute Details

#cookiesObject (readonly)

Returns the value of attribute cookies


14
15
16
# File 'lib/mediawiki_api/client.rb', line 14

def cookies
  @cookies
end

#logged_inObject Also known as: logged_in?

Returns the value of attribute logged_in


15
16
17
# File 'lib/mediawiki_api/client.rb', line 15

def logged_in
  @logged_in
end

Instance Method Details

#action(name, params = {}) ⇒ Object


35
36
37
38
39
40
41
42
43
44
# File 'lib/mediawiki_api/client.rb', line 35

def action(name, params = {})
  raw_action(name, params)
rescue ApiError => e
  if e.code == 'badtoken'
    @tokens.clear # ensure fresh token on re-try
    raw_action(name, params) # no rescue this time; only re-try once.
  else
    raise # otherwise, propagate the exception
  end
end

#create_account(username, password) ⇒ Object


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# File 'lib/mediawiki_api/client.rb', line 46

def (username, password)
  params = { modules: 'createaccount', token_type: false }
  d = action(:paraminfo, params).data
  params = d['modules'] && d['modules'][0] && d['modules'][0]['parameters']
  if !params || !params.map
    raise CreateAccountError, 'unexpected API response format'
  end
  params = params.map{ |o| o['name'] }

  if params.include? 'requests'
    (username, password)
  else
    (username, password)
  end
end

#create_account_new(username, password) ⇒ Object


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# File 'lib/mediawiki_api/client.rb', line 62

def (username, password)
  # post-AuthManager
  data = action(:query, { meta: 'tokens', type: 'createaccount', token_type: false }).data
  token = data['tokens'] && data['tokens']['createaccounttoken']
  unless token
    raise CreateAccountError, 'failed to get createaccount API token'
  end

  data = action(:createaccount, {
    username: username,
    password: password,
    retype: password,
    createreturnurl: 'http://example.com', # won't be used but must be a valid URL
    createtoken: token,
    token_type: false
  }).data
  raise CreateAccountError, data['message'] if data['status'] != 'PASS'
  data
end

#create_account_old(username, password, token = nil) ⇒ Object


82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
# File 'lib/mediawiki_api/client.rb', line 82

def (username, password, token = nil)
  # pre-AuthManager
  params = { name: username, password: password, token_type: false }
  params[:token] = token unless token.nil?

  data = action(:createaccount, params).data

  case data['result']
  when 'Success'
    @logged_in = true
    @tokens.clear
  when 'NeedToken'
    data = (username, password, data['token'])
  else
    raise CreateAccountError, data['result']
  end

  data
end

#create_page(title, content) ⇒ Object


102
103
104
# File 'lib/mediawiki_api/client.rb', line 102

def create_page(title, content)
  edit(title: title, text: content)
end

#delete_page(title, reason) ⇒ Object


106
107
108
# File 'lib/mediawiki_api/client.rb', line 106

def delete_page(title, reason)
  action(:delete, title: title, reason: reason)
end

#edit(params = {}) ⇒ Object

Raises:


110
111
112
113
114
# File 'lib/mediawiki_api/client.rb', line 110

def edit(params = {})
  response = action(:edit, params)
  raise EditError, response if response.data['result'] == 'Failure'
  response
end

#get_wikitext(title) ⇒ Object


116
117
118
# File 'lib/mediawiki_api/client.rb', line 116

def get_wikitext(title)
  @conn.get '/w/index.php', action: 'raw', title: title
end

#list(type, params = {}) ⇒ Object


120
121
122
# File 'lib/mediawiki_api/client.rb', line 120

def list(type, params = {})
  subquery(:list, type, params)
end

#log_in(username, password, token = nil) ⇒ Object


124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# File 'lib/mediawiki_api/client.rb', line 124

def (username, password, token = nil)
  params = { lgname: username, lgpassword: password, token_type: false }
  params[:lgtoken] = token unless token.nil?

  data = action(:login, params).data

  case data['result']
  when 'Success'
    @logged_in = true
    @tokens.clear
  when 'NeedToken'
    raise LoginError, "failed to log in with the returned token '#{token}'" unless token.nil?
    data = (username, password, data['token'])
  else
    raise LoginError, data['result']
  end

  data
end

#meta(type, params = {}) ⇒ Object


144
145
146
# File 'lib/mediawiki_api/client.rb', line 144

def meta(type, params = {})
  subquery(:meta, type, params)
end

#prop(type, params = {}) ⇒ Object


148
149
150
# File 'lib/mediawiki_api/client.rb', line 148

def prop(type, params = {})
  subquery(:prop, type, params)
end

#protect_page(title, reason, protections = 'edit=sysop|move=sysop') ⇒ Object


152
153
154
# File 'lib/mediawiki_api/client.rb', line 152

def protect_page(title, reason, protections = 'edit=sysop|move=sysop')
  action(:protect, title: title, reason: reason, protections: protections)
end

#query(params = {}) ⇒ Object


156
157
158
# File 'lib/mediawiki_api/client.rb', line 156

def query(params = {})
  action(:query, { token_type: false, http_method: :get }.merge(params))
end

#unwatch_page(title) ⇒ Object


160
161
162
# File 'lib/mediawiki_api/client.rb', line 160

def unwatch_page(title)
  action(:watch, token_type: 'watch', titles: title, unwatch: true)
end

#upload_image(filename, path, comment, ignorewarnings, text = nil) ⇒ Object


164
165
166
167
168
169
# File 'lib/mediawiki_api/client.rb', line 164

def upload_image(filename, path, comment, ignorewarnings, text = nil)
  file = Faraday::UploadIO.new(path, 'image/png')
  action(:upload,
         filename: filename, file: file, comment: comment, text: text,
         ignorewarnings: ignorewarnings)
end

#watch_page(title) ⇒ Object


171
172
173
# File 'lib/mediawiki_api/client.rb', line 171

def watch_page(title)
  action(:watch, token_type: 'watch', titles: title)
end