ruby_json_api_client 0.0.1

data/lib/ruby_json_api_client/store.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+module RubyJsonApiClient
+  class Store
+    def self.register_adapter(name, klass = nil, options = {})
+      @adapters ||= {}
+
+      # allow for 2 arguments (automatically figure out class if so)
+      if !klass.is_a?(Class)
+        # klass is options. autoamtically figure out klass and set options
+        temp = klass || options
+        class_name = name.to_s.camelize
+        klass = Kernel.const_get("RubyJsonApiClient::#{class_name}Adapter")
+        options = temp
+      end
+
+      @adapters[name] = OpenStruct.new({ klass: klass, options: options })
+    end
+
+
+    def self.register_serializer(name, klass = nil)
+      @serializers ||= {}
+
+      if klass.nil?
+        class_name = name.to_s.camelize
+        klass = Kernel.const_get("RubyJsonApiClient::#{class_name}Serializer")
+      end
+
+      @serializers[name] = OpenStruct.new({ klass: klass })
+    end
+
+    def self.get_serializer(name)
+      @serializers ||= {}
+      if @serializers[name]
+        @serializers[name].klass.new
+      end
+    end
+
+    def self.get_adapter(name)
+      @adapters ||= {}
+      if @adapters[name]
+        @adapters[name].klass.new(@adapters[name].options)
+      end
+    end
+
+    def self.default(format)
+      @store = new(format: format)
+    end
+
+    def self.instance
+      @store
+    end
+
+    attr_accessor :default_adapter
+    attr_accessor :default_serializer
+
+    def initialize(options)
+      if options[:format]
+        options[:adapter] = options[:format]
+        options[:serializer] = options[:format]
+      end
+
+      @default_adapter = self.class.get_adapter(options[:adapter])
+      @default_serializer = self.class.get_serializer(options[:serializer])
+
+      if @default_serializer && @default_serializer.respond_to?(:store=)
+        @default_serializer.store = self
+      end
+    end
+
+    def adapter_for_class(klass)
+      @default_adapter
+    end
+
+    def serializer_for_class(klass)
+      @default_serializer
+    end
+
+    def find(klass, id)
+      adapter = adapter_for_class(klass)
+      serializer = serializer_for_class(klass)
+
+      response = adapter.find(klass, id)
+      serializer.extract_single(klass, id, response).tap do |model|
+        model.__origin__ = response
+      end
+    end
+
+    def query(klass, params)
+      adapter = adapter_for_class(klass)
+      serializer = serializer_for_class(klass)
+
+      response = adapter.find_many(klass, params)
+      list = serializer.extract_many(klass, response)
+
+      list.each do |model|
+        # let the model know where it came from
+        model.__origin__ = response
+      end
+
+      # cant tap proxy
+      collection = RubyJsonApiClient::Collection.new(list)
+      collection.__origin__ = response
+      collection
+    end
+
+    def find_many_relationship(parent, name, options)
+      # needs to use adapter_for_class
+      serializer = @default_serializer
+
+      # ensure parent is loaded
+      reload(parent) if parent.__origin__.nil?
+
+      response = parent.__origin__
+
+      # find the relationship
+      list = serializer.extract_many_relationship(parent, name, options, response)
+
+      # wrap in enumerable proxy to allow reloading
+      collection = RubyJsonApiClient::Collection.new(list)
+      collection.__origin__ = response
+      collection
+    end
+
+    def find_single_relationship(parent, name, options)
+      # needs to use serializer_for_class
+      serializer = @default_serializer
+
+      reload(parent) if parent.__origin__.nil?
+
+      response = parent.__origin__
+
+      serializer.extract_single_relationship(parent, name, options, response)
+    end
+
+    def load_collection(klass, url)
+      adapter = adapter_for_class(klass)
+      serializer = serializer_for_class(klass)
+      response = adapter.get(url)
+      serializer.extract_many(klass, response)
+    end
+
+    def load_single(klass, id, url)
+      adapter = adapter_for_class(klass)
+      serializer = serializer_for_class(klass)
+      response = adapter.get(url)
+      serializer.extract_single(klass, id, response)
+    end
+
+    def load(klass, data)
+
+    end
+
+    def reload(model)
+      new_model = find(model.class, model.id)
+      merge(model, new_model)
+    end
+
+    def merge(into, from)
+      into.__origin__ = from.__origin__
+      into.meta = from.meta
+
+      from.class.fields.reduce(into) do |model, attr|
+        call = "#{attr}="
+        model.send(call, from.send(attr)) if model.respond_to?(call)
+        model
+      end
+    end
+
+  end
+end

