mixpanel_magic_lamp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c38f0a54b2215f7234f635b0deceee30894e2a9
+  data.tar.gz: 4dd271143b3fa52bade4221828ae161c26614e26
+SHA512:
+  metadata.gz: 93d6be32305f3927639065860f01d05856f5ac20a4e8cc9a4d086c2983d576e70fee63dfbfd51ee86f8edc30fb64ecb2f6e48765c7e8d5e752716b7f6e0cf744
+  data.tar.gz: 3474e0f5503df78eec61fbe54cf95d011cd72d846660d57b8e35592f8be4572fb2f7507c110608b7542ae511ecbde80c7664508117bbeee2fd683c4ab25c717d

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle/
+log/*.log
+pkg/
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## 0.1.0 (March 13, 2015)
+
+* Interface and expression builder
+* Generator for initialization
+* First doc
+
+## 1.0.0 (March 30, 2015)
+
+* Monkey patch for ```Mixpanel::Client::prepare_paralell_request```
+* Queue processor
+* Formatter
+* README info
+* First offical release

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in mixpanel_magic_lamp.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Guillermo Guerrero
+
+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

@@ -0,0 +1,258 @@
+# Mixpanel Magic Lamp
+
+[![Gem Version](https://badge.fury.io/rb/mixpanel_magic_lamp.svg)](http://badge.fury.io/rb/mixpanel_magic_lamp)
+
+Rub the magic lamp and your desired Mixpanel ORM will appear!
+
+If you're using [Mixpanel](https://mixpanel.com/) for your web site analytics you probably thought
+in make reports exporting your data through any **Mixpanel API** client. This gem is your answer 
+for not overwarming your head with so many doc, and it will remind you to ```ActiveRecord```.
+
+## Install
+You can install this *gem* by
+
+```
+$ gem install mixpanel_magic_lamp
+```
+
+Or bundle it on your app by adding this line at your *Gemfile*
+
+```ruby
+gem 'mixpanel_magic_lamp'
+```
+
+## Configuration
+To setup this gem you should add API keys and other config:
+```ruby
+MixpanelMagicLamp.configure do |config|
+  # Set your API Key/Secret
+  config.api_key     = "YOUR MIXPANEL API KEY"
+  config.api_secret  = "YOUR MIXPANEL API SECRET"
+
+  # Run query in parallel (recomended for better performance)
+  config.parallel = true
+
+  # Default interval on from/to dates when dates are not provided
+  config.interval = 30
+end
+```
+
+### Rails config generator
+Copy base config file on your **Rails app** by
+```bash
+rails generator mixpanel_magic_lamp:config
+```
+
+
+## Build your query
+The most interesting feature from this library is probably the query builder, that
+let you to build an 'ActiveRecord' like query to run API queries, it will remind you to
+the Mixpanel UI:
+
+### where
+Start any query with this keyword, and extend is as long as you need.
+This method accept a hash as first parameter where each pair of key/value are traslated
+to "key == value" (*equals_to*), a second parameter may change union word:
+
+```ruby
+Mixpanel.where(country: 'Spain', gender: 'Female').to_s
+=> "(properties[\"country\"] == \"Spain\" and properties[\"gender\"] == \"Female\")"
+
+Mixpanel.where({country: 'Spain', gender: 'Female'}, 'or').to_s
+=> "(properties[\"country\"] == \"Spain\" or properties[\"gender\"] == \"Female\")"
+```
+
+
+Then you may append any existent query build to complete your API query:
+
+```ruby
+Mixpanel.where(country: 'Spain').or.is_set('source').to_s
+=> "(properties[\"country\"] == \"Spain\") or (defined (properties[\"source\"]))"
+```
+
+### and/or
+Concat as many query builders as you need with ```and``` and ```or``` operators:
+
+```ruby
+Mixpanel.where(country: "Spain", browser: "Chrome")
+        .and.is_set('device_type')
+        .and.does_not_equal(user_type: 'bot')
+        .and.contains(url: '/sales')
+=> "(properties[\"country\"] == \"Spain\" and properties[\"browser\"] == \"Chrome\") and (defined (properties[\"device_type\"])) and (properties[\"user_type\"] != \"bot\") and (\"/sales\" in (properties[\"url\"]))">
+```
+
+
+### on
+Use it as **by** statement on your UI, in order to group segmentation:
+
+```ruby
+Mixpanel.on('country')
+=> "properties[\"country\"]"
+```
+
+### Builders
+
+#### equals
+
+```ruby
+Mixpanel.where.and.equals(country: 'Spain', user_type: 'human').to_s
+=> "(properties[\"country\"] == \"Spain\" and properties[\"user_type\"] == \"human\")"
+```
+
+#### does_not_equal
+
+```ruby
+Mixpanel.where.and.does_not_equal(country: 'Spain', user_type: 'human')
+=> "(properties[\"country\"] != \"Spain\" and properties[\"user_type\"] != \"human\")"
+```
+
+#### contains
+
+```ruby
+Mixpanel.where.and.contains(country: 'Spain', user_type: 'human').to_s
+=> "(\"Spain\" in (properties[\"country\"]) and \"human\" in (properties[\"user_type\"]))"
+```
+
+#### does_not_contain
+
+```ruby
+Mixpanel.where.and.does_not_contain(country: 'Spain', user_type: 'human').to_s
+=> "(not \"Spain\" in (properties[\"country\"]) and not \"human\" in (properties[\"user_type\"]))"
+```
+
+#### is_set
+
+```ruby
+Mixpanel.where.and.is_set(['country', 'user_type']).to_s
+=> "(defined (properties[\"country\"]) and defined (properties[\"user_type\"]))"
+```
+
+#### is_not_set
+
+```ruby
+Mixpanel.where.and.is_not_set(['country', 'user_type']).to_s
+=> "(not defined (properties[\"country\"]) and not defined (properties[\"user_type\"]))"
+```
+
+
+## Actions
+Mixpanel API client has a lot of possible actions, so far these are the supported actions:
+
+### Segementation
+Classic **Mixpanel** segmentation action, where you can specify *event name*, *from/to dates* and *any conditions* you want. Prepare and run as many request in parallel you need
+
+```ruby
+interface = Mixpanel::Interface.new
+
+page_visits_query = Mixpanel.where("product" => 'Finances')
+                            .and.is_set("subproduct")
+page_visits  = interface.segmentation('Page visit', { from: Data.parse('2015-01-31'),
+                                                      to: Date.today },
+                                                    { where: page_visits_query })
+
+
+login_clicks_query = Mixpanel.where("device_type" => 'mobile')
+login_clicks = interface.segmentation('Login', { from: Data.parse('2015-04-01'),
+                                                 to: Date.today },
+                                               { where: login_clicks_query })
+
+# Run all the queued queries
+interface.run!
+
+# Present your data...
+p page_visits[:data]
+p login_clicks[:data]
+```
+ 
+### Segmentation by
+Same as **segmentation** but grouping the output by any property you want to.
+
+```ruby
+interface = Mixpanel::Interface.new
+
+page_visits_query = Mixpanel.where("product" => 'Finances')
+                            .and.is_set("subproduct")
+page_visits  = interface.segmentation('Page visit', { from: Data.parse('2015-01-31'),
+                                                      to: Date.today },
+                                                    { where: page_visits_query,
+                                                      on: Mixpanel.on('device_type') })
+
+# Run all the queued queries
+interface.run!
+
+# Present your data...
+p page_visits[:data]
+```
+
+
+## Your own interface
+Now you master all the above concepts, the best thing you can do is to build your own interface model for extracting your reports:
+
+```ruby
+module Mixpanel
+  class LandingPagesInterface < Mixpanel::Interface
+
+    def initialize
+      super()
+    end
+
+    def views(from: nil, to: nil)
+      where_context = Mixpanel.where('page_type' => 'landing')
+                              .and.is_set('device_type')
+
+      segmentation 'Page view', { from: from, to: to },
+                                { where: where_context }
+    end
+
+    def views_by_devices(from: nil, to: nil)
+      where_context = Mixpanel.where('page_type' => 'landing')
+                              .and.is_set('device_type')
+
+      segmentation_interval 'Page view', { from: from, to: to },
+                                         { where: where_context,
+                                           on: Mixpanel.on('device_type') }
+    end
+
+  end
+end
+
+# Initialize your interface
+landing_interface = Mixpanel::LandingPagesInterface.new
+
+# Prepare all the queries
+landing_last_week_views = landing_interface.views(from: 14.days.ago, to: 7.days.ago)
+landing_this_week_views = landing_interface.views(from: 6.days.ago, to: Date.today)
+landing_last_week_view_by_devices = landing_interface.views_by_devices(from: 14.days.ago, to: 7.days.ago)
+
+# Run all the queries
+landing_interface.run!
+
+# Retrieve your data!
+p landing_last_week_views[:data]
+p landing_this_week_views[:data]
+p landing_last_week_view_by_devices[:data]
+
+```
+
+
+## On top of mixpanel_client Gem
+This ORM is build on top [mixpanel_client](https://github.com/keolo/mixpanel_client#mixpanel-data-api-client) gem.
+
+You'll find the oficial mixpanel info [here](https://mixpanel.com/docs/api-documentation/data-export-api#libs-ruby).
+
+### Monkey patching
+On this gem you'll find a ```Mixpanel::Client``` class monkey patch to avoid exceptions raise
+when any of the parallel request fails, i.e all the requests will run until completion and return
+their correspondent HTTP status (error or success) and body as usual.
+See it [here](https://github.com/gguerrero/mixpanel_magic_lamp/blob/master/lib/mixpanel_magic_lamp/client.rb).
+
+
+
+## Contribution
+If you have cool idea for improving this Gem or any bug fix just open a pull request and
+I'll be glad to have a look and merge it if seems fine.
+
+
+## License
+
+This project rocks and uses [MIT-LICENSE](https://github.com/gguerrero/mixpanel_magic_lamp/blob/master/MIT-LICENSE).

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks

data/lib/generators/mixpanel_magic_lamp/config_generator.rb

@@ -0,0 +1,10 @@
+module MixpanelMagicLamp
+  class ConfigGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    desc "Generates the config initializer file for Mixpanel Magic Lamp options"
+    def copy_initializer_file
+      copy_file "mixpanel_magic_lamp.rb", "config/initializers/mixpanel_magic_lamp.rb"
+    end
+  end
+end

data/lib/generators/mixpanel_magic_lamp/templates/mixpanel_magic_lamp.rb

@@ -0,0 +1,8 @@
+MixpanelMagicLamp.configure do |config|
+  # Set your API Key/Secret
+  # config.api_key     = "YOUR MIXPANEL API KEY"
+  # config.api_secret  = "YOUR MIXPANEL API SECRET"
+
+  config.parallel = true
+  config.interval = 30
+end

data/lib/mixpanel_magic_lamp/client.rb

@@ -0,0 +1,48 @@
+# MONKEY PATCH!
+# -------------
+#
+# Avoid 'fail' that makes all request to stop running...
+# Original 4.1.1 lib/mixpanel/client.rb source:
+#
+# def prepare_parallel_request
+#   request = ::Typhoeus::Request.new(@uri)
+#
+#   request.on_complete do |response|
+#     if response.success?
+#       Utils.to_hash(response.body, @format)
+#     elsif response.timed_out?
+#       fail TimeoutError
+#     elsif response.code == 0
+#       # Could not get an http response, something's wrong
+#       fail HTTPError, response.curl_error_message
+#     else
+#       # Received a non-successful http response
+#       if response.body && response.body != ''
+#         error_message = JSON.parse(response.body)['error']
+#       else
+#         error_message = response.code.to_s
+#       end
+#
+#       fail HTTPError, error_message
+#     end
+#   end
+#
+#   request
+# end
+#
+#
+module Mixpanel
+
+  class Client
+    def prepare_parallel_request
+      request = ::Typhoeus::Request.new(@uri)
+
+      request.on_complete do |response|
+        Utils.to_hash(response.body, @format) if response.success? 
+      end
+
+      request
+    end
+  end
+
+end

data/lib/mixpanel_magic_lamp/configuration.rb

@@ -0,0 +1,30 @@
+module MixpanelMagicLamp
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :api_key,
+                  :api_secret,
+                  :parallel,
+                  :interval
+
+    def initialize
+      @parallel = true
+      @interval = 30
+    end
+
+  end
+
+  class ApiKeyMissingError < StandardError
+    def initialize
+      super "Missing API key and/or secret. Please, configure them."
+    end
+  end
+  
+end

data/lib/mixpanel_magic_lamp/engine.rb

@@ -0,0 +1,4 @@
+module MixpanelMagicLamp
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/mixpanel_magic_lamp/expression_builder.rb

@@ -0,0 +1,85 @@
+module MixpanelMagicLamp
+
+  module ClassMethods
+    def where(*args)
+      MixpanelMagicLamp::InstanceMethods::ExpressionBuilder.new(*args)
+    end
+
+    def on(property)
+      "properties[\"#{property}\"]"
+    end
+  end
+
+  module InstanceMethods
+    class ExpressionBuilder
+      attr_reader :expression
+
+      def initialize(*args)
+        @expression = ''
+        equals(*args) if args.any?
+      end
+
+      def to_s
+        @expression
+      end
+
+      def and
+        @expression += ' and ' if @expression.present? and not @expression =~ /(and|or)\s*$/
+        self
+      end
+
+      def or
+        @expression += ' or ' if @expression.present? and not @expression =~ /(and|or)\s*$/
+        self
+      end
+
+      def equals(args = {}, union = 'and')
+        @expression += join(args, union, "properties[\":name\"] == \":value\"")
+        self
+      end
+
+      def does_not_equal(args = {}, union = 'and')
+        @expression += join(args, union, "properties[\":name\"] != \":value\"")
+        self
+      end
+
+      def contains(args = {}, union = 'and')
+        @expression += join(args, union, "\":value\" in (properties[\":name\"])")
+        self
+      end
+
+      def does_not_contain(args = {}, union = 'and')
+        @expression += join(args, union, "not \":value\" in (properties[\":name\"])")
+        self
+      end
+
+      def is_set(args = [], union = 'and')
+        @expression += join(args, union, "defined (properties[\":name\"])")
+        self
+      end
+
+      def is_not_set(args = [], union = 'and')
+        @expression += join(args, union, "not defined (properties[\":name\"])")
+        self
+      end
+
+      private
+      def join(args, union, exp)
+        args = [args] unless args.is_a? Array or args.is_a? Hash
+        built_in = '(' + args.compact.map do |name, values|
+          if values.nil?
+            exp.gsub(':name', name)
+          else
+            values = [values] unless values.is_a? Array
+            values.map do |value|
+              exp.gsub(':name', name.to_s).gsub(':value', value.to_s)
+            end
+          end
+        end.flatten.join(" #{union} ") + ')'
+
+        built_in == '()' ? '' : built_in
+      end
+    end
+  end
+
+end

data/lib/mixpanel_magic_lamp/formatter.rb

@@ -0,0 +1,42 @@
+module MixpanelMagicLamp
+
+  class Formatter
+
+    DEFAULT = 'values'
+
+    def initialize(request)
+      @response = request.response.handled_response.dup
+    end
+
+    def convert(format: DEFAULT)
+      send :"to_#{format}"  
+    end
+
+    def to_values
+      @response['data']['values']
+    end
+
+    def to_line
+      @response['data']
+    end
+
+    def to_pie
+      @response['data']['series'] = [ @response['data']['series'].first,
+                                      @response['data']['series'].last ]
+      date_for_value = @response['data']['series'].first
+
+      @response['data']['values'].each do |section, values|
+        @response['data']['values'][section] = @response['data']['values'][section][date_for_value]
+      end
+
+      @response['data']
+    end
+
+    def method_missing(method, *args)
+      puts "Format '#{method}' not available. Formatting as 'to_#{DEFAULT}' instead."
+      send :"to_#{DEFAULT}"
+    end
+
+  end
+
+end

data/lib/mixpanel_magic_lamp/interface.rb

@@ -0,0 +1,61 @@
+require 'mixpanel_client'
+
+module MixpanelMagicLamp
+
+  module InstanceMethods
+    class Interface < ::Mixpanel::Client
+
+      attr_reader :queue
+
+      def initialize(interval: nil, parallel: nil, unit: 'day', type: 'unique')
+        if MixpanelMagicLamp.configuration.api_key.nil? or 
+           MixpanelMagicLamp.configuration.api_secret.nil?
+          raise MixpanelMagicLamp::ApiKeyMissingError
+        end
+
+        @parallel = parallel.nil? ? MixpanelMagicLamp.configuration.parallel : parallel
+        @interval = interval.nil? ? MixpanelMagicLamp.configuration.interval : interval 
+        @from     = @interval.days.ago.to_date
+        @to       = Date.today
+        @unit     = unit
+        @type     = type
+
+        @queue = MixpanelMagicLamp::Queue.new
+
+        super api_key:    MixpanelMagicLamp.configuration.api_key,
+              api_secret: MixpanelMagicLamp.configuration.api_secret,
+              parallel:   @parallel
+      end
+
+      def segmentation(event, dates = {}, options = {})
+        dates = { from: dates[:from] || @from, to: dates[:to] || @to }
+        @queue.push request('segmentation',
+                            { event: event,
+                              type: @type,
+                              unit: @unit,
+                              from_date: dates[:from].strftime('%Y-%m-%d'),
+                              to_date: dates[:to].strftime('%Y-%m-%d') }.merge(options)),
+                    format: 'line'
+      end
+
+      def segmentation_interval(event, dates = {}, options = {})
+        dates = { from: dates[:from].to_date || @from, to: dates[:to].to_date || @to }
+
+        @queue.push request('segmentation',
+                            { event: event,
+                              type: @type,
+                              interval: (dates[:to] - dates[:from]).to_i + 1,
+                              from_date: dates[:from].strftime('%Y-%m-%d'),
+                              to_date: dates[:to].strftime('%Y-%m-%d') }.merge(options)),
+                    format: 'pie'
+      end
+
+      def run!
+        run_parallel_requests
+        @queue.process!
+      end
+
+    end
+  end
+
+end

data/lib/mixpanel_magic_lamp/queue.rb

@@ -0,0 +1,36 @@
+require 'json'
+
+module MixpanelMagicLamp
+
+  class Queue < Array
+
+    def push(request, opts = {})
+      item = {
+        request: request,
+        format: opts.delete(:format),
+        status: nil,
+        response: nil,
+        data: nil }
+
+      self << item and return item
+    end
+
+    def process!
+      self.each do |request|
+        next unless request[:status].nil?
+        request[:status] = request[:request].response.code
+
+        if request[:request].response.success?
+          formatter = MixpanelMagicLamp::Formatter.new(request[:request])
+          request[:data] = formatter.convert format: request[:format]
+        else
+          request[:response] = JSON.parse(request[:request].response.body)
+        end
+      end
+
+      self
+    end
+
+  end
+
+end

data/lib/mixpanel_magic_lamp/version.rb

@@ -0,0 +1,3 @@
+module MixpanelMagicLamp
+  VERSION = "1.0.0"
+end

data/lib/mixpanel_magic_lamp.rb

@@ -0,0 +1,14 @@
+require 'mixpanel_client'
+require 'mixpanel_magic_lamp/configuration'
+require 'mixpanel_magic_lamp/engine' if defined? Rails
+require 'mixpanel_magic_lamp/client'
+require 'mixpanel_magic_lamp/expression_builder'
+require 'mixpanel_magic_lamp/formatter'
+require 'mixpanel_magic_lamp/queue'
+require 'mixpanel_magic_lamp/interface'
+
+# Include and extend the magic lamp
+Mixpanel.extend MixpanelMagicLamp::ClassMethods
+module Mixpanel
+  include MixpanelMagicLamp::InstanceMethods
+end

data/mixpanel_magic_lamp.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "mixpanel_magic_lamp/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "mixpanel_magic_lamp"
+  s.version     = MixpanelMagicLamp::VERSION
+  s.authors     = ["Guillermo Guerrero"]
+  s.email       = ["g.guerrero.bus@gmail.com"]
+  s.homepage    = "https://github.com/gguerrero/mixpanel_client_interface"
+  s.summary     = "Mixpanel client ORM!"
+  s.description = "Mixpanel client ORM for easy querying and reporting data."
+  s.license     = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+  s.add_dependency "mixpanel_client", ">= 4.1.1"
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: mixpanel_magic_lamp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Guillermo Guerrero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mixpanel_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+description: Mixpanel client ORM for easy querying and reporting data.
+email:
+- g.guerrero.bus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/mixpanel_magic_lamp/config_generator.rb
+- lib/generators/mixpanel_magic_lamp/templates/mixpanel_magic_lamp.rb
+- lib/mixpanel_magic_lamp.rb
+- lib/mixpanel_magic_lamp/client.rb
+- lib/mixpanel_magic_lamp/configuration.rb
+- lib/mixpanel_magic_lamp/engine.rb
+- lib/mixpanel_magic_lamp/expression_builder.rb
+- lib/mixpanel_magic_lamp/formatter.rb
+- lib/mixpanel_magic_lamp/interface.rb
+- lib/mixpanel_magic_lamp/queue.rb
+- lib/mixpanel_magic_lamp/version.rb
+- mixpanel_magic_lamp.gemspec
+homepage: https://github.com/gguerrero/mixpanel_client_interface
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Mixpanel client ORM!
+test_files: []