RubyGems - ruby_optimize - Versions diffs - 2.3 - Mend

ruby_optimize 2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

checksums.yaml +7 -0
data/.gitignore +1 -0
data/Gemfile +3 -0
data/MIT-LICENSE +20 -0
data/README.md +90 -0
data/lib/ruby_optimize.rb +17 -0
data/lib/ruby_optimize/common_controllers_and_helpers.rb +10 -0
data/lib/ruby_optimize/controllers/action_controller_extension.rb +5 -0
data/lib/ruby_optimize/helpers/action_view_extension.rb +12 -0
data/lib/ruby_optimize/hooks.rb +10 -0
data/lib/ruby_optimize/models/ab_test_handler.rb +68 -0
data/lib/ruby_optimize/railtie.rb +7 -0
data/lib/ruby_optimize/version.rb +3 -0
data/ruby_optimize.gemspec +25 -0
data/spec/ruby_optimize_spec.rb +546 -0
metadata +116 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06219338afa9e9b6a5feb8b10e5accb8728a82c3
+  data.tar.gz: 35fc66284257c5c4327dc42dccfcec447352977c
+SHA512:
+  metadata.gz: 99088d7643a95a1c1e6ca9907f38a2909b056dac8ec7ec9a2d3857d0ad8f2c7676d84ee48d8299ebe6581fb68a85c48dd5cf8b3cdc031fc19f8cffd6e7f76b9e
+  data.tar.gz: 1ecff56be0b92756e88dafe26c52ed9ae22a3fd4cd810c17f1d2d15d13bce43f42bbdf92ff5d6f21913368b3229dfbaa30fa76820afc169ee6d13aa83436c409

data/.gitignore ADDED Viewed

	@@ -0,0 +1 @@
1	+ .DS_Store

data/Gemfile ADDED Viewed

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+gemspec

data/MIT-LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Adriano di Lauro
+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/README.md ADDED Viewed

