Class: Rollout

Inherits:
Object
  • Object
show all
Defined in:
lib/rollout.rb,
lib/rollout/version.rb

Defined Under Namespace

Classes: Feature

Constant Summary collapse

RAND_BASE = 
(2**32 - 1) / 100.0
VERSION = 
"2.4.3"

Instance Method Summary collapse

Constructor Details

#initialize(storage, opts = {}) ⇒ Rollout

Returns a new instance of Rollout.



135
136
137
138
139
 
# File 'lib/rollout.rb', line 135

def initialize(storage, opts = {})
  @storage = storage
  @options = opts
  @groups  = { all: lambda { |user| true } }
end

Instance Method Details

#activate(feature) ⇒ Object 



141
142
143
144
145
 
# File 'lib/rollout.rb', line 141

def activate(feature)
  with_feature(feature) do |f|
    f.percentage = 100
  end
end

#activate_group(feature, group) ⇒ Object 



170
171
172
173
174
 
# File 'lib/rollout.rb', line 170

def activate_group(feature, group)
  with_feature(feature) do |f|
    f.add_group(group)
  end
end

#activate_percentage(feature, percentage) ⇒ Object 



231
232
233
234
235
 
# File 'lib/rollout.rb', line 231

def activate_percentage(feature, percentage)
  with_feature(feature) do |f|
    f.percentage = percentage
  end
end

#activate_user(feature, user) ⇒ Object 



182
183
184
185
186
 
# File 'lib/rollout.rb', line 182

def activate_user(feature, user)
  with_feature(feature) do |f|
    f.add_user(user)
  end
end

#activate_users(feature, users) ⇒ Object 



194
195
196
197
198
 
# File 'lib/rollout.rb', line 194

def activate_users(feature, users)
  with_feature(feature) do |f|
    users.each{|user| f.add_user(user)}
  end
end

#active?(feature, user = nil) ⇒ Boolean

Returns:

  • (Boolean) 


217
218
219
220
 
# File 'lib/rollout.rb', line 217

def active?(feature, user = nil)
  feature = get(feature)
  feature.active?(self, user)
end

#active_features(user = nil) ⇒ Object 



280
281
282
283
284
 
# File 'lib/rollout.rb', line 280

def active_features(user = nil)
  features.select do |f|
    active?(f, user)
  end
end

#active_in_group?(group, user) ⇒ Boolean

Returns:

  • (Boolean) 


243
244
245
246
 
# File 'lib/rollout.rb', line 243

def active_in_group?(group, user)
  f = @groups[group.to_sym]
  f && f.call(user)
end

#clear! ⇒ Object 



286
287
288
289
290
291
292
293
 
# File 'lib/rollout.rb', line 286

def clear!
  features.each do |feature|
    with_feature(feature) { |f| f.clear }
    @storage.del(key(feature))
  end

  @storage.del(features_key)
end

#clear_feature_data(feature) ⇒ Object 



259
260
261
262
263
 
# File 'lib/rollout.rb', line 259

def clear_feature_data(feature)
  with_feature(feature) do |f|
    f.data = {}
  end
end

#deactivate(feature) ⇒ Object 



147
148
149
150
151
 
# File 'lib/rollout.rb', line 147

def deactivate(feature)
  with_feature(feature) do |f|
    f.clear
  end
end

#deactivate_group(feature, group) ⇒ Object 



176
177
178
179
180
 
# File 'lib/rollout.rb', line 176

def deactivate_group(feature, group)
  with_feature(feature) do |f|
    f.remove_group(group)
  end
end

#deactivate_percentage(feature) ⇒ Object 



237
238
239
240
241
 
# File 'lib/rollout.rb', line 237

def deactivate_percentage(feature)
  with_feature(feature) do |f|
    f.percentage = 0
  end
end

#deactivate_user(feature, user) ⇒ Object 



188
189
190
191
192
 
# File 'lib/rollout.rb', line 188

def deactivate_user(feature, user)
  with_feature(feature) do |f|
    f.remove_user(user)
  end
end

#deactivate_users(feature, users) ⇒ Object 



200
201
202
203
204
 
# File 'lib/rollout.rb', line 200

def deactivate_users(feature, users)
  with_feature(feature) do |f|
    users.each{|user| f.remove_user(user)}
  end
end

#define_group(group, &block) ⇒ Object 



213
214
215
 
# File 'lib/rollout.rb', line 213

def define_group(group, &block)
  @groups[group.to_sym] = block
end

#delete(feature) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/rollout.rb', line 153

def delete(feature)
  features = (@storage.get(features_key) || "").split(",")
  features.delete(feature.to_s)
  @storage.set(features_key, features.join(","))
  @storage.del(key(feature))
end

#exists?(feature) ⇒ Boolean

Returns:

  • (Boolean) 


295
296
297
 
# File 'lib/rollout.rb', line 295

def exists?(feature)
  @storage.exists(key(feature))
end

#feature_states(user = nil) ⇒ Object 



274
275
276
277
278
 
# File 'lib/rollout.rb', line 274

def feature_states(user = nil)
  features.each_with_object({}) do |f, hash|
    hash[f] = active?(f, user)
  end
end

#features ⇒ Object 



270
271
272
 
# File 'lib/rollout.rb', line 270

def features
  (@storage.get(features_key) || "").split(",").map(&:to_sym)
end

#get(feature) ⇒ Object 



248
249
250
251
 
# File 'lib/rollout.rb', line 248

def get(feature)
  string = @storage.get(key(feature))
  Feature.new(feature, string, @options)
end

#inactive?(feature, user = nil) ⇒ Boolean

Returns:

  • (Boolean) 


227
228
229
 
# File 'lib/rollout.rb', line 227

def inactive?(feature, user = nil)
  !active?(feature, user)
end

#multi_get(*features) ⇒ Object 



265
266
267
268
 
# File 'lib/rollout.rb', line 265

def multi_get(*features)
  feature_keys = features.map{ |feature| key(feature) }
  @storage.mget(*feature_keys).map.with_index { |string, index| Feature.new(features[index], string, @options) }
end

#set(feature, desired_state) ⇒ Object 



160
161
162
163
164
165
166
167
168
 
# File 'lib/rollout.rb', line 160

def set(feature, desired_state)
  with_feature(feature) do |f|
    if desired_state
      f.percentage = 100
    else
      f.clear
    end
  end
end

#set_feature_data(feature, data) ⇒ Object 



253
254
255
256
257
 
# File 'lib/rollout.rb', line 253

def set_feature_data(feature, data)
  with_feature(feature) do |f|
    f.data.merge!(data) if data.is_a? Hash
  end
end

#set_users(feature, users) ⇒ Object 



206
207
208
209
210
211
 
# File 'lib/rollout.rb', line 206

def set_users(feature, users)
  with_feature(feature) do |f|
    f.users = []
    users.each{|user| f.add_user(user)}
  end
end

#user_in_active_users?(feature, user = nil) ⇒ Boolean

Returns:

  • (Boolean) 


222
223
224
225
 
# File 'lib/rollout.rb', line 222

def user_in_active_users?(feature, user = nil)
  feature = get(feature)
  feature.user_in_active_users?(user)
end