geotrigger 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1681ff89f1fb5fa48cee8fb34b31de586e2ca57b
+  data.tar.gz: c4e1f585cc211d2a40e6ddadf9043ae36a831271
+SHA512:
+  metadata.gz: a76125f1e937a2a6dffb38e98a966034adc6dab207743c1dc23b091897ec6f7d606ac1841c678a5922dcd0823c142a704ac0a2a56197d5f34b9ddc3fd29c8d2c
+  data.tar.gz: cdf2862f6dce564353b9f9f363729a504a75da4f1ae15c6557b1496103d44ac728f040cfe1e304da1eaa9dd1f2b1f845cace0641d3313697f470b8e3d7654f8b

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+config.yml
+geotrigger-0.0.1.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'httpclient'
+gem 'timecop'

data/README.md

@@ -0,0 +1,4 @@
+geotrigger-ruby
+===============
+
+a small ruby client for https://developers.arcgis.com/en/geotrigger-service/.

data/geotrigger.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/geotrigger/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kenichi Nakamura"]
+  gem.email         = ["kenichi.nakamura@gmail.com"]
+  gem.description   = gem.summary = "A small ruby client for Esri's Geotrigger service"
+  gem.homepage      = "https://github.com/esripdx/geotrigger-ruby"
+  gem.files         = `git ls-files | grep -Ev '^(myapp|examples)'`.split("\n")
+  gem.test_files    = `git ls-files -- spec/*`.split("\n")
+  gem.name          = "geotrigger"
+  gem.require_paths = ["lib"]
+  gem.version       = Geotrigger::VERSION
+  gem.license       = 'apache'
+
+  gem.add_dependency 'httpclient'
+  gem.add_development_dependency 'timecop'
+end

data/lib/ext/string.rb

@@ -0,0 +1,26 @@
+class String
+
+  alias_method :blank?, :empty?
+
+  # these are pretty much ripped from:
+  # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+  #
+  def camelcase
+    string = self.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    string.gsub!('/', '::')
+    string
+  end
+
+  def underscore
+    acronym_regex = /(?=a)b/
+    word = self.gsub('::', '/')
+    word.gsub!(/(?:([A-Za-z\d])|^)(#{acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+end

data/lib/geotrigger.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+require 'httpclient'; class HTTPClient; def inspect; to_s; end; end
+require 'json'
+
+module Geotrigger
+  class AGOError < StandardError; end
+  class GeotriggerError < StandardError
+    attr_accessor :code, :headers, :message, :params
+  end
+end
+
+lib = File.expand_path '../..', __FILE__
+$:.push lib unless $:.include? lib
+require 'ext/string'
+
+require 'geotrigger/ago/session'
+require 'geotrigger/session'
+require 'geotrigger/model'
+
+require 'geotrigger/application'
+require 'geotrigger/device'
+require 'geotrigger/tag'
+require 'geotrigger/trigger'

data/lib/geotrigger/ago/session.rb

@@ -0,0 +1,145 @@
+module Geotrigger
+  module AGO
+    class Session
+      extend ::Forwardable
+      def_delegators :@impl, :access_token, :access_token=, :ago_data, :device_data, :refresh_token
+
+      AGO_BASE_URL = (ENV.key?('AGO_BASE_URL') ?
+                      (ENV['AGO_BASE_URL'] + '%s') :
+                      'https://www.arcgis.com/sharing/%s').freeze
+
+      def initialize opts = {}
+        @hc = HTTPClient.new
+        @impl = case opts[:type] || :application
+                when :application
+                  Application.new self, opts
+                when :device
+                  Device.new self, opts
+                else
+                  raise ArgumentError 'unknown type'
+                end
+      end
+
+      def type
+        case @impl
+        when Application
+          :application
+        when Device
+          :device
+        end
+      end
+
+      # http the specified method to the specified path with the given params.
+      # json parse the response body or raise errors.
+      #
+      def hc meth, path, params
+        r = @hc.__send__ meth, AGO_BASE_URL % path, params.merge(f: 'json')
+        raise AGOError.new r.body unless r.status == 200
+        h = JSON.parse r.body
+        raise AGOError.new r.body if h['error']
+        h
+      end
+
+      module ExpirySet
+
+        TOKEN_EXPIRY_BUFFER = 10
+
+        def wrap_token_retrieval &block
+          yield
+          expires_at = Time.now.to_i + @ago_data['expires_in']
+          @ago_data[:expires_at] = Time.at expires_at - TOKEN_EXPIRY_BUFFER
+          @ago_data
+        end
+
+      end
+
+      class Application
+        include ExpirySet
+        extend ::Forwardable
+        def_delegator :@session, :hc
+
+        attr_reader :ago_data
+
+        def initialize session, opts = {}
+          @session, @client_id, @client_secret =
+            session, opts[:client_id], opts[:client_secret]
+        end
+
+        def access_token
+          fetch_access_token if @ago_data.nil? or
+                                (not @ago_data[:expires_at].nil? and
+                                Time.now >= @ago_data[:expires_at])
+          @ago_data['access_token']
+        end
+
+        private
+
+        def fetch_access_token
+          wrap_token_retrieval do
+            @ago_data = hc :post, 'oauth2/token',
+              client_id: @client_id,
+              client_secret: @client_secret,
+              grant_type: 'client_credentials'
+          end
+        end
+
+      end
+
+      class Device
+        include ExpirySet
+        extend Forwardable
+        def_delegator :@session, :hc
+
+        attr_accessor :refresh_token
+        attr_reader :ago_data
+
+        def initialize session, opts = {}
+          @session, @client_id, @refresh_token =
+            session, opts[:client_id], opts[:refresh_token]
+        end
+
+        def access_token
+          if @ago_data.nil?
+            if @refresh_token.nil?
+              register
+            else
+              refresh_access_token
+            end
+          elsif not @ago_data[:expires_at].nil? and Time.now >= @ago_data[:expires_at]
+            refresh_access_token
+          end
+          @ago_data['access_token']
+        end
+
+        def device_data
+          @device_data ||= hc(:get, 'portals/self', token: access_token)['deviceInfo']
+        end
+
+        private
+
+        def register
+          wrap_token_retrieval do
+            data = hc :post, 'oauth2/registerDevice', client_id: @client_id, expiration: -1
+            @ago_data = {
+              'access_token' => data['deviceToken']['access_token'],
+              'expires_in' => data['deviceToken']['expires_in']
+            }
+            @device_data = data['device']
+            @refresh_token = data['deviceToken']['refresh_token']
+          end
+        end
+
+        def refresh_access_token
+          wrap_token_retrieval do
+            @ago_data = hc :post, 'oauth2/token',
+              client_id: @client_id,
+              refresh_token: @refresh_token,
+              grant_type: 'refresh_token'
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/geotrigger/application.rb

@@ -0,0 +1,27 @@
+module Geotrigger
+
+  class Application < Model
+
+    def permissions
+      post 'application/permissions'
+    end
+
+    def permissions= perms
+      post 'application/permissions/update', perms
+    end
+
+    def devices params = {}
+      post_list 'devices', params
+    end
+
+    def tags params = {}
+      post_list 'tags', params
+    end
+
+    def triggers params = {}
+      post_list 'triggers', params
+    end
+
+  end
+
+end

data/lib/geotrigger/device.rb

@@ -0,0 +1,50 @@
+module Geotrigger
+
+  class Device < Model
+    include Taggable
+
+    def initialize opts = {}
+      super opts
+      case session.type
+      when :application
+        if opts[:device_id] and @data.nil?
+          grok_self_from post('device/list', deviceIds: opts[:device_id]), opts[:device_id]
+        end
+      when :device
+        if @data.nil?
+          grok_self_from post('device/list'), opts[:device_id] || :first
+        end
+      end
+    end
+
+    def default_tag
+      'device:%s' % deviceId
+    end
+
+    def post_update
+      post_data = @data.dup
+      case @session.type
+      when :application
+        post_data['deviceIds'] = post_data.delete 'deviceId'
+      when :device
+        post_data.delete 'deviceId'
+      end
+      post_data.delete 'tags'
+      post_data.delete 'lastSeen'
+
+      grok_self_from post 'device/update', post_data
+      self
+    end
+    alias_method :save, :post_update
+
+    def grok_self_from data, id = nil
+      if id == :first
+        @data = data['devices'].first
+      else
+        @data = data['devices'].select {|t| t['deviceId'] == (id || @data['deviceId'])}.first
+      end
+    end
+
+  end
+
+end

data/lib/geotrigger/model.rb

@@ -0,0 +1,84 @@
+module Geotrigger
+
+  class Model
+
+    class StateError < StandardError; end
+
+    extend Forwardable
+    def_delegator :@session, :post
+
+    attr_accessor :data
+    attr_reader :session
+
+    def self.from_api data, session
+      i = self.new session: session
+      i.data = data
+      return i
+    end
+
+    def initialize opts = {}
+      @session = opts[:session] || Session.new(opts)
+    end
+
+    def post_list models, params = {}, default_params = {}
+      model = models.sub /s$/, ''
+      params = default_params.merge params
+      post(model + '/list', params)[models].map do |data|
+        Geotrigger.const_get(model.capitalize).from_api data, @session
+      end
+    end
+
+    def method_missing meth, *args
+      meth_s = meth.to_s
+      if meth_s =~ /=$/ and args.length == 1
+        key = meth_s.sub(/=$/,'').camelcase
+        if @data and @data.key? key
+          @data[key] = args[0]
+        else
+          super meth, *args
+        end
+      else
+        key = meth_s.camelcase
+        if @data and @data.key? key
+          @data[key]
+        else
+          super meth, *args
+        end
+      end
+    end
+
+    def == obj
+      if Model === obj
+        self.data == obj.data
+      else
+        false
+      end
+    end
+
+    module Taggable
+
+      def tags params = {}
+        post_list 'tags', params, tags: @data['tags']
+      end
+
+      def add_tags *names
+        @data['addTags'] = names.flatten
+      end
+
+      def remove_tags *names
+        names = names.flatten
+        raise ArgumentError.new "default tag prohibited" if names.include? default_tag
+        @data['removeTags'] = names
+      end
+
+      def tags= *names
+        names = names.flatten
+        raise ArgumentError.new "default tag required" unless names.include? default_tag
+        @data['setTags'] = names
+      end
+
+    end
+
+  end
+
+end

data/lib/geotrigger/session.rb

@@ -0,0 +1,57 @@
+module Geotrigger
+
+  class Session
+    extend Forwardable
+    def_delegator :@ago, :type
+
+    BASE_URL = (ENV.key?('GT_BASE_URL') ?
+               (ENV['GT_BASE_URL'] + '%s') :
+               'https://geotrigger.arcgis.com/%s').freeze
+
+    attr_writer :access_token
+
+    def initialize opts = {}
+      @ago = AGO::Session.new opts
+      @hc = HTTPClient.new
+    end
+
+    def access_token
+      @access_token || @ago.access_token
+    end
+
+    def headers
+      {
+        'Content-Type' => 'application/json',
+        'Authorization' => "Bearer #{access_token}"
+      }
+    end
+
+    def post path, params = {}
+      r = @hc.post BASE_URL % path, params.to_json, headers
+      raise GeotriggerError.new r.body unless r.status == 200
+      h = JSON.parse r.body
+      raise_error h['error'] if h['error']
+      h
+    end
+
+    def raise_error error
+      ge = GeotriggerError.new error['message']
+      ge.code = error['code']
+      ge.headers = error['headers']
+      ge.message = error['message']
+      ge.params = error['params']
+      jj error
+      raise ge
+    end
+
+    def device?
+      type == :device
+    end
+
+    def application?
+      type == :application
+    end
+
+  end
+
+end

data/lib/geotrigger/tag.rb

@@ -0,0 +1,47 @@
+module Geotrigger
+
+  class Tag < Model
+
+    def self.create session, opts
+      t = ::Geotrigger::Tag.new session: session
+      t.data = opts
+      t.post_create
+    end
+
+    def initialize opts = {}
+      super opts
+      if opts[:name] and @data.nil?
+        grok_self_from post('tag/list', tags: opts[:name]), opts[:name]
+      end
+    end
+
+    def triggers params = {}
+      post_list 'triggers', params, tags: name
+    end
+
+    def devices params = {}
+      post_list 'devices', params, tags: name
+    end
+
+    def post_create
+      post_data = @data.dup
+      grok_self_from post('tag/permissions', post_data), @data[:tags]
+      self
+    end
+
+    def post_update
+      raise StateError.new 'device access_token prohibited' if @session.device?
+      post_data = @data.dup
+      post_data['tags'] = post_data.delete 'name'
+      grok_self_from post 'tag/permissions', post_data
+      self
+    end
+    alias_method :save, :post_update
+
+    def grok_self_from data, name = nil
+      @data = data['tags'].select {|t| t['name'] == (name || @data['name'])}.first
+    end
+
+  end
+
+end

data/lib/geotrigger/trigger.rb

@@ -0,0 +1,45 @@
+module Geotrigger
+
+  class Trigger < Model
+    include Taggable
+
+    def self.create session, opts
+      t = Trigger.new session: session
+      t.data = opts
+      t.post_create
+    end
+
+    def initialize opts = {}
+      super opts
+      if opts[:trigger_id] and @data.nil?
+        grok_self_from post('trigger/list', triggerIds: opts[:trigger_id]), opts[:trigger_id]
+      end
+    end
+
+    def default_tag
+      'trigger:%s' % triggerId
+    end
+
+    def post_create
+      post_data = @data.dup
+      @data = post 'trigger/create', post_data
+      self
+    end
+
+    def post_update opts = {}
+      post_data = @data.dup
+      post_data['triggerIds'] = post_data.delete 'triggerId'
+      post_data.delete 'tags'
+
+      grok_self_from post 'trigger/update', post_data.merge(opts)
+      self
+    end
+    alias_method :save, :post_update
+
+    def grok_self_from data, id = nil
+      @data = data['triggers'].select {|t| t['triggerId'] == (id || @data['triggerId'])}.first
+    end
+
+  end
+
+end

data/lib/geotrigger/version.rb

@@ -0,0 +1,3 @@
+module Geotrigger
+  VERSION = '0.0.2'
+end

data/spec/config.yml.example

@@ -0,0 +1,3 @@
+:client_id: xxx
+:client_secret: yyy
+:refresh_token: zzz

data/spec/geotrigger/application_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../helper'
+
+describe Geotrigger::Application do
+
+  PERMS = 'deviceList',
+          'deviceLocation',
+          'deviceTagging',
+          'deviceToken',
+          'discoverableDevice',
+          'discoverableApplication',
+          'triggerApply',
+          'triggerDelete',
+          'triggerHistory',
+          'triggerList',
+          'triggerUpdate'
+
+  let :app do
+    Geotrigger::Application.new client_id: CONF[:client_id],
+                                client_secret: CONF[:client_secret]
+  end
+
+  it 'fetches permissions' do
+    ps = app.permissions
+    ps.should_not be nil
+    ps.should be_a Hash
+    ps.keys.should include *PERMS
+  end
+
+  it 'sets permissions' do
+    PERMS.each do |p|
+      ps = app.permissions
+      _ps = ps.merge p => !ps[p]
+      app.permissions = _ps
+      __ps = app.permissions
+      __ps.should eq ps.merge(p => !ps[p])
+      app.permissions = ps
+    end
+  end
+
+  it 'fetches devices' do
+    ds = app.devices
+    ds.should_not be nil
+    ds.should be_a Array
+    ds.first.should be_a Geotrigger::Device unless ds.empty?
+  end
+
+  it 'fetches tags' do
+    ts = app.tags
+    ts.should_not be nil
+    ts.should be_a Array
+    ts.first.should be_a Geotrigger::Tag unless ts.empty?
+  end
+
+  it 'fetches triggers' do
+    ts = app.triggers
+    ts.should_not be nil
+    ts.should be_a Array
+    ts.first.should be_a Geotrigger::Trigger unless ts.empty?
+  end
+
+end

data/spec/geotrigger/device_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../helper'
+
+describe Geotrigger::Device do
+
+  let :dev do
+    s = GT::AGO::Session.new client_id: CONF[:client_id],
+                                     type: :device
+
+    # can't use this because GT doesn't know it yet
+    #
+    ago_did = s.device_data['deviceId']
+
+    # make a call to GT so it learns of new device
+    #
+    at = s.access_token
+    r = HTTPClient.new.get Geotrigger::Session::BASE_URL % 'device/list',
+                           nil,
+                           'Authorization' => "Bearer #{at}"
+
+    gt_did = JSON.parse(r.body)['devices'][0]['deviceId']
+
+    # assert ids are the same
+    #
+    ago_did.should eq gt_did
+
+    GT::Device.new client_id: CONF[:client_id],
+                   client_secret: CONF[:client_secret],
+                   device_id: ago_did
+  end
+
+  it 'fetches tags' do
+    ts = dev.tags
+    ts.should_not be nil
+    ts.should be_a Array
+    ts.first.should be_a GT::Tag
+    ts.first.name.should eq dev.default_tag
+  end
+
+  it 'knows the default tag' do
+    dev.default_tag =~ /^device:\S+$/
+  end
+
+  it 'updates' do
+    dev.properties = {'foo' => 'bar'}
+    dev.trackingProfile = 'adaptive'
+    dev.save
+    dev.properties.should eq({'foo' => 'bar'})
+    dev.trackingProfile.should eq 'adaptive'
+  end
+
+  it 'adds tags' do
+    ts = dev.tags
+    ts.length.should eq 1
+    dev.add_tags 'foo', 'bar'
+    dev.save
+    ts = dev.tags
+    ts.length.should eq 3
+  end
+
+  it 'sets tags' do
+    ts = dev.tags
+    ts.length.should eq 1
+    dev.tags = dev.default_tag, 'fu', 'bat'
+    dev.save
+    ts = dev.tags
+    ts.length.should eq 3
+  end
+
+  it 'removes tags' do
+    dev.tags = dev.default_tag, 'fizz', 'buzz'
+    dev.save
+    sleep 3
+    ts = dev.tags
+    ts.length.should eq 3
+    dev.remove_tags 'fizz', 'buzz'
+    dev.save
+    ts = dev.tags
+    ts.length.should eq 1
+  end
+
+end

data/spec/geotrigger/geotrigger_spec.rb

@@ -0,0 +1,108 @@
+require_relative '../helper'
+
+describe Geotrigger::AGO::Session do
+
+  def session_should_be_ok agos
+    agos.access_token.should_not be nil
+    agos.ago_data.should_not be nil
+    agos.ago_data.keys.should include 'access_token', 'expires_in', :expires_at
+    (agos.ago_data[:expires_at] > Time.now).should be true
+  end
+
+  it 'fetches an access token for client credentials' do
+    session_should_be_ok Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                                      client_secret: CONF[:client_secret]
+  end
+
+  it 'fetches access and refresh tokens for client id' do
+    session_should_be_ok Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                                      type: :device
+  end
+
+  it 'fetches access token for client id and refresh token' do
+    session_should_be_ok Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                                      refresh_token: CONF[:refresh_token],
+                                                      type: :device
+  end
+
+  it 'updates an expired access token with client credentials' do
+    agos = Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                        client_secret: CONF[:client_secret]
+    at = agos.access_token
+    Timecop.travel agos.ago_data[:expires_at] do
+      _at = agos.access_token
+      session_should_be_ok agos
+      at.should_not eq _at
+    end
+  end
+
+  it 'updates an expired access token without given refresh token' do
+    agos = Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                        type: :device
+    at = agos.access_token
+    Timecop.travel agos.ago_data[:expires_at] do
+      _at = agos.access_token
+      session_should_be_ok agos
+      at.should_not eq _at
+    end
+  end
+
+  it 'updates an expired access token given refresh token' do
+    agos = Geotrigger::AGO::Session.new client_id: CONF[:client_id],
+                                        refresh_token: CONF[:refresh_token],
+                                        type: :device
+    at = agos.access_token
+    Timecop.travel agos.ago_data[:expires_at] do
+      _at = agos.access_token
+      session_should_be_ok agos
+      at.should_not eq _at
+    end
+  end
+
+end
+
+describe Geotrigger::Session do
+
+  it 'fetches an access token for client credentials' do
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                client_secret: CONF[:client_secret]
+    s.access_token.should_not be nil
+  end
+
+  it 'fetches an access token for client id' do
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                type: :device
+    s.access_token.should_not be nil
+  end
+
+  it 'uses a given access token' do
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                client_secret: CONF[:client_secret]
+    s.access_token = 'foo'
+    s.access_token.should eq 'foo'
+  end
+
+  it 'uses a given refresh token' do
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                refresh_token: CONF[:refresh_token],
+                                type: :device
+    s.access_token.should_not be nil
+  end
+
+  it 'knows what type it is' do
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                client_secret: CONF[:client_secret]
+    s.application?.should be true
+    s.device?.should be false
+    s = Geotrigger::Session.new client_id: CONF[:client_id],
+                                type: :device
+    s.application?.should be false
+    s.device?.should be true
+  end
+
+  it 'raises errors correctly' do
+    s = Geotrigger::Session.new
+    ->{ s.post 'application/permissions' }.should raise_error
+  end
+
+end

data/spec/geotrigger/tag_spec.rb

@@ -0,0 +1,106 @@
+require_relative '../helper'
+
+describe Geotrigger::Tag do
+
+  TAG_PERMS = 'deviceList',
+          'deviceLocation',
+          'deviceTagging',
+          'deviceToken',
+          'discoverable',
+          'triggerApply',
+          'triggerDelete',
+          'triggerHistory',
+          'triggerList',
+          'triggerUpdate'
+
+  let :session do
+    Geotrigger::Session.new client_id: CONF[:client_id],
+                            client_secret: CONF[:client_secret]
+  end
+
+  let :tag do
+    GT::Tag.create session, tags: "foo#{Time.now.to_i}"
+  end
+
+  let :dev do
+    s = GT::AGO::Session.new client_id: CONF[:client_id],
+                             type: :device
+
+    # can't use this because GT doesn't know it yet
+    #
+    ago_did = s.device_data['deviceId']
+
+    # make a call to GT so it learns of new device
+    #
+    at = s.access_token
+    r = HTTPClient.new.get Geotrigger::Session::BASE_URL % 'device/list',
+                           nil,
+                           'Authorization' => "Bearer #{at}"
+
+    gt_did = JSON.parse(r.body)['devices'][0]['deviceId']
+
+    # assert ids are the same
+    #
+    ago_did.should eq gt_did
+
+    GT::Device.new client_id: CONF[:client_id],
+                   client_secret: CONF[:client_secret],
+                   device_id: ago_did
+  end
+
+  let :trigger_opts do
+    {
+      'condition' => {
+        'direction' => 'enter',
+        'geo' => {
+          'latitude' => 45.5165,
+          'longitude' => -122.6764,
+          'distance' => 100
+        }
+      },
+      'action' => {
+        'trackingProfile' => 'adaptive'
+      }
+    }
+  end
+
+  let :trigger do
+    GT::Trigger.create session, trigger_opts
+  end
+
+  it 'creates a tag' do
+    t = tag
+    t.name.should match /^foo/
+    TAG_PERMS.each {|p| t.__send__(p).should_not be nil}
+  end
+
+  it 'fetches triggers' do
+    t = tag
+    trig = trigger
+    trig.add_tags t.name
+    trig.save
+    t.triggers.first.data.should eq trig.data
+  end
+
+  it 'fetches devices' do
+    t = tag
+    d = dev
+    d.add_tags t.name
+    d.save
+    t.devices.first.device_id.should eq d.device_id
+  end
+
+  it 'updates permissions' do
+    t = tag
+    t.name.should match /^foo/
+    t_data = t.data.dup
+    TAG_PERMS.each do |p|
+      t.data[p] = !t_data[p]
+      doid = t.data.object_id
+      t.save
+      t.data.object_id.should_not eq doid
+      t.data[p].should eq !t_data[p]
+    end
+  end
+
+end

data/spec/geotrigger/trigger_spec.rb

@@ -0,0 +1,88 @@
+require_relative '../helper'
+
+describe Geotrigger::Trigger do
+
+  let :session do
+    Geotrigger::Session.new client_id: CONF[:client_id],
+                            client_secret: CONF[:client_secret]
+  end
+
+  let :opts do
+    {
+      'condition' => {
+        'direction' => 'enter',
+        'geo' => {
+          'latitude' => 45.5165,
+          'longitude' => -122.6764,
+          'distance' => 100
+        }
+      },
+      'action' => {
+        'trackingProfile' => 'adaptive'
+      }
+    }
+  end
+
+  let :trigger do
+    GT::Trigger.create session, opts
+  end
+
+  it 'should create a trigger' do
+    t = trigger
+    t.trigger_id.should_not be nil
+    t.condition.should eq opts['condition']
+    t.action.should eq opts['action']
+  end
+
+  it 'fetches tags' do
+    ts = trigger.tags
+    ts.should_not be nil
+    ts.should be_a Array
+    ts.first.should be_a GT::Tag
+    ts.first.name.should eq trigger.default_tag
+  end
+
+  it 'knows the default tag' do
+    trigger.default_tag =~ /^trigger:\S+$/
+  end
+
+  it 'updates' do
+    trigger.properties = {'foo' => 'bar'}
+    trigger.action['trackingProfile'] = 'adaptive'
+    trigger.save
+    trigger.properties.should eq({'foo' => 'bar'})
+    trigger.action['trackingProfile'].should eq 'adaptive'
+  end
+
+  it 'adds tags' do
+    ts = trigger.tags
+    ts.length.should eq 1
+    trigger.add_tags 'foo', 'bar'
+    trigger.save
+    ts = trigger.tags
+    ts.length.should eq 3
+  end
+
+  it 'sets tags' do
+    ts = trigger.tags
+    ts.length.should eq 1
+    trigger.tags = trigger.default_tag, 'fu', 'bat'
+    trigger.save
+    ts = trigger.tags
+    ts.length.should eq 3
+  end
+
+  it 'removes tags' do
+    trigger.tags = trigger.default_tag, 'fizz', 'buzz'
+    trigger.save
+    sleep 3
+    ts = trigger.tags
+    ts.length.should eq 3
+    trigger.remove_tags 'fizz', 'buzz'
+    trigger.save
+    ts = trigger.tags
+    ts.length.should eq 1
+  end
+
+
+end

data/spec/helper.rb

@@ -0,0 +1,8 @@
+lib = File.expand_path '../..', __FILE__
+$:.unshift lib unless $:.include? lib
+
+require 'yaml'
+CONF = YAML.load_file File.expand_path '../config.yml', __FILE__
+
+require 'timecop'
+require 'geotrigger'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: geotrigger
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Kenichi Nakamura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small ruby client for Esri's Geotrigger service
+email:
+- kenichi.nakamura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- geotrigger.gemspec
+- lib/ext/string.rb
+- lib/geotrigger.rb
+- lib/geotrigger/ago/session.rb
+- lib/geotrigger/application.rb
+- lib/geotrigger/device.rb
+- lib/geotrigger/model.rb
+- lib/geotrigger/session.rb
+- lib/geotrigger/tag.rb
+- lib/geotrigger/trigger.rb
+- lib/geotrigger/version.rb
+- spec/config.yml.example
+- spec/geotrigger/application_spec.rb
+- spec/geotrigger/device_spec.rb
+- spec/geotrigger/geotrigger_spec.rb
+- spec/geotrigger/tag_spec.rb
+- spec/geotrigger/trigger_spec.rb
+- spec/helper.rb
+homepage: https://github.com/esripdx/geotrigger-ruby
+licenses:
+- apache
+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.0.3
+signing_key: 
+specification_version: 4
+summary: A small ruby client for Esri's Geotrigger service
+test_files:
+- spec/config.yml.example
+- spec/geotrigger/application_spec.rb
+- spec/geotrigger/device_spec.rb
+- spec/geotrigger/geotrigger_spec.rb
+- spec/geotrigger/tag_spec.rb
+- spec/geotrigger/trigger_spec.rb
+- spec/helper.rb