proxima 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46b4cda9ea1fe4d5e4d977217e5b2cf99712382f
-  data.tar.gz: 76131830057e48b59c26a1064eed22b1fde1519c
+  metadata.gz: 7e43b6f5e5522b1396e73fdbcf6608f1db3a44fc
+  data.tar.gz: 5432d294fe344f96b47ba62641362de142a3d414
 SHA512:
-  metadata.gz: 09b7e1b9009dc42cdea2ae0af852c117c493ad356e407f7b31d0db760dd892095b29ee965e7a6ad829feee76ff216588d1caf79e28c14795b608a8dfdb332d6c
-  data.tar.gz: bc2f27c0a9761c53289b77631590bcfb21899405ac35f2235dd8b831c9daa853a2e488a2d80425be0ac9e9b0225e99849adfaa8bdd81971fa439c9938d80007d
+  metadata.gz: dafbbfceaf50644a3e41da18933059bec823692c2d97dd9e64308cc9e4a251ed93e9550b40a908e8a6eaabd0d8921417bade9197892bb17b63aa9b31039ba8ca
+  data.tar.gz: 21ff91fc7848d129724d2ff411d488c93a1ad72c6ed1b2c088c6ed26b8310488575a4d1d5bac1c57d7b11f9eb336b56045bd904a306fe26ae2325f8668547442

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proxima
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Robert Hurst
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-26 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,31 +99,7 @@ email:
 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-0.1.0.gem
-- proxima-0.1.1.gem
-- proxima-0.1.2.gem
-- proxima.gemspec
+files: []
 homepage: https://github.com/fintechdev/proxima
 licenses:
 - MIT

data/.gitignore

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

data/.rspec

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

data/.travis.yml

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

data/Gemfile

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

data/LICENSE.txt

@@ -1,21 +0,0 @@
-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

@@ -1,29 +0,0 @@
-# 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

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

data/bin/console

@@ -1,14 +0,0 @@
-#!/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

@@ -1,7 +0,0 @@
-#!/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

@@ -1,50 +0,0 @@
-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

@@ -1,75 +0,0 @@
-
-
-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 value != nil && 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

@@ -1,165 +0,0 @@
-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.create 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

@@ -1,75 +0,0 @@
-
-
-module Proxima
-  module Paths
-    module ClassMethods
-
-      def base_uri(base_uri = nil)
-        if base_uri.is_a? String
-          base_uri_str = base_uri
-          base_uri     = ->(m) { base_uri_str }
-        end
-        @base_uri = base_uri if base_uri
-        @base_uri ||= ->(m) { "" }
-      end
-
-      def create_path(create_path = nil)
-        if create_path.is_a? String
-          create_path_str = create_path
-          create_path     = ->(m) { create_path_str }
-        end
-        @create_path = create_path if create_path
-        @create_path ||= ->(m) { "#{@base_uri.call(m)}" }
-      end
-
-      def find_path(find_path = nil)
-        if find_path.is_a? String
-          find_path_str = find_path
-          find_path     = ->(m) { find_path_str }
-        end
-        @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)
-        if find_by_id_path.is_a? String
-          find_by_id_path_str = find_by_id_path
-          find_by_id_path     = ->(m) { find_by_id_path_str }
-        end
-        @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)
-        if update_by_id_path.is_a? String
-          update_by_id_path_str = update_by_id_path
-          update_by_id_path     = ->(m) { update_by_id_path_str }
-        end
-        @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)
-        if delete_by_id_path.is_a? String
-          delete_by_id_path_str = delete_by_id_path
-          delete_by_id_path     = ->(m) { delete_by_id_path_str }
-        end
-        @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)
-        if restore_by_id_path.is_a? String
-          restore_by_id_path_str = restore_by_id_path
-          restore_by_id_path     = ->(m) { restore_by_id_path_str }
-        end
-        @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

@@ -1,117 +0,0 @@
-
-
-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

@@ -1,29 +0,0 @@
-
-
-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

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

data/lib/proxima/watch.rb

@@ -1,11 +0,0 @@
-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

@@ -1,174 +0,0 @@
-
-
-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

@@ -1,78 +0,0 @@
-
-
-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

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

data/proxima.gemspec

@@ -1,28 +0,0 @@
-# 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", '~> 4.0', '>= 4.0.0'
-  spec.add_dependency "rest-client", '~> 2.0', '>= 2.0.0'
-end