proxima 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34bb68254ff2fc2f9ffd3f9c169fd3f66308310c
+  data.tar.gz: f4c5998226f4bf0a072a9019da212e0d68da2fc4
+SHA512:
+  metadata.gz: 5d5b5035f3de7e39e6e06b82f63bebd3c0e43971db2a0d734a579c39fc892a6bf8e9f4e35a1d39f91c38317b4f037e396102b2f2d8c7c2237f1690a79f8e884f
+  data.tar.gz: 34e426d98076d9ab26fb5bce50dde5fb290333f5b4cb81696caafbcadb84c7f92562e2ce1ce5f243b3c32b7d97c49d80726fa73819c3c269b8788c3e5866aeb0

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Robert Hurst
+
+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,29 @@
+# Proxima
+
+Proxima is a REST Model for use with REST APIs. Proxima's goal is to be
+flexible, so it refrains from imposing opinions about the remote api. The goal
+is to allow a Rails application to model any remote REST resource regardless of
+how the remote REST is implemented. Things like object shape and property names
+can be completely remapped. Even subpaths can be putted out into attributes.
+
+Proxima implements the entire Active Model interface.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'proxima'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install proxima
+
+## Usage
+
+To use proxima first create an initializer

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "proxima"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/proxima/api.rb

@@ -0,0 +1,50 @@
+require 'rest-client'
+
+
+module Proxima
+
+  class Api
+
+    attr_accessor :url, :headers
+
+    def initialize(base_url, opts = {})
+      @base_url = base_url
+      @headers  = opts[:headers] || {}
+    end
+
+    def post(path, opts = {}, &block)
+      self.request(:post, path, opts, &block)
+    end
+
+    def get(path, opts = {}, &block)
+      self.request(:get, path, opts, &block)
+    end
+
+    def put(path, opts = {}, &block)
+      self.request(:put, path, opts, &block)
+    end
+
+    def delete(path, opts = {}, &block)
+      self.request(:delete, path, opts, &block)
+    end
+
+    def request(method, path, opts = {}, &block)
+      headers = @headers.clone
+      headers.merge!(opts[:headers])  if opts[:headers]
+      headers[:params] = opts[:query] if opts[:query]
+      headers[:content_type] = :json  if opts[:json]
+      payload = opts[:json].to_json   if opts[:json]
+
+      begin
+        RestClient::Request.execute({
+          method:  method,
+          url:     @base_url + path,
+          headers: headers,
+          payload: payload
+        }, &block)
+      rescue RestClient::Exception => e
+        e.response
+      end
+    end
+  end
+end

data/lib/proxima/attributes.rb

@@ -0,0 +1,75 @@
+
+
+module Proxima
+  module Attributes
+
+    def attributes
+      attributes_hash = {}
+      self.class.attributes.each do |attribute, params|
+        value = self.send attribute
+        attributes_hash[attribute.to_s] = value
+      end
+      attributes_hash
+    end
+
+    def attributes=(params = {})
+      self.class.attributes.each do |attribute, attribute_params|
+        value = params[attribute]
+
+        if value == nil && default = attribute_params[:default]
+          value = default.respond_to?(:call) ? default.call(self, params) : default
+        end
+
+        if attribute_params[:klass] && !value.is_a?(attribute_params[:klass])
+          klass = attribute_params[:klass]
+          value = klass.new value
+        end
+
+        self.send "#{attribute}=", value
+      end
+    end
+
+    module ClassMethods
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def attribute(attribute, klass = nil, json_path = nil, params = nil)
+        params ||= json_path if json_path.is_a? Hash
+        params ||= klass     if klass.is_a? Hash
+        params ||= {}
+
+        params[:klass]     ||= klass     if klass.is_a? Class
+        params[:json_path] ||= json_path if json_path.is_a? String
+        params[:json_path] ||= klass     if klass.is_a? String
+        params[:json_path] ||= attribute.to_s
+
+        # Create attribute accessors
+        attr_reader attribute
+        define_method("#{attribute}=") do |value|
+          self.persisted = false
+          attribute_will_change! attribute
+          self.instance_variable_set "@#{attribute}", value
+          Proxima.watch value do
+            attribute_will_change! attribute
+          end
+        end
+
+        # Create attribute? methods
+        define_method "#{attribute}?" do
+          self.instance_variable_get("@#{attribute}") != nil
+        end
+
+        # Create suffixed/prefixed attribute methods
+        self.define_attribute_method attribute
+
+        self.attributes[attribute] = params
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/proxima/model.rb

