meta_events 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
----
-SHA1:
-  metadata.gz: b0e91bff1639de3f7c06814202408e65284d049e
-  data.tar.gz: 44e8e53c21fef0ed5d59264359e695f8f63735a9
-SHA512:
-  metadata.gz: 347f0e4b5bb972dc9eb0ea40f636edc5a73c6f956def29db094beeb3c906d9bc88e58557163a40f114946e755f47e36d901d65ed9ec2ed02a5aa196fe0eb2003
-  data.tar.gz: 4afaffbe07364ff7f2c8601108c5e440dd0dccd69c5d46233671a076710b1d4998e44055beba7525b1a05ccad05352aec231b29458a4751cb6acd66b521e66ab
+--- 
+SHA1: 
+  metadata.gz: c8e90b6eab418b987148fddd9cef0821956dc09f
+  data.tar.gz: eba083b1ffef6f56b1775cc28ac55bd94e5c7dc9
+SHA512: 
+  metadata.gz: f2e1dbafa769577654782ecdfc7c1a7f8d0fb4b06a983b10677710bec4e85a79164412bcabc7af0ed77f8941588d4b9d40cdbe3c5881b3dba1f91a87bbf4e1e1
+  data.tar.gz: 39f251715f387ad67b30c8bee7ba12e9fa8be416e95c9309cfe18b9c57446721ef06dffae1ee3de84a167cd9685d7a0bf61a9bb8cafeca16b667f477f4f47c07

data/CHANGES.md

@@ -1,6 +1,10 @@
 # `meta_events` Changelog
 
