pipeline_dealers 0.0.1

data/lib/pipeline_dealers/model.rb

@@ -0,0 +1,158 @@
+require "json"
+require "active_support/hash_with_indifferent_access"
+
+module PipelineDealers
+  class Model
+    class << self
+      attr_accessor :collection_url
+      attr_accessor :attribute_name
+      attr_reader :attributes
+
+      def attrs *attrs
+        if attrs.last.kind_of?(Hash)
+          options = attrs.pop
+        else
+          options = {}
+        end
+
+        attrs.each do |attr|
+          attr attr, options
+        end
+      end
+
+      def attr name, options = {}
+        @attributes ||= {}
+        @attributes[name] = options
+
+        # Getter
+        define_method name do
+          @attributes[name.to_s]
+        end
+
+        # Setter, only if not read only
+        if options[:read_only] != true
+          define_method "#{name}=".to_sym do |value|
+            @attributes[name.to_s] = value
+          end
+        end
+      end
+
+      def inherited(klass)
+        (@attributes || []).each do |name, options|
+          klass.attr(name, options)
+        end
+      end
+    end
+
+    attr_accessor :attributes
+    attr_reader :id
+
+    def initialize(options = {})
+      @options    = options
+      @persisted  = options.delete(:persisted) == true
+      @client     = options.delete(:client)
+      @collection = options.delete(:collection)
+
+      import_attributes! options.delete(:attributes)
+    end
+
+    def ==(other)
+      if other.kind_of?(self.class)
+        other.id == self.id && other.attributes == self.attributes
+      else
+        super(other)
+      end
+    end
+
+    def persisted?
+      @persisted == true
+    end
+
+    def new_record?
+      @persisted == false
+    end
+
+    def save
+      @collection.save(self)
+      self
+    end
+
+    def destroy
+      @collection.destroy(self)
+      self
+    end
+
+    IGNORE_ATTRIBUTES_WHEN_SAVING = [:updated_at, :created_at]
+    def save_attrs
+      # Ignore some attributes
+      save_attrs = @attributes.reject { |k, v| IGNORE_ATTRIBUTES_WHEN_SAVING.member?(k) }
+
+      # And allow a model class to modify / edit attributes even further
+      if respond_to?(:attributes_for_saving)
+        save_attrs = attributes_for_saving(save_attrs)
+      else
+        save_attrs
+      end
+    end
+
+    def to_s
+      "<#{self.class}:#{self.object_id} @attibutes=#{@attributes.inspect}>"
+    end
+
+    protected
+
+    def import_attributes! attributes
+      @attributes    = stringify_keys(attributes || {})
+      @id            = @attributes.delete(:id)
+
+      # Give subclasses the opportunity to hook in here.
+      process_attributes if respond_to?(:process_attributes)
+
+      check_for_non_existent_attributes!
+    end
+
+    def check_for_non_existent_attributes!
+      attribute_keys = @attributes.keys.collect(&:to_sym)
+
+      invalid_attributes = attribute_keys - valid_attribute_names
+
+      if invalid_attributes.any?
+        raise Error::InvalidAttributeName.new(self.class, invalid_attributes.first)
+      end
+    end
+
+    # Recursively converts a hash structure with symbol keys to a hash
+    # with indifferent keys
+    def stringify_keys original
+      result = HashWithIndifferentAccess.new
+
+      original.each do |key, value|
+        result[key] = stringify_value(value)
+      end
+
+      result
+    end
+
+    def valid_attribute_names
+      attrs = self.class.instance_variable_get(:@attributes)
+      if attrs.nil?
+        []
+      else
+        attrs.keys
+      end
+    end
+
+    def stringify_value value
+      case value
+      when String, Fixnum, NilClass, FalseClass, TrueClass
+        return value
+      when Hash, HashWithIndifferentAccess
+        return stringify_keys(value)
+      when Array
+        return value.collect { |item| stringify_value(item) }
+      else
+        raise "Unkown type: #{value.class}"
+      end
+    end
+  end
+end

data/lib/pipeline_dealers/test.rb

@@ -0,0 +1,10 @@
+require "pipeline_dealers"
+require "pipeline_dealers/backend/test"
+
+module PipelineDealers
+  class TestClient < Client
+    def initialize(options = {})
+      super(options.merge(backend: Backend::Test))
+    end
+  end
+end

data/lib/pipeline_dealers/version.rb

@@ -0,0 +1,3 @@
+module PipelineDealers
+  VERSION = "0.0.1"
+end

data/lib/pipeline_dealers.rb

@@ -0,0 +1,24 @@
+require "pipeline_dealers/version"
+
+module PipelineDealers
+  require "pipeline_dealers/delegator"
+
+  require "pipeline_dealers/limits"
+  require "pipeline_dealers/error"
+  require "pipeline_dealers/client"
+
+  # Base model
+  require "pipeline_dealers/model"
+  require "pipeline_dealers/model/custom_field"
+  require "pipeline_dealers/model/has_custom_fields"
+
+  # Models
+  require "pipeline_dealers/model/company"
+  require "pipeline_dealers/model/company/custom_field"
+  require "pipeline_dealers/model/person"
+  require "pipeline_dealers/model/person/custom_field"
+  require "pipeline_dealers/model/note"
+
+  require "pipeline_dealers/backend/base"
+  require "pipeline_dealers/backend/http"
+end

data/pipeline_dealers.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pipeline_dealers/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pipeline_dealers"
+  gem.version       = PipelineDealers::VERSION
+  gem.authors       = ["Maarten Hoogendoorn"]
+  gem.email         = ["maarten@springest.com"]
+  gem.description   = %q{API client for PipelineDeals}
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/Springest/pipeline_dealers"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "faraday", "~> 0.8.0"
+  gem.add_dependency "faraday_middleware", "~> 0.9.0"
+  gem.add_dependency "multi_json", "~> 1.0"
+
+  gem.add_development_dependency "rspec", ">2"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "reek"
+  gem.add_development_dependency "activesupport", "> 3.0.0"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "debugger"
+  gem.add_development_dependency "rake"
+
+
+  if RUBY_PLATFORM.include? "linux"
+    gem.add_development_dependency "rb-inotify", "~> 0.8.8"
+  elsif RUBY_PLATFORM.include? "darwin"
+    gem.add_development_dependency "growl"
+    gem.add_development_dependency "rb-fsevent"
+  end
+end

data/spec/acceptance/companies/creation_spec.rb

@@ -0,0 +1,30 @@
+__END__
+describe "Company", :acceptance do
+  describe "creation" do
+    include AcceptanceHelper
+
+    context "using client.companies.new" do
+      let(:company) { client.companies.new(name: "Meh") }
+
+      context "with a valid model" do
+        before { company.name = "Meh" }
+
+        context "when saved" do
+          it "returns a model" do
+            company.save.should be_kind_of PLD::Model::Base
+          end
+        end
+      end
+
+      context "with an invalid model" do
+        before { company.name = nil }
+
+        context "when saved" do
+          it "raises an error" do
+            expect { company.save}.to raise_error PipeLineDealer::Error::Connection::Unprocessable
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/companies/custom_fields_spec.rb

@@ -0,0 +1,8 @@
+__END__
+require "helper"
+
+describe "Company", :acceptance do
+  describe "custom fields" do
+    pending "Can't test this (yet), since it's not accessible via the API."
+  end
+end

data/spec/acceptance/companies/updating_spec.rb

@@ -0,0 +1,36 @@
+__END__
+require "helper"
+
+describe "Company", :acceptance do
+  describe "updating" do
+    include AcceptanceHelper
+    let(:company) { client.companies.create(name: "Old") }
+
+    context "using client.companies.new" do
+      context "with a valid model" do
+        before { company.name = "new" }
+
+        context "when saved" do
+          it "returns a model" do
+            company.save.should be_kind_of PLD::Model::Base
+          end
+
+          it "has the new name" do
+            company.save
+            client.companies.find(company.id).name.should == "new"
+          end
+        end
+      end
+
+      context "with an invalid model" do
+        before { company.name = nil }
+
+        context "when saved" do
+          it "raises an error" do
+            expect { company.save }.to raise_error PipeLineDealer::Error::Connection::Unprocessable
+          end
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/people/creation_spec.rb

@@ -0,0 +1,20 @@
+__END__
+require "helper"
+
+describe "Person", :acceptance do
+  describe "creation" do
+    include AcceptanceHelper
+
+    context "using client.people.new" do
+      let(:person) { client.people.new(first_name: "Maarten", last_name: "Hoogendoorn") }
+
+      before { person.first_name = "MoreTea" }
+
+      context "when saved" do
+        it "returns a model" do
+          person.save.should be_kind_of PLD::Model::Base
+        end
+      end
+    end
+  end
+end

data/spec/pipeline_dealers/backend/http/backend_spec.rb

