mixpal 0.0.5 → 0.4.0

data/lib/mixpal/util.rb

@@ -2,12 +2,12 @@ module Mixpal
   module Util
     class << self
       def hash_to_js_object_string(hash)
-        hash.reject! { |k,v| v.nil? }
+        hash.reject! { |_, v| v.nil? }
 
-        contents = hash.map do |k,v|
+        contents = hash.map do |k, v|
           js_value = v.is_a?(String) || v.is_a?(Time) ? "\"#{v}\"" : v
           "\"#{k}\": #{js_value}"
-        end.join(",").html_safe
+        end.join(',').html_safe
 
         "{#{contents}}"
       end

data/lib/mixpal/version.rb

@@ -1,3 +1,3 @@
 module Mixpal
-  VERSION = "0.0.5"
+  VERSION = '0.4.0'
 end

data/mixpanel_assistant.gemspec

@@ -6,7 +6,7 @@ require 'mixpal/version'
 Gem::Specification.new do |spec|
   spec.name          = "mixpal"
   spec.version       = Mixpal::VERSION
-  spec.authors       = ["patbenatar"]
+  spec.authors       = ["patbenatar", "mikehmorrissey"]
   spec.email         = ["nick@gophilosophie.com"]
   spec.description   = "Use Mixpanel's JavaScript library from your backend with ease"
   spec.summary       = "As the JavaScript library is Mixpanel's preferred method of usage, Mixpal aims to make it easier to work with from your Rails backend. Most notably it persists tracking data across redirects, perfect for handling events like user sign ups or form submissions."
@@ -18,14 +18,15 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler", "~> 2"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "rspec", "~> 2.14.0"
-  spec.add_development_dependency "guard-rspec", "~> 3.0.3"
-  spec.add_development_dependency "rb-fsevent", "~> 0.9.3"
-  spec.add_development_dependency "awesome_print", "~> 1.1.0"
-  spec.add_development_dependency "nokogiri", "~> 1.6.0"
+  spec.add_development_dependency "rubocop", "~> 0.91.0"
+  spec.add_development_dependency "rspec", "~> 3.9.0"
+  spec.add_development_dependency "guard-rspec", "~> 4.7.3"
+  spec.add_development_dependency "rb-fsevent", "~> 0.10.4"
+  spec.add_development_dependency "awesome_print", "~> 1.8.0"
+  spec.add_development_dependency "nokogiri", "~> 1"
 
   spec.add_development_dependency "actionpack", ">= 3.0"
 

data/spec/lib/mixpal/event_spec.rb

@@ -1,48 +1,50 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Mixpal::Event do
-  let(:name) { "Event 1" }
-  let(:properties) { { title: "Awesome Product" } }
+  let(:name) { 'Event 1' }
+  let(:properties) { { title: 'Awesome Product' } }
   subject { described_class.new(name, properties) }
 
-  describe "#render" do
-    it "delegates to Util for js_object composition" do
-      Mixpal::Util.should_receive(:hash_to_js_object_string).with(properties)
+  describe '#render' do
+    it 'delegates to Util for js_object composition' do
+      expect(Mixpal::Util).to receive(:hash_to_js_object_string).with(properties)
       subject.render
     end
 
-    it "outputs a call to track" do
+    it 'outputs a call to track' do
       js_object = Mixpal::Util.hash_to_js_object_string(properties)
       expect(subject.render).to eq "mixpanel.track(\"#{name}\", #{js_object});"
     end
 
-    it "outputs an html safe string" do
+    it 'outputs an html safe string' do
       expect(subject.render).to be_html_safe
     end
   end
 
-  describe "#to_store" do
-    it "returns a hash with its data" do
+  describe '#to_store' do
+    it 'returns a hash with its data' do
       expect(subject.to_store).to eq(
-        name: name,
-        properties: properties,
+        'name' => name,
+        'properties' => properties
       )
     end
   end
 
-  describe ".from_store" do
-    let(:result) { described_class.from_store(name: name, properties: properties) }
+  describe '.from_store' do
+    let(:result) do
+      described_class.from_store('name' => name, 'properties' => properties)
+    end
 