data/lib/ruby_json_api_client/version.rb

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

data/lib/ruby_json_api_client.rb

@@ -0,0 +1,14 @@
+require 'active_model'
+
+module RubyJsonApiClient
+end
+
+require "ruby_json_api_client/version"
+require 'ruby_json_api_client/serializers/json_api_serializer'
+require 'ruby_json_api_client/serializers/ams_serializer'
+require 'ruby_json_api_client/adapters/rest_adapter'
+require 'ruby_json_api_client/adapters/json_api_adapter'
+require 'ruby_json_api_client/adapters/ams_adapter'
+require 'ruby_json_api_client/collection'
+require 'ruby_json_api_client/store'
+require 'ruby_json_api_client/base'

data/ruby_json_api_client.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_json_api_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_json_api_client"
+  spec.version       = RubyJsonApiClient::VERSION
+  spec.authors       = ["Ryan Toronto"]
+  spec.email         = ["ryanto@gmail.com"]
+  spec.summary       = %q{API client for activemodel instances}
+  spec.description   = %q{API client for activemodel instances}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'json', '>= 1.8.1'
+  spec.add_dependency 'faraday', '>= 0.9.0'
+  spec.add_dependency 'addressable', '>= 2.3.6'
+  spec.add_dependency 'activemodel', '>= 4.0'
+  spec.add_dependency 'activesupport', '>= 4.0'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency 'rspec-collection_matchers', '~> 1.0.0'
+  spec.add_development_dependency 'rspec-its', '~> 1.0.1'
+  spec.add_development_dependency 'webmock', '~> 1.18.0'
+end

data/spec/integration/ams/find_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe "AMS find single" do
+  context "person" do
+
+    before(:each) do
+      RubyJsonApiClient::Store.register_adapter(:ams, {
+        hostname: 'www.example.com',
+        namespace: 'testing',
+        secure: true
+      });
+
+      RubyJsonApiClient::Store.register_serializer(:ams)
+
+      RubyJsonApiClient::Store.default(:ams)
+    end
+
+    context "it exists" do
+      before(:each) do
+        response = {
+          person: {
+            id: 123,
+            firstname: 'ryan',
+            lastname: 'test'
+          }
+        }
+
+        json = response.to_json
+
+        stub_request(:get, "https://www.example.com/testing/people/123")
+          .to_return(
+            status: 200,
+            headers: { 'Content-Length' => json.size },
+            body: json,
+          )
+      end
+
+      context "loads the right model" do
+        subject { Person.find(123) }
+        its(:id) { should eq(123) }
+        its(:firstname) { should eq("ryan") }
+        its(:full_name) { should eq("ryan test") }
+      end
+    end
+  end
+end

data/spec/integration/ams/has_many_links_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe "AMS load has_many linked records" do
+
+  before(:each) do
+    RubyJsonApiClient::Store.register_adapter(:ams, {
+      hostname: 'www.example.com'
+    });
+
+    RubyJsonApiClient::Store.register_serializer(:ams)
+
+    RubyJsonApiClient::Store.default(:ams)
+  end
+
+  context "that are loaded" do
+    before(:each) do
+      people_response = {
+        people: [{
+          id: 123,
+          firstname: 'ryan',
+          lastname: 'test',
+          links: {
+            items: "http://www.example.com/items?person=123"
+          }
+        },{
+          id: 456,
+          firstname: 'testing',
+          lastname: 'again',
+          links: {
+            items: "/items?person=456"
+          }
+        }]
+      }.to_json
+
+      items_response = {
+        items: [{
+          id: 10,
+          name: "testing"
+        },{
+          id: 11,
+          name: "another test"
+        }]
+      }.to_json
+
+      no_items_response = {
+        items: []
+      }.to_json
+
+      stub_request(:get, "http://www.example.com/people")
+        .to_return(
+          status: 200,
+          body: people_response,
+        )
+
+      stub_request(:get, "http://www.example.com/items?person=123")
+        .to_return(
+          status: 200,
+          body: items_response
+        )
+
+      stub_request(:get, "http://www.example.com/items?person=456")
+        .to_return(
+          status: 200,
+          body: no_items_response
+        )
+    end
+
+    let(:collection) { Person.all }
+    let(:person1) { collection[0] }
+    let(:person2) { collection[1] }
+
+    context "using the first person" do
+      subject { person1 }
+      its(:id) { should eq(123) }
+      its(:items) { should have(2).items }
+
+      it "should have mappable items" do
+        expect(person1.items.map(&:name))
+          .to match_array(['testing', 'another test'])
+      end
+
+      context "and their first item" do
+        subject { person1.items[0] }
+        its(:id) { should eq(10) }
+        its(:name) { should eq("testing") }
+      end
+
+      context "and their second item" do
+        subject { person1.items[1] }
+        its(:id) { should eq(11) }
+        its(:name) { should eq("another test") }
+      end
+    end
+  end
+
+  context "that are not loaded" do
+    # this tests Person.new(id: 123).items will load the person
+    # then load the items
+
+    before(:each) do
+      person_response = {
+        person: {
+          id: 123,
+          firstname: "ryan",
+          links: {
+            # use a strange url
+            items: "/testing/items?p_id=123"
+          }
+        }
+      }.to_json
+
+      items_response = {
+        items: [{
+          id: 1,
+          name: "first"
+        }, {
+          id: 2,
+          name: "second"
+        }]
+      }.to_json
+
+      stub_request(:get, "http://www.example.com/people/123")
+        .to_return(
+          status: 200,
+          body: person_response,
+        )
+
+      stub_request(:get, "http://www.example.com/testing/items?p_id=123")
+        .to_return(
+          status: 200,
+          body: items_response,
+        )
+    end
+
+    let(:person) { Person.new(id: 123) }
+    let(:items) { person.items }
+
+    context "the person" do
+      subject { person }
+
+      before(:each) do
+        # load items (which should load person)
+        person.items
+      end
+
+      its(:id) { should eq(123) }
+      its(:firstname) { should eq('ryan') }
+    end
+
+    context "the items" do
+      subject { items }
+      it { should have(2).items }
+
+      context "the first item" do
+        subject { items[0] }
+        its(:name) { should eq('first') }
+        its(:id) { should eq(1) }
+      end
+    end
+  end
+end

data/spec/integration/ams/has_many_sideload_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe "AMS load has_many sideloaded records" do
+
+  before(:each) do
+    RubyJsonApiClient::Store.register_adapter(:ams, {
+      hostname: 'www.example.com'
+    });
+
+    RubyJsonApiClient::Store.register_serializer(:ams)
+
+    RubyJsonApiClient::Store.default(:ams)
+  end
+
+  context "that are loaded" do
+    before(:each) do
+      response = {
+        people: [{
+          id: 123,
+          firstname: 'ryan',
+          lastname: 'test',
+          item_ids: [1,2]
+        },{
+          id: 456,
+          firstname: 'testing',
+          lastname: 'again',
+          item_ids: [2,3]
+        }],
+        items: [{
+          id: 1,
+          name: 'test 1'
+        },{
+          id: 2,
+          name: 'test 2'
+        },{
+          id: 3,
+          name: 'test 3'
+        },{
+          id: 4,
+          name: 'test 4'
+        }]
+      }.to_json
+
+      stub_request(:get, "http://www.example.com/people")
+        .to_return(
+          status: 200,
+          body: response,
+        )
+    end
+
+    let(:collection) { Person.all }
+    let(:person1) { collection[0] }
+    let(:person2) { collection[1] }
+
+    context "using the first person" do
+      subject { person1 }
+      its(:id) { should eq(123) }
+      its(:items) { should have(2).items }
+
+      it "should have mappable items" do
+        expect(person1.items.map(&:name))
+          .to match_array(['test 1', 'test 2'])
+      end
+
+      context "and their first item" do
+        subject { person1.items[0] }
+        its(:id) { should eq(1) }
+        its(:name) { should eq("test 1") }
+      end
+
+      context "and their second item" do
+        subject { person1.items[1] }
+        its(:id) { should eq(2) }
+        its(:name) { should eq("test 2") }
+      end
+    end
+  end
+
+  context "that are not loaded" do
+    # this tests Person.new(id: 123).items will load the person
+    # then load the items
+
+    before(:each) do
+      response = {
+        person: {
+          id: 123,
+          firstname: "ryan",
+          item_ids: [1, 2]
+        },
+        items: [{
+          id: 1,
+          name: "first"
+        }, {
+          id: 2,
+          name: "second"
+        }]
+      }.to_json
+
+      stub_request(:get, "http://www.example.com/people/123")
+        .to_return(
+          status: 200,
+          body: response,
+        )
+    end
+
+    let(:person) { Person.new(id: 123) }
+    let(:items) { person.items }
+
+    context "the person" do
+      subject { person }
+
+      before(:each) do
+        # load items (which should load person)
+        person.items
+      end
+
+      its(:id) { should eq(123) }
+      its(:firstname) { should eq('ryan') }
+    end
+
+    context "the items" do
+      subject { items }
+      it { should have(2).items }
+
+      context "the first item" do
+        subject { items[0] }
+        its(:name) { should eq('first') }
+        its(:id) { should eq(1) }
+      end
+    end
+  end
+
+  context "using a different relationship class name" do
+    before(:each) do
+      response = {
+        person: {
+          id: 123,
+          firstname: "ryan",
+          other_item_ids: [1, 2]
+        },
+        other_items: [{
+          id: 1,
+          name: "first"
+        },{
+          id: 2,
+          name: "second"
+        }]
+      }.to_json
+
+      stub_request(:get, "http://www.example.com/people/123")
+        .to_return(
+          status: 200,
+          body: response,
+        )
+    end
+
+    let(:person) { Person.new(id: 123) }
+    let(:other_items) { person.other_items }
+
+    subject { other_items }
+    it { should have(2).items }
+
+    context "the first item" do
+      subject { other_items[0] }
+      its(:name) { should eq('first') }
+      its(:id) { should eq(1) }
+    end
+  end
+
+end

data/spec/integration/ams/has_one_links_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe "AMS load has_one linked record" do
+
+  before(:each) do
+    RubyJsonApiClient::Store.register_adapter(:ams, {
+      hostname: 'www.example.com'
+    });
+
+    RubyJsonApiClient::Store.register_serializer(:ams)
+
+    RubyJsonApiClient::Store.default(:ams)
+  end
+
+  before(:each) do
+    person_response = {
+      person: {
+        id: 123,
+        firstname: 'ryan',
+        lastname: 'test',
+        links: {
+          item: "http://www.example.com/items/10"
+        }
+      }
+    }.to_json
+
+    item_response = {
+      item: {
+        id: 10,
+        name: "testing"
+      }
+    }.to_json
+
+    stub_request(:get, "http://www.example.com/people/123")
+      .to_return(
+        status: 200,
+        body: person_response,
+      )
+
+      stub_request(:get, "http://www.example.com/items/10")
+        .to_return(
+          status: 200,
+          body: item_response
+        )
+  end
+
+
+  let(:person) { Person.find(123) }
+  let(:item) { person.item }
+
+  context "the item" do
+    subject { item }
+    it { should be_instance_of(Item) }
+    its(:id) { should eq(10) }
+    its(:name) { should eq('testing') }
+  end
+end