ablab-core 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5f41b9cd3f4f0cfc04bfd00fcf5209cc800d932
+  data.tar.gz: 9e3afbbd5baf0a22bcb4a6719f111c8a38e6af6f
+SHA512:
+  metadata.gz: cbe6dc86065bd3fa2e57e99292e008958c8d1829625a0774162bfa2d25a5d243fbc9bbaa31f1ed7b9a38fb5bb6bb647d101395556d3f7d19eb6705f798843b7f
+  data.tar.gz: 80b85998ece7e265af961bb25089d0e4d57ac0b2ecde848c0f002122e1e8aea35c5cf759cbdd7244a14a258f37ebc648fd3338e3dbe664b7ff362c08101f55e8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Luca Ongaro
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Ablab'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+load 'rails/tasks/statistics.rake'
+
+require "rspec/core/rake_task"
+
+Bundler::GemHelper.install_tasks(name: 'ablab')
+
+namespace :core do
+  Bundler::GemHelper.install_tasks(name: 'ablab-core')
+end
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/ablab.rb

@@ -0,0 +1,158 @@
+require "ablab/version"
+require "ablab/helper"
+require "ablab/store"
+require "ablab/engine"
+require "forwardable"
+
+module Ablab
+  module ModuleMethods
+    attr_reader :experiments
+
+    def setup(&block)
+      instance_exec(&block)
+    end
+
+    def experiment(name, &block)
+      @experiments ||= {}
+      @experiments[name] = Experiment.new(name, &block)
+    end
+
+    def store(type, *args)
+      if type.is_a? Class
+        @tracker = Class.new(*args)
+      else
+        class_name = type.to_s.split('_').map(&:capitalize).join
+        @tracker = Ablab::Store.const_get(class_name).new(*args)
+      end
+    end
+
+    def tracker
+      @tracker ||= Ablab::Store::Memory.new
+    end
+
+    def dashboard_credentials(credentials = nil)
+      if credentials
+        unless credentials[:name] && credentials[:password]
+          raise InvalidCredentials, 'credentials should provide name and password'
+        end
+        @dashboard_credentials = credentials
+      end
+      @dashboard_credentials
+    end
+  end
+
+  class InvalidCredentials < ArgumentError; end
+
+  extend ModuleMethods
+
+  class Experiment
+    attr_reader :name, :groups, :control
+
+    def initialize(name, &block)
+      @name    = name.to_sym
+      @control = Group.new(:control, 'control group')
+      @groups  = [@control]
+      instance_exec(&block)
+    end
+
+    def description(desc = nil)
+      @description = desc if desc
+      @description
+    end
+
+    def goal(goal = nil)
+      @goal = goal if goal
+      @goal
+    end
+
+    def percentage_of_visitors(percentage = nil)
+      @percentage_of_visitors = percentage if percentage
+      @percentage_of_visitors || 100
+    end
+
+    def group(name, options = {})
+      group = Group.new(name, options[:description])
+      @groups << group
+    end
+
+    def results
+      @result ||= Result.new(self)
+      @result.data
+    end
+
+    def run(session_id)
+      Run.new(self, session_id)
+    end
+  end
+
+  class Run
+    attr_reader :experiment, :session_id
+
+    def initialize(experiment, session_id)
+      @experiment, @session_id = experiment, session_id
+    end
+
+    def in_group?(name)
+      group == name
+    end
+
+    def track_view!
+      Ablab.tracker.track_view!(experiment.name, group, session_id)
+    end
+
+    def track_success!
+      Ablab.tracker.track_success!(experiment.name, group, session_id)
+    end
+
+    def group
+      return @group unless @group.nil?
+      size = 1000.0 * (experiment.percentage_of_visitors) / 100.0
+      idx = (draw * experiment.groups.size / size).floor
+      @group = experiment.groups[idx].try(:name)
+    end
+
+    def draw
+      Random.new(session_id.hash ^ experiment.name.hash).rand(1000)
+    end
+  end
+
+  class Group
+    attr_reader :name, :description
+    def initialize(name, description = nil)
+      @name, @description = name.to_sym, description
+    end
+  end
+
+  class Result
+    extend Forwardable
+    def_delegators :@experiment, :name, :control, :groups
+
+    def initialize(experiment)
+      @experiment = experiment
+    end
+
+    def data
+      counts_c = counts(control)
+      groups.map do |group|
+        if group == control
+          next [group.name, counts_c.merge(control: true, description: group.description)]
+        end
+        counts = counts(group)
+        z = z_score(counts[:sessions], counts[:conversions],
+                    counts_c[:sessions], counts_c[:conversions])
+        [group.name, counts.merge(z_score: z, control: false, description: group.description)]
+      end.to_h
+    end
+
+    private def counts(group)
+      Ablab.tracker.counts(name, group.name)
+    end
+
+    private def z_score(s, c, sc, cc)
+      return nil if s == 0 || sc == 0
+      p  = c.to_f / s
+      pc = cc.to_f / sc
+      (p - pc) / Math.sqrt((p*(1 - p) / s) + (pc*(1 - pc) / sc))
+    end
+  end
+end