-    it "instantiates a new instance" do
+    it 'instantiates a new instance' do
       expect(result).to be_an_instance_of(described_class)
     end
 
-    it "sets its name from the data" do
+    it 'sets its name from the data' do
       expect(result.name).to eq name
     end
 
-    it "sets its properties from the data" do
+    it 'sets its properties from the data' do
       expect(result.properties).to eq properties
     end
   end
-end
+end

data/spec/lib/mixpal/revenue_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Mixpal::Revenue do
+  let(:properties) do
+    {
+      sku: 'SKU-1010'
+    }
+  end
+
+  let(:amount) { 50 }
+
+  let(:subject) { described_class.new(amount, properties) }
+
+  describe '#render' do
+    it 'delegates to Util for js_object composition' do
+      expect(Mixpal::Util).to receive(:hash_to_js_object_string).with(properties)
+      subject.render
+    end
+
+    it 'outputs a call to people.track_charge' do
+      js_object = Mixpal::Util.hash_to_js_object_string(properties)
+      expect(subject.render)
+        .to eq "mixpanel.people.track_charge(#{amount}, #{js_object});"
+    end
+
+    it 'outputs an html safe string' do
+      expect(subject.render).to be_html_safe
+    end
+  end
+
+  describe '#to_store' do
+    it 'returns a hash with its data' do
+      expect(subject.to_store).to eq(
+        'amount' => amount,
+        'properties' => properties
+      )
+    end
+  end
+
+  describe '#from_store' do
+    let(:result) do
+      described_class.from_store(
+        'amount' => amount,
+        'properties' => properties
+      )
+    end
+
+    it 'instantiates a new instance' do
+      expect(result).to be_an_instance_of(described_class)
+    end
+
+    it 'sets its amount from the data' do
+      expect(result.amount).to eq amount
+    end
+
+    it 'sets its properties from the data' do
+      expect(result.properties).to eq properties
+    end
+  end
+end

data/spec/lib/mixpal/tracker_spec.rb

@@ -1,278 +1,306 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Mixpal::Tracker do
   subject { Mixpal::Tracker.new }
-  let(:identity) { "nick" }
+  let(:identity) { 'nick' }
   let(:subject_with_identity) { Mixpal::Tracker.new(identity: identity) }
 
-  describe "custom storage adapter" do
+  context 'with configured helper module' do
     before do
-      @original_adapter = described_class.storage
-
-      MyCustomStorageAdapter = Class.new(MockStorage)
-      @adapter_instance = MyCustomStorageAdapter.new
-
-      described_class.storage = @adapter_instance
+      Mixpal.configure do |config|
+        config.helper_module = CustomEventsModule
+      end
     end
 
-    after { described_class.storage = @original_adapter }
-
-    it "uses the specified adapter" do
-      @adapter_instance.should_receive :write
-      subject.store!
+    it 'exposes helper module methods on tracker instance' do
+      expect(subject.custom_event).to eq true
     end
   end
 
-  describe "#initialize" do
-    it "creates an empty set of events" do
+  describe '#initialize' do
+    it 'creates an empty set of events' do
       expect(subject.events).to eq []
     end
 
-    it "creates an empty set of user_updates" do
+    it 'creates an empty set of user_updates' do
       expect(subject.user_updates).to eq []
     end
 
-    context "with an :identity arg" do
-      subject { subject_with_identity }
-
-      it "sets the identity" do
-        expect(subject.identity).to eq "nick"
-      end
+    it 'creates an empty set of revenue_updates' do
+      expect(subject.revenue_updates).to eq []
     end
 
-    context "when data exists in storage" do
-      let(:old_tracker) { Mixpal::Tracker.new(identity: identity) }
-
-      before do
-        old_tracker.track "Event 1"
-        old_tracker.register_user name: "Nick Giancola"
-        old_tracker.store!
-      end
-
-      it "restores the alias_user property" do
-        expect(subject.alias_user).to eq true
-      end
-
-      it "restores the events" do
-        expect(subject.events.size).to eq 1
-      end
-
-      it "delegates event restoration to the Event class" do
-        Mixpal::Event.should_receive(:from_store).
-          with(old_tracker.events.first.to_store)
-
-        subject
-      end
-
-      it "restores the events" do
-        expect(subject.events.size).to eq 1
-      end
-
-      context "when initialized with an identity" do
-        subject { Mixpal::Tracker.new(identity: "Franky") }
+    context 'with an :identity arg' do
+      subject { subject_with_identity }
 
-        it "overrides anything from storage" do
-          expect(subject.identity).to eq "Franky"
-        end
+      it 'sets the identity' do
+        expect(subject.identity).to eq 'nick'
       end
     end
   end
 
-  describe "#register_user" do
-    it "sets the alias_user flag so we render the alias call" do
-      subject.register_user(name: "Nick")
-      expect(subject.alias_user).to be_true
+  describe '#register_user' do
+    it 'sets the alias_user flag so we render the alias call' do
+      subject.register_user(name: 'Nick')
+      expect(subject.alias_user).to be true
     end
 
-    it "delegates to #update_user for tracking user properties" do
-      properties = { name: "Nick" }
-      subject.should_receive(:update_user).with(properties)
+    it 'delegates to #update_user for tracking user properties' do
+      properties = { name: 'Nick' }
+      expect(subject).to receive(:update_user).with(properties)
       subject.register_user(properties)
     end
   end
 
-  describe "#update_user" do
-    it "instantiates a new User object with properties" do
-      properties = { name: "Nick" }
-      Mixpal::User.should_receive(:new).with(properties)
+  describe '#update_user' do
+    it 'instantiates a new User object with properties' do
+      properties = { name: 'Nick' }
+      expect(Mixpal::User).to receive(:new).with(properties)
       subject.update_user(properties)
     end
 
-    it "adds the User to user_updates for rendering later" do
+    it 'adds the User to user_updates for rendering later' do
       expect do
-        subject.update_user(name: "Nick")
+        subject.update_user(name: 'Nick')
       end.to change(subject.user_updates, :size).by(1)
 
-      subject.user_updates.first.should be_an_instance_of(Mixpal::User)
+      expect(subject.user_updates.first).to be_an_instance_of(Mixpal::User)
     end
   end
 
-  describe "#track" do
-    it "instantiates a new Event object with properties" do
-      name = "Clicked Button"
-      properties = { color: "Green" }
+  describe '#track' do
+    it 'instantiates a new Event object with properties' do
+      name = 'Clicked Button'
+      properties = { color: 'Green' }
 
-      Mixpal::Event.should_receive(:new).with(name, properties)
+      expect(Mixpal::Event).to receive(:new).with(name, properties)
       subject.track(name, properties)
     end
 
-    it "adds the Event to events for rendering later" do
+    it 'adds the Event to events for rendering later' do
       expect do
-        subject.track("Clicked Button", color: "Green")
+        subject.track('Clicked Button', color: 'Green')
       end.to change(subject.events, :size).by(1)
 
-      subject.events.first.should be_an_instance_of(Mixpal::Event)
+      expect(subject.events.first).to be_an_instance_of(Mixpal::Event)
+    end
+  end
+
+  describe '#track_charge' do
+    it 'instantiates a new Revenue object with properties' do
+      properties = { sku: 'SKU-1010' }
+      expect(Mixpal::Revenue).to receive(:new).with(50, properties)
+      subject.track_charge(50, properties)
+    end
+
+    it 'adds the Revenue to revenue_updates for rendering later' do
+      expect do
+        subject.track_charge(50, sku: 'SKU-1010')
+      end.to change(subject.revenue_updates, :size).by(1)
+
+      expect(subject.revenue_updates.first).to be_an_instance_of(Mixpal::Revenue)
     end
   end
 
-  describe "#render" do
-    it "outputs script tag" do
-      expect(subject.render).to have_tag("script")
+  describe '#render' do
+    it 'outputs script tag' do
+      expect(subject.render).to have_tag('script')
     end
 
-    it "outputs an html safe string" do
+    it 'outputs an html safe string' do
       expect(subject.render).to be_html_safe
     end
 
-    context "with an identity" do
+    context 'with an identity' do
       subject { subject_with_identity }
 
-      it "outputs call to identify" do
+      it 'outputs call to identify' do
         expect(subject.render).to include "mixpanel.identify(\"#{identity}\");"
       end
 
-      context "when user is being registered" do
-        before { subject.register_user({ name: "Nick Giancola" }) }
+      context 'when user is being registered' do
+        before { subject.register_user(name: 'Nick Giancola') }
 
-        it "outputs call to alias by identity" do
+        it 'outputs call to alias by identity' do
           expect(subject.render).to include "mixpanel.alias(\"#{identity}\");"
         end
       end
     end
 
-    context "with no registered user" do
-      it "does not output call to alias" do
-        expect(subject.render).not_to include "mixpanel.alias"
+    context 'with no registered user' do
+      it 'does not output call to alias' do
+        expect(subject.render).not_to include 'mixpanel.alias'
       end
     end
 
-    context "without an identity" do
-      it "does not output call to identify" do
-        expect(subject.render).not_to include "mixpanel.indentify"
+    context 'without an identity' do
+      it 'does not output call to identify' do
+        expect(subject.render).not_to include 'mixpanel.indentify'
       end
     end
 
-    context "with tracked events" do
+    context 'with tracked events' do
       before do
-        subject.track("Event 1", { color: "Green" })
-        subject.track("Event 2", { title: "Something Awesome" })
+        subject.track('Event 1', color: 'Green')
+        subject.track('Event 2', title: 'Something Awesome')
       end
 
-      it "delegates render to the events" do
-        subject.events.each { |event| event.should_receive :render }
+      it 'delegates render to the events' do
+        subject.events.each { |event| expect(event).to receive :render }
         subject.render
       end
 
-      it "joins each rendered event" do
+      it 'joins each rendered event' do
         joined = subject.events[0].render + subject.events[1].render
         expect(subject.render).to include joined
       end
     end
 
-    context "with user properties" do
+    context 'with user properties' do
       before do
-        subject.update_user({ name: "Hank" })
-        subject.update_user({ location: "Los Angeles" })
+        subject.update_user(name: 'Hank')
+        subject.update_user(location: 'Los Angeles')
       end
 
-      it "delegates render to the users" do
-        subject.user_updates.each { |user| user.should_receive :render }
+      it 'delegates render to the users' do
+        subject.user_updates.each { |user| expect(user).to receive :render }
         subject.render
       end
 
-      it "joins each rendered user" do
+      it 'joins each rendered user' do
         joined = subject.user_updates[0].render + subject.user_updates[1].render
         expect(subject.render).to include joined
       end
     end
-  end
-
-  describe "#store!" do
-    let(:storage) { described_class::storage }
 
-    after { MockRails.cache.delete(described_class::STORAGE_KEY) }
+    context 'with revenue' do
+      before do
+        subject.track_charge(50)
+        subject.track_charge(100, sku: 'SKU-1010')
+      end
 
-    def storage_should_include(hash_fragment)
-      storage.should_receive(:write).with(
-        described_class::STORAGE_KEY,
-        hash_including(hash_fragment)
-      )
-    end
+      it 'delegates render to the revenues' do
+        subject.revenue_updates.each { |r| expect(r).to receive :render }
+        subject.render
+      end
 
-    it "writes to the storage adapter" do
-      storage.should_receive(:write)
-      subject.store!
+      it 'joins each rendered revenue' do
+        joined =
+          subject.revenue_updates[0].render + subject.revenue_updates[1].render
+        expect(subject.render).to include joined
+      end
     end
+  end
 
-    context "when alias_user is set" do
-      before { subject.register_user({}) }
+  describe '#store!' do
+    let(:session) { {} }
 