@@ -0,0 +1,90 @@
+To know more about RubyOptimize look at the [full documentation](https://github.com/adrdilauro/ruby_optimize/wiki/Full-documentation).
+# Features
+1. Set up an A/B test with a very **simple** and **descriptive code** (the gem consists of just three methods)
+2. A/B tests are valid across different pages, using cookies
+3. You can test **multiple versions** with changes as complicated as you need, while still keeping the code clean and understandable
+4. Effortlessly set up **multiple A/B tests** that don't clash with each other (remembering of course to ensure that results of the tests are kept separated)
+5. Very easy to select a special version for crawlers, so you don't affect your SEO while you are running the test
+6. The gem is safe and super tested (https://github.com/adrdilauro/ruby_optimize/blob/master/spec/ruby_optimize_spec.rb)
+# Usage
+Install it using bundler
+```ruby
+gem 'ruby_optimize'
+```
+#### (1) - Initialize the A/B test in the actions you need inside the controller
+```ruby
+before_action :initialize_ab_test
+def initialize_ab_test
+  ruby_optimize [ :v1, :v2, :v3 ] # Declare the names of all the versions you are going to test
+end
+```
+#### (2) - Render the script that reads / writes the cookie
+```html
+<head>
+  <%= ruby_optimize_init %>
+  ...
+</head>
+```
+#### (3) - Wrap blocks of HTML that will be rendered depending on the version
+```html
+<%= ruby_optimize_wrap(:v1) do %>
+  <div class="for-version-1">
+    ...
+  </div>
+<% end %>
+<%= ruby_optimize_wrap(:v2) do %>
+  <div class="for-version-2">
+    ...
+  </div>
+<% end %>
+```
+# How it works
+When you call `ruby_optimize_init` in your `.erb` files, you will render a simple synchronous script that
+- tries to read the cookie relative to your A/B test
+- if the cookie is not present, extract a random version among the ones you defined, and store it in a cookie
+- save the version in an internal javascript object that will be used across the page
+When you wrap a block of HTML inside `ruby_optimize_wrap`, passing a specific version, the block will be wrapped inside a `<div>` with a generated random id, and after the block it will be appended a synchronous `<script>` tag that looks like this:
+```html
+<script>
+  window.rubyOptimizerObject.keepOrRemoveHtmlBlock('[random id]', '[version]');
+</script>
+```
+If the version passed doesn't match with the version that has been stored on the top of the page, then the block is removed. This happens before the page is fully rendered, so there isn't any chance to get page flickering.
+The synchronous scripts are really simple and don't slow down page rendering time.
+# Why RubyOptimize is good for complex A/B tests
+You can create several different versions of the same page, as complex and as big as you need, without filling your HTML with unnecessary code. This will make your A/B test less error prone, and also it will make it easier to remove the loser versions after the test, because the code is clear and descriptive.
+You can easily span your tests across different pages reading the same cookie, with no additional code, RubyOptimize does all the work for you.
+You can maintain as many different A/B tests you want without risking them to clash.
+# Why RubyOptimize is good for small A/B tests as well
+Usually, to set up a small A/B test (changing a color, removing or adding a div, etc) people use client side tools like Google Optimize.
+This approach can potentially affect user experience, because Google Optimize has to change parts of the page depending on the specific version selected, and, if this happens while the user is already looking at the page, we have the effect called "page flickering". To prevent page flickering Google Optimize introduced a "hide-page tag", i.e. a script that hides the page until the external call to Google Optimize server has responded.
+Now, usually Google Optimize tag loads fast, but you cannot always rely on external calls, especially in conditions of low network; in the worst scenario, if Google Optimize server doesn't respond, the hide-page tag gets unblocked after the threshold of 4 seconds.
+This means that, even if your server has responded in 150 milliseconds, your user won't be able to see anything in the page until the 4 seconds have expired.
+Are you sure you want to risk this? With RubyOptimize you can set up a simple A/B test easily and cleanly directly in the code, this means that you can get rid of the hide-page tag, and let Google Optimize focus only on data collection.

data/lib/ruby_optimize.rb ADDED Viewed

@@ -0,0 +1,17 @@
+module RubyOptimize
+end
+begin
+  require 'rails'
+rescue LoadError
+end
+require 'ruby_optimize/common_controllers_and_helpers'
+require 'ruby_optimize/controllers/action_controller_extension'
+require 'ruby_optimize/helpers/action_view_extension'
+require 'ruby_optimize/models/ab_test_handler'
+require 'ruby_optimize/hooks'
+if defined? Rails
+  require 'ruby_optimize/railtie'
+end

data/lib/ruby_optimize/common_controllers_and_helpers.rb ADDED Viewed

@@ -0,0 +1,10 @@
+module RubyOptimize
+  module CommonControllersAndHelpers
+    def ruby_optimize(versions, **params)
+      @ruby_optimize = {} if @ruby_optimize.nil?
+      scope = params[:scope] || :default
+      raise "RubyOptimize - scope already defined: #{scope.inspect}" if @ruby_optimize.has_key?(scope)
+      @ruby_optimize[scope] = AbTestHandler.new(cookies, versions, scope, request.user_agent, params[:domain], params[:cookie_expiration], params[:version_for_crawler])
+    end
+  end
+end

data/lib/ruby_optimize/controllers/action_controller_extension.rb ADDED Viewed

@@ -0,0 +1,5 @@
+module RubyOptimize
+  module ActionControllerExtension
+    include CommonControllersAndHelpers
+  end
+end

data/lib/ruby_optimize/helpers/action_view_extension.rb ADDED Viewed

@@ -0,0 +1,12 @@
+module RubyOptimize
+  module ActionViewExtension
+    include CommonControllersAndHelpers
+    def ruby_optimize_wrap(*version_and_scope, **params, &block)
+      scope = version_and_scope[1] || :default
+      raise "RubyOptimize - A/B test not initialized" if @ruby_optimize.nil?
+      raise "RubyOptimize - scope not found: #{scope.inspect}" if !@ruby_optimize.has_key?(scope)
+      @ruby_optimize[scope].show?(version_and_scope[0], !!params[:version_for_crawler]) ? capture(&block).html_safe : ''
+    end
+  end
+end

data/lib/ruby_optimize/hooks.rb ADDED Viewed

@@ -0,0 +1,10 @@
+module RubyOptimize
+  class Hooks
+    def self.init
+      ActiveSupport.on_load(:action_view) do
+        ::ActionView::Base.send :include, RubyOptimize::ActionViewExtension
+        ::ActionController::Base.send :include, RubyOptimize::ActionControllerExtension
+      end
+    end
+  end
+end

data/lib/ruby_optimize/models/ab_test_handler.rb ADDED Viewed

@@ -0,0 +1,68 @@
+module RubyOptimize
+  class AbTestHandler
+    ALPHANUMERIC_STRING = /\A[a-zA-Z0-9]+\z/
+    CRAWLER = /#{[
+      'bot', 'crawl', 'slurp', 'spider', 'Google favicon', 'Mediapartners-Google', 'java', 'wget', 'curl', 'Commons-HttpClient',
+      'Python-urllib', 'libwww', 'httpunit', 'nutch', 'biglotron', 'teoma', 'convera', 'gigablast', 'ia_archiver', 'webmon',
+      'httrack', 'grub.org', 'netresearchserver', 'speedy', 'fluffy', 'bibnum.bnf', 'findlink', 'panscient', 'IOI', 'ips-agent',
+      'yanga', 'Voyager', 'CyberPatrol', 'postrank', 'page2rss', 'linkdex', 'ezooms', 'heritrix', 'findthatfile', 'europarchive.org',
+      'Aboundex', 'summify', 'ec2linkfinder', 'facebookexternalhit', 'yeti', 'RetrevoPageAnalyzer', 'sogou', 'wotbox', 'ichiro',
+      'drupact', 'coccoc', 'integromedb', 'siteexplorer.info', 'proximic', 'changedetection', 'WeSEE:SearchLipperhey SEO Service',
+      'CC Metadata Scaper', 'g00g1e.net', 'binlar', 'A6-Indexer', 'ADmantX', 'MegaIndex', 'ltx71', 'BUbiNG', 'Qwantify', 'lipperhey',
+      'y!j-asr', 'AddThis'
+    ].join('|')}/i
+    def initialize(cookies, some_versions, scope, agent, domain=nil, a_cookie_expiration=nil, a_version_for_crawler=nil)
+      @versions = some_versions
+      validate_versions
+      validate_scope(scope)
+      @cookie_name = "ruby-optimize-cookie-#{scope}"
+      @is_crawler = !CRAWLER.match(agent).nil?
+      @cookie_expiration = (a_cookie_expiration || 180.days).to_i
+      validate_cookie_expiration
+      @version_for_crawler = a_version_for_crawler
+      validate_version_for_crawler
+      return if is_crawler
+      if cookies.has_key?(cookie_name)
+        @version = cookies[cookie_name].to_sym
+      else
+        @version = versions.sample
+        cookies[cookie_name] = {
+          value: version,
+          expires: cookie_expiration.from_now,
+          domain: domain || :all,
+        }
+      end
+    end
+    def show?(a_version, for_crawler)
+      raise "RubyOptimize - for_crawler must be a boolean: #{for_crawler.inspect}" if for_crawler != !!for_crawler
+      return for_crawler || (!version_for_crawler.nil? && a_version == version_for_crawler) if is_crawler
+      raise "RubyOptimize - version must be one of the available versions: #{a_version.inspect}" if !a_version.nil? && !versions.include?(a_version)
+      a_version == version
+    end
+    private
+    def validate_versions
+      raise "RubyOptimize - you need to pass an array of at least two versions: #{versions.inspect}" if !versions.is_a?(Array) || versions.length < 2
+      raise "RubyOptimize - versions need to be alphanumeric symbols: #{versions.inspect}" if versions.any? do |version|
+        !version.is_a?(Symbol) || ALPHANUMERIC_STRING.match(version.to_s).nil?
+      end
+    end
+    def validate_scope(scope)
+      raise "RubyOptimize - scope needs to be an alphanumeric symbol: #{scope.inspect}" if !scope.is_a?(Symbol) || ALPHANUMERIC_STRING.match(scope.to_s).nil?
+    end
+    def validate_cookie_expiration
+      raise "RubyOptimize - cookie_expiration needs to be an integer greater than zero: #{cookie_expiration.inspect}" if cookie_expiration <= 0
+    end
+    def validate_version_for_crawler
+      raise "RubyOptimize - version_for_crawler must be one of the available versions: #{version_for_crawler.inspect}" if !version_for_crawler.nil? && !versions.include?(version_for_crawler)
+    end
+    attr_reader :cookie_expiration, :cookie_name, :version_for_crawler, :is_crawler, :version, :versions
+  end
+end