data/lib/ablab/store.rb

@@ -0,0 +1,2 @@
+require 'ablab/store/memory'
+require 'ablab/store/redis'

data/lib/ablab/store/memory.rb

@@ -0,0 +1,61 @@
+require 'set'
+
+module Ablab
+  module Store
+    class Memory
+      def initialize
+        @views = Hash.new do |hash, key|
+          hash[key] = Hash.new { |h, k| h[k] = 0 }
+        end
+        @sessions = Hash.new do |hash, key|
+          hash[key] = Hash.new { |h, k| h[k] = Set.new }
+        end
+        @successes = Hash.new do |hash, key|
+          hash[key] = Hash.new { |h, k| h[k] = 0 }
+        end
+        @conversions = Hash.new do |hash, key|
+          hash[key] = Hash.new { |h, k| h[k] = Set.new }
+        end
+      end
+
+      def track_view!(experiment, bucket, session_id)
+        track(experiment, bucket, session_id, @views, @sessions)
+      end
+
+      def track_success!(experiment, bucket, session_id)
+        track(experiment, bucket, session_id, @successes, @conversions)
+      end
+
+      def views(experiment, bucket)
+        @views[experiment][bucket]
+      end
+
+      def sessions(experiment, bucket)
+        @sessions[experiment][bucket].size
+      end
+
+      def successes(experiment, bucket)
+        @successes[experiment][bucket]
+      end
+
+      def conversions(experiment, bucket)
+        @conversions[experiment][bucket].size
+      end
+
+      def counts(experiment, bucket)
+        {
+          views:       views(experiment, bucket),
+          sessions:    sessions(experiment, bucket),
+          successes:   successes(experiment, bucket),
+          conversions: conversions(experiment, bucket)
+        }
+      end
+
+      private def track(experiment, bucket, session_id, counter, set)
+        return false if bucket.nil?
+        counter[experiment][bucket] += 1
+        set[experiment][bucket].add(session_id)
+      end
+    end
+  end
+end

data/lib/ablab/store/redis.rb

