mixpal 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f7b06bf4a86525182d6d44a19848532e62cc51a
-  data.tar.gz: eb38535ae4ef5a101b61a8d30c0a4ed041c04b9d
+  metadata.gz: c04724d3a3e803dfd392c4635ee4480a41e959d4
+  data.tar.gz: 0ddb3d1b74618d3523cf32ed59ddbbbf39df457a
 SHA512:
-  metadata.gz: 8d4079b4038dad025ca08dfaefcb1239abeacbedccb1c0c7553e1cdaa8cea64849cd03717d83cf2315ede897b85634a55d6950e6de299dbd61f3354f9d97a08d
-  data.tar.gz: 883548ba1bb19454caa6052e2d812efe80f09680b22b1647034865f0c885042b462d1412a37ac152ca1c2786ee89e61ea827a721f6fce11331aab1346907380f
+  metadata.gz: 33668e11499b7a84380c2421d710213af257c858ed45cdc017c4e1aec0855277c73f65f818a323dc35ef520cc3484f8cbd320ff9dff3d9a0940dfebfbe25633f
+  data.tar.gz: 2ac2f904b86d599230c60b0d9a7f31327f03c3920ed60b2ce221ac1414992a556ed021951001852060bb3d88eabd38e0122697fa8d2a64a6f3d475568b47215f

data/.rubocop.yml

@@ -0,0 +1,23 @@
+Encoding:
+  Enabled: false
+
+Documentation:
+  Enabled: false
+
+ClassAndModuleChildren:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+MethodLength:
+  Enabled: false
+
+DoubleNegation:
+  Enabled: false
+
+AllCops:
+  Include:
+    - "Rakefile"
+  Exclude:
+    - "test_app/**/*"

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3

data/README.md

@@ -1,4 +1,4 @@
-# Mixpal
+# Mixpal [![Build Status](https://travis-ci.org/patbenatar/mixpal.svg?branch=master)](https://travis-ci.org/patbenatar/mixpal) [![Code Climate](https://codeclimate.com/github/patbenatar/mixpal/badges/gpa.svg)](https://codeclimate.com/github/patbenatar/mixpal)
 
 As the JavaScript library is Mixpanel's preferred method of usage,
 Mixpal aims to make it easier to work with from your Rails backend.
@@ -80,7 +80,7 @@ As with `register_user`, this method will also identify "special properties".
 
 ### Persistance Across Redirects
 
-Mixpal stores any tracked events or user data in `Rails.cache` when
+Mixpal stores any tracked events or user data in the session when
 it detects a redirect so it can output the appropriate Mixpanel JS integration
 code to the client on the following render. This enables us to do cool things
 like:
@@ -104,16 +104,12 @@ class UsersController < ActionController::Base
 end
 ```
 
-#### Customizing the storage adapter
+#### A note about `CookieStore` size limit
 
-You can specify a custom persistence storage adapter like so:
-
-```ruby
-Mixpal::Tracker.storage = MyCustomAdapter.new
-```
-
-Storage adapters must implement the following API: `write(key, value)`,
-`read(key)`, and `delete(key)`.
+When using Rails' default `ActionDispatch::Session::CookieStore`, a 4K cookie
+size limit is enforced. This cookie is shared by anything using the session.
+If you anticipate tracking many events or large data sets to Mixpal,
+[consider a different session store](http://guides.rubyonrails.org/action_controller_overview.html#session).
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]

data/lib/mixpal.rb

@@ -1,10 +1,10 @@
-require "mixpal/version"
-require "active_support/core_ext"
+require 'mixpal/version'
+require 'active_support/core_ext'
 
 module Mixpal
-  autoload :Util, "mixpal/util"
-  autoload :Tracker, "mixpal/tracker"
-  autoload :Event, "mixpal/event"
-  autoload :User, "mixpal/user"
-  autoload :Integration, "mixpal/integration"
+  autoload :Util, 'mixpal/util'
+  autoload :Tracker, 'mixpal/tracker'
+  autoload :Event, 'mixpal/event'
+  autoload :User, 'mixpal/user'
+  autoload :Integration, 'mixpal/integration'
 end

data/lib/mixpal/event.rb

@@ -14,13 +14,13 @@ module Mixpal
 
     def to_store
       {
-        name: name,
-        properties: properties,
+        'name' => name,
+        'properties' => properties
       }
     end
 
     def self.from_store(data)
-      new(data[:name], data[:properties])
+      new(data['name'], data['properties'])
     end
   end
-end
+end

data/lib/mixpal/integration.rb

@@ -10,25 +10,25 @@ module Mixpal
       def self.mixpanel_identity(object_method, attribute_method)
         self.mixpanel_identity_data = {
           object_method: object_method,
-          attribute_method: attribute_method,
+          attribute_method: attribute_method
         }
       end
     end
 
     def mixpanel
       @mixpanel ||= begin
-        identity = if data = self.class.mixpanel_identity_data
-          send(data[:object_method]).try(data[:attribute_method])
-        end
+        identity = if (data = self.class.mixpanel_identity_data)
+                     send(data[:object_method]).try(data[:attribute_method])
+                   end
 
-        Mixpal::Tracker.new(identity: identity)
+        Mixpal::Tracker.new(identity: identity).tap { |t| t.restore!(session) }
       end
     end
 
     private
 
     def store_mixpanel_if_redirecting
-      mixpanel.store! if status == 302
+      mixpanel.store!(session) if status == 302
     end
   end
-end
+end

data/lib/mixpal/tracker.rb

@@ -2,16 +2,12 @@ module Mixpal
   class Tracker
     attr_reader :events, :user_updates, :identity, :alias_user
 
-    STORAGE_KEY = "mixpal"
-    class_attribute :storage
-    self.storage = Rails.cache
+    STORAGE_KEY = 'mixpal'
 
-    def initialize(args={})
+    def initialize(args = {})
       @events = []
       @user_updates = []
 
-      restore!
-
       @identity = args[:identity]
     end
 
@@ -24,44 +20,51 @@ module Mixpal
       user_updates << Mixpal::User.new(properties)
     end
 
-    def track(name, properties={})
+    def track(name, properties = {})
       events << Mixpal::Event.new(name, properties)
     end
 
     def render
-      "".tap do |html|
-        html << "<script type=\"text/javascript\">"
+      ''.tap do |html|
+        html << '<script type="text/javascript">'
         html << "mixpanel.alias(\"#{identity}\");" if alias_user
         html << "mixpanel.identify(\"#{identity}\");" if identity
-        html << events.map(&:render).join("")
-        html << user_updates.map(&:render).join("")
-        html << "</script>"
+        html << events.map(&:render).join('')
+        html << user_updates.map(&:render).join('')
+        html << '</script>'
       end.html_safe
     end
 
-    def store!
-      self.class.storage.write(STORAGE_KEY, to_store)
+    def store!(session)
+      session[STORAGE_KEY] = to_store
     end
 
-    private
+    def restore!(session)
+      data = session[STORAGE_KEY] || {}
+
+      @alias_user = data['alias_user']
+      @identity ||= data['identity']
 
-    def restore!
-      data = self.class.storage.read(STORAGE_KEY) || {}
+      if data['events']
+        @events = data['events'].map { |e| Mixpal::Event.from_store(e) }
+      end
 
-      @alias_user = data[:alias_user]
-      @identity = data[:identity]
-      @events = data[:events].map { |e| Mixpal::Event.from_store(e) } if data[:events]
-      @user_updates = data[:user_updates].map { |u| Mixpal::User.from_store(u) } if data[:user_updates]
+      if data['user_updates']
+        @user_updates = data['user_updates']
+          .map { |u| Mixpal::User.from_store(u) }
+      end
 
-      self.class.storage.delete(STORAGE_KEY)
+      session.delete(STORAGE_KEY)
     end
 
+    private
+
     def to_store
       {
-        alias_user: @alias_user,
-        identity: identity,
-        events: events.map(&:to_store),
-        user_updates: user_updates.map(&:to_store),
+        'alias_user' => alias_user,
+        'identity' => identity,
+        'events' => events.map(&:to_store),
+        'user_updates' => user_updates.map(&:to_store)
       }
     end
   end

data/lib/mixpal/user.rb

@@ -12,12 +12,12 @@ module Mixpal
 
     def to_store
       {
-        properties: properties,
+        'properties' => properties
       }
     end
 
     def self.from_store(data)
-      new(data[:properties])
+      new(data['properties'])
     end
 
     private
@@ -29,15 +29,17 @@ module Mixpal
     # Isolate special properties and rename their keys to align with
     # Mixpanel's naming.
     def properties_for_mixpanel
-      Hash[properties.map {|k, v| [mixpanel_special_properties_map[k] || k, v] }]
+      Hash[
+        properties.map { |k, v| [mixpanel_special_properties_map[k] || k, v] }
+      ]
     end
 
     def mixpanel_special_properties_map
       {
-        name: "$name",
-        email: "$email",
-        created_at: "$created",
+        name: '$name',
+        email: '$email',
+        created_at: '$created'
       }.with_indifferent_access
     end
   end
-end
+end

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.1.0'
 end

data/mixpanel_assistant.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "rubocop", "~> 0.24.1"
   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"

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
+  describe '#render' do
+    it 'delegates to Util for js_object composition' do
       Mixpal::Util.should_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/tracker_spec.rb

@@ -1,278 +1,256 @@
-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
-    before do
-      @original_adapter = described_class.storage
-
-      MyCustomStorageAdapter = Class.new(MockStorage)
-      @adapter_instance = MyCustomStorageAdapter.new
-
-      described_class.storage = @adapter_instance
-    end
-
-    after { described_class.storage = @original_adapter }
-
-    it "uses the specified adapter" do
-      @adapter_instance.should_receive :write
-      subject.store!
-    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
+    context 'with an :identity arg' do
       subject { subject_with_identity }
 
-      it "sets the identity" do
-        expect(subject.identity).to eq "nick"
-      end
-    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") }
-
-        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")
+  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" }
+    it 'delegates to #update_user for tracking user properties' do
+      properties = { name: 'Nick' }
       subject.should_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" }
+  describe '#update_user' do
+    it 'instantiates a new User object with properties' do
+      properties = { name: 'Nick' }
       Mixpal::User.should_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)
     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)
       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)
     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
+      it 'delegates render to the events' do
         subject.events.each { |event| event.should_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
+      it 'delegates render to the users' do
         subject.user_updates.each { |user| user.should_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) }
+  describe '#store!' do
+    let(:session) { {} }
 
     def storage_should_include(hash_fragment)
-      storage.should_receive(:write).with(
-        described_class::STORAGE_KEY,
-        hash_including(hash_fragment)
-      )
-    end
-
-    it "writes to the storage adapter" do
-      storage.should_receive(:write)
-      subject.store!
+      expect(session[described_class::STORAGE_KEY]).to include hash_fragment
     end
 
-    context "when alias_user is set" do
-      before { subject.register_user({}) }
-
-      it "stores the alias_user property" do
-        storage_should_include(alias_user: true)
-        subject.store!
-      end
+    it 'stores the alias_user property' do
+      subject.register_user({})
+      subject.store!(session)
+      storage_should_include('alias_user' => true)
     end
 
-    context "when identity is set" do
-      subject { subject_with_identity }
-
-      it "stores the identity" do
-        storage_should_include(identity: identity)
-        subject.store!
-      end
+    it 'stores the identity' do
+      subject_with_identity.store!(session)
+      storage_should_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
+      it 'delegates composition to the events' do
         subject.events.each { |event| event.should_receive :to_store }
-        subject.store!
+        subject.store!(session)
       end
 
-      it "stores the events' composed hashes in an array" do
+      it 'stores the events composed hashes in an array' do
+        subject.store!(session)
         storage_should_include(
-          events: [subject.events[0].to_store, subject.events[1].to_store]
+          '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
+      it 'delegates composition to the users' do
         subject.user_updates.each { |user| user.should_receive :to_store }
-        subject.store!
+        subject.store!(session)
       end
 
-      it "stores the users' composed hashes in an array" do
+      it 'stores the users composed hashes in an array' do
+        subject.store!(session)
+
         storage_should_include(
-          user_updates: [
+          '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
+      Mixpal::Event.should_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