@@ -0,0 +1,165 @@
+require 'active_model'
+require 'proxima/watch'
+require 'proxima/attributes'
+require 'proxima/paths'
+require 'proxima/serialization'
+require 'proxima/validation'
+
+
+module Proxima
+
+  class Model
+    extend  ActiveModel::Naming
+    extend  ActiveModel::Translation
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+    include ActiveModel::Model
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Validations
+
+    include Proxima::Attributes
+    include Proxima::Paths
+    include Proxima::Serialization
+    include Proxima::Validation
+
+    # TODO: Implement callbacks
+    # extend  ActiveModel::Callbacks
+    # define_model_callbacks :create, :update
+
+    def self.api(api = nil)
+      @api = api if api
+      @api
+    end
+
+    def self.create(record)
+      return record.map { |record| self.new record } if record.is_a? Array
+      model = self.new(record)
+      return nil unless model.save
+      model
+    end
+
+    def self.find(query = {}, opts = {})
+      opts[:query] = self.convert_query_or_delta_to_json query
+      response     = self.api.get self.find_path.call(query), opts
+
+      return [] unless response.code == 200
+
+      records = ActiveSupport::JSON.decode response.body
+      records.map do |record|
+        model = self.new
+        model.from_json record
+        model.new_record = false
+        model
+      end
+    end
+
+    def self.find_one(query = {}, opts = {})
+      query['$limit'] = 1;
+      self.find(query, opts)[0]
+    end
+
+    def self.count(query = {}, opts = {})
+      query['$limit'] = 0
+      opts[:query]    = self.convert_query_or_delta_to_json query
+      response        = self.api.get self.find_path.call(query), opts
+
+      return nil unless response.code == 200
+
+      response.headers[:x_total_count] || 0
+    end
+
+    def self.find_by_id(id, query = {}, opts = {})
+      if opts.empty? && query
+        opts  = query
+        query = {}
+      end
+
+      query[:id] = id
+      response = self.api.get self.find_by_id_path.call(query), opts
+
+      return nil unless response.code == 200
+
+      model = self.new
+      model.from_json response.body
+      model.new_record = false
+      model
+    end
+
+    def initialize(record = {})
+      self.new_record = true
+      self.attributes = record
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def persisted=(val)
+      @persisted = !!val
+      changes_applied if val
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def new_record=(val)
+      @new_record = !!val
+      @persisted  = !val
+      clear_changes_information unless val
+    end
+
+    def save(options = {})
+      return false unless self.valid?
+
+      if self.new_record?
+        path     = self.class.create_path.call self.to_h
+        payload  = { json: self.as_json(options) }
+        response = self.class.api.post path, payload
+
+        return false unless response.code == 201
+
+        self.from_json response.body, options[:include_root]
+        self.new_record = false
+        return true
+      end
+
+      return true if self.persisted?
+
+      options[:flatten] = true if options[:flatten] == nil
+      path     = self.class.update_by_id_path.call self.to_h
+      payload  = { json: self.as_json(options) }
+      response = self.class.api.put path, payload
+
+      return false unless response.code == 204
+      self.persisted = true
+    end
+
+    def reload!
+      self.clear_changes_information
+    end
+
+    def rollback!
+      self.restore_attributes
+    end
+
+    def destroy
+      return false if new_record?
+
+      response = self.class.api.delete(self.class.delete_by_id_path.call(self.to_h))
+
+      return false unless response.code == 204
+      self.persisted = true
+    end
+
+    def restore
+      return false if new_record?
+
+      response = self.class.api.post(self.class.restore_by_id_path.call(self.to_h))
+
+      return false unless response.code == 204
+      self.persisted = true
+    end
+  end
+end

data/lib/proxima/paths.rb

@@ -0,0 +1,54 @@
+
+
+module Proxima
+  module Paths
+    module ClassMethods
+
+      def base_uri(base_uri = nil)
+        base_uri = ->(m) { base_uri } if base_uri.is_a? String
+        @base_uri = base_uri if base_uri
+        @base_uri ||= ->(m) { "" }
+      end
+
+      def create_path(create_path = nil)
+        create_path = ->(m) { create_path } if create_path.is_a? String
+        @create_path = create_path if create_path
+        @create_path ||= ->(m) { "#{@base_uri.call(m)}" }
+      end
+
+      def find_path(find_path = nil)
+        find_path = ->(m) { find_path } if find_path.is_a? String
+        @find_path = find_path if find_path
+        @find_path ||= ->(m) { "#{@base_uri.call(m)}" }
+      end
+
+      def find_by_id_path(find_by_id_path = nil)
+        find_by_id_path = ->(m) { find_by_id_path } if find_by_id_path.is_a? String
+        @find_by_id_path = find_by_id_path if find_by_id_path
+        @find_by_id_path ||= ->(m) { "#{@base_uri.call(m)}/#{m[:id]}" }
+      end
+
+      def update_by_id_path(update_by_id_path = nil)
+        update_by_id_path = ->(m) { update_by_id_path } if update_by_id_path.is_a? String
+        @update_by_id_path = update_by_id_path if update_by_id_path
+        @update_by_id_path ||= ->(m) { "#{@base_uri.call(m)}/#{m[:id]}" }
+      end
+
+      def delete_by_id_path(delete_by_id_path = nil)
+        delete_by_id_path = ->(m) { delete_by_id_path } if delete_by_id_path.is_a? String
+        @delete_by_id_path = delete_by_id_path if delete_by_id_path
+        @delete_by_id_path ||= ->(m) { "#{@base_uri.call(m)}/#{m[:id]}" }
+      end
+
+      def restore_by_id_path(restore_by_id_path = nil)
+        restore_by_id_path = ->(m) { restore_by_id_path } if restore_by_id_path.is_a? String
+        @restore_by_id_path = restore_by_id_path if restore_by_id_path
+        @restore_by_id_path ||= ->(m) { "#{@base_uri.call(m)}/restore/#{m[:id]}" }
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/proxima/serialization.rb