@@ -0,0 +1,67 @@
+require 'redis'
+
+module Ablab
+  module Store
+    class Redis
+      attr_reader :redis
+
+      def initialize(opts = {})
+        @key_prefix = opts[:key_prefix] || 'ablab'
+        @redis = ::Redis.new(opts)
+      end
+
+      def track_view!(experiment, bucket, session_id)
+        track(experiment, bucket, session_id, :views, :sessions)
+      end
+
+      def track_success!(experiment, bucket, session_id)
+        track(experiment, bucket, session_id, :successes, :conversions)
+      end
+
+      def views(experiment, bucket)
+        (redis.get(key(:views, experiment, bucket)) || 0).to_i
+      end
+
+      def sessions(experiment, bucket)
+        (redis.pfcount(key(:sessions, experiment, bucket)) || 0).to_i
+      end
+
+      def successes(experiment, bucket)
+        (redis.get(key(:successes, experiment, bucket)) || 0).to_i
+      end
+
+      def conversions(experiment, bucket)
+        (redis.pfcount(key(:conversions, experiment, bucket)) || 0).to_i
+      end
+
+      def counts(experiment, bucket)
+        v, s, x, c = nil, nil, nil, nil
+        redis.multi do
+          v = redis.get(key(:views, experiment, bucket))
+          s = redis.pfcount(key(:sessions, experiment, bucket))
+          x = redis.get(key(:successes, experiment, bucket))
+          c = redis.pfcount(key(:conversions, experiment, bucket))
+        end
+        {
+          views:       (v.value || 0).to_i,
+          sessions:    (s.value || 0).to_i,
+          successes:   (x.value || 0).to_i,
+          conversions: (c.value || 0).to_i
+        }
+      end
+
+      private def key(type, experiment, bucket)
+        "#{@key_prefix}:#{type}:#{experiment}:#{bucket}"
+      end
+
+      private def track(experiment, bucket, session_id, counter, set)
+        return false if bucket.nil?
+        redis.pipelined do
+          redis.incr(key(counter, experiment, bucket))
+          redis.pfadd(key(set, experiment, bucket), session_id)
+        end
+      end
+    end
+  end
+end
+

data/lib/ablab/version.rb

@@ -0,0 +1,3 @@
+module Ablab
+  VERSION = "0.2.1"
+end

data/lib/tasks/ablab_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :ablab do
+#   # Task goes here
+# end

data/spec/ablab/store/memory_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'ablab/store/store_examples'
+
+describe Ablab::Store::Memory do
+  let(:store) { Ablab::Store::Memory.new }
+  include_examples 'store', Ablab::Store::Memory.new
+end

data/spec/ablab/store/redis_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'ablab/store/store_examples'
+
+describe Ablab::Store::Redis do
+  def cleanup
+    redis = ::Redis.new(db: 2)
+    keys  = redis.keys('ablabtest:*')
+    redis.pipelined do
+      keys.each { |key| redis.del(key) }
+    end
+  end
+
+  around do |example|
+    begin
+      cleanup
+      example.run
+    ensure
+      cleanup
+    end
+  end
+
+  let(:store) { Ablab::Store::Redis.new(db: 2, key_prefix: 'ablabtest') }
+  include_examples 'store'
+end
+