-## 1.0.3,
+## 1.1.0, 25 May 2014
+
+* Support for customizing the event names to Mixpanel using any algorithm you want (`:external_name` in `MetaEvents::Tracker#initialize` or `MetaEvents::Tracker.default_external_name`), or by overriding them on an `Event`-by-`Event` basis (`:external_name` in the DSL on an `Event`). Many thanks to [Aaron Lerch](https://github.com/aaronlerch) for the awesome code and responsiveness!
+
+### 1.0.3, 24 March 2014
 
 * Fixed an issue where the `TestReceiver`'s `Rails.logger` reference could happen before `Rails.logger` was actually loaded, causing an exception. (Thanks to [Jesse Rusak](https://github.com/jder)!)
 * Fixed a minor documentation bug (Thanks to [Jesse Rusak](https://github.com/jder)!)

data/README.md

@@ -11,7 +11,9 @@ particularly dependent on exact Ruby versions, and should be compatible with a b
 
 Current build status: ![Current Build Status](https://api.travis-ci.org/swiftype/meta_events.png?branch=master)
 
-Brought to you by the folks at [Swiftype](https://www.swiftype.com/). First version written by [Andrew Geweke](https://www.github.com/ageweke).
+Brought to you by the folks at [Swiftype](https://www.swiftype.com/). First version written by [Andrew Geweke](https://www.github.com/ageweke). Major contributions by:
+
+* [Aaron Lerch](https://github.com/aaronlerch): support for sending human-readable event names to Mixpanel via `:external_name` in the DSL on an Event, or via `:external_name` in `MetaEvents::Tracker#initialize` or `MetaEvents::Tracker.default_external_name`.
 
 ### Background
 
@@ -589,6 +591,39 @@ it is difficult or impossible to know if true underlying usage, etc., _actually_
 of changing events.) You can simply create two `MetaEvents::Tracker` instances, one for each version, and use them
 in parallel.
 
+### Customizing the Event Name
+
+Developers love names like "xyz1_user_signed_up" but sometimes it's not a developer doing the analysis.
+Depending on what the back-end analytics library supports, event names in external systems are frequently not
+given a lot of real estate.
+
+In cases like these, you can override the default external event name behavior. There are three ways to
+override these external names.
+
+First, you can override them globally for all `MetaEvents::Tracker` instances:
+
+    MetaEvents::Tracker.default_external_name = lambda { |event| "#{event.category_name} #{event.name}" }
+
+Second, you can override them for a specific `MetaEvents::Tracker` instance:
+
+    MetaEvents::Tracker.new(current_user.try(:id),
+                        request.remote_ip,
+                        :external_name => lambda { |event| "#{event.category_name} #{event.name}" }
+                       )
+
+Finally, you can override each event's external name in the events DSL:
+
+    global_events_prefix :ab
+
+    version 1, "2014-02-11" do
+      category :example_category do
+        event :example_event, "2014-02-11", "Example was exampled!", :external_name => 'ex. was ex.'
+      end
+    end
+
+The order of precedence for determining the external event name is the DSL's `event :external_name => 'foo'`,
+`MetaEvents::Tracker.new`, `MetaEvents::Tracker.default_external_name`, built-in default.
+
 ## Contributing
 
 1. Fork it ( http://github.com/swiftype/meta_events/fork )

data/lib/meta_events/definition/category.rb

@@ -1,5 +1,6 @@
 require "meta_events"
 require "meta_events/definition/event"
+require "active_support"
 require "active_support/core_ext"
 
 module MetaEvents

data/lib/meta_events/definition/event.rb

@@ -89,12 +89,18 @@ module MetaEvents
         @introduced
       end
 
+      # Returns, or sets, an external_name to use for an event.
+      def external_name(name = nil)
+        @external_name = name if name
+        @external_name
+      end
+
       # Returns the name of the category for an event.
       def category_name
         category.name
       end
 
-      # Returns the full name of an event, including all prefixes.
+      # Returns the canonical full name of an event, including all prefixes.
       def full_name
         "#{category.prefix}#{name}"
       end
@@ -139,12 +145,12 @@ module MetaEvents
       # Called with the set of options (which can be empty) supplied in the constructor; responsible for applying those
       # to the object properly.
       def apply_options!(options)
-        options.assert_valid_keys(:introduced, :desc, :description, :retired_at)
+        options.assert_valid_keys(:introduced, :desc, :description, :retired_at, :external_name)
 
         introduced options[:introduced] if options[:introduced]
         desc options[:desc] if options[:desc]
         desc options[:description] if options[:description]
-
+        external_name options[:external_name] if options[:external_name]
 
         @retired_at = Time.parse(options[:retired_at]) if options[:retired_at]
       end

data/lib/meta_events/definition/version.rb

@@ -50,7 +50,7 @@ module MetaEvents
         instance_eval(&block) if block
       end
 
-      # Returns the prefix that all events in this version should have -- something like "st1", for example.
+      # Returns the prefix that all events in this version should have -- something like "pz1", for example.
       def prefix
         "#{definition_set.global_events_prefix}#{number}_"
       end

data/lib/meta_events/tracker.rb

@@ -219,6 +219,22 @@ module MetaEvents
   #
   # We recommend that you keep the global events prefix short, simply because tools like Mixpanel often have a
   # relatively small amount of screen real estate available for event names.
+  #
+  # ### Overriding Event Names
+  #
+  # There might be a situation where users performing analysis desire a friendlier name than the default.
+  # The external name can be customized with a lambda (or any object that responds to <tt>#call(event)</tt>).
+  # To customize the external name for all MetaEvents::Tracker instances, 
+  # specify <tt>MetaEvents::Tracker.default_external_name = lambda { |event| "custom event name" }</tt>.
+  # 
+  # To customize the external name for a specific MetaEvents::Tracker instance, pass the lambda 
+  # in the constructor, for example:
+  # <tt>MetaEvents::Tracker.new(current_user.id, request.remote_ip, :external_name => lambda {|e| "#{e.full_name}_CUSTOM" })</tt>
+  #
+  # To reset default behavior back to the built-in default, simply set <tt>MetaEvents::Tracker.default_external_name = nil</tt>
+  #
+  # The event passed to external_name is an instance of ::MetaEvents::Definition::Event
+  #
   class Tracker
     class EventError < StandardError; end
     class PropertyCollisionError < EventError; end
@@ -231,17 +247,34 @@ module MetaEvents
     cattr_accessor :default_event_receivers
     self.default_event_receivers = [ ]
 
-    # The set of event definitions from the MetaEvents DSL that MetaEvents::Tracker instances will use, by default (_i.e._, if not
-    # passed a separate definitions file using <tt>:definitions =></tt> in the constructor). You can set this to
-    # the pathname of a file containing event definitions, an +IO+ object containing the text of event definitions, or
-    # an ::MetaEvents::Definition::DefinitionSet object that you create any way you want.
-    #
-    # Reading +default_definitions+ always will return an instance of ::MetaEvents::Definition::DefinitionSet.
     class << self
+
+      # The set of event definitions from the MetaEvents DSL that MetaEvents::Tracker instances will use, by default (_i.e._, if not
+      # passed a separate definitions file using <tt>:definitions =></tt> in the constructor). You can set this to
+      # the pathname of a file containing event definitions, an +IO+ object containing the text of event definitions, or
+      # an ::MetaEvents::Definition::DefinitionSet object that you create any way you want.
+      #
+      # Reading +default_definitions+ always will return an instance of ::MetaEvents::Definition::DefinitionSet.
       def default_definitions=(source)
         @default_definitions = ::MetaEvents::Definition::DefinitionSet.from(source)
       end
       attr_reader :default_definitions
+
+      # The built-in default calculation of an external event name, which is the event's <tt>:full_name</tt>
+      DEFAULT_EXTERNAL_NAME = lambda { |event| event.full_name }
+
+      # The default value that new MetaEvents::Tracker instances will use to provide external names for events.
+      def default_external_name=(provider)
+        if provider && !provider.respond_to?(:call)
+          raise ArgumentError, "default_external_name must respond to #call"
+        end
+        @default_external_name = provider
+      end
+
+      # If a default external name provider was not specified, use the built-in default.
+      def default_external_name
+        @default_external_name || DEFAULT_EXTERNAL_NAME
+      end
     end
 
     # The default version that new MetaEvents::Tracker instances will use to look up events in the MetaEvents DSL.
@@ -260,6 +293,9 @@ module MetaEvents
     # The version of events that this Tracker is using.
     attr_reader :version
 
+    # A method that provides the external name for an event.
+    attr_reader :external_name
+
     # Creates a new instance.
     #
     # +distinct_id+ is the "distinct ID" of the user on behalf of whom events are going to be fired; this can be +nil+
@@ -297,8 +333,11 @@ module MetaEvents
     #                        with every event fired from this Tracker. This can use the hash-merge and object syntax
     #                        (#to_event_properties) documented above. Any properties explicitly passed with an event
     #                        that have the same name as these properties will override these properties for that event.
+    # [:external_name] If present, this should be a lambda that takes a single argument and returns a string, or an 
+    #                  object that responds to call(event). If +:external_name+ is not provided, it will use the
+    #                  default configured for the MetaEvents::Tracker class.
     def initialize(distinct_id, ip, options = { })
-      options.assert_valid_keys(:definitions, :version, :implicit_properties, :event_receivers)
+      options.assert_valid_keys(:definitions, :version, :external_name, :implicit_properties, :event_receivers)
 
       definitions = options[:definitions] || self.class.default_definitions
       unless definitions
@@ -311,6 +350,8 @@ module MetaEvents
 
       @definitions = ::MetaEvents::Definition::DefinitionSet.from(definitions)
       @version = options[:version] || self.class.default_version || raise(ArgumentError, "Must specify a :version")
+      @external_name = options[:external_name] || self.class.default_external_name || raise(ArgumentError, "Must specify an :external_name")
+      raise ArgumentError, ":external_name option must respond to #call" unless @external_name.respond_to? :call
 
       @implicit_properties = { }
       self.class.merge_properties(@implicit_properties, { :ip => normalize_ip(ip).to_s }) if ip
@@ -346,19 +387,20 @@ module MetaEvents
       event_data[:properties] = { 'time' => Time.now.to_i }.merge(event_data[:properties])
 
       self.event_receivers.each do |receiver|
-        receiver.track(event_data[:distinct_id], event_data[:event_name], event_data[:properties])
+        receiver.track(event_data[:distinct_id], event_data[:external_name], event_data[:properties])
       end
     end
 
     # Given a category, an event, and (optionally) additional properties, performs all of the expansion and validation
     # of #event!, but does not actually fire the event -- rather, returns a Hash containing:
     #
-    # [:distinct_id] The +distinct_id+ that should be passed with the event; this can be +nil+ if there is no distinct
-    #                ID being passed.
-    # [:event_name]  The fully-qualified event name, including +global_events_prefix+ and version number, exactly as
-    #                it should be passed to an events backend.
-    # [:properties]  The full set of properties, expanded (so values will only be scalars, never Hashes or objects),
-    #                with String keys, exactly as they should be passed to an events system.
+    # [:distinct_id]   The +distinct_id+ that should be passed with the event; this can be +nil+ if there is no distinct
+    #                  ID being passed.
+    # [:event_name]    The fully-qualified event name, including +global_events_prefix+ and version number.
+    # [:external_name] The event name for use in an events backend.
+    #                  By default this is +:event_name+ but can be overridden.
+    # [:properties]    The full set of properties, expanded (so values will only be scalars, never Hashes or objects),
+    #                  with String keys, exactly as they should be passed to an events system.
     #
     # This method can be used for many things, but its primary purpose is to support front-end (Javascript-fired)
     # events: you can have it compute exactly the set of properties that should be attached to such events, embed
@@ -376,10 +418,14 @@ module MetaEvents
       # We need to do this instead of just using || so that you can override a present distinct_id with nil.
       net_distinct_id = if properties.has_key?('distinct_id') then properties.delete('distinct_id') else self.distinct_id end
 
+      event_external_name = event.external_name || external_name.call(event)
+      raise TypeError, "The external name of an event must be a String" unless event_external_name.kind_of?(String)
+
       {
-        :distinct_id => net_distinct_id,
-        :event_name  => event.full_name,
-        :properties  => properties
+        :distinct_id   => net_distinct_id,
+        :event_name    => event.full_name,
+        :external_name => event_external_name,
+        :properties    => properties
       }
     end
 

data/lib/meta_events/version.rb

@@ -1,3 +1,3 @@
 module MetaEvents
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/spec/meta_events/controller_methods_and_helpers_spec.rb

@@ -7,6 +7,7 @@ describe MetaEvents::ControllerMethods do
         category :foo do
           event :bar, '2014-01-31', 'this is bar'
           event :baz, '2014-01-31', 'this is baz'
+          event :custom, '2014-01-31', 'this is quux', :external_name => 'super-amazing-custom'
         end
       end
     end
@@ -50,11 +51,16 @@ describe MetaEvents::ControllerMethods do
   end
 
   describe "frontend-event registration" do
-    def expect_defined_event(name, event_name, properties, options = { })
+    def expect_defined_event(name, external_name, properties, options = { })
+      expect_defined_event_with_event_name(name, external_name, external_name, properties, options)
+    end
+
+    def expect_defined_event_with_event_name(name, external_name, event_name, properties, options = { })
       expected_distinct_id = options[:distinct_id] || 'abc123'
       expect(@obj.meta_events_defined_frontend_events[name]).to eq({
         :distinct_id => expected_distinct_id,
         :event_name => event_name,
+        :external_name => external_name,
         :properties => properties
       })
 
@@ -63,7 +69,7 @@ describe MetaEvents::ControllerMethods do
       js =~ /["']#{name}["']\s*,\s*(.*?)\s*\)\s*\;/i
       matched = $1
       hash = JSON.parse($1)
-      expect(hash).to eq('distinct_id' => expected_distinct_id, 'event_name' => event_name, 'properties' => properties)
+      expect(hash).to eq('distinct_id' => expected_distinct_id, 'event_name' => event_name, 'external_name' => external_name, 'properties' => properties)
     end
 
     it "should work fine if there are no registered events" do
@@ -99,6 +105,11 @@ describe MetaEvents::ControllerMethods do
       expect_defined_event('foo_bar', 'xy1_foo_bar', { 'imp1' => 'imp1val2', 'a_b' => 'c', 'a_d' => 'e' })
     end
 
+    it "should use an overridden external_name" do
+      @obj.meta_events_define_frontend_event(:foo, :custom, { :imp1 => 'imp1val1' })
+      expect_defined_event_with_event_name('foo_custom', 'super-amazing-custom', 'xy1_foo_custom', { 'imp1' => 'imp1val1' })
+    end
+
     context "with one simple defined event" do
       before :each do
         @obj.meta_events_define_frontend_event(:foo, :bar, { :quux => 123 })

data/spec/meta_events/definition/event_spec.rb

@@ -52,6 +52,11 @@ describe ::MetaEvents::Definition::Event do
     expect(klass.new(category, :foo, "2014-01-01") { desc 'foobar' }.desc).to eq("foobar")
   end
 
+  it "should let you set external_name via both mechanisms" do
+    expect(klass.new(category, :foo, "2014-01-01", "foobar", :external_name => "custom external name").external_name).to eq("custom external name")
+    expect(klass.new(category, :foo, "2014-01-01", "foobar") { external_name "custom external name" }.external_name).to eq("custom external name")
+  end
+
   context "with an instance" do
     let(:instance) { klass.new(category, :foo, "2014-01-01", "foobar") }
 
@@ -142,5 +147,15 @@ describe ::MetaEvents::Definition::Event do
       expect(note_2[:who]).to eq("someone else")
       expect(note_2[:text]).to eq("whatever")
     end
+
+    context "with a custom external name" do
+      let(:instance) { klass.new(category, :foo, "2014-01-01", "foobar", :external_name => "custom external name") }
+
+      it "should return and allow setting its external name via #external_name" do
+        expect(instance.external_name).to eq("custom external name")
+        instance.external_name "my name"
+        expect(instance.external_name).to eq("my name")
+      end
+    end
   end
 end

data/spec/meta_events/tracker_spec.rb

@@ -1,3 +1,4 @@
+require "active_support"
 require 'active_support/core_ext/numeric/time'
 require 'ipaddr'
 
@@ -8,7 +9,7 @@ describe MetaEvents::Tracker do
       version 1, '2014-01-31' do
         category :foo do
           event :bar, '2014-01-31', 'this is bar'
-          event :baz, '2014-01-31', 'this is baz'
+          event :baz, '2014-01-31', 'this is baz', :external_name => 'foo bazzeroo'
           event :nolonger, '2014-01-31', 'should be retired', :retired_at => '2020-01-01'
         end
       end
@@ -299,11 +300,92 @@ EOS
     end
 
     it "should pick up the default version from the class" do
-      klass.default_version = 2
+      original_default_version = klass.default_version
 
-      i = klass.new(@distinct_id, nil, :event_receivers => receiver_1, :definitions => definition_set)
-      i.event!(:foo, :quux)
-      expect_event("xy2_foo_quux", { })
+      begin
+        klass.default_version = 2
+
+        i = klass.new(@distinct_id, nil, :event_receivers => receiver_1, :definitions => definition_set)
+        i.event!(:foo, :quux)
+        expect_event("xy2_foo_quux", { })
+      ensure
+        klass.default_version = original_default_version
+      end
+    end
+
+    it "should use the default external name from the class" do
+      begin
+        klass.default_external_name = lambda { |event| "#{event.category_name}-super-custom-#{event.name}" }
+
+        i = klass.new(@distinct_id, nil, :event_receivers => receiver_1, :definitions => definition_set)
+        i.event!(:foo, :bar, { })
+        expect_event('foo-super-custom-bar', { })
+      ensure
+        klass.default_external_name = nil
+      end
+    end
+
+    it "should allow resetting the default external name from the class back to the built-in default" do
+      begin
+        klass.default_external_name = lambda { |event| "#{event.category_name}-super-custom-#{event.name}" }
+
+        i = klass.new(@distinct_id, nil, :event_receivers => receiver_1, :definitions => definition_set)
+        i.event!(:foo, :bar, { })
+        expect_event('foo-super-custom-bar', { })
+
+        klass.default_external_name = nil
+
+        i = klass.new(@distinct_id, nil, :event_receivers => receiver_1, :definitions => definition_set)
+        i.event!(:foo, :bar, { })
+        expect_event('xy1_foo_bar', { })
+      ensure
+        klass.default_external_name = nil
+      end
+    end
+
+    it "should allow overriding the external name in the constructor" do
+      i = new_instance(@distinct_id, nil, :definitions => definition_set, :external_name => lambda { |event| "#{event.category_name}-super-custom-#{event.name}" })
+      i.event!(:foo, :bar, { })
+      expect_event('foo-super-custom-bar', { })
+    end
+
+    it "should require the result of the external name to be a string" do
+      expect {
+        i = new_instance(@distinct_id, nil, :definitions => definition_set, :external_name => lambda { |event| 1234 })
+        i.event!(:foo, :bar, { })
+      }.to raise_error(TypeError, /external name/i)
+    end
+
+    context "with default_external_name set" do
+      before :each do
+        klass.default_external_name = lambda { |event| "default-#{event.category_name}-#{event.name}-custom" }
+      end
+
+      after :each do
+        klass.default_external_name = nil
+      end
+
+      it "should return event external_name if set" do
+        i = new_instance(@distinct_id, nil, :definitions => definition_set, :external_name => lambda { |event| "#{event.category_name}-#{event.name}-custom" })
+        i.event!(:foo, :baz, { })
+        expect_event('foo bazzeroo', { })
+      end
+
+      context "no event external_name is set" do
+        it "should return instance external_name" do
+          i = new_instance(@distinct_id, nil, :definitions => definition_set, :external_name => lambda { |event| "#{event.category_name}-#{event.name}-custom" })
+          i.event!(:foo, :bar, { })
+          expect_event('foo-bar-custom', { })
+        end
+
+        context "no instance external_name is set" do
+          it "should return default_external_name" do
+            i = new_instance(@distinct_id, nil, :definitions => definition_set)
+            i.event!(:foo, :bar, { })
+            expect_event('default-foo-bar-custom', { })
+          end
+        end
+      end
     end
 
     it "should allow firing a valid event, and include implicit properties" do
@@ -413,7 +495,7 @@ EOS
     end
 
     it "should include no additional keys" do
-      expect(@instance.effective_properties(:foo, :bar).keys.sort_by(&:to_s)).to eq(%w{distinct_id event_name properties}.map(&:to_sym).sort_by(&:to_s))
+      expect(@instance.effective_properties(:foo, :bar).keys.sort_by(&:to_s)).to eq(%w{distinct_id event_name external_name properties}.map(&:to_sym).sort_by(&:to_s))
     end
   end
 

data/vendor/assets/javascripts/meta_events.js.erb

@@ -92,7 +92,7 @@ MetaEvents = (function() {
    *
    * @param name - The name that we'll use to access this event, using 'event', below; this is different from the name
    *               of the actual event that will be fired and need not have any correlation;
-   * @param eventData - The data for the event; this must be an object containing 'event_name', which is the name of
+   * @param eventData - The data for the event; this must be an object containing 'external_name', which is the name of
    *                    the event to fire, and 'properties', the set of properties to fire with that event.
    */
   out.registerFrontendEvent = function(name, eventData) {
@@ -128,14 +128,15 @@ MetaEvents = (function() {
       $.extend(effectiveProperties, arguments[i]);
     }
 
-    this.eventHandler(eventData.event_name, effectiveProperties);
+    var external_name = eventData.external_name || eventData.event_name;
+    this.eventHandler(external_name, effectiveProperties);
   };
 
   /**
    * The default event handler that we use if you haven't called setEventHandler(), below.
    */
-  out.mixpanelEventHandler = function(eventName, properties) {
-    mixpanel.track(eventName, properties);
+  out.mixpanelEventHandler = function(externalName, properties) {
+    mixpanel.track(externalName, properties);
   };
 
   /**

metadata

@@ -1,100 +1,82 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: meta_events
-version: !ruby/object:Gem::Version
-  version: 1.0.3
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
 platform: ruby
-authors:
+authors: 
 - Andrew Geweke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-05-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: 4.99.99
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<="
-      - !ruby/object:Gem::Version
-        version: 4.99.99
-- !ruby/object:Gem::Dependency
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "4.0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.5"
   type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id006 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.14"
+  type: :development
+  version_requirements: *id005
 description: 
-email:
+email: 
 - ageweke@swiftype.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
-- ".gitignore"
-- ".travis.yml"
+
+files: 
+- .gitignore
+- .travis.yml
 - CHANGES.md
 - Gemfile
 - LICENSE.txt
@@ -121,31 +103,29 @@ files:
 - spec/meta_events/tracker_spec.rb
 - vendor/assets/javascripts/meta_events.js.erb
 homepage: http://www.github.com/swiftype/meta_events
-licenses:
+licenses: 
 - MIT
 metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+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'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id006
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id006
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
-summary: Structured, documented, powerful event emitting library for Mixpanel and
-  other such systems.
-test_files:
+summary: Structured, documented, powerful event emitting library for Mixpanel and other such systems.
+test_files: 
 - spec/meta_events/controller_methods_and_helpers_spec.rb
 - spec/meta_events/definition/category_spec.rb
 - spec/meta_events/definition/definition_set_spec.rb