riq 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e861c8df701fcf3bc680f3061da48295ab332d2
-  data.tar.gz: 27ab3509e83f59d86fd018b0a6f9f852812d8e75
+  metadata.gz: 6763599ea332a7fe04b54aab09334f95b74ddeec
+  data.tar.gz: 165b2617d0f2beb63947893e90c5389c9d62f63e
 SHA512:
-  metadata.gz: 1f5c66f3151336e1e93d6e56170a7aaedabf1c1140fb8b888f0a421952d247c2e2863004d3f5766e33c72e4d06d84dbe743179e26447fe11e1edb91ac591fa08
-  data.tar.gz: 240b0c53d2bae6c5ed73a169721cef3b51bf72e27ddf15e5e68ca48d1940e107a429cce1a959e111901e65baf8cb439c343caa9b810b09870ae544e65df30fd7
+  metadata.gz: 959c78bf06de627ce564b1fa1de491219dcd9abab31f523a04207bd8d6658f09da5a764894b00b0e4559b238c722a3c89f26b740bd7c57acc6d12035ce865fa3
+  data.tar.gz: 5722f9d6c18ec6329a7bccdb5a547aee635fb6bf4358f2f9a0e379b4323467dc6ca868faac8959ec5aed77efad3ccec1a7c84dc8d7a52f5cf66e51a05f051b03

data/.gitignore

@@ -0,0 +1,42 @@
+# Created by https://www.gitignore.io
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+Gemfile.lock
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# test file
+t.rb

data/.yardopts

@@ -0,0 +1,2 @@
+lib/**/*.rb
+--title RelateIQ

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'pry'
+end
+
+gem 'httparty', '0.13.3'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 RelateIQ
+
+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,33 @@
+# RelateIQ Ruby SDK
+
+A full featured API interface for interacting with the [RelateIQ](https://relateiq.com) API. 
+
+## Overview
+
+<!--[![Gem Version](https://badge.fury.io/rb/riq.svg)](http://badge.fury.io/rb/riq)-->
+[![Gem Version](https://img.shields.io/gem/v/riq.svg)](http://badge.fury.io/rb/riq)
+<!--[![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)-->
+
+## Code Examples
+
+    require 'riq'
+    RIQ.init(ENV['RIQ_API_KEY'], ENV['RIQ_API_SECRET'])
+
+    # Contacts
+    RIQ.contacts.each do |c|
+        # do something
+        puts c.name
+    end
+    # => Bruce Wayne
+    # => Malcolm Reynolds
+    # => Michael Bluth
+    # => Tony Stark
+    ...
+
+    # Etc
+
+
+## Helpful Links
+
+* [Full ruby docs](http://www.rubydoc.info/gems/riq)
+* [Examples and API docs](https://api.relateiq.com/#/ruby)

data/lib/riq.rb

@@ -0,0 +1,103 @@
+# The namespace from which all magic springs
+module RIQ
+  # Could fetch defaults or something here
+end
+
+# Monkeypatches
+# cry about it, nerd
+module RIQExtensions
+  refine Symbol do
+    def to_cam
+      temp = self.to_s.split('_').map(&:capitalize).join
+      (temp[0].downcase + temp[1..-1]).to_sym
+    end
+
+    def to_snake
+      a = self.to_s.split('')
+      n = []
+      a.each do |l|
+        n << '_' if l.is_upper_char?
+        n << l.downcase
+      end
+      n = n[1..-1] if n.first == '_'
+      n.join.to_sym
+    end
+  end 
+
+  refine String do
+    def is_upper_char?
+      !self[/[A-Z]/].nil? && self.length == 1
+    end
+
+    def is_lower_char?
+      !self[/[a-z]/].nil? && self.length == 1
+    end
+  end
+
+  refine Fixnum do
+    def cut_milis
+      self.to_s[0...-3].to_i
+    end
+
+    def to_sym
+      self.to_s.to_sym
+    end
+  end
+
+  refine Hash do
+    # Converts to RIQ API's [{raw: "VALUE"}] format
+    def to_raw
+      return {} if self.empty?
+      o = {}
+      self.each do |k, v|
+        o[k.to_cam] = [{raw: v}]
+      end
+      o
+    end
+
+    # Converts from RIQ API's [{raw: "VALUE"}] format
+    def from_raw
+      return {} if self.empty?
+      o = {}
+      self.each do |k,v| 
+        if v.is_a?(Array) && v.first.include?(:raw)
+          o[k.to_sym.to_snake] = v.first[:raw]
+        else
+          o[k.to_sym.to_snake] = v
+        end
+      end
+      o
+    end
+
+    def to_cam
+      o = {}
+      self.each do |k,v|
+        o[k.to_cam] = v
+      end
+      o
+    end
+  end
+
+  refine Object do
+    def symbolize
+      return self unless self.respond_to? :keys
+      o = {}
+      self.each do |k, v|
+        if v.respond_to? :keys
+          o[k.to_sym.to_snake] = v.symbolize
+        else
+          if v.respond_to? :each
+            v.map! do |i|
+              i.symbolize
+            end
+          end
+          o[k.to_sym.to_snake] = v
+        end
+      end
+      o
+    end
+  end
+end
+
+# Base file from which everything else is included
+Dir[__dir__ + '/riq/*.rb'].each {|file| require file }

data/lib/riq/account.rb

@@ -0,0 +1,82 @@
+require_relative 'riq_obj'
+using RIQExtensions
+
+module RIQ
+  # Accounts represent companies (or other entities).
+  class Account < RIQObject
+    attr_accessor :name
+    attr_accessor :field_values
+
+    # (see RIQObject#node)
+    def node
+      "accounts/#{@id}"
+    end
+
+    # (see #node)
+    def self.node(arg = nil)
+      "accounts"
+    end
+
+    # (see RIQObject#data)
+    def data
+      {
+        id: @id,
+        name: @name,
+        field_values: @field_values
+      }
+    end
+
+    # (see RIQObject#payload)
+    def payload
+      # TODO: find more elegant way to do this
+      pld = data
+      pld['fieldValues'] = @field_values.to_raw
+      pld.delete(:field_values)
+      pld.to_json
+    end
+
+    # @overload field_value(key)
+    #   @param key [String, Integer] 
+    #   @return [Array] Value of key
+    # @overload field_value(key, value)
+    #   Sets key to value
+    #   @param key [String, Integer] Key to set
+    #   @param value [#to_s] Sets key to value
+    def field_value(key, value = nil)
+      # TODO: double check that this works with arrays of stuff
+      # or, have a format function that casts ints to string on save
+      if value.nil?
+        @field_values.fetch(key.to_sym, nil)
+      else
+        @field_values[key.to_sym] = value.to_s
+        {key.to_sym => value.to_s}
+      end
+    end
+
+    private
+    def init(obj = nil)
+      unless obj.nil?
+        @id = obj[:id]
+        @name = obj[:name]
+        @field_values = obj[:field_values] ? obj[:field_values].from_raw : {}
+        @modified_date = obj[:modified_date].cut_milis if obj[:modified_date]
+      else
+        @id = nil
+        @name = nil
+        @field_values = {}
+      end
+      self
+    end
+
+  end
+
+  class << self
+    # Convenience method to create new Accounts
+    # @param id [String, nil] create a blank Account object or 
+    #   fetch an existing one by id.
+    # @return [Account]
+    def account(id = nil)
+      Account.new(id)
+    end
+  end
+end

data/lib/riq/batch_manager.rb

@@ -0,0 +1,133 @@
+using RIQExtensions
+
+module RIQ
+  # Manages caching and fetching for a certain type of child object.
+  class BatchManager
+    # @return [Hash] current fetch options
+    attr_reader :fetch_options
+
+    # @param klass [RIQObject] The child class that's being fetched, such as {Account} or {List}
+    # @param opts [Hash] fetch options
+    def initialize(klass, opts = {})
+      @klass = klass
+      begin
+        raise unless @klass.ancestors.include? RIQ::RIQObject
+      rescue
+        raise RIQError, 'Must pass a RIQ Class'
+      end
+      @fetch_options = {}
+      reset_cache
+      
+      # cause otherwise it's a variable
+      self.send(:fetch_options=, opts)
+      @client = RIQ.client
+    end
+
+    # Iterator for each item in the manager. Pass a block to it!
+    # @example
+    #   RIQ.lists.each do |l|
+    #     puts l
+    #   end
+    def each(&blok)
+      reset_cache
+      loop do
+        x = next_item
+        if x
+          blok.call(x)
+        else
+          return
+        end
+      end
+    end
+
+    # Returns the first child object, mainly used for testing
+    # @return [RIQObject]
+    def first
+      reset_cache
+      fetch_page.first
+    end
+
+    # Set fetch options
+    # @param opts [Hash] Where values are either strings or arrays
+    def fetch_options=(opts = {})
+      valid_keys = [:_ids, :_start, :_limit, :contactIds, :accountIds, :modifiedDate]
+      reset_cache
+      options = {}
+      opts.each do |k, v|
+        # some args are comma-separated arrays, some are just args
+        warn("[WARN] key #{k} is not one of #{valid_keys} and won't do anything") unless valid_keys.include?(k.to_sym)
+        if v.is_a? Array
+          options[k.to_sym] = v.join(',')
+        else
+          options[k.to_sym] = v
+        end
+      end
+      # ruby says that nil is an argument and page_size was getting set to 0
+      options[:_limit] ||= 200
+      @fetch_options.merge! options#.to_cam
+    end
+
+    private
+    def reset_cache
+      # shouldn't reset options, that's silly
+      # @fetch_options = {}
+      @cache = []
+      @cache_index = 0
+      @page_index = 0
+    end
+
+    def next_item
+      # I believe this is resetting opts somehow/not respecting limit
+      if @cache_index == @cache.size
+        return nil if ![0, @fetch_options[:_limit]].include? @cache.size
+        # puts "\n=== fetching page! (#{@page_index}) (#{@fetch_options[:_limit]})"
+        @cache = fetch_page(@page_index)
+        @page_index += @cache.size
+        @cache_index = 0
+      end
+
+      if @cache_index < @cache.size
+        obj = @cache[@cache_index]
+        @cache_index += 1
+        obj
+      else
+        nil
+      end
+    end
+
+    def fetch_page(index = 0)
+      @fetch_options.merge!({_start: index})
+
+      # all class#node functions can take an arg, so far, only list items need it. 
+      # having list_id usually be nil (that is, undefined) is fine. probably.
+      data = @client.get(@klass.node(@list_id), options: @fetch_options)
+
+      objects = []
+      data.fetch('objects', []).each do |obj|
+        objects << @klass.new(obj)
+      end
+      objects
+    end
+  end
+
+  class << self
+    # @!macro [new] conv
+    #   Returns an iterator for all $0
+    #   @return [BatchManager] 
+
+    # @macro conv
+    def lists(opts = {})
+      BatchManager.new(RIQ::List, opts)
+    end
+
+    # @macro conv
+    def contacts(opts = {})
+      BatchManager.new(RIQ::Contact, opts)
+    end
+
+    # @macro conv
+    def accounts(opts = {})
+      BatchManager.new(RIQ::Account, opts)
+    end
+  end
+end

data/lib/riq/client.rb

@@ -0,0 +1,130 @@
+require 'httparty'
+require 'json'
+require_relative 'error'
+
+module RIQ
+  # HTTP client responsible for actually handling the HTTP requests.
+  # @note Utility class to perform HTTP requests. This shouldn't be
+  #   instantiated directly but used by children of RIQObject instead.
+  class Client
+    attr_accessor :cache
+
+    def initialize(key, secret)
+      raise 'Missing credentials' if key.nil? || secret.nil?
+
+      @root_url = 'https://api.relateiq.com/v2'
+
+      @auth = {username: key, password: secret}
+      @headers = {
+        'Content-type' => 'application/json', 
+        'Accept' => 'application/json'
+      }
+      @cache = {}
+    end
+      
+    # for caching, used with #next ? 
+    # def store(endpoint, objects)
+      # @cache[endpoint] = objects unless objects.nil?
+    # end
+
+    # Makes a GET request, used for fetching existing objects.
+    # @return (see #request)
+    def get(endpoint, options: nil)
+      request(endpoint, :get, nil, options)
+    end
+
+    # Makes a POST request, used for creating new objects.
+    # @return (see #request)
+    def post(endpoint, body, options: nil)
+      request(endpoint, :post, body, options)
+    end
+
+    # Makes a PUT request, used for updating existing objects.
+    # @return (see #request)
+    def put(endpoint, body, options: nil)
+      request(endpoint, :put, body, options)
+    end
+
+    # Makes a DELETE request, used for deleting existing objects.
+    # @return (see #request)
+    def delete(endpoint, options: nil)
+      request(endpoint, :delete, nil, options)
+    end
+
+    private
+
+    # actually does the requesting
+    # @return (see #process_response)
+    def request(endpoint, method = :get, body = nil, options = nil)
+      # there may be a better way to do this, but this is close
+      url = "#{@root_url}/#{endpoint}"
+      # pp "#{method} request to #{url} with body: #{body} and options: #{options}"
+      if [:get, :delete].include? method
+        resp = HTTParty.method(method).call(
+          url, 
+          headers: @headers, 
+          basic_auth: @auth, 
+          query: options
+        )
+      elsif [:post, :put].include? method
+        resp = HTTParty.method(method).call(
+          url, 
+          headers: @headers, 
+          basic_auth: @auth, 
+          query: options, 
+          body: body
+        )
+      else
+        # this shouldn't ever get hit?
+        raise RIQError, 'Invalid method'
+      end
+      
+      # HTTParty response object
+      process_response(resp)
+    end
+
+    def process_response(resp)
+      # pp "processing #{resp}, code: #{resp.code}"
+      if resp.code == 503
+        raise NotImplementedError, 'This function is not currently supported by RelateIQ'
+      elsif resp.code == 404 
+        raise NotFoundError, 'Object Not Found'
+      elsif resp.code >= 400 
+        # Record Response Data
+        raise HTTPError, resp 
+      end
+      # 404 Object not found
+      #    if List, have them check if it is shared
+      # 500
+      # 422
+      # 400 Bad Request - pass on internal message
+      # 502 Bad Gateway - Reattempt
+      
+      # if resp.include? 'objects'
+      #   resp['objects']
+      # else
+      resp.parsed_response
+      # end
+    end
+  end
+
+  class << self  
+    # @param key [String] RelateIQ API key
+    # @param secret [String] RelateIQ API secret
+    # @return [RIQ] The module, in case you want it.
+    def init(key = nil, secret = nil)
+      key ||= ENV['RIQ_TEST_API_KEY']
+      secret ||= ENV['RIQ_TEST_API_SECRET']
+
+      @@client = Client.new(key, secret)
+      self
+    end
+
+    # Always use RIQ.client to retrieve the client object.
+    # @return [Client] The client object
+    def client
+      raise RIQError, 'Client not initialized' unless @@client
+      @@client
+    end
+  end
+end