@@ -0,0 +1,48 @@
+require "pipeline_dealers"
+require "support/test_model"
+
+module PipelineDealers::Backend
+  describe Http do
+    let(:backend) { described_class.new(api_key: "zekret")  }
+    let(:collection) { Http::Collection.new(backend, client: double("Client"), model_klass: TestModel) }
+    let(:connection) { subject.connection }
+
+    subject { backend }
+
+    describe "saving a model" do
+     context "that is new" do
+       let(:model) { collection.new(name: "Springest") }
+       after(:each) { model.save }
+
+       it "uses the POST method" do
+         connection.should_receive(:post).and_return([200, {}])
+       end
+
+       it "posts to the correct address" do
+         connection.should_receive(:post).with("test_models.json", anything).and_return([200, {}])
+       end
+
+       it "posts the correct attributes" do
+         connection.should_receive(:post).with(anything, "moeha" => { "name" => "Springest" }).and_return([200, {}])
+       end
+     end
+
+     context "that has been persisted" do
+       let(:model) { TestModel.new(collection: collection, persisted: true, attributes: { "id" => 123, name: "Springest"}) }
+       after(:each) { model.save }
+
+       it "uses the PUT method" do
+         connection.should_receive(:put).and_return([200, {}])
+       end
+
+       it "posts to the correct address" do
+         connection.should_receive(:put).with("test_models/123.json", anything).and_return([200, {}])
+       end
+
+       it "posts the correct attributes" do
+         connection.should_receive(:put).with(anything, "moeha" => { "name" => "Springest" }).and_return([200, {}])
+       end
+     end
+   end
+ end
+end

data/spec/pipeline_dealers/backend/http/collection_spec.rb

@@ -0,0 +1,158 @@
+require "pipeline_dealers"
+require "support/test_model"
+
+describe PipelineDealers::Backend::Http::Collection do
+  let(:connection) { double("Connection") }
+  let(:backend)    { double("Backend").tap { |b| b.stub(:connection).and_return(connection) } }
+  let(:collection) { described_class.new(backend, client: double("Client"), model_klass: TestModel) }
+
+  subject { collection }
+
+  context "transparant pagination" do
+    let(:expected_params_a) { ["test_models.json", { page: 1, per_page: 200 } ] }
+    let(:expected_params_b) { ["test_models.json", { page: 2, per_page: 200 } ] }
+
+    let(:response_a) do
+      [
+        200, # Status code
+        {    # 'JSON' body
+          "pagination" => {
+            "page"      => 1,
+            "pages"     => 2,
+            "per_page"  => 1,
+            "total"     => 2,
+            "url"       => '/resource',
+          },
+          "entries" => [model_a.attributes]
+        }
+      ]
+    end
+
+    let(:response_b) do
+      [
+        200, # Status code
+        {    # 'JSON' body
+          "pagination" => {
+            "page"      => 2,
+            "pages"     => 2,
+            "per_page"  => 1,
+            "total"     => 2,
+            "url"       => '/resource',
+          },
+          "entries" => [model_b.attributes]
+        }
+      ]
+    end
+
+    let(:model_a) { TestModel.new(collection: subject, attributes: { name: "Maarten" }) }
+    let(:model_b) { TestModel.new(collection: subject, attributes: { name: "Hoogendoorn" }) }
+
+    it "fetches the correct models" do
+      connection.should_receive(:get).ordered.once.with(*expected_params_a).and_return(response_a)
+      connection.should_receive(:get).ordered.once.with(*expected_params_b).and_return(response_b)
+
+      subject.all.to_a.should =~ [model_a, model_b]
+    end
+
+    it "returns records that are not new" do
+      connection.should_receive(:get).ordered.once.with(*expected_params_a).and_return(response_a)
+      connection.should_receive(:get).ordered.once.with(*expected_params_b).and_return(response_b)
+
+      a, b = subject.all.to_a
+
+      a.new_record?.should == false
+      b.new_record?.should == false
+    end
+  end
+
+  context "limit fetching" do
+    let(:expected_params) { ["test_models.json", { page:1, per_page: 1} ] }
+
+    let(:response) do
+      [
+        200, # Status code
+        {    # 'JSON' body
+          "pagination" => {
+             "page"      => 1,
+             "pages"     => 2,
+             "per_page"  => 1,
+             "total"     => 2,
+             "url"       => '/resource',
+           },
+          "entries" => [model_a.attributes]
+        }
+      ]
+    end
+
+    let(:model_a) { TestModel.new(collection: subject, attributes: { name: "Maarten"}) }
+
+    it "fetches only the resouces before the limit" do
+      connection.should_receive(:get).once.with(*expected_params).and_return(response)
+      subject.first.should == model_a
+    end
+  end
+
+  describe "cacheing" do
+    let(:response) do
+      [
+        200, # Status code
+        {
+          "pagination" => {
+             "page"      => 1,
+             "pages"     => 1,
+             "per_page"  => 1,
+             "total"     => 1,
+             "url"       => '/resource',
+           },
+          "entries" => [{}]
+        }
+      ]
+    end
+
+    before do
+      connection.stub(:get).and_return(response)
+    end
+
+    context "not cached" do
+      subject { described_class.new(backend, client: double("Client"), model_klass: TestModel, cached: false) }
+
+      it "doesn't try to cache the result" do
+        connection.should_not_receive(:cache)
+        subject.all.to_a
+      end
+    end
+
+    context "cached" do
+      subject { described_class.new(backend, client: double("Client"), model_klass: TestModel, cached: true) }
+
+      it "caches the request" do
+        backend.should_receive(:cache)
+        subject.all
+      end
+    end
+  end
+
+  describe "building new objects" do
+    context "with no initial attributes" do
+      subject { collection.new }
+      it { should be_kind_of TestModel }
+      its(:persisted?) { should == false}
+    end
+
+    context "with initial attributes" do
+      context "valid attributes" do
+        subject { collection.new(name: "Springest") }
+
+        its(:name) { should == "Springest" }
+      end
+
+      context "invalid attributes" do
+        context "invalid name" do
+          it "raises an exception" do
+            expect { subject.new(no_such_name: "Springest") }.to raise_error(PipelineDealers::Error::InvalidAttributeName)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/pipeline_dealers/model/custom_field_spec.rb