@@ -0,0 +1,117 @@
+
+
+module Proxima
+  module Serialization
+
+    def from_json(json, include_root = self.include_root_in_json)
+      json = ActiveSupport::JSON.decode(json) if json.is_a?(String)
+      json = json.values.first if include_root
+      hash = {}
+
+      self.class.attributes.each do |attribute, params|
+        json_path        = params[:json_path]
+        json_path_chunks = json_path.split '.'
+        json_ctx         = json
+        for json_path_chunk in json_path_chunks
+          json_ctx = json_ctx[json_path_chunk]
+          break if json_ctx.nil?
+        end
+        value = json_ctx
+
+        next unless value
+
+        if params[:klass] && params[:klass].respond_to?(:from_json)
+          value = params[:klass].from_json(value)
+        end
+
+        hash[attribute] = value
+      end
+
+      self.attributes = hash
+      self
+    end
+
+    def as_json(options = {})
+      hash = serializable_hash options
+      json = {}
+      self.class.attributes.each do |attribute, params|
+        next if (
+          !options.key?(:include_clean) && !send("#{attribute}_changed?") ||
+          !options.key?(:include_nil) && hash[attribute.to_s] == nil
+        )
+
+        json_path = params[:json_path]
+        value     = hash[attribute.to_s]
+        value     = value.as_json if value.respond_to? :as_json
+
+        if options.key? :flatten
+          json[json_path] = value
+          next
+        end
+
+        json_path_chunks     = json_path.split '.'
+        last_json_path_chunk = json_path_chunks.pop
+        json_ctx             = json
+        for json_path_chunk in json_path_chunks
+          json_ctx[json_path_chunk] = {} unless json_ctx[json_path_chunk].is_a?(Hash)
+          json_ctx = json_ctx[json_path_chunk]
+        end
+        json_ctx[last_json_path_chunk] = value
+      end
+
+      root = if options.key? :root
+        options[:root]
+      else
+        self.include_root_in_json
+      end
+
+      if root
+        root = self.class.model_name.element if root == true
+        { root => json }
+      else
+        json
+      end
+    end
+
+    def to_h
+      hash = {}
+      self.class.attributes.each do |attribute, params|
+        hash[attribute] = self.send attribute
+      end
+      hash
+    end
+
+    module ClassMethods
+
+      def from_json(json, include_root=self.include_root_in_json)
+        json = ActiveSupport::JSON.decode(json) if json.is_a? String
+        json = json.values.first if include_root
+
+        if json.is_a? Array
+          return json.map { |json| self.new.from_json json }
+        end
+
+        self.new.from_json json
+      end
+
+      def convert_query_or_delta_to_json(query)
+        json_query = {}
+        query.each do |attribute, val|
+          attr_str  = attribute.to_s
+          json_path = attributes[attribute] ? attributes[attribute][:json_path] : attr_str
+
+          json_query[json_path] = unless attr_str[0] == '$' && val.is_a?(Hash)
+            val
+          else
+            self.convert_query_or_delta_to_json val
+          end
+        end
+        json_query
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/proxima/validation.rb

@@ -0,0 +1,29 @@
+
+
+module Proxima
+  module Validation
+
+    def read_attribute_for_validation(attr)
+      self.send attr
+    end
+
+    def self.errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+
+    module ClassMethods
+
+      def human_attribute_name(attr, options = {})
+        attr
+      end
+
+      def lookup_ancestors
+        [self]
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/proxima/version.rb

@@ -0,0 +1,5 @@
+
+
+module Proxima
+  VERSION = "0.1.0"
+end

data/lib/proxima/watch.rb

@@ -0,0 +1,11 @@
+require 'proxima/watch_hash'
+require 'proxima/watch_array'
+
+
+module Proxima
+
+  def self.watch(value, &block)
+    Proxima.watch_hash(value, &block)  if value.is_a? Hash
+    Proxima.watch_array(value, &block) if value.is_a? Array
+  end
+end

