vero 0.3.2 → 0.4

data/lib/vero/api/users/track_api.rb

@@ -0,0 +1,25 @@
+module Vero
+  module API
+    module Users
+      class TrackAPI < BaseAPI
+        def url
+          "#{@domain}/api/v2/users/track.json"
+        end
+
+        def request
+          RestClient.post(url, @options)
+        end
+
+        def validate!
+          result = true
+          result &&= options[:email].to_s.blank? == false
+          result &&= (options[:data].nil? || options[:data].is_a?(Hash))
+
+          unless result
+            raise ArgumentError.new(:email => options[:email], :data => options[:data])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vero/api/users/unsubscribe_api.rb

@@ -0,0 +1,24 @@
+module Vero
+  module API
+    module Users
+      class UnsubscribeAPI < BaseAPI
+        def url
+          "#{@domain}/api/v2/users/unsubscribe.json"
+        end
+
+        def request
+          RestClient.post(url, @options)
+        end
+
+        def validate!
+          result = true
+          result &&= options[:email].to_s.blank? == false
+
+          unless result
+            raise ArgumentError.new(:email => options[:email])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vero/config.rb

@@ -27,7 +27,11 @@ module Vero
     end
 
     def domain
-      @domain || 'www.getvero.com'
+      if @domain.blank?
+        'https://www.getvero.com'
+      else
+        @domain =~ /http[s]?\:\/\/.+/ ? @domain : "http://#{@domain}" 
+      end
     end
 
     def auth_token

data/lib/vero/context.rb

@@ -1,7 +1,3 @@
-require 'json'
-require 'delayed_job'
-require 'vero/jobs/rest_post_job'
-
 module Vero
   class Context
     attr_accessor :config, :subject
@@ -46,74 +42,73 @@ module Vero
       @config.configured?
     end
 
-    def track(event_name, event_data = {})
-      validate_configured!
-      validate_track_params!(event_name, event_data)
+    ### API methods
 
-      request_params = @config.request_params
-      request_params.merge!({:event_name => event_name, :identity => subject.to_vero, :data => event_data})
+    def track!(event_name, event_data)
+      validate_configured!
       
-      method = if @config.async
-        :post_later
-      else
-        :post_now
+      identity = subject.to_vero
+      options = @config.request_params
+      options.merge!(:data => event_data, :event_name => event_name, :identity => identity)
+
+      unless @config.disabled
+        Vero::Sender.send Vero::API::Events::TrackAPI, @config.async, @config.domain, options
       end
-      self.send(method, "http://#{@config.domain}/api/v1/track.json", request_params, 'track')
     end
 
     def identify!
       validate_configured!
-
+      
       data = subject.to_vero
-      request_params = @config.request_params
-      request_params.merge!({:email => data[:email], :data => data})
+      options = @config.request_params
+      options.merge!(:email => data[:email], :data => data)
 
-      method = if @config.async
-        :post_later
-      else
-        :post_now
+      unless @config.disabled
+        Vero::Sender.send Vero::API::Users::TrackAPI, @config.async, @config.domain, options
       end
-      self.send(method, "http://#{@config.domain}/api/v1/user.json", request_params, 'identify!')
     end
 
-    private
-    def post_now(url, params, method_name)
+    def update_user!(email = nil)
+      validate_configured!
+      
+      changes = subject.to_vero
+      options = @config.request_params
+      options.merge!(:email => (email || changes[:email]), :changes => changes)
+
       unless @config.disabled
-        Vero::Jobs::RestPostJob.new(url, params).perform
-        Vero::App.log(self, "method: #{method_name}, params: #{params.to_json}, response: job performed")
+        Vero::Sender.send Vero::API::Users::EditAPI, @config.async, @config.domain, options
       end
-      'success'
-    rescue => e
-      Vero::App.log(self, "method: #{method_name}, params: #{params.to_json} error: #{e.message}")
     end
 
-    def post_later(url, params, method_name)
+    def update_user_tags!(add = [], remove = [])
+      validate_configured!
+      
+      identity = subject.to_vero
+      options = @config.request_params
+      options.merge!(:email => identity[:email], :add => add, :remove => remove)
+
       unless @config.disabled
-        ::Delayed::Job.enqueue Vero::Jobs::RestPostJob.new(url, params)
-        Vero::App.log(self, "method: #{method_name}, params: #{params.to_json}, response: delayed job queued")
+        Vero::Sender.send Vero::API::Users::EditTagsAPI, @config.async, @config.domain, options
       end
-      'success'
-    rescue => e
-      if e.message == "Could not find table 'delayed_jobs'"
-        raise "To send ratings asynchronously, you must configure delayed_job. Run `rails generate delayed_job:active_record` then `rake db:migrate`."
-      else
-        raise e
+    end    
+
+    def unsubscribe!
+      validate_configured!
+      
+      identity = subject.to_vero
+      options = @config.request_params
+      options.merge!(:email => identity[:email])
+
+      unless @config.disabled
+        Vero::Sender.send Vero::API::Users::UnsubscribeAPI, @config.async, @config.domain, options
       end
     end
 