data/lib/ruby_optimize/railtie.rb ADDED Viewed

@@ -0,0 +1,7 @@
+module RubyOptimize
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'ruby_optimize' do |_app|
+      RubyOptimize::Hooks.init
+    end
+  end
+end

data/lib/ruby_optimize/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module RubyOptimize
+  VERSION = '2.3'
+end

data/ruby_optimize.gemspec ADDED Viewed

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_optimize/version'
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_optimize'
+  spec.version       = RubyOptimize::VERSION
+  spec.authors       = ['Adriano di Lauro']
+  spec.email         = ['adr_dilauro@hotmail.it']
+  spec.summary       = 'Tool to implement flexible A/B tests in Ruby on Rails'
+  spec.description   = 'With ruby_optimize you can set up multiple A/B tests, consistent across session, in a clean way and without page flickering'
+  spec.homepage      = 'https://github.com/adrdilauro/ruby_optimize'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.add_dependency 'activesupport', ['>= 3.0.0']
+  spec.add_dependency 'actionpack', ['>= 3.0.0']
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/spec/ruby_optimize_spec.rb ADDED Viewed

@@ -0,0 +1,546 @@
+require 'rails_helper'
+RSpec.describe AbTestHandler, type: :model do
+  def ruby_optimize(versions, **params)
+    @ruby_optimize = {} if @ruby_optimize.nil?
+    scope = params[:scope] || :default
+    raise "RubyOptimize - scope already defined: #{scope.inspect}" if @ruby_optimize.has_key?(scope)
+    @ruby_optimize[scope] = AbTestHandler.new({}, versions, scope, request.user_agent, params[:domain], params[:cookie_expiration], params[:version_for_crawler])
+  end
+  def ruby_optimize_wrap(*version_and_scope, **params, &block)
+    scope = version_and_scope[1] || :default
+    raise "RubyOptimize - A/B test not initialized" if @ruby_optimize.nil?
+    raise "RubyOptimize - scope not found: #{scope.inspect}" if !@ruby_optimize.has_key?(scope)
+    @ruby_optimize[scope].wrap(yield, version_and_scope[0], !!params[:version_for_crawler])
+  end
+  def fake_wrapped(version, random_div_id, js_object_id)
+    "      <div id=\"#{random_div_id}\">\n        hello\n      </div>\n      <script>\n        window['#{js_object_id}'].handle('#{version}', '#{random_div_id}');\n      </script>\n"
+  end
+  describe 'create' do
+    context 'not crawler' do
+      let(:request) do
+        OpenStruct.new(user_agent: 'safari')
+      end
+      it 'raises an error if "versions" is not an array' do
+        expect do
+          ruby_optimize 'hello'
+        end.to raise_error('RubyOptimize - you need to pass an array of at least two versions: "hello"')
+      end
+      it 'raises an error if there are less than two versions, 1' do
+        expect do
+          ruby_optimize [ 'helllo' ]
+        end.to raise_error('RubyOptimize - you need to pass an array of at least two versions: ["helllo"]')
+      end
+      it 'raises an error if there are less than two versions, 2' do
+        expect do
+          ruby_optimize []
+        end.to raise_error('RubyOptimize - you need to pass an array of at least two versions: []')
+      end
+      it 'raises an error if there versions are not alphanumeric, 1' do
+        expect do
+          ruby_optimize [ 'v1', :v2 ]
+        end.to raise_error('RubyOptimize - versions need to be alphanumeric symbols: ["v1", :v2]')
+      end
+      it 'raises an error if there versions are not alphanumeric, 2' do
+        expect do
+          ruby_optimize [ :v1, :v2, 3 ]
+        end.to raise_error('RubyOptimize - versions need to be alphanumeric symbols: [:v1, :v2, 3]')
+      end
+      it 'raises an error if there versions are not alphanumeric, 3' do
+        expect do
+          ruby_optimize [ :'v-1', :v2, :v3 ]
+        end.to raise_error('RubyOptimize - versions need to be alphanumeric symbols: [:"v-1", :v2, :v3]')
+      end
+      it 'raises an error if there versions are not alphanumeric, 4' do
+        expect do
+          ruby_optimize [ :'v1-', :v2, :v3 ]
+        end.to raise_error('RubyOptimize - versions need to be alphanumeric symbols: [:"v1-", :v2, :v3]')
+      end
+      it 'raises an error if scope is not alphanumeric, 1' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], scope: 23
+        end.to raise_error('RubyOptimize - scope needs to be an alphanumeric symbol: 23')
+      end
+      it 'raises an error if scope is not alphanumeric, 2' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], scope: 'ehi23'
+        end.to raise_error('RubyOptimize - scope needs to be an alphanumeric symbol: "ehi23"')
+      end
+      it 'raises an error if scope is not alphanumeric, 3' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], scope: :'ehi-'
+        end.to raise_error('RubyOptimize - scope needs to be an alphanumeric symbol: :"ehi-"')
+      end
+      it 'raises an error if cookie_expiration is not a positive integer, 1' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], cookie_expiration: 'ahi'
+        end.to raise_error('RubyOptimize - cookie_expiration needs to be an integer greater than zero: 0')
+      end
+      it 'raises an error if cookie_expiration is not a positive integer, 2' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], cookie_expiration: -1
+        end.to raise_error('RubyOptimize - cookie_expiration needs to be an integer greater than zero: -1')
+      end
+      it 'raises an error if version_for_crawler is not one of the whitelisted versions' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], version_for_crawler: 'ehi'
+        end.to raise_error('RubyOptimize - version_for_crawler must be one of the available versions: "ehi"')
+      end
+      it 'raises an error if version_for_crawler is not one of the whitelisted versions' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], version_for_crawler: :v4
+        end.to raise_error('RubyOptimize - version_for_crawler must be one of the available versions: :v4')
+      end
+      it 'does not raise any error if cookie_expiration is explicitly nil' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], cookie_expiration: nil
+        end.not_to raise_error
+      end
+      it 'does not raise any error if version_for_crawler is explicitly nil' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], version_for_crawler: nil
+        end.not_to raise_error
+      end
+      it 'raises an error if you try to access the same scope twice' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], scope: :myscope
+          ruby_optimize [ :v4, :v5 ], scope: :myscope
+        end.to raise_error('RubyOptimize - scope already defined: :myscope')
+      end
+      it 'raises an error if you try to access the same scope twice (default)' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ]
+          ruby_optimize [ :v4, :v5 ]
+        end.to raise_error('RubyOptimize - scope already defined: :default')
+      end
+      it 'raises an error if you try to access the same scope twice (default set explicitly 1)' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ], scope: :default
+          ruby_optimize [ :v4, :v5 ]
+        end.to raise_error('RubyOptimize - scope already defined: :default')
+      end
+      it 'raises an error if you try to access the same scope twice (default set explicitly 2)' do
+        expect do
+          ruby_optimize [ :v1, :v2, :v3 ]
+          ruby_optimize [ :v4, :v5 ], scope: :default
+        end.to raise_error('RubyOptimize - scope already defined: :default')
+      end
+      it 'raises an error if you try using the object without having initialized it previously' do
+        expect do
+          ruby_optimize_wrap(:v1) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - A/B test not initialized')
+        expect do
+          ruby_optimize_wrap(:v1, :somescope) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - A/B test not initialized')
+      end
+      it 'correctly sets up the object, init scripts, wrap' do
+        ruby_optimize [ :v1, :v2, :v3 ]
+        ruby_optimize [ :old, :new ], scope: :test
+        ruby_optimize [ :old, :new ], scope: :test2, cookie_expiration: nil, version_for_crawler: nil
+        ruby_optimize [ :v4, :v5 ], scope: :test3, cookie_expiration: 33
+        ruby_optimize [ :v4, :v5 ], scope: :test4, version_for_crawler: :v5
+        expect(@ruby_optimize.class.to_s).to eq('Hash')
+        expect(@ruby_optimize.keys.length).to eq(5)
+        expect(@ruby_optimize.keys.sort[0]).to eq(:default)
+        expect(@ruby_optimize.keys.sort[1]).to eq(:test)
+        expect(@ruby_optimize.keys.sort[2]).to eq(:test2)
+        expect(@ruby_optimize.keys.sort[3]).to eq(:test3)
+        expect(@ruby_optimize.keys.sort[4]).to eq(:test4)
+        # WRAP GENERIC
+        expect do
+          ruby_optimize_wrap(:v1, :anotherscope) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - scope not found: :anotherscope')
+        expect do
+          @ruby_optimize[:default].wrap('hello', :v1, 'true') do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - for_crawler must be a boolean: "true"')
+        # DEFAULT SET UP
+        def (@ruby_optimize[:default]).set_version(a_version)
+          @version = a_version
+        end
+        def (@ruby_optimize[:default]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:default]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:default]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:default]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:default]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:default].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:default].get_cookie_name).to eq('ruby-optimize-cookie-default')
+        expect(@ruby_optimize[:default].get_version_for_crawler).to eq(nil)
+        expect(@ruby_optimize[:default].get_is_crawler).to eq(false)
+        expect(@ruby_optimize[:default].get_versions.sort).to eq([:v1, :v2, :v3])
+        # DEFAULT WRAP
+        expect do
+          ruby_optimize_wrap(:new) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - version must be one of the available versions: :new')
+        expect(ruby_optimize_wrap do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:default].set_version(:v1)
+        expect(ruby_optimize_wrap(:v1) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:default].set_version(:other)
+        expect(ruby_optimize_wrap(:v1) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:default].set_version(:v2)
+        expect(ruby_optimize_wrap(:v2, :default) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:default].set_version(:other)
+        expect(ruby_optimize_wrap(:v2, :default) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:default].set_version(:v3)
+        expect(ruby_optimize_wrap(:v3, :default, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:default].set_version(:other)
+        expect(ruby_optimize_wrap(:v3, :default, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:default].set_version(:v1)
+        expect(ruby_optimize_wrap(:v1, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:default].set_version(:other)
+        expect(ruby_optimize_wrap(:v1, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        # TEST SET UP
+        def (@ruby_optimize[:test]).set_version(a_version)
+          @version = a_version
+        end
+        def (@ruby_optimize[:test]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:test]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:test]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:test]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:test]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:test].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:test].get_cookie_name).to eq('ruby-optimize-cookie-test')
+        expect(@ruby_optimize[:test].get_version_for_crawler).to eq(nil)
+        expect(@ruby_optimize[:test].get_is_crawler).to eq(false)
+        expect(@ruby_optimize[:test].get_versions.sort).to eq([:new, :old])
+        # TEST WRAP
+        expect do
+          ruby_optimize_wrap(:v444, :test) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - version must be one of the available versions: :v444')
+        @ruby_optimize[:test].set_version(:old)
+        expect(ruby_optimize_wrap(:old, :test) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test].set_version(:other)
+        expect(ruby_optimize_wrap(:old, :test) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:test].set_version(:new)
+        expect(ruby_optimize_wrap(:new, :test, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test].set_version(:other)
+        expect(ruby_optimize_wrap(:new, :test, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        # TEST2 SET UP
+        def (@ruby_optimize[:test2]).set_version(a_version)
+          @version = a_version
+        end
+        def (@ruby_optimize[:test2]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:test2]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:test2]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:test2]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:test2]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:test2].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:test2].get_cookie_name).to eq('ruby-optimize-cookie-test2')
+        expect(@ruby_optimize[:test2].get_version_for_crawler).to eq(nil)
+        expect(@ruby_optimize[:test2].get_is_crawler).to eq(false)
+        expect(@ruby_optimize[:test2].get_versions.sort).to eq([:new, :old])
+        # TEST2 WRAP
+        expect do
+          ruby_optimize_wrap(:v444, :test2) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - version must be one of the available versions: :v444')
+        @ruby_optimize[:test2].set_version(:old)
+        expect(ruby_optimize_wrap(:old, :test2) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test2].set_version(:other)
+        expect(ruby_optimize_wrap(:old, :test2) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:test2].set_version(:new)
+        expect(ruby_optimize_wrap(:new, :test2, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test2].set_version(:other)
+        expect(ruby_optimize_wrap(:new, :test2, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        # TEST3 SET UP
+        def (@ruby_optimize[:test3]).set_version(a_version)
+          @version = a_version
+        end
+        def (@ruby_optimize[:test3]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:test3]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:test3]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:test3]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:test3]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:test3].get_cookie_expiration).to eq(33)
+        expect(@ruby_optimize[:test3].get_cookie_name).to eq('ruby-optimize-cookie-test3')
+        expect(@ruby_optimize[:test3].get_version_for_crawler).to eq(nil)
+        expect(@ruby_optimize[:test3].get_is_crawler).to eq(false)
+        expect(@ruby_optimize[:test3].get_versions.sort).to eq([:v4, :v5])
+        # TEST3 WRAP
+        expect do
+          ruby_optimize_wrap(:v444, :test3) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - version must be one of the available versions: :v444')
+        @ruby_optimize[:test3].set_version(:v4)
+        expect(ruby_optimize_wrap(:v4, :test3) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test3].set_version(:other)
+        expect(ruby_optimize_wrap(:v4, :test3) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:test3].set_version(:v5)
+        expect(ruby_optimize_wrap(:v5, :test3, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test3].set_version(:other)
+        expect(ruby_optimize_wrap(:v5, :test3, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+        # TEST4 SET UP
+        def (@ruby_optimize[:test4]).set_version(a_version)
+          @version = a_version
+        end
+        def (@ruby_optimize[:test4]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:test4]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:test4]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:test4]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:test4]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:test4].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:test4].get_cookie_name).to eq('ruby-optimize-cookie-test4')
+        expect(@ruby_optimize[:test4].get_version_for_crawler).to eq(:v5)
+        expect(@ruby_optimize[:test4].get_is_crawler).to eq(false)
+        expect(@ruby_optimize[:test4].get_versions.sort).to eq([:v4, :v5])
+        # TEST4 WRAP
+        expect do
+          ruby_optimize_wrap(:v444, :test4) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - version must be one of the available versions: :v444')
+        @ruby_optimize[:test4].set_version(:v5)
+        expect(ruby_optimize_wrap(:v5, :test4) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test4].set_version(:other)
+        expect(ruby_optimize_wrap(:v5, :test4) do
+          'hello'
+        end).to eq('')
+        @ruby_optimize[:test4].set_version(:v4)
+        expect(ruby_optimize_wrap(:v4, :test4, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        @ruby_optimize[:test4].set_version(:other)
+        expect(ruby_optimize_wrap(:v4, :test4, version_for_crawler: true) do
+          'hello'
+        end).to eq('')
+      end
+    end
+    context 'crawler' do
+      let(:request) do
+        OpenStruct.new(user_agent: 'summify')
+      end
+      it 'correctly sets up the object, empty init scripts, empty wrap' do
+        ruby_optimize [ :v1, :v2, :v3 ]
+        ruby_optimize [ :old, :new ], scope: :test, version_for_crawler: :old
+        # WRAP GENERIC
+        expect do
+          ruby_optimize_wrap(:v1, :anotherscope) do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - scope not found: :anotherscope')
+        expect do
+          @ruby_optimize[:default].wrap('hello', :v1, 'true') do
+            'hello'
+          end
+        end.to raise_error('RubyOptimize - for_crawler must be a boolean: "true"')
+        # DEFAULT SET UP
+        def (@ruby_optimize[:default]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:default]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:default]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:default]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:default]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:default].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:default].get_cookie_name).to eq('ruby-optimize-cookie-default')
+        expect(@ruby_optimize[:default].get_version_for_crawler).to eq(nil)
+        expect(@ruby_optimize[:default].get_is_crawler).to eq(true)
+        expect(@ruby_optimize[:default].get_versions.sort).to eq([:v1, :v2, :v3])
+        # DEFAULT WRAP
+        expect(ruby_optimize_wrap(:xxx) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(:v1) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(:v2, :default) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(:v3, :default, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        expect(ruby_optimize_wrap(:v1, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        expect(ruby_optimize_wrap(version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        # TEST SET UP
+        def (@ruby_optimize[:test]).get_cookie_expiration
+          cookie_expiration
+        end
+        def (@ruby_optimize[:test]).get_cookie_name
+          cookie_name
+        end
+        def (@ruby_optimize[:test]).get_version_for_crawler
+          version_for_crawler
+        end
+        def (@ruby_optimize[:test]).get_is_crawler
+          is_crawler
+        end
+        def (@ruby_optimize[:test]).get_versions
+          versions
+        end
+        expect(@ruby_optimize[:test].get_cookie_expiration).to eq(15552000)
+        expect(@ruby_optimize[:test].get_cookie_name).to eq('ruby-optimize-cookie-test')
+        expect(@ruby_optimize[:test].get_version_for_crawler).to eq(:old)
+        expect(@ruby_optimize[:test].get_is_crawler).to eq(true)
+        expect(@ruby_optimize[:test].get_versions.sort).to eq([:new, :old])
+        # TEST WRAP
+        expect(ruby_optimize_wrap(:xxx, :test) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(:old, :test) do
+          'hello'
+        end).to eq('hello')
+        expect(ruby_optimize_wrap(:new, :test) do
+          'hello'
+        end).to eq('')
+        expect(ruby_optimize_wrap(:old, :test, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+        expect(ruby_optimize_wrap(:new, :test, version_for_crawler: true) do
+          'hello'
+        end).to eq('hello')
+      end
+    end
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: ruby_optimize
+version: !ruby/object:Gem::Version
+  version: '2.3'
+platform: ruby
+authors:
+- Adriano di Lauro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2017-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: With ruby_optimize you can set up multiple A/B tests, consistent across
+  session, in a clean way and without page flickering
+email:
+- adr_dilauro@hotmail.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- lib/ruby_optimize.rb
+- lib/ruby_optimize/common_controllers_and_helpers.rb
+- lib/ruby_optimize/controllers/action_controller_extension.rb
+- lib/ruby_optimize/helpers/action_view_extension.rb
+- lib/ruby_optimize/hooks.rb
+- lib/ruby_optimize/models/ab_test_handler.rb
+- lib/ruby_optimize/railtie.rb
+- lib/ruby_optimize/version.rb
+- ruby_optimize.gemspec
+- spec/ruby_optimize_spec.rb
+homepage: https://github.com/adrdilauro/ruby_optimize
+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.2.2
+signing_key:
+specification_version: 4
+summary: Tool to implement flexible A/B tests in Ruby on Rails
+test_files: []
+has_rdoc: