projector 0.1.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2b3dbd1610c6ce053ccd4e5a0566b6f77475ff5
+  data.tar.gz: d39d7bcb4f57f8e9970de3b461db9b71f4ae4a75
+SHA512:
+  metadata.gz: a716767bae171e383ccc6ce0081bd7dcc520efabf3a6134e5556d1e08e87ba7dc14131b1347f71609b229ac115bdc170c83d126fa31d2b1f77a8d420144c42c5
+  data.tar.gz: ab4278cfe220f32606c78a457414a57af849e5bf6dd4f10512e48668b194a28cfdf0ee5aea05cb76aa2d738490233c0c7464c4ff7cfd96ce57394d4bf1f31a93

data/.gitignore

@@ -1,4 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
 *.gem
-.bundle
-Gemfile.lock
-pkg/*
+.ruby-version

data/Gemfile

@@ -1,4 +1,18 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in projector.gemspec
 gemspec
+
+gem 'rake', :group => [:development, :test]
+
+# Testing dependencies
+group :test do
+  gem 'minitest'
+  gem 'webmock', :require => 'webmock/minitest'
+  gem 'mocha', :require => 'mocha/setup'
+  gem 'simplecov', :require => false
+  gem 'm'
+  gem 'addressable'
+  gem 'factory_girl'
+  gem 'timecop'
+end

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2016, Orphid, Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -1,44 +1,21 @@
-# Projector
+# Projector Ruby SDK
 
-A simple command-line app to keep your projects directory up to date with all of your Github projects.  I got tired of having to re-clone new projects all the time, and figured there had to be an easier way.  Turns out there wasn't, so I built one.
+[SDK Guide](https://goprojector.readme.io/docs/ruby-1)
 
-## Dependencies
+## Installation
 
-Requires the [Thor](https://github.com/wycats/thor) and JSON gems.  You'll also need a Github account and API key.
+The `projector` gem is hosted on Gemfury so you will need to add the Gemfury repository to your gemfile:
 
-## Installation and Usage
+```
+gem 'projector', :source => 'https://gem.fury.io/projector/'
+```
 
-Install the gem:
 
-    gem install projector
+## Building / Testing
 
-Configure your Github settings (if you haven't done so already).  Details are [here](http://help.github.com/set-your-user-name-email-and-github-token/), but the short version is:
+### Testing
 
-    git config --global github.user <username>
-    git config --global github.token <token>
-
-Configure your working directory.  I have a `Projects` directory under my home directory where I keep all of my working copies.  Adjust to your own convention as needed.
-
-    git config --global projector.workingdir ~/Projects
-
-Run `projector checkout`.  Projector will find all of the repos you have access to and prompt you to clone them under your working directory if they're not already cloned.  By default, it will create a nested directory structure based on the repository owner, something like this:
-
-    jayzes/
-    jayzes/projector
-    jayzes/cucumber-api-steps
-    gvarela/
-    gvarela/food_court_recipes
-
-If you want it to forge ahead and clone everything, there's a `-a` option that assumes yes to every clone confirmation and doesn't bother prompting.
-
-## Future Ideas
-* Skiplist/repo ignore regexes
-* Checking for repos that aren't under version control and prompting to create or prune them
-* An easier way to run this under cron
-
-# Author
-Jay Zeschin
-
-## Copyright
-
-Copyright (c) 2011 Jay Zeschin. Distributed under the MIT License.
+```
+bin/setup
+bundle exec run test
+```

data/Rakefile

@@ -1,2 +1,30 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'projector'
+  ARGV.clear
+  IRB.start
+end
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new(:doc) do |task|
+    task.files   = ['Readme.markdown', 'LICENSE', 'lib/**/*.rb']
+    task.options = [
+      '--output-dir', 'doc',
+      '--markup', 'markdown',
+    ]
+  end
+rescue LoadError
+end

data/bin/console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "projector"
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.2.3

data/lib/projector/api_methods.rb

@@ -0,0 +1,30 @@
+module Projector
+  module ApiMethods
+    def register_end_user(end_user)
+      # If a hash is passed, use it to populate a user object
+      if end_user.instance_of?(Hash)
+        user = Projector::EndUser.new(end_user)
+      # If a User instance is passed, use it
+      elsif end_user.instance_of?(Projector::EndUser)
+        user = end_user
+      end
+      # return the data element of the resulting envelope
+      post(host, '/end_users', Projector::Envelope.new(Projector::EndUser::SCHEMA, user).to_hash).body
+    end
+
+    def set_end_user_tags(id, tags)
+      user = Projector::EndUser.new(id: id, tags: tags)
+      register_end_user(user)
+    end
+
+    def deliver_event(event)
+      # Create an Event instance if the parameter is a Hash.
+      if event.instance_of?(Hash)
+        event = Projector::Event.new(event)
+      end
+      # Verify that we've got an Event object.
+      raise Projector::InvalidEvent.new("Invalid event data") unless event.instance_of?(Projector::Event)
+      post(host, '/events', Projector::Envelope.new(Projector::Event::SCHEMA, event).to_hash).body
+    end
+  end
+end

data/lib/projector/client.rb

@@ -0,0 +1,46 @@
+ module Projector
+  require 'projector/transport/http'
+  require 'projector/error'
+  require 'projector/envelope'
+  require 'projector/end_user'
+  require 'projector/event'
+  require 'projector/api_methods'
+
+  class Client
+    include Projector::ApiMethods
+    include Projector::Transport::HTTP
+
+    attr_accessor :host, :token, :result_format
+
+    # The current configuration parameters for all clients
+    def self.options
+      @options ||= {
+        host: ENV['PROJECTOR_API_HOST'] || 'https://api.projector.com'
+      }
+    end
+
+    # Sets the current configuration parameters for all clients
+    def self.options=(val)
+      @options = val
+    end
+
+    # Allows the setting of configuration parameters in a configure block.
+    def self.configure
+      yield options
+    end
+
+    # Initialize a new client.
+    #
+    # @param options [Hash] optionally specify `:access_token`, `:host`, `:api_version`
+    def initialize(options = {})
+      options = self.class.options.merge(options)
+      @host = options[:host] || ENV['PROJECTOR_API_HOST']
+      @token = options[:token] || ENV['PROJECTOR_API_TOKEN']
+      @options = options
+    end
+
+    def host
+       @options[:host]
+    end
+  end
+end

data/lib/projector/end_user.rb

@@ -0,0 +1,27 @@
+module Projector
+  class EndUser
+
+    SCHEMA = 'http://schemas.projector.com/schemas/com.projector/server_api/jsonschema/0-9-1#/definitions/end_user_post'
+
+    attr_accessor :id, :tags
+
+    def initialize(params = {})
+      raise Projector::InvalidEndUser.new("Invalid end user, id missing") if params[:id].nil?
+      if params.instance_of?(Hash)
+        params.each do |k, v|
+          self.send("#{k}=", v) if self.respond_to?("#{k}=")
+        end
+      else
+        self.id = params.to_s
+      end
+    end
+
+    def to_hash
+      { 
+        customer_end_user_id: id.to_s,
+        tags: (tags || []),
+        profile: {}
+      }
+    end
+  end
+end

data/lib/projector/envelope.rb

@@ -0,0 +1,22 @@
+module Projector
+  class Envelope
+    attr_accessor :schema, :data
+
+    def initialize(schema, data)
+      @schema = schema
+      @data = data
+    end
+
+    def payload
+      data.respond_to?(:to_hash) ? data.to_hash : data
+    end
+
+    def to_hash(params = {})
+      raise Projector::InvalidEnvelope unless @data && @schema
+      {
+        schema: schema,
+        data: payload
+      }
+    end
+  end
+end

data/lib/projector/error.rb

@@ -0,0 +1,61 @@
+module Projector
+  # Standard Projector error
+  class Error < StandardError
+    attr_accessor :request, :response, :response_body, :request_id
+  end
+
+  # Raised when Projector returns a 400 HTTP status code
+  class BadRequest < Error; end
+
+  # Raised when Projector returns a 401 HTTP status code
+  class Unauthorized < Error; end
+
+  # Raised when Projector returns a 403 HTTP status code
+  class Forbidden < Error; end
+
+  # Raised when Projector returns a 404 HTTP status code
+  class NotFound < Error; end
+
+  # Raised when Projector returns a 406 HTTP status code
+  class NotAcceptable < Error; end
+
+  # Raised when Projector returns a 422 HTTP status code
+  class UnprocessableEntity < Error; end
+
+  # Raised when Projector returns a 500 HTTP status code
+  class InternalServerError < Error;
+    attr_accessor :retry_after
+  end
+
+  # Raised when Projector returns a 501 HTTP status code
+  class NotImplemented < Error; end
+
+  # Raised when Projector returns a 502 HTTP status code
+  class BadGateway < Error; end
+
+  # Raised when Projector returns a 503 HTTP status code
+  class ServiceUnavailable < Error; end
+
+  # Raised when a unique ID is required but not provided
+  class UniqueIDRequired < Error; end
+
+  class InvalidEndUser < StandardError; end
+  class InvalidEvent < StandardError; end
+  class InvalidDevice < StandardError; end
+  class InvalidRegistration < StandardError; end
+  class InvalidEnvelope < StandardError; end
+
+  # Status code to exception map
+  ERROR_MAP = {
+    400 => Projector::BadRequest,
+    401 => Projector::Unauthorized,
+    403 => Projector::Forbidden,
+    404 => Projector::NotFound,
+    406 => Projector::NotAcceptable,
+    422 => Projector::UnprocessableEntity,
+    500 => Projector::InternalServerError,
+    501 => Projector::InternalServerError,
+    502 => Projector::InternalServerError,
+    503 => Projector::InternalServerError
+  }
+end

data/lib/projector/event.rb

@@ -0,0 +1,19 @@
+module Projector
+  require 'securerandom'
+
+  class Event
+    SCHEMA = 'http://schemas.projector.com/schemas/com.projector/events_api/jsonschema/0-9-3#/links/0/schema'
+
+    def initialize(params)
+      @params = params.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+    def to_hash
+      overrides = {
+        id: @params[:id] ? @params[:id].to_s : SecureRandom.uuid,
+        event_time: ((@params[:event_time].instance_of?(Time) ? @params[:event_time] : Time.now).to_f * 1000).to_i
+      }
+      @params.merge overrides
+    end
+  end
+end

data/lib/projector/transport/http.rb

@@ -0,0 +1,203 @@
+module Projector
+  module Transport
+    # Persistent HTTP API transport adapter
+    module HTTP
+      require 'net/http/persistent'
+      require 'uri'
+      require 'json'
+
+      MAX_REDIRECTS = 2
+
+      [:get, :post, :put, :delete, :patch].each do |method|
+        define_method method do |*args|
+          json_request(method, *args)
+        end
+      end
+
+      protected
+
+      def request(method, host, path, params = nil, redirect_count = 0)
+        uri = URI.parse("#{host}#{path}")
+
+        # if the request requires parameters in the query string, merge them in
+        if params && !can_post_data?(method)
+          query_values = uri.query ? URI.decode_www_form(uri.query).inject({}) {|h,(k,v)| h[k]=v; h} : {}
+          uri.query = to_url_params((query_values || {}).merge(params))
+        end
+
+        # Build request
+        request = build_request(method, uri)
+
+        # Add headers
+        request['Authorization'] = "Token #{self.token}"
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = "application/vnd.projector+json;"
+        request['Request-Id'] = SecureRandom.uuid
+
+        # Add params as JSON if they exist
+        request.body = JSON.generate(params) if can_post_data?(method) && params
+
+        log_debug_data(uri, request.method, request.body)
+
+        # Request
+        response = http.request(uri, request)
+
+        # Log debug data if needed
+        log_debug_data(uri, response.code, response.body)
+
+        # If we've been given a redirect
+        if [301, 302].include?(response.code.to_i)
+
+          # Make sure we aren't in a giant redirect loop
+          if redirect_count >= MAX_REDIRECTS
+            err = TooManyRedirectsError.new
+            err.request = request
+            err.response = response
+            err.redirect_count = redirect_count
+            raise err
+          end
+
+          # Parse the new location
+          uri = URI.parse(response['Location'])
+          # Make the call to the redirected location, incrementing the redirect count by 1
+          return request(method, uri.select(:scheme, :host).join("://"), uri.path, params, redirect_count + 1)
+          # Return the result of the redirected request
+        end
+
+        # Check for errors
+        handle_error(request, response)
+
+
+        # Return the raw response object
+        response
+      end
+
+      def http
+        @http ||= begin
+                    http = Net::HTTP::Persistent.new('projector')
+                    http.open_timeout = 5
+                    http.read_timeout = 2
+                    http
+                  end
+      end
+
+      def build_request(method, uri)
+        case method
+          when :get
+            Net::HTTP::Get.new(uri.request_uri)
+          when :post
+            Net::HTTP::Post.new(uri.request_uri)
+          when :put
+            Net::HTTP::Put.new(uri.request_uri)
+          when :delete
+            Net::HTTP::Delete.new(uri.request_uri)
+          when :patch
+            Net::HTTP::Patch.new(uri.request_uri)
+        end
+      end
+
+      def to_url_params(hash)
+        params = []
+        hash.each_pair do |key, value|
+          params << param_for(key, value).flatten
+        end
+        params.sort.join('&')
+      end
+
+      def param_for(key, value, parent = nil)
+        if value.is_a?(Hash)
+          params = []
+          value.each_pair do |value_key, value_value|
+            value_parent = parent ? parent + "[#{key}]" : key.to_s
+            params << param_for(value_key, value_value, value_parent)
+          end
+          params
+        else
+          ["#{parent ? parent + "[#{key}]" : key.to_s}=#{CGI::escape(value.to_s)}"]
+        end
+      end
+
+      def handle_error(request, response)
+        return unless error = Projector::ERROR_MAP[response.code.to_i]
+        message = nil
+        begin
+          message = JSON.parse(response.body) || request.path
+        rescue JSON::ParserError => e
+        end
+        # Raise error
+        err = error.new(message)
+        err.retry_after = response['retry-after'].to_i if response.code.to_i >= 500
+        err.request = request
+        err.response = response
+        err.response_body = message
+        err.request_id = request['request-id']
+        raise err
+      end
+
+      def json_request(*args)
+        # Perform request, pass result format
+        Response.new(request(*args))
+      end
+
+      def boolean_from_response(*args)
+        response = request(*args)
+        (200..299).include? response.code.to_i
+      end
+
+      def can_post_data?(method)
+        [:post, :put, :patch].include?(method)
+      end
+
+      def log_debug_data(*args)
+        return unless ENV['PROJECTOR_DEBUG_HTTP']
+        @logger ||= begin
+          require 'logger'
+          Logger.new(STDOUT)
+        end
+        @logger.info(args.reject{|s| s = s.to_s; s.nil? || s.empty?}.join(' - '))
+      end
+
+      # Response class responsible for deserializing API calls
+      # @attr [Object] body The parsed response
+      # @attr [Hash] headers HTTP headers returned as part of the response
+      # @attr [String] code The HTTP response code
+      class Response
+        attr_accessor :body, :headers, :code
+
+        # Initializes a new result
+        #
+        # @param http_response [Net::HTTPResponse] the raw response to parse
+        def initialize(http_response)
+          @code = http_response.code
+          parse_headers(http_response.to_hash)
+          parse_body(http_response.body)
+        end
+
+        private
+
+        # Parses raw headers in to a reasonable hash
+        def parse_headers(raw_headers)
+          # raw headers from net_http have an array for each result. Flatten them out.
+          @headers = raw_headers.inject({}) do |remainder, (k, v)|
+            remainder[k] = [v].flatten.first
+            remainder
+          end
+        end
+
+        # Parses the raw body in to a hash
+        def parse_body(response_body)
+          # Parse JSON
+          begin
+            self.body = JSON.parse(response_body)
+          rescue JSON::ParserError => ex
+            self.body = response_body
+          end
+        end
+      end
+
+      class TooManyRedirectsError < StandardError
+        attr_accessor :request, :response, :redirect_count
+      end
+    end
+  end
+end

data/lib/projector/version.rb

@@ -1,3 +1,3 @@
 module Projector
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/projector.rb

@@ -1,7 +1,57 @@
-require 'projector/repo'
-require 'projector/helpers'
-require 'projector/cli'
 require 'projector/version'
+require 'projector/client'
 
 module Projector
-end
+  class << self
+    # Alias for Projector::Client.new
+    #
+    # @return [Projector::Client]
+    def new(options = {})
+      Projector::Client.new(options)
+    end
+
+    # Delegate to Projector::Client.new
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    # Forward respond_to? to Projector::Client.new
+    def respond_to?(method, include_private = false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+
+    def logger
+      @logger ||= begin
+                    if defined?(::Rails)
+                      Rails.logger
+                    else
+                      require 'logger'
+                      ::Logger.new(STDOUT)
+                    end
+                  end
+    end
+
+    def logger=(x)
+      @logger = x
+    end
+
+    DEFAULT_ERROR_HANDLER = Proc.new do |ex, ctx|
+      Projector.logger.error(ex)
+      Projector.logger.error(ctx.inspect)
+      ex.backtrace.each do |line|
+        Projector.logger.error(line)
+      end if ex.backtrace
+    end
+
+    ##
+    # Add a global error handler for any async errors Projector encounters.
+    # Error handlers must respond to `call(exception, context_hash)`:
+    #
+    #     Projector.error_handlers << Proc.new {|ex, ctx| do_something(ex) }
+    #
+    def error_handlers
+      @handlers ||= [DEFAULT_ERROR_HANDLER]
+    end
+  end
+end

data/projector.gemspec

@@ -1,22 +1,21 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "projector/version"
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'projector/version'
 
-Gem::Specification.new do |s|
-  s.name        = "projector"
-  s.version     = Projector::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Jay Zeschin"]
-  s.email       = ["jay@zeschin.org"]
-  s.homepage    = "https://github.com/jayzes/projector"
-  s.summary     = %q{Automatically keep a working directory with checkouts of all your Github projects}
-  s.description = %q{Automatically keep a working directory with checkouts of all your Github projects}
-  
-  s.add_dependency 'json'
-  s.add_dependency 'thor'
+Gem::Specification.new do |spec|
+  spec.name          = "projector"
+  spec.version       = Projector::VERSION
+  spec.authors       = ["Projector"]
+  spec.email         = ["engineering@projector.com"]
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.summary       = %q{Ruby SDK for interacting with the Projector SDK}
+  spec.description   = %q{Create and manage users, devices, and events going to Projector.}
+  spec.homepage      = "https://www.projector.com"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+  spec.license       = "BSD-3-Clause"
+
+  spec.add_dependency 'net-http-persistent', '~> 2.9', '>= 2.9.4'
 end

data/sample/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'sinatra'
+gem 'sinatra-contrib'
+
+gem 'projector', :source => 'https://gem.fury.io/projector/'

data/sample/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: https://rubygems.org/
+  remote: https://gem.fury.io/projector/
+  specs:
+    backports (3.6.8)
+    multi_json (1.11.2)
+    net-http-persistent (2.9.4)
+    projector (1.0.0)
+      net-http-persistent (~> 2.9, >= 2.9.4)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    sinatra (1.4.7)
+      rack (~> 1.5)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    sinatra-contrib (1.4.6)
+      backports (>= 2.0)
+      multi_json
+      rack-protection
+      rack-test
+      sinatra (~> 1.4.0)
+      tilt (>= 1.3, < 3)
+    tilt (2.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  projector!
+  sinatra
+  sinatra-contrib
+
+BUNDLED WITH
+   1.11.2

data/sample/README.md

@@ -0,0 +1,30 @@
+# Projector Ruby SDK - Sample App Implementation
+
+This directory houses a sample Sinatra implementation app using the Projector Ruby SDK.
+
+Be sure to grab your Projector token from the dashboard and update the `config.yml` with it.
+
+You should be able to run the application and hit the endpoints in `index.rb` with the following commands.
+
+```sh
+> (cd ../; gem build projector.gemspec)
+> bundle install
+> bundle exec rackup -p 8080
+```
+
+The application is configured to automatically send test events on a scheduled timer every 10 s.
+
+You should see logging in the session std out.
+
+## Sample curl
+
+```sh
+# In order to test the registration flow:
+curl -XPOST localhost:8080/register_projector -d ''
+
+# In order to send a tag-targeted event
+curl -XPOST localhost:8080/cheeseburger_alert -d ''
+
+# In order to send an end user-targeted event
+curl -XPOST localhost:8080/alert_jane -d ''
+```

data/sample/config.ru

@@ -0,0 +1,3 @@
+require './index'
+
+run Sample

data/sample/config.yml

@@ -0,0 +1,2 @@
+host: https://api.projector.com
+token: <CHANGE ME TO PROJECTOR TOKEN FROM DASHBOARD>

data/sample/index.rb

@@ -0,0 +1,101 @@
+require 'sinatra'
+require 'sinatra/config_file'
+require 'projector'
+require 'sinatra/json'
+require 'thread'
+
+class Sample < Sinatra::Base
+
+  register Sinatra::ConfigFile
+
+  config_file './config.yml'
+
+  Projector::Client.configure do |client|
+    client[:host] = settings.host
+    client[:token] = settings.token
+    client
+  end
+
+  # Forward an end user registration, i.e. from a mobile client device,
+  # to projector's register end user endpoint.
+  # Then, return the response data back to the requesting device.
+  # Here we're specifying two tags which Jane is part of.
+  post '/register_projector' do
+    # Implementer TODO: Handle authentication
+    # Extract user id and tags and insert into the
+    # end user object like below:
+    res = Projector.register_end_user({id: 'Jane', tags: ['likes dogs', 'eats_cheeseburgers']})
+    json res
+  end
+
+  # Deliver an event to the tags group called eats_cheeseburgers.
+  # Jane would receive this notification, as she's part of the eats_cheeseburgers
+  # tag set. Use the cheeseburger_alert event key.
+  post '/cheeseburger_alert' do
+    res = Projector.deliver_event({
+            target: {
+              tags: ['eats_cheeseburgers']
+            },
+            event_context: {
+              discount_price: 12,
+              restaurant_name: "Bill's Cheeseburgerz"
+            },
+            event_key: 'cheeseburger_alert'
+          })
+    json res
+  end
+
+  # Deliver an event specifically to Jane for the event_key cheeseburger_alert.
+  post '/alert_jane' do
+    res = Projector.deliver_event({
+            target: {
+              end_users: [{id: 'Jane'}]
+            },
+            event_context: {
+              discount_price: 12,
+              restaurant_name: "Bill's Cheeseburgerz"
+            },
+            event_key: 'cheeseburger_alert'
+          })
+    json res
+  end
+
+  # Example Application Logic:
+  # Our application delivers random discounts to
+  # registered end users on a timer using the Projector Node SDK.
+  @discounts = [
+    {
+      discount_price: 12,
+      restaurant_name: "Bill's Cheeseburgerz"
+    },
+    {
+      discount_price: 11,
+      restaurant_name: "Ted's Cheeseburger Shack"
+    },
+    {
+      discount_price: 14,
+      restaurant_name: "Joan of Arc's Cheesesteaks"
+    }
+  ]
+
+  # An example of custom logic which sends cheeseburger discounts
+  # to registered end users on a timer schedule.
+  Thread.new do
+    loop do
+      begin
+        disc = @discounts.sample
+        res = Projector.deliver_event({
+                target: {
+                  tags: ['eats_cheeseburgers']
+                },
+                event_context: disc,
+                event_key: 'cheeseburger_alert'
+              })
+        puts "Successfully sent cheeseburger_alert #{res}"
+      rescue Error => e
+        puts e
+      end
+      sleep 10
+    end
+  end
+end

metadata

@@ -1,105 +1,88 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: projector
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
-- Jay Zeschin
+authors:
+- Projector
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-09 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+date: 2016-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: 2.9.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: thor
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
-description: Automatically keep a working directory with checkouts of all your Github projects
-email: 
-- jay@zeschin.org
-executables: 
-- projector
+      - !ruby/object:Gem::Version
+        version: 2.9.4
+description: Create and manage users, devices, and events going to Projector.
+email:
+- engineering@projector.com
+executables: []
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
-- bin/projector
+- bin/console
+- bin/setup
+- circle.yml
 - lib/projector.rb
-- lib/projector/cli.rb
-- lib/projector/helpers.rb
-- lib/projector/repo.rb
+- lib/projector/api_methods.rb
+- lib/projector/client.rb
+- lib/projector/end_user.rb
+- lib/projector/envelope.rb
+- lib/projector/error.rb
+- lib/projector/event.rb
+- lib/projector/transport/http.rb
 - lib/projector/version.rb
 - projector.gemspec
-has_rdoc: true
-homepage: https://github.com/jayzes/projector
-licenses: []
-
+- sample/Gemfile
+- sample/Gemfile.lock
+- sample/README.md
+- sample/config.ru
+- sample/config.yml
+- sample/index.rb
+homepage: https://www.projector.com
+licenses:
+- BSD-3-Clause
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
-summary: Automatically keep a working directory with checkouts of all your Github projects
+specification_version: 4
+summary: Ruby SDK for interacting with the Projector SDK
 test_files: []
-

data/bin/projector

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# -*- mode: ruby -*-
-
-# Requires
-begin
-  require 'projector'
-rescue LoadError
-  $:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
-  require 'rubygems'
-  require 'projector'
-end
-
-# Setup Constants
-Projector::GEM_ROOT = File.expand_path( File.dirname( __FILE__ ) + '/../' )
-
-# Run
-Projector::CLI.start

data/lib/projector/cli.rb

@@ -1,86 +0,0 @@
-require 'thor'
-require 'thor/actions'
-
-module Projector
-
-  class CLI < Thor
-
-    # Includes
-    include Thor::Actions
-    include Projector::Helpers
-
-    # Tasks
-    desc "check", "Check Git settings to make sure Projector can work its magic properly"
-    long_desc <<-DESC
-      Projector will check to make sure that your Git settings contain your Github username 
-      and API key (see http://help.github.com/set-your-user-name-email-and-github-token/) 
-      as well as your preferred working directory
-    DESC
-    def check
-      unless github_username?
-        say 'You need to configure your github.user setting - "git config --global github.user <username>" should do the trick'
-        exit 1
-      end
-      unless github_token?
-        say 'You need to configure your github.token setting - "git config --global github.token <token>" should do the trick'
-        exit 1
-      end
-      unless projector_working_dir?
-        say 'You need to configure your projector.workingdir setting - "git config --global projector.workingdir <directory>" should do the trick'
-        exit 1
-      end      
-    end
-    
-    
-    desc "checkout", "Go through the Github repositories you can access and ensure that working copies for them are cloned into your working directory"
-    long_desc <<-DESC
-      Projector loops through all of the repositories that you can access and clones working
-      copies of them under your configured working directory if they don't already exist
-    DESC
-    method_option :assume, :type => :boolean, :aliases => "-a"
-    def checkout
-      invoke :check
-      repos = all_repos
-      say "Checking #{repos.size} repositories"
-      repos.each do |repo|
-        say "Looking at #{repo.path}"
-        if should_clone_repo?(repo, options[:assume])
-          say "Cloning #{repo.clone_url} to #{repo.clone_path(projector_working_dir)}"
-          repo.clone(projector_working_dir) 
-        end
-      end 
-    end
-    
-    desc "update", "Go through the Github repositories you have in your working copy and see which ones need updating from origin"
-    long_desc <<-DESC
-      Projector loops through all of the repositories that you can access and updates the working
-      copies of them under your configured working directory if they are outdated
-    DESC
-    method_option :assume, :type => :boolean, :aliases => "-a"
-    def update
-      invoke :check
-      repos = all_repos
-      say "Checking #{repos.size} repositories"
-      repos.each do |repo|
-        unless repo_cloned?(repo)
-          say "Skipping #{repo.path} since it is not cloned"
-          next
-        end
-        say "Looking at #{repo.path}"
-        update_repo(repo) if repo_out_of_date?(repo) && (yes?("Repo #{repo.path} has remote changes.  Update it? (y/n)") || options[:assume])
-      end 
-    end
-    
-    
-    
-    
-
-    desc "version", "Prints Projector's version information"
-    def version
-      say "Projector version #{Projector::VERSION}"
-    end
-    map %w(-v --version) => :version
-
-  end
-
-end

data/lib/projector/helpers.rb

@@ -1,76 +0,0 @@
-require "net/https"
-require "uri"
-require 'json'
-
-module Projector
-  module Helpers
-    def github_username
-      `git config --get github.user`.strip
-    end
-    
-    def github_username?
-      github_username && github_username.length > 0
-    end
-    
-    def github_token
-      `git config --get github.token`.strip
-    end
-    
-    def github_token?
-      github_token && github_token.length > 0
-    end
-    
-    def projector_working_dir
-      `git config --get projector.workingdir`.strip
-    end
-    
-    def projector_working_dir?
-      projector_working_dir && projector_working_dir.length > 0
-    end
-    
-    def repo_cloned?(repo)
-      File.directory?(File.join(repo.clone_path(projector_working_dir), '.git'))
-    end
-    
-    def repo_out_of_date?(repo)
-      repo.fetch_refs(projector_working_dir)
-      repo.local_head(projector_working_dir) != repo.remote_head(projector_working_dir)
-    end
-    
-    def update_repo(repo)
-      repo.update(projector_working_dir)
-    end
-    
-    def should_clone_repo?(repo, assume_yes = false)
-      !repo_cloned?(repo) && (assume_yes || yes?("Repo #{repo.path} is not cloned yet.  Clone it? (y/n)"))
-    end
-    
-    def user_repos
-      repo_api_request("https://github.com/api/v2/json/repos/show/#{github_username}")
-    end
-    
-    def organization_repos
-      repo_api_request("https://github.com/api/v2/json/organizations/repositories?owned=1")
-    end    
-    
-    def collaborator_repos
-      repo_api_request("https://github.com/api/v2/json/repos/pushable")
-    end
-    
-    def all_repos
-      (user_repos + organization_repos + collaborator_repos).uniq
-    end
-    
-    def repo_api_request(endpoint)
-      uri = URI.parse(endpoint)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE # TODO: http://www.rubyinside.com/how-to-cure-nethttps-risky-default-https-behavior-4010.html
-      request = Net::HTTP::Get.new(uri.request_uri)
-      request.basic_auth("#{github_username}/token", github_token)
-      response = http.request(request)
-      JSON.parse(response.body)['repositories'].map { |repo| Repo.new(repo['owner'], repo['name']) }
-    end
-      
-  end
-end

data/lib/projector/repo.rb

@@ -1,34 +0,0 @@
-Repo = Struct.new(:owner, :name) do
-  def path
-    "#{self.owner}/#{self.name}"
-  end
-  
-  def clone_path(base_dir)
-    File.join(base_dir, self.owner, self.name)
-  end
-  
-  def clone_url
-    "git@github.com:#{self.owner}/#{self.name}.git"
-  end
-
-  def clone(base_dir)
-    system("git clone #{clone_url} #{clone_path(base_dir)}")
-  end
-  
-  def local_head(base_dir)
-    `cd #{clone_path(base_dir)} && git rev-parse master`.strip
-  end
-  
-  def remote_head(base_dir)
-    `cd #{clone_path(base_dir)} && git rev-parse origin/master`.strip
-  end
-  
-  def fetch_refs(base_dir)
-    system("cd #{clone_path(base_dir)} && git fetch origin")
-  end
-  
-  def update(base_dir)
-    system("cd #{clone_path(base_dir)} && git pull --rebase origin master")
-  end
-  
-end