proxima 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e43b6f5e5522b1396e73fdbcf6608f1db3a44fc
-  data.tar.gz: 5432d294fe344f96b47ba62641362de142a3d414
+  metadata.gz: b9082fd4c6ba1326eb83db92d14150445b4d9eec
+  data.tar.gz: 6c466ac77e3a61819e9efd7561777f1858becfaf
 SHA512:
-  metadata.gz: dafbbfceaf50644a3e41da18933059bec823692c2d97dd9e64308cc9e4a251ed93e9550b40a908e8a6eaabd0d8921417bade9197892bb17b63aa9b31039ba8ca
-  data.tar.gz: 21ff91fc7848d129724d2ff411d488c93a1ad72c6ed1b2c088c6ed26b8310488575a4d1d5bac1c57d7b11f9eb336b56045bd904a306fe26ae2325f8668547442
+  metadata.gz: 76bea80680d18521f68110e045102960c3a852ca3c6aa13e05fb18f20a08733728e44d29a067a083033b92f6290a0268728b544f22b878bb7dad912386c97e9d
+  data.tar.gz: 0e16411d9cda093632d8c9638b65f4fbdc0f1dc66edb3ae1af9e2cb26cd29d44d2ff093e54dcbff84b0d4e320739f8ca21496679d2959a5e3164aceceea2d838

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 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

@@ -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.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 == nil && 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,75 @@
+
+
+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

@@ -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.5"
+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

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: proxima
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Robert Hurst
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
@@ -99,7 +99,18 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- 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
 homepage: https://github.com/fintechdev/proxima
 licenses:
 - MIT
@@ -120,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: REST Models for Ruby on Rails