@@ -0,0 +1,129 @@
+require "pipeline_dealers"
+
+module PipelineDealers
+  class Model
+    describe CustomField do
+      let(:model) { nil }
+
+      describe "decode" do
+        context "numeric" do
+          before { subject.field_type = "numeric" }
+
+          it "decodes correctly" do
+            subject.decode(model, 123).should == 123
+          end
+        end
+
+        context "text" do
+          before { subject.field_type = "text" }
+
+          it "decodes correctly" do
+            subject.decode(model, "Moehaha").should == "Moehaha"
+          end
+        end
+
+        context "currency" do
+          before { subject.field_type = "currency" }
+
+          it "decodes correctly" do
+            subject.decode(model, 42).should == 42
+          end
+        end
+
+        context "dropdown" do
+          subject do
+            CustomField.new(attributes: {
+              "field_type" => "dropdown",
+              "custom_field_label_dropdown_entries" => [{"id" => 123, "value" => "My Item"}]
+            })
+          end
+
+          it "decodes correctly" do
+            subject.decode(model, 123).should == "My Item"
+          end
+        end
+
+        context "multi_select" do
+          subject do
+            CustomField.new(attributes: {
+              "field_type" => "multi_select",
+              "custom_field_label_dropdown_entries" => [{"id" => 123, "value" => "My Item"}]
+            })
+          end
+
+          it "decodes correctly" do
+            subject.decode(model, [123]).should == ["My Item"]
+          end
+        end
+
+        context "Unkown type" do
+          before { subject.field_type = "not-known" }
+
+          it "throws an exception" do
+            expect { subject.decode(model, 42) }.to raise_error
+          end
+        end
+      end
+
+      describe "encode" do
+        context "numeric" do
+          before { subject.field_type = "numeric" }
+
+          it "encodes correctly" do
+            subject.encode(model, 123).should == 123
+          end
+        end
+
+        context "text" do
+          before { subject.field_type = "text" }
+
+          it "encodes correctly" do
+            subject.encode(model, "Moehaha").should == "Moehaha"
+          end
+        end
+
+        context "currency" do
+          before { subject.field_type = "currency" }
+
+          it "encodes correctly" do
+            subject.encode(model, 42).should == 42
+          end
+        end
+
+        context "dropdown" do
+          subject do
+            CustomField.new(attributes: {
+              "field_type" => "dropdown",
+              "custom_field_label_dropdown_entries" => [{"id" => 123, "value" => "My Item"}]
+            })
+          end
+
+          it "encodes correctly" do
+            subject.encode(model, "My Item").should == 123
+          end
+        end
+
+        context "multi_select" do
+          subject do
+            CustomField.new(attributes: {
+              "field_type" => "multi_select",
+              "custom_field_label_dropdown_entries" => [{"id" => 123, "value" => "My Item"}]
+            })
+          end
+
+          it "encodes correctly" do
+            subject.encode(model, ["My Item"]).should == [123]
+          end
+        end
+
+        context "Unkown type" do
+          before { subject.field_type = "not-known" }
+
+          it "throws an exception" do
+            expect { subject.encode(model, 42) }.to raise_error
+          end
+        end
+      end
+    end
+  end
+end