active_record-remote 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d72e68a69e314e8e66a694f12fe52dd5a46c16d1
+  data.tar.gz: d4c80560035c03ad31a25f7ff4fe730558bb364c
+SHA512:
+  metadata.gz: 467fe7bd459140a835db5cbfa3309e24e684198cf82891f9ca6729c4a83d15ccde8acce9007aad57a724f328c9cbf15b2b38eaa8c295d52acdde45e8c90f84bd
+  data.tar.gz: 312a3f2a0ffb0771820d952bf3b5f275df9743c459c65f4a3d3b2904c726769cab55b1eb369b83e4ba6f9d2a545d3606376804727e9da98db06424a0d09b90cb

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Justin Grubbs
+
+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,32 @@
+# ActiveRecord::Remote
+
+This gem is a work in progress. The goal is to create a library that allows Ruby wrappers to be agnostic of the communication method. SOAP, XML, JSON, and Flat File all can be written in a similar format. To see a working example for a SOAP API [jGRUBBS/rlm_logistics](https://github.com/jGRUBBS/rlm_logistics).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record-remote'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record-remote
+
+## TODO
+- [ ] implement for JSON
+- [ ] implement for Flat File
+- [ ] implement Rspec
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_record-remote/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/active_record-remote.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record/remote/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record-remote"
+  spec.version       = ActiveRecord::Remote::VERSION
+  spec.authors       = ["Justin Grubbs"]
+  spec.email         = ["justin@jgrubbs.net"]
+  spec.summary       = %q{Active Record pattern for remote APIs}
+  spec.description   = %q{Active Record pattern for remote APIs}
+  spec.homepage      = "https://github.com/jGRUBBS/active_record-remote"
+  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 "virtus",        "~> 1.0.5"
+  spec.add_dependency "activesupport", "~> 4.2.5"
+  spec.add_dependency "builder",       "~> 3.2.2"
+  spec.add_dependency "activemodel",   "~> 4.2.5"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/active_record/remote.rb

@@ -0,0 +1,9 @@
+require 'virtus'
+require 'active_model'
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/string/inflections'
+require 'active_record/remote/core_ext/hash'
+require 'active_record/remote/version'
+require 'active_record/remote/base'
+require 'active_record/remote/client'
+require 'active_record/remote/response'

data/lib/active_record/remote/base.rb

@@ -0,0 +1,112 @@
+require 'active_record/remote/helpers/association_helper'
+require 'active_record/remote/helpers/request_helper'
+require 'active_record/remote/helpers/serialization_helper'
+require 'active_record/remote/helpers/xml_helper'
+require 'active_record/remote/helpers/soap_helper'
+
+module ActiveRecord
+  module Remote
+    class Base
+
+      class_attribute :action_path, :api_type, :operation_path, :base_element_name
+
+      include Virtus.model
+      include ActiveModel::Validations
+      extend  ActiveRecord::Remote::Helpers::AssociationHelper
+      extend  ActiveRecord::Remote::Helpers::RequestHelper
+      include ActiveRecord::Remote::Helpers::SerializationHelper
+      include ActiveRecord::Remote::Helpers::XMLHelper
+      include ActiveRecord::Remote::Helpers::SOAPHelper
+
+      attr_accessor :response, :raw_data, :parsed_data
+
+      def self.api_type(type)
+        self.api_type = type
+      end
+
+      def initialize(options = {})
+        super(options.merge(custom_options))
+      end
+
+      def custom_options
+        # overwrite in subclass to provide custom options to initalizer
+      end
+
+      def save
+        @response = handle_response(request)
+        valid?
+      end
+
+      def self.where(attrs)
+        instance = new(attrs)
+        instance.response = instance.handle_response(instance.request)
+        instance.parse_records
+      end
+
+      def self.all
+        where({})
+      end
+
+      def request
+        request_body    = send("as_#{api_type}")
+        client.api_type = api_type
+        client.request(request_body)
+      end
+
+      def update_attributes(attrs)
+        attrs.each { |k, v| send("#{k}=", v) }
+      end
+
+      def valid?
+        if response.present?
+          # all model validations may pass, but response
+          # may have contained an error message
+          response.success?
+        else
+          # use model validations
+          super
+        end
+      end
+
+      def base_module
+        self.class.to_s.split('::').first.constantize
+      end
+
+      def full_module
+        self.class.to_s.split('::')[0..-2].join('::').constantize
+      end
+
+      def record_class
+        self.class.to_s.split('::').last
+      end
+
+      def parse_records
+        data = response.data.is_a?(Array) ? response.data : [response.data]
+        return [] if data.compact.empty?
+        data.flat_map do |data_item|
+          instance = self.class.new
+          read_attributes = "#{record_class}ReadAttributes"
+          if full_module.const_defined?(read_attributes)
+            instance.extend(read_attributes.constantize)
+          end
+          attrs = data_item.transform_keys! {|k| k.downcase.to_sym }
+          instance.update_attributes(attrs)
+          instance
+        end
+      end
+
+      def handle_response(response)
+        base_module.const_get("Response").new(
+          operation:    self.class.operation_path,
+          raw_response: response,
+          instance:     self
+        )
+      end
+
+      def client
+        base_module.const_get("Client").new(self.class.action_path)
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/client.rb

@@ -0,0 +1,70 @@
+require "net/http"
+require "net/https"
+
+module ActiveRecord
+  module Remote
+    class Client
+
+      cattr_accessor :content_type, :host, :read_timeout, :api_type, :secure
+      attr_accessor :action
+
+      def initialize(action)
+        @action = action
+      end
+
+      def self.content_type(content_type)
+        self.content_type = content_type
+      end
+
+      def self.host(host)
+        self.host = host
+      end
+
+      def self.read_timeout(read_timeout)
+        self.read_timeout = read_timeout
+      end
+
+      def self.secure(secure)
+        self.secure = secure
+      end
+
+      def http
+        @http ||= Net::HTTP.new(host)
+      end
+
+      def formatted_action
+        action
+      end
+
+      def formatted_path
+        "/#{endpoint_path}/#{formatted_action}"
+      end
+
+      def complete_request_url
+        "#{http_protocol}://#{host}#{formatted_path}"
+      end
+
+      def http_protocol
+        secure ? "https" : "http"
+      end
+
+      def endpoint_path
+        # define in subclass
+      end
+
+      def request(request_body)
+        request              = Net::HTTP::Post.new(formatted_path)
+        request.body         = request_body
+        request.content_type = content_type
+        if secure
+          http.use_ssl     = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        request.add_field("SOAPAction", "") if api_type == :soap
+        http.read_timeout = read_timeout    if read_timeout
+        http.request(request)
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/core_ext/hash.rb

@@ -0,0 +1,40 @@
+class Hash
+
+  def to_soap(options = {})
+    require 'active_support/builder' unless defined?(Builder)
+
+    options = options.dup
+    options[:indent]       ||= 2
+    options[:root]         ||= 'hash'
+    options[:soap_builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
+
+    soap_builder = options[:soap_builder]
+
+    soap_builder.Envelope xmlns: "http://schemas.xmlsoap.org/soap/envelope/" do
+
+      soap_builder.Body do
+
+        soap_builder.tag!(options[:operation], xmlns: options[:namespace]) do
+          soap_builder.tag!(options[:base_element], "\n#{build_internal_xml(options)}")
+        end
+
+      end
+
+    end
+  end
+
+  def build_internal_xml(options = {})
+    options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
+    builder = options[:builder]
+
+    root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
+
+    builder.tag!(root) do
+      each { |key, value| ActiveSupport::XmlMini.to_tag(key, value, options) }
+      yield builder if block_given?
+    end
+
+    builder.target!.gsub(" ", "")
+  end
+
+end

data/lib/active_record/remote/helpers/association_helper.rb

@@ -0,0 +1,56 @@
+module ActiveRecord::Remote
+  module Helpers
+    module AssociationHelper
+
+      def has_many(association, options = {})
+        association_name = parse_association_name(association, options)
+        set_inflection(association, options)
+        self.attribute association, Array[association_klass(association_name)], options
+      end
+
+      def parse_association_name(association, options = {})
+        if options[:collection].present?
+          options[:collection]
+        else
+          association
+        end
+      end
+
+      def set_inflection(association, options)
+        return if options[:collection].nil?
+        # since RLM has an irregular API we have to adjust the inflections
+        # so we can have children collections that do not match the parents
+        # i.e.
+        # <DETAILS>
+        #   <LINE>
+        # instead of default behavior
+        # <DETAILS>
+        #   <DETAIL>
+        #
+        # the code below dynamically adjusts active_support inflections
+        # here is a basic example
+        #
+        # ActiveSupport::Inflector.inflections do |inflect|
+        #   inflect.singular 'DETAILS', 'LINE'
+        # end
+        if options[:strict]
+          assoc_name = association.to_s
+          collection = options[:collection].to_s
+        else
+          assoc_name = association.to_s.upcase
+          collection = options[:collection].to_s.upcase
+        end
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular assoc_name, collection
+        end
+      end
+
+      def association_klass(name)
+        singular = name.to_s.singularize
+        parent_module = to_s.split('::')[0..-2].join('::').constantize
+        parent_module.const_get(singular.classify)
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/helpers/request_helper.rb

@@ -0,0 +1,19 @@
+module ActiveRecord::Remote
+  module Helpers
+    module RequestHelper
+
+      def action(kind)
+        self.action_path = kind
+      end
+
+      def operation(kind)
+        self.operation_path = kind
+      end
+
+      def base_element(name)
+        self.base_element_name = name
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/helpers/serialization_helper.rb

@@ -0,0 +1,53 @@
+module ActiveRecord::Remote
+  module Helpers
+    module SerializationHelper
+
+      def serializable_hash
+        Hash.new.tap do |attribute_hash|
+          attribute_set.each do |attribute|
+            serialize_attribute(attribute_hash, attribute)
+          end
+        end
+      end
+
+      def serialize_attribute(attribute_hash, attribute)
+        return if attributes[attribute.name].nil?
+        name = _attribute_name(attribute)
+        attribute_hash[name] = _serialize(attributes[attribute.name], attribute)
+      end
+
+      def _attribute_name(attribute)
+        if !!attribute.options[:as]
+          attribute.options[:as]
+        elsif !!attribute.options[:strict]
+          attribute.name
+        else
+          attribute.name.upcase
+        end
+      end
+
+      def _serialize(serialized, attribute = nil)
+        if serialized.respond_to?(:serializable_hash)
+          serialized.serializable_hash
+        else
+          case serialized
+          when Array
+            serialized.map { |attr| _serialize(attr) }
+          when BigDecimal
+            serialized.to_s("F")
+          when Hash
+            Hash[
+              serialized.map do |k, v|
+                k = attribute.options[:strict] ? k : k.upcase
+                [k, v]
+              end
+            ]
+          else
+            serialized
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/helpers/soap_helper.rb

@@ -0,0 +1,19 @@
+module ActiveRecord::Remote
+  module Helpers
+    module SOAPHelper
+
+      def as_soap
+        serializable_hash.to_soap(soap_options)
+      end
+
+      def soap_options
+        {
+          dasherize:  false,
+          skip_types: true,
+          omit_nils:  true
+        }
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/helpers/xml_helper.rb

@@ -0,0 +1,19 @@
+module ActiveRecord::Remote
+  module Helpers
+    module XMLHelper
+
+      def as_xml
+        serializable_hash.to_xml(xml_options)
+      end
+
+      def xml_options
+        {
+          root: "ITEM_FILTER",
+          dasherize: false,
+          skip_types: true
+        }
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/response.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module Remote
+    class Response
+
+      attr_accessor :parsed_response, :options
+
+      alias_method :parsed, :parsed_response
+
+      def initialize(options)
+        @options = options
+        handle_response(options[:raw_response])
+      end
+
+      def operation
+        options[:operation]
+      end
+
+      def record_instance
+        options[:instance]
+      end
+
+      def success?
+        record_instance.errors.blank?
+      end
+
+      def handle_response(response)
+        # implement in subclass
+      end
+
+      def response_message
+        # implement in subclass
+      end
+
+      def valid?
+        # implement in subclass
+      end
+
+    end
+  end
+end

data/lib/active_record/remote/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Remote
+    VERSION = "0.0.1"
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: active_record-remote
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Grubbs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+description: Active Record pattern for remote APIs
+email:
+- justin@jgrubbs.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record-remote.gemspec
+- lib/active_record/remote.rb
+- lib/active_record/remote/base.rb
+- lib/active_record/remote/client.rb
+- lib/active_record/remote/core_ext/hash.rb
+- lib/active_record/remote/helpers/association_helper.rb
+- lib/active_record/remote/helpers/request_helper.rb
+- lib/active_record/remote/helpers/serialization_helper.rb
+- lib/active_record/remote/helpers/soap_helper.rb
+- lib/active_record/remote/helpers/xml_helper.rb
+- lib/active_record/remote/response.rb
+- lib/active_record/remote/version.rb
+homepage: https://github.com/jGRUBBS/active_record-remote
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Active Record pattern for remote APIs
+test_files: []