data/lib/proxima/watch_array.rb

@@ -0,0 +1,174 @@
+
+
+module Proxima
+
+  def self.watch_array(array, &on_change)
+
+    array.instance_variable_set(:@on_change, on_change)
+
+    array.each do |value|
+      Proxima.watch(value, &on_change)
+    end
+
+    class << array
+
+      def <<(*args)
+        result = super
+        args.each do |value|
+          Proxima.watch(value, &@on_change)
+        end
+        @on_change.call
+        result
+      end
+
+      def []=(*args)
+        result = super
+        Proxima.watch(args[2] || args[1], &@on_change)
+        @on_change.call
+        result
+      end
+
+      def clear(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def collect!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def compact!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def delete(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def delete_at(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def delete_if(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def fill(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def flatten!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def replace(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def insert(*args)
+        args[1..-1].each do |value|
+          Proxima.watch(value, &@on_change)
+        end
+        result = super
+        @on_change.call if args[1] != nil
+        result
+      end
+
+      def pop(*args)
+        result = super
+        @on_change.call if args[0] == nil || args[0] > 0
+        result
+      end
+
+      def push(*args)
+        args.each do |value|
+          Proxima.watch(value, &@on_change)
+        end
+        result = super
+        @on_change.call if args.length > 0
+        result
+      end
+
+      def reject!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def reverse!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def rotate!(*args)
+        result = super
+        @on_change.call if args[0] != 0
+        result
+      end
+
+      def select!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def shift(*args)
+        result = super
+        @on_change.call if args[0] == nil || args[0] > 0
+        result
+      end
+
+      def shuffle!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def slice!(*args)
+        result = super
+        if result.is_a? Array
+          @on_change.call if result.length > 0
+        else
+          @on_change.call if result != nil
+        end
+        result
+      end
+
+      def sort!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def sort_by!(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def uniq!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+    end
+  end
+end

data/lib/proxima/watch_hash.rb

@@ -0,0 +1,78 @@
+
+
+module Proxima
+
+  def self.watch_hash(hash, &on_change)
+
+    hash.instance_variable_set(:@on_change, on_change)
+
+    hash.values.each do |value|
+      Proxima.watch(value, &on_change)
+    end
+
+    class << hash
+
+      def []=(*args)
+        Proxima.watch(args[1], &@on_change)
+        result = super
+        @on_change.call if args[1]
+        result
+      end
+
+      def clear(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def delete(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def delete_if(*args)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def merge!(*args)
+        args[0].values.each do |value|
+          Proxima.watch(value, &@on_change)
+        end
+        result = super
+        @on_change.call
+        result
+      end
+
+      def reject!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def select!(*args)
+        result = super
+        @on_change.call if result
+        result
+      end
+
+      def store(*args)
+        Proxima.watch(args[1], &@on_change)
+        result = super
+        @on_change.call
+        result
+      end
+
+      def update(*args)
+        args[0].values.each do |value|
+          Proxima.watch(value, &@on_change)
+        end
+        result = super
+        @on_change.call
+        result
+      end
+    end
+  end
+end

data/lib/proxima.rb

@@ -0,0 +1,7 @@
+require "proxima/version"
+require "proxima/api"
+require "proxima/model"
+
+
+module Proxima
+end

data/proxima.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'proxima/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "proxima"
+  spec.version       = Proxima::VERSION
+  spec.authors       = ["Robert Hurst"]
+  spec.email         = ["robertwhurst@gmail.com"]
+
+  spec.summary       = "REST Models for Ruby on Rails"
+  spec.description   = "Proxima is a gem the provides models for use with REST endpoints. These models are based upon the Active Model interface"
+  spec.homepage      = "https://github.com/fintechdev/proxima"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
+
+  spec.add_dependency "activemodel", '~> 5.0', '>= 5.0.0'
+  spec.add_dependency "rest-client", '~> 2.0', '>= 2.0.0'
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: proxima
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Robert Hurst
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Proxima is a gem the provides models for use with REST endpoints. These
+  models are based upon the Active Model interface
+email:
+- robertwhurst@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/proxima.rb
+- lib/proxima/api.rb
+- lib/proxima/attributes.rb
+- lib/proxima/model.rb
+- lib/proxima/paths.rb
+- lib/proxima/serialization.rb
+- lib/proxima/validation.rb
+- lib/proxima/version.rb
+- lib/proxima/watch.rb
+- lib/proxima/watch_array.rb
+- lib/proxima/watch_hash.rb
+- proxima.gemspec
+homepage: https://github.com/fintechdev/proxima
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: REST Models for Ruby on Rails
+test_files: []