-      it "stores the alias_user property" do
-        storage_should_include(alias_user: true)
-        subject.store!
-      end
+    def expect_storage_to_include(hash_fragment)
+      expect(session[described_class::STORAGE_KEY]).to include hash_fragment
     end
 
-    context "when identity is set" do
-      subject { subject_with_identity }
+    it 'stores the alias_user property' do
+      subject.register_user({})
+      subject.store!(session)
+      expect_storage_to_include('alias_user' => true)
+    end
 
-      it "stores the identity" do
-        storage_should_include(identity: identity)
-        subject.store!
-      end
+    it 'stores the identity' do
+      subject_with_identity.store!(session)
+      expect_storage_to_include('identity' => identity)
     end
 
-    context "when events have been tracked" do
+    context 'when events have been tracked' do
       before do
-        subject.track("Event 1", { color: "Green" })
-        subject.track("Event 2", { title: "Something Awesome" })
+        subject.track('Event 1', color: 'Green')
+        subject.track('Event 2', title: 'Something Awesome')
       end
 
-      it "delegates composition to the events" do
-        subject.events.each { |event| event.should_receive :to_store }
-        subject.store!
+      it 'delegates composition to the events' do
+        subject.events.each { |event| expect(event).to receive :to_store }
+        subject.store!(session)
       end
 
-      it "stores the events' composed hashes in an array" do
-        storage_should_include(
-          events: [subject.events[0].to_store, subject.events[1].to_store]
+      it 'stores the events composed hashes in an array' do
+        subject.store!(session)
+        expect_storage_to_include(
+          'events' => [subject.events[0].to_store, subject.events[1].to_store]
         )
-
-        subject.store!
       end
     end
 
-    context "when user properties have been updated" do
+    context 'when user properties have been updated' do
       before do
-        subject.update_user({ name: "Hank" })
-        subject.update_user({ location: "Los Angeles" })
+        subject.update_user(name: 'Hank')
+        subject.update_user(location: 'Los Angeles')
       end
 
-      it "delegates composition to the users" do
-        subject.user_updates.each { |user| user.should_receive :to_store }
-        subject.store!
+      it 'delegates composition to the users' do
+        subject.user_updates.each { |user| expect(user).to receive :to_store }
+        subject.store!(session)
       end
 
-      it "stores the users' composed hashes in an array" do
-        storage_should_include(
-          user_updates: [
+      it 'stores the users composed hashes in an array' do
+        subject.store!(session)
+
+        expect_storage_to_include(
+          'user_updates' => [
             subject.user_updates[0].to_store,
             subject.user_updates[1].to_store
           ]
         )
+      end
+    end
+  end
+
+  describe '#restore!' do
+    let(:old_tracker) { Mixpal::Tracker.new(identity: identity) }
+    let(:session) { {} }
+
+    before do
+      old_tracker.track 'Event 1'
+      old_tracker.register_user name: 'Nick Giancola'
+      old_tracker.store!(session)
+    end
+
+    it 'restores the alias_user property' do
+      subject.restore!(session)
+      expect(subject.alias_user).to eq true
+    end
+
+    it 'restores the events' do
+      subject.restore!(session)
+      expect(subject.events.size).to eq 1
+    end
+
+    it 'delegates event restoration to the Event class' do
+      expect(Mixpal::Event).to receive(:from_store)
+        .with(old_tracker.events.first.to_store)
+
+      subject.restore!(session)
+    end
+
+    it 'restores the events' do
+      subject.restore!(session)
+      expect(subject.events.size).to eq 1
+    end
+
+    context 'with a different identity (e.g. after login)' do
+      subject { Mixpal::Tracker.new(identity: "#{identity}-2") }
+
+      it 'does not override identity with value in storage' do
+        subject.restore!(session)
+        expect(subject.identity).to eq "#{identity}-2"
+      end
+    end
+
+    context 'with no identity (e.g. after logout)' do
+      subject { Mixpal::Tracker.new(identity: nil) }
 
-        subject.store!
+      it 'overrides identity with value in storage' do
+        subject.restore!(session)
+        expect(subject.identity).to eq identity
       end
     end
   end
-end
+end