ruby_json_api_client 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cf21703bffbc99abd22c2bef3825db7ff9f67f4c
+  data.tar.gz: 49b8168022402b4fb3181b47826b8155f92e509d
+SHA512:
+  metadata.gz: 5e9219c09fe7bb70c03cd6d8587bf1000e2fe5da981e7eae5142dabded8823daf34810a686f2a8c1acac3b0c21b3ab61806e8e18f461eca998eca33d5455d991
+  data.tar.gz: fcf2012a06ac3b1766d99ec2d56cf6717a740ac1ce41de60d31953b3dc7e708c89f320cb528a1b623811b4c40b70197fec152d689a93256395a6010aa3c354df

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ryan Toronto
+
+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,25 @@
+# RubyJsonApiClient
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby_json_api_client'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+TODO: Write usage instructions here
+
+## TODO
+
+* Per model serializers and adapters (Store#adapter_for_class)
+* Store#find_many_relationship should return reloadable proxy
+
+#### AMS
+
+* serializer json to model rename data to model

data/Rakefile

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

data/lib/ruby_json_api_client/adapters/ams_adapter.rb

@@ -0,0 +1,15 @@
+module RubyJsonApiClient
+  class AmsAdapter < RubyJsonApiClient::RestAdapter
+    def create(model)
+
+    end
+
+    def update(model)
+
+    end
+
+    def destroy(model)
+
+    end
+  end
+end

data/lib/ruby_json_api_client/adapters/json_api_adapter.rb

@@ -0,0 +1,15 @@
+module RubyJsonApiClient
+  class JsonApiAdapter < RubyJsonApiClient::RestAdapter
+    def create(model)
+
+    end
+
+    def update(model)
+
+    end
+
+    def destroy(model)
+
+    end
+  end
+end

data/lib/ruby_json_api_client/adapters/rest_adapter.rb

@@ -0,0 +1,80 @@
+require 'faraday'
+require "addressable/uri"
+require 'active_support'
+
+module RubyJsonApiClient
+  class RestAdapter
+    attr_accessor :secure
+    attr_accessor :hostname
+    attr_accessor :namespace
+    attr_accessor :port
+    attr_accessor :url_root
+
+    def initialize(options = {})
+      options.each do |(field, value)|
+        send("#{field}=", value)
+      end
+    end
+
+    def single_path(klass, params = {})
+      name = klass.name
+      plural = ActiveSupport::Inflector.pluralize(name)
+      path = plural.underscore
+      id = params[:id]
+      "#{@namespace}/#{path}/#{id}"
+    end
+
+    def collection_path(klass, params)
+      name = klass.name
+      plural = ActiveSupport::Inflector.pluralize(name)
+      "#{@namespace}/#{plural.underscore}"
+    end
+
+    def find(klass, id)
+      path = single_path(klass, id: id)
+      status, _, body = http_request(:get, path, {})
+
+      if status >= 200 && status <= 299
+        body
+      else
+        raise "Could not find #{klass.name} with id #{id}"
+      end
+    end
+
+    def find_many(klass, params)
+      path = collection_path(klass, params)
+      status, _, body = http_request(:get, path, params)
+
+      if status >= 200 && status <= 299
+        body
+      else
+        raise "Could not query #{klass.name}"
+      end
+    end
+
+    def get(url)
+      status, _, body = http_request(:get, url, {})
+
+      if status >= 200 && status <= 299
+        body
+      else
+        raise "Could not query #{path}"
+      end
+    end
+
+    protected
+
+    def http_request(method, url, params)
+      uri = Addressable::URI.parse(url)
+
+      proto = uri.scheme || (@secure ? "https" : "http")
+      hostname = uri.host || @hostname
+      path = uri.path
+      query_params = (uri.query_values || {}).merge(params)
+
+      conn = Faraday.new("#{proto}://#{hostname}")
+      response = conn.send(method, path, query_params)
+      [response.status, response.headers, response.body]
+    end
+  end
+end

data/lib/ruby_json_api_client/base.rb

@@ -0,0 +1,98 @@
+module RubyJsonApiClient
+  class Base
+    include ActiveModel::Model
+    include ActiveModel::AttributeMethods
+
+    def self.field(name, type = :string)
+      @_fields ||= []
+      @_fields << name
+      attr_accessor name
+    end
+
+    def self.fields
+      @_fields || []
+    end
+
+    def self.has_field?(name)
+      (@_fields | [_identifier]).include?(name)
+    end
+
+    def self.identifier(name)
+      @_identifier = name
+      field(name, :number)
+    end
+
+    def self._identifier
+      @_identifier || superclass._identifier
+    end
+
+    identifier :id
+    attr_accessor :meta
+    attr_accessor :__origin__
+
+    def self.has_many(name, options = {})
+      @_has_many_relationships ||= []
+      @_has_many_relationships << name
+      define_method(name) do
+        # make cachable
+        RubyJsonApiClient::Store
+          .instance
+          .find_many_relationship(self, name, options)
+      end
+    end
+
+    def self.has_many_relationships
+      @_has_many_relationships
+    end
+
+    def self.has_one(name, options = {})
+      define_method(name) do
+        @_loaded_has_ones ||= {}
+
+        if @_loaded_has_ones[name].nil?
+          result = RubyJsonApiClient::Store
+            .instance
+            .find_single_relationship(self, name, options)
+
+          @_loaded_has_ones[name] = result
+        end
+
+        @_loaded_has_ones[name]
+      end
+
+      define_method("#{name}=".to_sym) do |related|
+        @_loaded_has_ones ||= {}
+        @_loaded_has_ones[name] = related
+      end
+    end
+
+    def loaded_has_ones
+      @_loaded_has_ones || {}
+    end
+
+    def self.find(id)
+      RubyJsonApiClient::Store.instance.find(self, id)
+    end
+
+    def self.all
+      where({})
+    end
+
+    def self.where(params)
+      RubyJsonApiClient::Store.instance.query(self, params)
+    end
+
+    def persisted?
+      !!send(self.class._identifier)
+    end
+
+    def reload
+      RubyJsonApiClient::Store.instance.reload(self)
+    end
+
+    def links
+      store.find(self.class._identifier).__data__
+    end
+
+  end
+end

data/lib/ruby_json_api_client/collection.rb

@@ -0,0 +1,13 @@
+module RubyJsonApiClient
+  class Collection < BasicObject
+    attr_accessor :__origin__
+
+    def initialize(list)
+      @list = list
+    end
+
+    def method_missing(name, *args, &blk)
+      @list.send(name, *args, &blk)
+    end
+  end
+end

data/lib/ruby_json_api_client/serializers/ams_serializer.rb

@@ -0,0 +1,187 @@
+require 'json'
+require 'active_support'
+
+module RubyJsonApiClient
+  class AmsSerializer
+    attr_accessor :store
+
+    def transform(response)
+      JSON.parse(response)
+    end
+
+    def to_json(model)
+      key = model.class.to_s.underscore.downcase
+      data = {}
+      data[key] = {}
+
+      if model.persisted?
+        data[key][:id] = model.id
+      end
+
+      # conert fields to json
+      model.class.fields.reduce(data[key]) do |result, field|
+        result[field] = model.send(field)
+        result
+      end
+
+      # convert has one relationships to json
+      relationships = model.loaded_has_ones || {}
+      relationships.reduce(data[key]) do |result, (name, relationship)|
+        if relationship.id
+          result["#{name}_id"] = relationship.id
+        end
+        result
+      end
+
+      JSON::generate(data)
+    end
+
+    def assert(test, failure_message)
+      raise failure_message if !test
+    end
+
+    def _create_model(klass, data)
+      model = klass.new(meta: {})
+
+      model.meta[:data] = data
+
+      if data['links']
+        model.meta[:links] = data['links']
+      end
+
+      data.reduce(model) do |record, (field, value)|
+        if klass.has_field?(field.to_sym)
+          record.send("#{field}=", value)
+        end
+
+        record
+      end
+    end
+
+    def extract_single(klass, id, response)
+      name = klass.to_s.underscore
+      data = transform(response)
+
+      assert data[name],
+        "No key #{name} in json response."
+
+      assert data[name]['id'],
+        "No id included in #{name} json data"
+
+      if id
+        # we will allow idless loading, but if an id is given we
+        # will try to verify it.
+        assert data[name]['id'].to_s == id.to_s,
+          "Tried to find #{name} with id #{id}, but got #{name} with id #{data[name]['id']}."
+      end
+
+      _create_model(klass, data[name])
+    end
+
+    def extract_many(klass, response, key = nil)
+      key = klass.to_s.underscore if key.nil?
+      plural = ActiveSupport::Inflector.pluralize(key)
+
+      data = transform(response)
+
+      assert data[plural],
+        "No key #{plural} in json response."
+
+      assert data[plural].is_a?(Array),
+        "Key #{plural} should be an array"
+
+      data[plural].reduce([]) do |collection, json|
+        collection << _create_model(klass, json)
+      end
+    end
+
+    def extract_many_relationship(parent, name, options, response)
+      # given response this will find the relationship
+      # for ams based apis the relationship will either be
+      # 1) in links
+      # 2) in sideloaded data
+      data = transform(response)
+      singular = ActiveSupport::Inflector.singularize(name)
+      meta = parent.meta || {}
+      meta_links = meta[:links]
+      meta_data = meta[:data]
+
+      if meta_links && meta_links[name.to_s]
+        extract_many_relationship_from_links(parent, name, options, meta_links[name.to_s])
+
+      elsif data[name.to_s] && meta_data && meta_data["#{singular}_ids"]
+        extract_many_relationship_from_sideload(parent, name, options, response)
+
+      else
+        []
+
+      end
+    end
+
+    def extract_many_relationship_from_links(parent, name, options, url)
+      # since we only have a url pointing to where to pull
+      # this info from we need to go back to the store and
+      # have it pull this data
+      klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+      klass = ActiveSupport::Inflector.constantize(klass_name)
+
+      store.load_collection(klass, url)
+    end
+
+    def extract_many_relationship_from_sideload(parent, name, options, response)
+      singular = ActiveSupport::Inflector.singularize(name)
+      plural = ActiveSupport::Inflector.pluralize(name)
+      klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+      klass = ActiveSupport::Inflector.constantize(klass_name)
+      meta_data = parent.meta[:data]
+
+      ids = meta_data["#{singular}_ids"]
+      idMap = ids.reduce({}) do |map, id|
+        map[id] = true
+        map
+      end
+
+      extract_many(klass, response, plural)
+        .select { |record| idMap[record.id] }
+    end
+
+    def extract_single_relationship(parent, name, options, response)
+      plural = ActiveSupport::Inflector.pluralize(name)
+      data = transform(response)
+      meta = parent.meta || {}
+      meta_links = meta[:links]
+      meta_data = meta[:data]
+
+      if meta_links && meta_links[name.to_s]
+        extract_single_relationship_from_links(parent, name, options, meta_links[name.to_s])
+
+      elsif data[plural.to_s] && meta_data && meta_data["#{name}_id"]
+        extract_single_relationship_from_sideload(parent, name, options, response)
+
+      else
+        nil # nothing found, return nil object
+
+      end
+    end
+
+    def extract_single_relationship_from_links(parent, name, options, url)
+      klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+      klass = ActiveSupport::Inflector.constantize(klass_name)
+      meta = parent.meta || {}
+      meta_data = meta[:data] || {}
+
+      store.load_single(klass, meta_data["#{name}_id"], url)
+    end
+
+    def extract_single_relationship_from_sideload(parent, name, options, response)
+      plural = ActiveSupport::Inflector.pluralize(name)
+      klass_name = options[:class_name] || ActiveSupport::Inflector.classify(name)
+      klass = ActiveSupport::Inflector.constantize(klass_name)
+      meta_data = parent.meta[:data]
+      id = meta_data["#{name}_id"]
+
+      extract_many(klass, response, plural)
+        .detect { |record| record.id == id }
+    end
+  end
+end

data/lib/ruby_json_api_client/serializers/json_api_serializer.rb

@@ -0,0 +1,93 @@
+require 'json'
+require 'active_support'
+
+module RubyJsonApiClient
+  class JsonApiSerializer
+    attr_accessor :store
+
+    def transform(response)
+      JSON.parse(response)
+    end
+
+    def assert(test, failure_message)
+      raise failure_message if !test
+    end
+
+    def _json_to_model(klass, json)
+      json.reduce(klass.new) do |model, (field, value)|
+        if klass.has_field?(field.to_sym)
+          model.send("#{field}=", value)
+        end
+
+        model
+      end
+    end
+
+    def extract_single(klass, id, response)
+      name = klass.to_s.underscore
+      plural = ActiveSupport::Inflector.pluralize(name)
+      data = transform(response)
+
+      assert data[plural],
+        "No key #{plural} in json response."
+
+      assert data[plural].is_a?(Array),
+        "Key #{plural} should be an array"
+
+      assert data[plural][0]['id'],
+        "No id included in #{plural}[0] json data"
+
+      assert data[plural][0]['id'].to_s == id.to_s,
+        "Tried to find #{name} with id #{id}, but got #{name} with id #{data[plural][0]['id']}."
+
+      _json_to_model(klass, data[plural][0])
+    end
+
+    def extract_many(klass, response)
+      name = klass.to_s.underscore
+      plural = ActiveSupport::Inflector.pluralize(name)
+      data = transform(response)
+
+      assert data[plural],
+        "No key #{plural} in json response."
+
+      assert data[plural].is_a?(Array),
+        "Key #{plural} should be an array"
+
+      data[plural].reduce([]) do |collection, json|
+        collection << _json_to_model(klass, json)
+      end
+    end
+
+    def extract_many_relationship(parent, name, response)
+      # given response this will find the relationship
+      # for json api the response will either be
+      # 1) in links
+      # 2) in linked
+      json = transform(response)
+
+      if json['links'] && json['links'][name]
+        extract_many_relationship_from_links(name, json['links'][name])
+
+      elsif json['linked'] && json['linked'][name]
+        extract_many_relationship_from_linked(name, json['linked'][name])
+
+      else
+        raise "You asked for #{name} but it does not exist in links or linked"
+
+      end
+    end
+
+    def extract_many_relationship_from_links(name, link)
+      link_url = link['href']
+      # since we only have a url pointing to where to pull
+      # this info from we need to go back to the store and
+      # have it pull this data
+      store.load_collection(name, link_url)
+    end
+
+    def extract_relationship_from_linked(klass, name, linked)
+      extract_many(linked)
+    end
+  end
+end