+    private
     def validate_configured!
       unless @config.configured?
         raise "You must configure the 'vero' gem. Visit https://github.com/semblancesystems/vero for more details."
       end
     end
-
-    def validate_track_params!(event_name, event_data)
-      result = true
-
-      result &&= event_name.kind_of?(String) && !event_name.blank?
-      result &&= event_data.nil? || event_data.kind_of?(Hash)
-
-      raise ArgumentError.new({:event_name => event_name, :event_data => event_data}) unless result
-    end
   end
 end

data/lib/vero/sender.rb

@@ -0,0 +1,22 @@
+module Vero
+  class Sender
+    def self.senders
+      @senders ||= {
+        true          => Vero::Senders::Thread,
+        false         => Vero::Senders::Base,
+        :none         => Vero::Senders::Base,
+        :thread       => Vero::Senders::Thread,
+        :delayed_job  => Vero::Senders::DelayedJob
+      }
+    end
+
+    def self.send(api_class, sender_strategy, domain, options)
+      sender_class = self.senders.fetch(sender_strategy) { self.senders[false] }
+      (sender_class.new).call(api_class, domain, options)
+    rescue => e
+      Vero::App.log(self.new, "method: #{api_class.name}, options: #{options.to_json}, error: #{e.message}")
+      raise e
+    end
+
+  end
+end

data/lib/vero/senders/base.rb

@@ -0,0 +1,11 @@
+module Vero
+  module Senders
+    class Base
+      def call(api_class, domain, options)
+        response = api_class.perform(domain, options)
+        Vero::App.log(self, "method: #{api_class.name}, options: #{options.to_json}, response: job performed")
+        response
+      end
+    end
+  end
+end

data/lib/vero/senders/delayed_job.rb

@@ -0,0 +1,17 @@
+module Vero
+  module Senders
+    class DelayedJob
+      def call(api_class, domain, options)
+        response = ::Delayed::Job.enqueue api_class.new(domain, options)
+        Vero::App.log(self, "method: #{api_class.name}, options: #{options.to_json}, response: delayed job queued")
+        response
+      rescue => e
+        if e.message == "Could not find table 'delayed_jobs'"
+          raise "To send ratings asynchronously, you must configure delayed_job. Run `rails generate delayed_job:active_record` then `rake db:migrate`."
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/vero/senders/thread.rb

@@ -0,0 +1,24 @@
+require 'girl_friday'
+
+module Vero
+  module Senders
+    class Thread
+      VERO_SENDER_QUEUE ||= ::GirlFriday::WorkQueue.new(:vero_queue, :size => 1) do |msg|
+        api_class = msg[:api_class]
+        domain    = msg[:domain]
+        options   = msg[:options]
+
+        begin
+          api_class.perform(domain, options)
+          Vero::App.log(self, "method: #{api_class.name}, options: #{options.to_json}, response: job performed")
+        rescue => e
+          Vero::App.log(self, "method: #{api_class.name}, options: #{options.to_json}, response: #{e.message}")
+        end
+      end
+
+      def call(api_class, domain, options)
+        !!VERO_SENDER_QUEUE.push(:api_class => api_class, :domain => domain, :options => options)
+      end
+    end
+  end
+end

data/lib/vero/trackable/base.rb

@@ -27,7 +27,8 @@ module Vero
       def to_vero
         klass = self.class
         result = klass.trackable_map.inject({}) do |hash, symbol|
-          hash[symbol] = self.send(symbol)
+          t = respond_to?(symbol) ? send(symbol) : nil
+          hash[symbol] = t unless t.nil?
           hash
         end
 

data/lib/vero/trackable/interface.rb

@@ -2,7 +2,11 @@ module Vero
   module Trackable
     module Interface
       def track(event_name, event_data = {})
-        with_default_vero_context.track(event_name, event_data)
+        track!(event_name, event_data)
+      end
+
+      def track!(event_name, event_data = {})
+        with_default_vero_context.track!(event_name, event_data)
       end
 
       def identify!

data/lib/vero/version.rb

@@ -1,3 +1,3 @@
 module Vero
-  VERSION = '0.3.2'
+  VERSION = '0.4'
 end