data/spec/ablab/store/store_examples.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.shared_examples 'store' do
+  describe '#track_view!' do
+    it 'returns false if group is nil' do
+      expect(store.track_view!(:foo, nil, 'abc')).to be(false)
+    end
+
+    it 'tracks views' do
+      5.times { store.track_view!(:foo, :a, 'abc') }
+      7.times { store.track_view!(:foo, :b, 'abc') }
+      3.times { store.track_view!(:bar, :b, 'abc') }
+      expect(store.views(:foo, :a)).to eq(5)
+      expect(store.views(:foo, :b)).to eq(7)
+      expect(store.views(:bar, :b)).to eq(3)
+    end
+
+    it 'tracks unique sessions' do
+      2.times { store.track_view!(:foo, :a, 'foo') }
+      3.times { store.track_view!(:foo, :a, 'bar') }
+      3.times { store.track_view!(:foo, :b, 'foo') }
+      3.times { store.track_view!(:bar, :b, 'bar') }
+      expect(store.sessions(:foo, :a)).to eq(2)
+      expect(store.sessions(:foo, :b)).to eq(1)
+      expect(store.sessions(:bar, :b)).to eq(1)
+    end
+  end
+
+  describe '#track_success!' do
+    it 'returns false if group is nil' do
+      expect(store.track_success!(:foo, nil, 'abc')).to be(false)
+    end
+
+    it 'tracks successes' do
+      5.times { store.track_success!(:foo, :a, 'abc') }
+      7.times { store.track_success!(:foo, :b, 'abc') }
+      3.times { store.track_success!(:bar, :b, 'abc') }
+      expect(store.successes(:foo, :a)).to eq(5)
+      expect(store.successes(:foo, :b)).to eq(7)
+      expect(store.successes(:bar, :b)).to eq(3)
+    end
+
+    it 'tracks unique conversions' do
+      5.times { |i| store.track_success!(:foo, :a, i) }
+      2.times { store.track_success!(:foo, :b, 'foo') }
+      3.times { store.track_success!(:foo, :b, 'bar') }
+      3.times { store.track_success!(:bar, :b, 'foo') }
+      expect(store.conversions(:foo, :a)).to eq(5)
+      expect(store.conversions(:foo, :b)).to eq(2)
+      expect(store.conversions(:bar, :b)).to eq(1)
+    end
+  end
+
+  describe '#views' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.views(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#conversions' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.conversions(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#sessions' do
+    it 'returns 0 if nothing was tracked' do
+      expect(store.sessions(:xxx, :a)).to eq(0)
+    end
+  end
+
+  describe '#counts' do
+    it 'returns all counts in one call' do
+      2.times { store.track_view!(:foo, :a, 'foo') }
+      3.times { store.track_view!(:foo, :a, 'bar') }
+      1.times { store.track_success!(:foo, :a, 'foo') }
+      5.times { store.track_success!(:foo, :a, 'bar') }
+      2.times { store.track_success!(:foo, :a, 'baz') }
+      expect(store.counts(:foo, :a)).to eq(views: 5, sessions: 2, successes: 8, conversions: 3)
+    end
+  end
+end

data/spec/ablab_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe Ablab do
+  let(:ab) do
+    Module.new { extend Ablab::ModuleMethods }
+  end
+
+  it 'has a version number' do
+    expect(Ablab::VERSION).not_to be nil
+  end
+
+  describe '.experiment' do
+    it 'creates an experiment' do
+      ab.experiment :foo_bar do; end
+      expect(ab.experiments[:foo_bar]).to be_a(Ablab::Experiment)
+    end
+  end
+
+  describe '.tracker' do
+    around do |example|
+      begin
+        Ablab::Store::Dummy = Class.new
+        example.run
+      ensure
+        Ablab::Store.send(:remove_const, :Dummy)
+      end
+    end
+
+    it 'returns a Ablab::Store::Memory instance if store was never set' do
+      expect(ab.tracker).to be_a(Ablab::Store::Memory)
+    end
+
+    it 'returns the store if it was set' do
+      ab.store :dummy
+      expect(ab.tracker).to be_a(Ablab::Store::Dummy)
+    end
+  end
+
+  describe '.dashboard_credentials' do
+    it 'raises if called without name or password' do
+      expect {
+        ab.dashboard_credentials(name: 'foo')
+      }.to raise_error(Ablab::InvalidCredentials)
+
+      expect {
+        ab.dashboard_credentials(password: 'foo')
+      }.to raise_error(Ablab::InvalidCredentials)
+    end
+
+    it 'sets and gets the credentials' do
+      ab.dashboard_credentials(name: 'foo', password: 'bar')
+      expect(ab.dashboard_credentials).to eq(name: 'foo', password: 'bar')
+    end
+  end
+
+  describe Ablab::Experiment do
+    let(:experiment) do
+      Ablab::Experiment.new('foo') do; end
+    end
+
+    it 'automatically creates a control group' do
+      expect(experiment.control).to be_a(Ablab::Group)
+      expect(experiment.groups).to_not be_empty
+    end
+
+    it 'symbolizes its name' do
+      expect(experiment.name).to eq(:foo)
+    end
+
+    describe '#description' do
+      it 'sets the description' do
+        experiment.description 'foo bar'
+        expect(experiment.description).to eq('foo bar')
+      end
+    end
+
+    describe '#goal' do
+      it 'sets the experiment goal' do
+        experiment.goal 'foo bar'
+        expect(experiment.goal).to eq('foo bar')
+      end
+    end
+
+    describe '#percentage_of_visitors' do
+      it 'returns 100 if never set' do
+        expect(experiment.percentage_of_visitors).to eq(100)
+      end
+
+      it 'sets the percentage of visitors included in the experiment' do
+        experiment.percentage_of_visitors 25
+        expect(experiment.percentage_of_visitors).to eq(25)
+      end
+    end
+
+    describe '#group' do
+      it 'creates a group' do
+        experiment.group :a, description: 'foo bar baz'
+        expect(experiment.groups.last).to be_a(Ablab::Group)
+        expect(experiment.groups.last.description).to eq('foo bar baz')
+      end
+
+      it 'symbolizes the group name' do
+        experiment.group 'yeah'
+        expect(experiment.groups.last.name).to eq(:yeah)
+      end
+    end
+
+    describe '.results' do
+      it 'returns the results of the experiment' do
+        experiment.group :x, description: 'a test group'
+        allow(Ablab.tracker).to receive(:views) do |_, group|
+          { control: 201, x: 238 }[group]
+        end
+        allow(Ablab.tracker).to receive(:sessions) do |_, group|
+          { control: 182, x: 188 }[group]
+        end
+        allow(Ablab.tracker).to receive(:successes) do |_, group|
+          { control: 38, x: 70 }[group]
+        end
+        allow(Ablab.tracker).to receive(:conversions) do |_, group|
+          { control: 35, x: 61 }[group]
+        end
+        results = experiment.results
+        expect(results[:control]).to eq({
+          views:       201,
+          sessions:    182,
+          successes:   38,
+          conversions: 35,
+          control:     true,
+          description: 'control group'
+        })
+        expect(results[:x]).to eq({
+          views:       238,
+          sessions:    188,
+          successes:   70,
+          conversions: 61,
+          control:     false,
+          z_score:     2.9410157224928595,
+          description: 'a test group'
+        })
+      end
+    end
+  end
+
+  describe Ablab::Run do
+    let(:experiment) do
+      Ablab::Experiment.new(:foo) do
+        group :a
+        group :b
+      end
+    end
+
+    it 'gets assigned to the right group' do
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 0
+      expect(run).to be_in_group(:control)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 334
+      expect(run).to be_in_group(:a)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 999
+      expect(run).to be_in_group(:b)
+    end
+
+    it 'assigns the same session ID to the same group' do
+      run1 = Ablab::Run.new(experiment, 'foobar')
+      run2 = Ablab::Run.new(experiment, 'foobar')
+      expect(run1.group).to eq(run2.group)
+    end
+
+    it 'selects only the given percentage of users' do
+      experiment.percentage_of_visitors 30
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 0
+      expect(run).to be_in_group(:control)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 100
+      expect(run).to be_in_group(:a)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 200
+      expect(run).to be_in_group(:b)
+      run = Ablab::Run.new(experiment, 0)
+      allow(run).to receive(:draw).and_return 300
+      expect(run.group).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'ablab'

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: ablab-core
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Luca Ongaro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ablab - A/B testing library
+email:
+- lukeongaro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/ablab.rb
+- lib/ablab/store.rb
+- lib/ablab/store/memory.rb
+- lib/ablab/store/redis.rb
+- lib/ablab/version.rb
+- lib/tasks/ablab_tasks.rake
+- spec/ablab/store/memory_spec.rb
+- spec/ablab/store/redis_spec.rb
+- spec/ablab/store/store_examples.rb
+- spec/ablab_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/lucaong/ablab
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ablab core - A/B testing library
+test_files:
+- spec/ablab/store/memory_spec.rb
+- spec/ablab/store/redis_spec.rb
+- spec/ablab/store/store_examples.rb
+- spec/ablab_spec.rb
+- spec/spec_helper.rb