pipeline_dealers 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pipelinedealers.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard "rspec" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch("spec/helper.rb") { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Maarten Hoogendoorn
+
+MIT License
+
+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,64 @@
+# Pipelinedealers
+
+API client for pipelinedeals.com
+
+## Installation
+
+Add it to your application's Gemfile:
+
+  ```gem 'pipeline_dealers'```
+
+## Usage
+
+The client's API is modelled after ActiveRecord.
+
+```ruby
+require 'pipeline_dealers'
+
+client = Pipelinedealers::Client.new(api_key: "z3kr3tp@zzw0rd")
+
+# Get all companies
+client.companies.all.each do |company|
+ puts company.name
+end
+
+# Find company by ID
+my_company = client.companies.find(id)
+
+my_company.name = "foobar"
+my_company.save
+```
+
+For more details and how to use people and notes, see [the examples](examples/)
+
+## Test your application's usage of pipeline\_dealers.
+
+```ruby
+require 'pipeline_dealers'
+require 'pipeline_dealers/test'
+
+describe "MyClass" do
+  let(:client) { Pipelinedealers::TestClient.new }
+
+  it "should create a company" do
+    expect do
+      client.companies.create(name: "AwesomeCompany")
+    end.to change(client.companies, :length).from(0).to(1)
+  end
+end
+```
+*Note:* Be sure to stub the client in your code. This only works if you use the same client reference in both the specs and your application.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Thanks to
+
+The awesome people at
+
+[![Springest](http://static-1.cdnhub.nl/images/logo-springest.jpg "Logo springest.com")](http://www.springest.com/about-springest)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/examples/companies_create_and_destroy.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+company = client.companies.create(name: "Awesome Company")
+company.destroy

data/examples/companies_list_all.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+client.companies.each do |company|
+  p company
+  puts
+end

data/examples/company_details.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+id = ask_id("Enter the ID of the company")
+
+company = client.companies.find(id)
+
+attributes = PipelineDealers::Model::Company.attributes.collect do |attribute, options|
+  [attribute, options, company.attributes[attribute]]
+end
+
+print_table ["Name", "Options", "Value"], attributes
+
+puts
+
+puts "Custom fields of this company:"
+print_table ["Name", "Value"], company.custom_fields.collect { |k,v| [k,v] }

data/examples/company_notes.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+client.companies.each do |company|
+  puts "Company: " + company.name
+  puts "Notes:"
+
+  company.notes.each do |note|
+    puts "Title      : #{note.title}"
+    puts "  - Person : #{note.person.full_name}" if note.person_id != nil
+    puts "  - Content: #{note.content.gsub("\n","\n             ")}"
+  end
+
+  puts
+end

data/examples/company_people.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+client.companies.each do |company|
+  puts "Company: " + company.name
+  puts "People:"
+
+  company.people.each do |person|
+    puts "  - " + person.full_name
+  end
+
+  puts
+end

data/examples/config.rb

@@ -0,0 +1,54 @@
+require "rubygems"
+require "bundler"
+
+Bundler.setup
+
+require "pipeline_dealers"
+
+YOUR_API_KEY = ENV["API_KEY"]
+
+if YOUR_API_KEY.nil?
+  puts "Run these examples like: "
+  puts "  $ API_KEY=<YOUR_API_KEY> bundle exec ./<EXAMPLE>.rb"
+  exit
+end
+
+def ask_id question
+  puts question
+  while true
+    id = gets.chomp.strip.to_i
+    if id < 1
+      puts "Invalid id!"
+      puts question
+    else
+      return id
+    end
+  end
+end
+
+def print_table header, rows
+  rows     = [header] +rows.map { |row| row.map { |item| item.inspect} }
+  maximums = {}
+  rows.each do |row| 
+    row.each_with_index do |val, idx|
+      maximums[idx] = 0 if maximums[idx].nil?
+
+      length = val.length
+      maximums[idx] = length if maximums[idx] < length
+    end
+  end
+
+  format = "|"
+  separator="+"
+  maximums.keys.sort.each do |idx|
+    format    += " %-#{maximums[idx]}s |"
+    separator += "-#{'-'*maximums[idx] }-+"
+  end
+
+  header = rows.shift
+  puts separator
+  puts(format % header)
+  puts separator
+  rows.each { |row| puts(format % row) }
+  puts separator
+end

data/examples/find_person.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+id = ask_id("Enter the ID of the person you want to find")
+
+person = client.people.find(id)
+p person

data/examples/list_custom_fields.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+puts "Custom fields for companies:"
+custom_fields = client.companies.custom_fields.all.collect do |field|
+  [field.name, field.is_required, field.field_type]
+end
+print_table ["Name", "Required?", "Field type"], custom_fields
+
+puts
+
+puts "Custom fields for people:"
+custom_fields = client.people.custom_fields.all.collect do |field|
+  [field.name, field.is_required, field.field_type]
+end
+print_table ["Name", "Required?", "Field type"], custom_fields
+

data/examples/people_create_and_destroy.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+person = client.people.create(first_name: "Maarten", last_name: "Hoogendoorn")
+person.destroy

data/examples/people_list_all.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require_relative "config"
+
+client = PipelineDealers::Client.new(api_key: YOUR_API_KEY)
+
+client.people.each do |person|
+  p person
+  puts
+end

data/lib/pipeline_dealers/backend/base/backend.rb

@@ -0,0 +1,13 @@
+module PipelineDealers
+  module Backend
+    class Base
+      def cache(key, &block)
+        if not @cache.has_key?(key)
+          @cache[key] = block.call
+        end
+
+        @cache[key]
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/base/collection.rb

@@ -0,0 +1,111 @@
+module PipelineDealers
+  module Backend
+    class Base
+      class Collection
+        extend Delegator
+
+        Identity = lambda { |x| x }
+
+        delegate :connection,     to: :backend
+        delegate :collection_url, to: :model_klass
+
+        attr_reader :model_klass, :backend, :client
+
+        def initialize(backend, options)
+          @options     = options
+          @backend     = backend
+          @client      = options[:client]      || raise("No client given")
+          @model_klass = options[:model_klass] || raise("No :model_klass given")
+        end
+
+        def custom_fields
+          if @options[:custom_fields]
+            @custom_fields ||= @backend.collection(@options[:custom_fields].merge(client: @client))
+          else
+            raise "Collection of #{@model_klass} doesn not have any custom fields"
+          end
+        end
+
+        def all
+          if use_cache?
+            @backend.cache(@options[:cache_key]) { self.to_a }
+          else
+            self
+          end
+        end
+
+        def select &block
+          results = []
+
+          self.each do |result|
+            results << result if block.call(result)
+          end
+
+          results
+        end
+
+        def collect &operation
+          results = []
+
+          self.each do
+          end
+
+          results
+        end
+
+        def where(condition)
+          refine(where: condition)
+        end
+
+        def limit(to)
+          refine(limit: to)
+        end
+
+        def first
+          limit(1).collect { |x| return x }
+        end
+
+        def to_a
+          collect &Identity
+        end
+
+        def count
+          @backend.count(self)
+        end
+
+        def new(attributes = {})
+          if @options[:new_defaults]
+            attributes = @options[:new_defaults].merge(attributes)
+          end
+
+          model_klass.new(collection: self, record_new: true, attributes: attributes)
+        end
+
+        def create(attributes = {})
+          save(new(attributes))
+        end
+
+        def save(model)
+          @backend.save(self, model)
+          model
+        end
+
+        def destroy(model)
+          @backend.destroy(self, model)
+          model
+        end
+
+        protected
+        
+        # Refine the criterea
+        def refine(refinements)
+          self.class.new(@backend, @options.merge(refinements))
+        end
+
+        def use_cache?
+          @options[:cached] == true
+        end
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/base.rb

@@ -0,0 +1,2 @@
+require "pipeline_dealers/backend/base/backend"
+require "pipeline_dealers/backend/base/collection"

data/lib/pipeline_dealers/backend/http/backend.rb

@@ -0,0 +1,64 @@
+module PipelineDealers
+  module Backend
+    class Http < Base
+      attr_reader :connection
+
+      def initialize(options)
+        @cache      = {}
+        @options    = options
+        @connection = Connection.new(@options)
+      end
+
+      def collection(options)
+        Collection.new(self, options)
+      end
+
+      def save(collection, model)
+        model_attr_name = model.class.attribute_name
+
+        if model_attr_name.nil?
+          raise "Model #{model.class} doesn't have a attribute_name field"
+        end
+
+        # Use :post for new records, :put for existing ones
+        method = model.new_record? ? :post : :put
+
+        status, response = @connection.send(method, model_url(collection, model), model_attr_name  => model.save_attrs)
+
+        case status
+          when 200 then 
+            model.send(:import_attributes!, response) # Update with server side copy
+            model.send(:instance_variable_set, :@persisted, true) # Mark as persisted
+          when 422 then handle_errors_during_save(response)
+          else;         raise "Unexepcted response status #{status.inspect}"
+        end
+
+        self
+      end
+
+      def destroy(collection, model)
+        state, response = @connection.delete(model_url(collection, model), {})
+        if (state == 200)
+          model.send(:instance_variable_set, :@persisted, false) # Mark as persisted
+          model
+        else
+          raise "Could not remove"
+        end
+      end
+
+      def model_url(collection, model)
+        if model.persisted?
+          collection.send(:collection_url) + "/" + model.id.to_s + ".json"
+        else
+          collection.send(:collection_url) + ".json"
+        end
+      end
+
+      protected
+
+      def handle_errors_during_save(response)
+        raise response.collect { |error| "field '#{error["field"]}' #{error["msg"]}" }.join(" and ").capitalize
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/http/collection.rb

@@ -0,0 +1,32 @@
+module PipelineDealers
+  module Backend
+    class Http
+      class Collection < Backend::Base::Collection
+        def find id
+          status, result = @backend.connection.get(collection_url + "/#{id}.json", {})
+          if status == 200
+            model_klass.new(collection: self, persisted: true, attributes: result)
+          else
+            raise Error::NotFound
+          end
+        end
+
+        def each &operation
+          Fetcher.new(@backend.connection, self, model_klass, @options).each do |result|
+            operation.call(result)
+          end
+        end
+
+        def collect &operation
+          results = []
+
+          Fetcher.new(@backend.connection, self, model_klass, @options).each do |result|
+            results << operation.call(result)
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/http/connection.rb

@@ -0,0 +1,69 @@
+require "faraday"
+
+module PipelineDealers
+  module Backend
+    class Http
+      class Connection
+        ENDPOINT = "https://api.pipelinedeals.com/api/v3/"
+
+        def initialize(options)
+          @key     = options.delete(:api_key)
+          @options = options
+          @http    = build_connection
+        end
+
+        def build_connection
+          Faraday.new(url: ENDPOINT) do |faraday|
+            faraday.request  :url_encoded
+            faraday.response :logger if @options[:http_debug]
+            faraday.adapter  Faraday.default_adapter
+          end
+        end
+
+        # HTTP methods
+        {get: :get_style, post: :post_style, put: :post_style, delete: :get_style}.each do |name, style|
+          class_eval <<-RUBY
+            def #{name} url, params = {}
+              request_#{style}(:#{name}, url, params)
+            end
+          RUBY
+        end
+
+        protected
+
+        # get / delete
+        def request_get_style method, request_url, params
+          request_params = params.merge(api_key: @key)
+          query = Faraday::Utils.build_nested_query(request_params)
+          server_response = @http.send(method, request_url + "?" + query)
+
+          # Bwelch. Only a delete doesn't return valid json :(
+          raw = (method == :delete)
+
+          build_response_from server_response, raw: raw
+        end
+
+        # post / put
+        def request_post_style method, request_url, params
+          request_url += "?api_key=#{@key}"
+          request_body = Faraday::Utils.build_nested_query(params)
+          build_response_from @http.send(method, request_url, request_body)
+        end
+
+        DEFAULT_REQUEST_OPTIONS = { raw: false }
+
+        def build_response_from response, options = DEFAULT_REQUEST_OPTIONS
+          if options[:raw]
+            return [response.status, JSON.parse('{ "msg": "' + response.body + '" }')]
+          else
+            return [response.status, JSON.parse(response.body)]
+          end
+        end
+
+        def debug?
+          ENV['DEBUG'] == "true"
+        end
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/http/fetcher.rb

@@ -0,0 +1,78 @@
+module PipelineDealers
+  module Backend
+    class Http
+      class Fetcher
+        attr_reader :options
+        
+        # This struct captures the state we need to implement an transparent API
+        Cursor = Struct.new(:params, :results_yielded, :done)
+
+        def initialize(connection, collection, model_klass, options)
+          @connection  = connection
+          @collection  = collection
+          @model_klass = model_klass
+          @options     = options
+        end
+
+        def each(&block)
+          cursor = Cursor.new(build_params, 0, false)
+          if @collection.collection_url.nil?
+            raise "Model #{@model_klass.to_s} doesn't have 'collection_url' value"
+          end
+
+          while not cursor.done
+            status, result = @connection.get(@collection.collection_url + ".json", cursor.params)
+
+            if status == 200
+              yield_results(cursor, result, &block)
+            else
+              raise "Unexpected status! #{status.inspect}. Expected 200"
+            end
+          end
+        end
+
+        def build_params
+          params = { page: 1, per_page: Limits::MAX_RESULTS_PER_PAGE }
+
+          # Improve efficiency by only fetching as much as we need.
+          if requesting_to_many_results?
+            params[:per_page] = @options[:limit]
+          end
+
+          # Additional condition for filtering
+          if @options.has_key?(:where)
+            params.merge!(@options[:where])
+          end
+
+          params
+        end
+
+        def requesting_to_many_results?
+          @options[:limit] && @options[:limit] < Limits::MAX_RESULTS_PER_PAGE
+        end
+
+        def yield_results cursor, result, &block
+          result["entries"].each do |entry|
+            block.call(@model_klass.new(client: @collection.client, collection: @collection, persisted: true, attributes: entry))
+            cursor.results_yielded += 1
+
+            # Have we reached the limit?
+            if options[:limit] && cursor.results_yielded >= options[:limit]
+              cursor.done = true
+              return
+            end
+          end
+
+          # Are we on the last page?
+          if result["pagination"]["page"] < result["pagination"]["pages"]
+            # No, go to next page
+            cursor.params[:page] += 1
+          else
+            # Yes, we're done
+            cursor.done = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/backend/http.rb

@@ -0,0 +1,5 @@
+require "pipeline_dealers/backend/base"
+require "pipeline_dealers/backend/http/backend"
+require "pipeline_dealers/backend/http/connection"
+require "pipeline_dealers/backend/http/collection"
+require "pipeline_dealers/backend/http/fetcher"