vignette 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2899584cc71727faccd169acd629f4823a1dcd8
-  data.tar.gz: f86dfe90395dbd08d08d426d83854034efb2986c
+  metadata.gz: f45e9d2eb38a89e35ec4bf6d0cf62d80f77b92ad
+  data.tar.gz: 8ab414f006635373e0a88eaae142b85f4a205c1c
 SHA512:
-  metadata.gz: e3edfbbff798f29ef81d164fc8871643f1b74c2b2e649fe7abf939cb28a8348cf022594b5570f8c387fdc8408969eaaa4e85fdf0215612fb3947cd445d966520
-  data.tar.gz: f364423a9963b72b70ae0ba27b166d74623f216e289b48f69155332625c1483bf536d80984ca101f5fd45269aa201db8012cb206100a673460bd35ca4db8c2c6
+  metadata.gz: 0f5b19dea4363391a52e2f7758e03007c0a616d29e15f59f285942d4b15ea3918ff7281160cee2427341bafd0139f7e7c658c97acd97fd13c565a75421c2d183
+  data.tar.gz: a98445107d11417e51eef0e16566a5cdc1559995ed061a8cc53b01930e02641ba68ccb96ef088620a10984ed14e60594a9c9e5a65946243975f009f5f38e6823

data/README.md

@@ -64,16 +64,6 @@ The choices for these tests are exposed through the `Vignette.test` method:
 
 You may store these values as properties in your analytics system.
 
-## Caveats
-
-Tests are stored in your store object based on the original input.  If you change the input of the test (regardless of the name), a new test will be created.  Thus [1,2,3].vignette(:numbers) and [2,3,4].vignette(:numbers) will always be considered unique tests.  New tests will overwrite old tests with the same name in `Vignette.tests`.  This is by design so that you can update the test, have new results, but keep the same test name in your analytics system.
-
-Note, you must use arrays that will not change between runs.  Thus, `[Date.today, 1.days.ago].vignette` will end up creating separate tests every time this code is run.  We use a `Zlib.crc32` check to check for uniqueness of an array.  Instead, this should be `[0,1].vignette.days.ago`.
-
-If you choose to store your `tests` in `cookies`, then the chosen result will be stored in a cookie sent to the user's browser.  Thus, be careful not to store any secret information in a test.
-
-For unnamed tests, the system will try to determine the name from the line in the file (e.g. `(app/models/user.rb:50)`).  When it does this, it will keep the name the same so long as the underlying array has the same crc32 code.  That is, even if that vignette moves off of line 50, the test will keep the same "name" until the choices of the test change.  This is a trade-off to allow un-named vignettes to be easily understood in an analytics system without having to name each one unless you would like to.
-
 ## Naming Tests
 
 Vignette tests can also be specifically named, e.g:
@@ -92,6 +82,16 @@ This will lead to `Vignette.tests` to include: `{ "cat_names" => "Chairman Meow"
 
 Without a name, Vignettes will try to name themselves based on the name of the falling calling them, e.g. `(app/models/user.rb:25)` or `(app/views/users/new.html.haml:22)`
 
+## Caveats
+
+Tests are stored in your store object based on the original input.  If you change the input of the test (regardless of the name), a new test will be created.  Thus [1,2,3].vignette(:numbers) and [2,3,4].vignette(:numbers) will always be considered unique tests.  New tests will overwrite old tests with the same name in `Vignette.tests`.  This is by design so that you can update the test, have new results, but keep the same test name in your analytics system.
+
+Note, you must use arrays that will not change between runs.  Thus, `[Date.today, 1.days.ago].vignette` will end up creating separate tests every time this code is run.  We use a `Zlib.crc32` check to check for uniqueness of an array.  Instead, this should be `[0,1].vignette.days.ago`.
+
+If you choose to store your `tests` in `cookies`, then the chosen result will be stored in a cookie sent to the user's browser.  Thus, be careful not to store any secret information in a test.
+
+For unnamed tests, the system will try to determine the name from the line in the file (e.g. `(app/models/user.rb:50)`).  When it does this, it will keep the name the same so long as the underlying array has the same crc32 code.  That is, even if that vignette moves off of line 50, the test will keep the same "name" until the choices of the test change.  This is a trade-off to allow un-named vignettes to be easily understood in an analytics system without having to name each one unless you would like to.
+
 ## Contributing
 
 1. Fork it

data/lib/vignette/object_extensions.rb

@@ -20,13 +20,12 @@ module ObjectExtensions
       key = "vignette_#{vignette_crc}"
       test_name = nil
 
-      store = Vignette.get_store
-      v = store[:v] ? JSON(store[:v]) : {}
+      vig = Vignette.vig
 
       test_name = if expect_consistent_name && name.present?
         name
-      elsif v[vignette_crc]
-        v[vignette_crc]['n']
+      elsif vig[vignette_crc]
+        vig[vignette_crc]['n']
       elsif name.present? # this logic looks weird, but this is if we don't expect consistent names *and* we don't have a name in v[]
         name
       else
@@ -34,13 +33,13 @@ module ObjectExtensions
         "(#{Vignette::strip_path(loc.absolute_path)}:#{loc.lineno})"
       end
 
-      result = if v.has_key?(vignette_crc)
-        v[vignette_crc]['v']
+      result = if vig.has_key?(vignette_crc)
+        vig[vignette_crc]['v']
       else
         # Store key into storage if not available
         new_value = self[Kernel.rand(length)]
 
-        store[:v] = v.merge(vignette_crc => { n: test_name, v: new_value, t: Time.now.to_i }).to_json
+        Vignette.set_vig( vig.merge(vignette_crc => { n: test_name, v: new_value, t: Time.now.to_i }) )
 
         new_value
       end
@@ -53,16 +52,25 @@ module ObjectExtensions
   module ActionControllerExtensions
 
     def self.included(controller)
-      controller.around_filter(:init_vignette)
+      controller.around_filter(:with_vignettes)
     end
 
     private
 
-    def init_vignette
-      Vignette.request_config(request, session, cookies)
-      yield
-    ensure
-      Vignette.clear_request # Clear request
+    def with_vignettes
+      # set repo based on what type of store we want
+      repo = case Vignette.store
+      when :session
+        session
+      when :cookies
+        cookies
+      when nil, :random
+        Hash.new
+      end
+
+      Vignette.with_repo(repo) do
+        yield
+      end
     end
 
   end

data/lib/vignette/version.rb

@@ -1,3 +1,3 @@
 module Vignette
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/lib/vignette.rb

@@ -13,10 +13,9 @@ module Vignette
     class TemplateRequiresNameError < VignetteStandardError; end
   end
 
-  # Your code goes here...
+  # Module Attributes, please set via `init()`
   mattr_accessor :logging
   mattr_accessor :store
-  mattr_accessor :request, :session, :cookies
 
   # Initialization Code
 
@@ -30,66 +29,67 @@ module Vignette
 
   # Member Functions
 
+  # Set any initializers
   def self.init(opts={})
-    opts = {
-      store: nil,
-      logging: nil
-    }.with_indifferent_access.merge(opts)
+    opts.each do |k,v|
+      Vignette.send("#{k}=", v)
+    end
+  end
 
-    Vignette.store = opts[:store]
+  # Sets the current repo to be used to get and store tests for this thread
+  def self.set_repo(repo)
+    Thread.current[:vignette_repo] = repo
   end
-  
-  # Settings for configuations
-  def self.request_config(request, session, cookies)
-    Vignette.request = request
-    Vignette.session = session
-    Vignette.cookies = cookies
+
+  # Clears the current repo on this thread
+  def self.clear_repo
+    set_repo(nil)
   end
 
-  def self.with_settings(request, session, cookies)
+  # Performs block with repo set to `repo` for this thread
+  def self.with_repo(repo)
     begin
-      Vignette.request_config(request, session, cookies)
+      Vignette.set_repo(repo)
 
       yield
     ensure
-      Vignette.clear_request
+      Vignette.clear_repo
     end
   end
-  
-  def self.clear_request
-    Vignette.request = Vignette.session = Vignette.cookies = nil # clear items
+
+  # Is Vignette active for this thread (i.e. do we have a repo?)
+  def self.active?
+    !Thread.current[:vignette_repo].nil?
   end
-  
-  def self.tests(session=Vignette.session, cookies=Vignette.cookies)
-    store = get_store(session, cookies)
-    store && store[:v].present? ? JSON(store[:v]) : {}
-    if store && store[:v].present?
-      v = JSON(store[:v])
 
-      name_values = v.values.map { |v| [ v['n'], [ v['t'], v['v'] ] ] }.group_by { |el| el[0] }
+  # Get the repo for this thread
+  def self.repo
+    raise Errors::ConfigError.new("Repo not active, please call Vignette.set_repo before using Vignette (or use around_filter in Rails)") if !active?
 
-      arr = name_values.map { |k,v| [ k.to_sym, v.sort { |a,b| b[1][0] <=> a[1][0] }.first[1][1] ] }
+    Thread.current[:vignette_repo]
+  end
 
-      Hash[arr]
-    else
-      {}
-    end
+  # From the repo (default whatever is set for the thread), grab Vignettes' repo and unpack
+  def self.vig(repo=nil)
+    repo ||= Vignette.repo # allow using existing
+
+    repo && repo[:v].present? ? JSON(repo[:v]) : {}
   end
-  
-  def self.get_store(session=Vignette.session, cookies=Vignette.cookies)
-    case Vignette.store
-    when :cookies
-      raise Errors::ConfigError, "Missing cookies configuration in Vignette.  Must access Vignette in controller within around_filter." if cookies.nil?
-      Rails.logger.debug [ 'Vignette::vignette', 'Cookies Sampling', cookies ] if Vignette.logging
-      cookies.signed
-    when :session
-      raise Errors::ConfigError, "Missing session configuration in Vignette.  Must access Vignette in controller within around_filter." if session.nil?
-      Rails.logger.debug [ 'Vignette::vignette', 'Session Sampling', session ] if Vignette.logging
-      session
-    else
-      Rails.logger.debug [ 'Vignette::vignette', 'Random Sampling' ] if Vignette.logging
-      {} # This is an empty storage
-    end
+
+  # For this repo, store an update Vig
+  def self.set_vig(vig)
+    repo[:v] = vig.to_json
+  end
+
+  # Pull all the tests for this current repo
+  def self.tests(vig=nil)
+    vig ||= Vignette.vig
+
+    name_values = vig.values.map { |v| [ v['n'], [ v['t'], v['v'] ] ] }.group_by { |el| el[0] }
+
+    arr = name_values.map { |k,v| [ k.to_sym, v.sort { |a,b| b[1][0] <=> a[1][0] }.first[1][1] ] }
+
+    Hash[arr]
   end
 
   private

data/spec/lib/vignette/filter_spec.rb

@@ -17,7 +17,7 @@ describe Haml::Filters::Vignette do
 " }
     
       it "should raise error" do
-        Vignette.with_settings(nil, session, nil) do
+        Vignette.with_repo(session) do
           html = Haml::Engine.new(template).render
 
           expect(html).to match(/\<p\>\s+three\s+\<\/p\>\n/)
@@ -38,7 +38,7 @@ describe Haml::Filters::Vignette do
 " }
 
       it "should correctly call vignette from render" do
-        Vignette.with_settings(nil, session, nil) do
+        Vignette.with_repo(session) do
           html = Haml::Engine.new(template).render
 
           expect(html).to eq("<p>\n  three\n</p>\n")
@@ -53,7 +53,7 @@ describe Haml::Filters::Vignette do
       before(:each) { expect(Kernel).to receive(:rand).and_return(2, 1) }
 
       it "should correctly call vignette from render" do
-        Vignette.with_settings(nil, session, nil) do
+        Vignette.with_repo(session) do
           template = File.read(template_file)
 
           html = Haml::Engine.new(template, filename: template_file).render

data/spec/lib/vignette/object_extensions_spec.rb

@@ -2,6 +2,47 @@ require 'spec_helper'
 
 describe ObjectExtensions do
 
-  pending "Add spec tests for object extensions" # note, these are mostly in `vignette_spec`
+  context "with a test controller" do
+    class TestController
+      @@filters = []
 
+      def self.filters
+        @@filters
+      end
+
+      def self.around_filter(filter)
+        @@filters << filter
+      end
+
+      include ObjectExtensions::ActionControllerExtensions
+
+      def session
+        { session_id: "whatever" }
+      end
+
+      def run(&block)
+        filter = @@filters.first # just make this easy
+
+        self.send(filter, &block)
+      end
+    end
+
+    it "should register an around_filter" do
+      expect(TestController.filters.count).to eq(1)
+    end
+
+    it "should correctly run around_filter" do
+      expect(Kernel).to receive(:rand).and_return(2)
+      expect(Vignette.active?).to be(false)
+
+      tc = TestController.new
+
+      tc.run do
+        expect(Vignette.repo).to eq(tc.session)
+        expect(Vignette.active?).to be(true)
+        expect([1,2,3].vignette(:number)).to eq(3)
+        expect(Vignette.tests).to eq(number: 3)
+      end
+    end
+  end
 end

data/spec/lib/vignette_spec.rb

@@ -5,7 +5,7 @@ describe Vignette do
   context 'with simple session store' do
     let!(:session) { Hash.new }
     let(:array) { %w{a b c} }
-    before { Vignette.session = session }
+    before { Vignette.set_repo(session) }
 
     it 'should have correct crc' do
       expect(array.crc).to eq(891568578)
@@ -98,4 +98,83 @@ describe Vignette do
     end
   end
 
+  context 'when threading' do
+    before(:each) { expect(Kernel).to receive(:rand).and_return(1, 2) }
+
+    context 'serially' do
+      it 'should work like normal' do
+        
+        Thread.new do
+          Vignette.with_repo(Hash.new) do
+            expect(%w{a b c}.vignette(:name)).to eq('b')
+            expect(Vignette.tests).to eq(name: 'b')
+          end
+        end.join
+
+        Thread.new do
+          Vignette.with_repo(Hash.new) do
+            expect(%w{a b c}.vignette(:name)).to eq('c')
+            expect(Vignette.tests).to eq(name: 'c')
+          end
+        end.join
+      end
+
+    end
+
+    context 'with no delays' do
+      it 'should work like normal' do
+        threads = []
+
+        threads << Thread.new do
+          Vignette.with_repo(Hash.new) do
+            expect(%w{a b c}.vignette(:name)).to eq('b')
+            expect(Vignette.tests).to eq(name: 'b')
+          end
+        end
+
+        threads << Thread.new do
+          Vignette.with_repo(Hash.new) do
+            expect(%w{a b c}.vignette(:name)).to eq('c')
+            expect(Vignette.tests).to eq(name: 'c')
+          end
+        end
+
+        threads.each(&:join)
+      end
+    end
+
+    context 'with a one second delay' do
+      it 'should work like normal' do
+        threads = []
+
+        threads << Thread.new do
+          Vignette.with_repo(Hash.new) do
+            sleep 0.1 # this is to cause a race condition
+            expect(%w{a b c}.vignette(:name)).to eq('c')
+            expect(Vignette.tests).to eq(name: 'c')
+
+            sleep 0.2
+            expect(%w{a b c}.vignette(:name)).to eq('c')
+            expect(Vignette.tests).to eq(name: 'c')
+          end
+        end
+
+        threads << Thread.new do
+          Vignette.with_repo(Hash.new) do
+            expect(%w{a b c}.vignette(:name)).to eq('b')
+            expect(Vignette.tests).to eq(name: 'b')
+
+            sleep 0.2
+
+            expect(%w{a b c}.vignette(:name)).to eq('b')
+            expect(Vignette.tests).to eq(name: 'b')            
+          end
+        end
+
+        threads.each(&:join)
+      end
+    end
+    
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vignette
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Geoff Hayes