data/spec/lib/api/events/track_api_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Vero::API::Events::TrackAPI do
+  subject { Vero::API::Events::TrackAPI.new('https://www.getvero.com', {}) }
+  it "should inherit from Vero::API::BaseCaller" do
+    subject.should be_a(Vero::API::BaseAPI)
+  end
+
+  it "should map to current version of Vero API" do
+    subject.send(:url).should == "https://www.getvero.com/api/v2/events/track.json"
+  end
+
+  subject { Vero::API::Events::TrackAPI.new('https://www.getvero.com', {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'}) }
+  describe :validate! do
+    it "should raise an error if test_event is a blank String" do
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => nil}
+      subject.options = options
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+    end
+
+    it "should raise an error if data is not either nil or a Hash" do
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => []}
+      subject.options = options
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => nil}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event', :data => {}}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+    end
+  end
+  
+  describe :request do
+    it "should send a request to the Vero API" do
+      RestClient.should_receive(:post).with("https://www.getvero.com/api/v2/events/track.json", {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :event_name => 'test_event'})
+      RestClient.stub(:post).and_return(200)
+      subject.send(:request)
+    end
+  end
+
+  describe "integration test" do
+    it "should not raise any errors" do
+      RestClient.stub(:post).and_return(200)
+      expect { subject.perform }.to_not raise_error
+    end
+  end
+end

data/spec/lib/api/users/edit_api_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Vero::API::Users::EditAPI do
+  subject { Vero::API::Users::EditAPI.new('https://www.getvero.com', {}) }
+  it "should inherit from Vero::API::BaseCaller" do
+    subject.should be_a(Vero::API::BaseAPI)
+  end
+
+  it "should map to current version of Vero API" do
+    subject.send(:url).should == "https://www.getvero.com/api/v2/users/edit.json"
+  end
+
+  subject { Vero::API::Users::EditAPI.new('https://www.getvero.com', {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }}) }
+  describe :validate! do
+  end
+
+  describe :request do
+    it "should send a request to the Vero API" do
+      RestClient.should_receive(:put).with("https://www.getvero.com/api/v2/users/edit.json", {:auth_token => 'abcd', :email => 'test@test.com', :changes => { :email => 'test@test.com' }})
+      RestClient.stub(:put).and_return(200)
+      subject.send(:request)
+    end
+  end
+
+  describe "integration test" do
+    it "should not raise any errors" do
+      RestClient.stub(:put).and_return(200)
+      expect { subject.perform }.to_not raise_error
+    end
+  end
+end

data/spec/lib/api/users/edit_tags_api_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Vero::API::Users::EditTagsAPI do
+  subject { Vero::API::Users::EditTagsAPI.new('https://www.getvero.com', {}) }
+  it "should inherit from Vero::API::BaseCaller" do
+    subject.should be_a(Vero::API::BaseAPI)
+  end
+
+  it "should map to current version of Vero API" do
+    subject.send(:url).should == "https://www.getvero.com/api/v2/users/tags/edit.json"
+  end
+
+  subject { Vero::API::Users::EditTagsAPI.new('https://www.getvero.com', {:auth_token => 'abcd', :email => 'test@test.com', :add => ["test"]}) }
+  describe :validate! do
+  end
+
+  describe :request do
+    it "should send a request to the Vero API" do
+      RestClient.should_receive(:put).with("https://www.getvero.com/api/v2/users/tags/edit.json", {:auth_token => 'abcd', :email => 'test@test.com', :add => ["test"]})
+      RestClient.stub(:put).and_return(200)
+      subject.send(:request)
+    end
+  end
+
+  describe "integration test" do
+    it "should not raise any errors" do
+      RestClient.stub(:put).and_return(200)
+      expect { subject.perform }.to_not raise_error
+    end
+  end
+end

data/spec/lib/api/users/track_api_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Vero::API::Users::TrackAPI do
+  subject { Vero::API::Users::TrackAPI.new('https://www.getvero.com', {}) }
+  it "should inherit from Vero::API::BaseCaller" do
+    subject.should be_a(Vero::API::BaseAPI)
+  end
+
+  it "should map to current version of Vero API" do
+    subject.send(:url).should == "https://www.getvero.com/api/v2/users/track.json"
+  end
+
+  subject { Vero::API::Users::TrackAPI.new('https://www.getvero.com', {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'}) }
+  describe :validate! do
+    it "should raise an error if email is a blank String" do
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => nil}
+      subject.options = options
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+    end
+
+    it "should raise an error if data is not either nil or a Hash" do
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => []}
+      subject.options = options
+      expect { subject.send(:validate!) }.to raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => nil}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+
+      options = {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com', :data => {}}
+      subject.options = options
+      expect { subject.send(:validate!) }.to_not raise_error(ArgumentError)
+    end
+  end
+  
+  describe :request do
+    it "should send a request to the Vero API" do
+      RestClient.should_receive(:post).with("https://www.getvero.com/api/v2/users/track.json", {:auth_token => 'abcd', :identity => {:email => 'test@test.com'}, :email => 'test@test.com'})
+      RestClient.stub(:post).and_return(200)
+      subject.send(:request)
+    end
+  end
+
+  describe "integration test" do
+    it "should not raise any errors" do
+      RestClient.stub(:post).and_return(200)
+      expect { subject.perform }.to_not raise_error
+    end
+  end
+end