fmrest 0.1.0

data/Rakefile

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

data/fmrest.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fmrest/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fmrest"
+  spec.version       = FmRest::VERSION
+  spec.authors       = ["Pedro Carbajal"]
+  spec.email         = ["pedro_c@beezwax.net"]
+
+  spec.summary       = %q{FileMaker Data API client using Faraday}
+  spec.description   = %q{FileMaker Data API client using Faraday, with optional ActiveRecord-like ORM based on Spyke}
+  spec.homepage      = "https://github.com/beezwax/fmrest-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|bin)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'faraday', '>= 0.9.0', '< 2.0'
+  spec.add_dependency 'faraday_middleware', '>= 0.9.1', '< 2.0'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "spyke"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "pry-byebug"
+end

data/lib/fmrest.rb

@@ -0,0 +1,13 @@
+require "faraday"
+require "faraday_middleware"
+
+require "fmrest/version"
+require "fmrest/v1"
+
+module FmRest
+  class << self
+    attr_accessor :token_store
+
+    attr_accessor :config
+  end
+end

data/lib/fmrest/spyke.rb

@@ -0,0 +1,11 @@
+require "fmrest/spyke/json_parser"
+require "fmrest/spyke/model"
+require "fmrest/spyke/base"
+
+module FmRest
+  module Spyke
+    def self.included(base)
+      base.include Model
+    end
+  end
+end

data/lib/fmrest/spyke/base.rb

@@ -0,0 +1,15 @@
+module FmRest
+  module Spyke
+    class Base < ::Spyke::Base
+      include FmRest::Spyke::Model
+    end
+
+    class << self
+      def Base(config = {})
+        Class.new(::FmRest::Spyke::Base) do
+          self.fmrest_config = config
+        end
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/json_parser.rb

@@ -0,0 +1,143 @@
+module FmRest
+  module Spyke
+    class JsonParser < ::Faraday::Response::Middleware
+      SINGLE_RECORD_RE = %r(/records/\d+\Z).freeze
+      FIND_RECORDS_RE = %r(/_find\b).freeze
+
+      def initialize(app, model)
+        super(app)
+        @model = model
+      end
+
+      def on_complete(env)
+        json = parse_json(env.body)
+
+        env.body =
+          if env.method == :get || find_results?(env.url)
+            if single_record_url?(env.url)
+              prepare_single_record(json)
+            else
+              prepare_collection(json)
+            end
+          else
+            prepare_save_response(json)
+          end
+      end
+
+      private
+
+      def prepare_save_response(json)
+        response = json[:response]
+
+        data = {}
+        data[:mod_id] = response[:modId].to_i if response[:modId]
+        data[:id]     = response[:recordId].to_i if response[:recordId]
+
+        base_hash(json).merge!(data: data)
+      end
+
+      def prepare_single_record(json)
+        data =
+          json[:response][:data] &&
+          prepare_record_data(json[:response][:data].first)
+
+        base_hash(json).merge!(data: data)
+      end
+
+      def prepare_collection(json)
+        data =
+          json[:response][:data] &&
+          json[:response][:data].map { |record_data| prepare_record_data(record_data) }
+
+        base_hash(json).merge!(data: data)
+      end
+
+      def base_hash(json)
+        {
+          metadata: { messages: json[:messages] },
+          errors:   {}
+        }
+      end
+
+      # json_data is expected in this format:
+      #
+      #     {
+      #       "fieldData": {
+      #         "fieldName1" : "fieldValue1",
+      #         "fieldName2" : "fieldValue2",
+      #         ...
+      #       },
+      #       "portalData": {
+      #         "portal1" : [
+      #           { <portalRecord1> },
+      #           { <portalRecord2> },
+      #           ...
+      #         ],
+      #         "portal2" : [
+      #           { <portalRecord1> },
+      #           { <portalRecord2> },
+      #           ...
+      #         ]
+      #       },
+      #       "modId": <Id_for_last_modification>,
+      #       "recordId": <Unique_internal_ID_for_this_record>
+      #     }
+      #
+      def prepare_record_data(json_data)
+        out = { id: json_data[:recordId].to_i, mod_id: json_data[:modId].to_i }
+        out.merge!(json_data[:fieldData])
+        out.merge!(prepare_portal_data(json_data[:portalData])) if json_data[:portalData]
+        out
+      end
+
+      # Extracts recordId and strips the PortalName:: field prefix for each
+      # portal
+      #
+      # Sample json_portal_data:
+      #
+      #     "portalData": {
+      #       "Orders":[
+      #         { "Orders::DeliveryDate":"3/7/2017", "recordId":"23" }
+      #       ]
+      #     }
+      #
+      def prepare_portal_data(json_portal_data)
+        json_portal_data.each_with_object({}) do |(portal_name, portal_records), out|
+          portal_options = @model.portal_options[portal_name.to_s] || {}
+
+          out[portal_name] =
+            portal_records.map do |portal_fields|
+              attributes = { id: portal_fields[:recordId].to_i }
+              attributes[:mod_id] = portal_fields[:modId].to_i if portal_fields[:modId]
+
+              prefix = portal_options[:attribute_prefix] || portal_name
+              prefix_matcher = /\A#{prefix}::/
+
+              portal_fields.each do |k, v|
+                next if :recordId == k || :modId == k
+                attributes[k.to_s.gsub(prefix_matcher, "")] = v
+              end
+
+              attributes
+            end
+        end
+      end
+
+      def find_results?(url)
+        url.path.match(FIND_RECORDS_RE)
+      end
+
+      def single_record_url?(url)
+        url.path.match(SINGLE_RECORD_RE)
+      end
+
+      def parse_json(source)
+        if defined?(::MultiJson)
+          ::MultiJson.load(source, symbolize_keys: true)
+        else
+          ::JSON.parse(source, symbolize_names: true)
+        end
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/model.rb

@@ -0,0 +1,23 @@
+require "fmrest/spyke/model/connection"
+require "fmrest/spyke/model/uri"
+require "fmrest/spyke/model/attributes"
+require "fmrest/spyke/model/associations"
+require "fmrest/spyke/model/orm"
+
+module FmRest
+  module Spyke
+    module Model
+      extend ::ActiveSupport::Concern
+
+      include Connection
+      include Uri
+      include Attributes
+      include Associations
+      include Orm
+
+      included do
+        attr_accessor :mod_id
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/model/associations.rb

@@ -0,0 +1,77 @@
+require "fmrest/spyke/portal"
+
+module FmRest
+  module Spyke
+    module Model
+      module Associations
+        extend ::ActiveSupport::Concern
+
+        included do
+          # Keep track of portal options by their FM keys as we could need it
+          # to parse the portalData JSON in JsonParser
+          class_attribute :portal_options, instance_accessor: false,
+                                           instance_predicate: false,
+                                           default:           {}.freeze
+
+          class << self; private :portal_options=; end
+        end
+
+        class_methods do
+          # Based on +has_many+, but creates a special Portal association
+          # instead.
+          #
+          # Custom options:
+          #
+          # * <tt>:portal_key</tt> - The key used for the portal in the FM Data JSON portalData.
+          # * <tt>:attribute_prefix</tt> - The prefix used for portal attributes in the FM Data JSON.
+          #
+          # Example:
+          #
+          #   has_portal :jobs, portal_key: "JobsTable", attribute_prefix: "Job"
+          #
+          def has_portal(name, options = {})
+            create_association(name, Portal, options)
+
+            # Store options for JsonParser to use if needed
+            portal_key = options[:portal_key] || name
+            self.portal_options = portal_options.merge(portal_key.to_s => options.dup.merge(name: name.to_s)).freeze
+
+            define_method "#{name.to_s.singularize}_ids" do
+              association(name).map(&:id)
+            end
+          end
+        end
+
+        # Override Spyke's association reader to keep a cache of loaded
+        # portals. Spyke's default behavior is to reload the association
+        # each time.
+        #
+        def association(name)
+          @loaded_portals ||= {}
+
+          if @loaded_portals.has_key?(name.to_sym)
+            return @loaded_portals[name.to_sym]
+          end
+
+          super.tap do |assoc|
+            next unless assoc.kind_of?(FmRest::Spyke::Portal)
+            @loaded_portals[name.to_sym] = assoc
+          end
+        end
+
+        def reload
+          super.tap { @loaded_portals = nil }
+        end
+
+        def portals
+          self.class.associations.each_with_object([]) do |(key, _), portals|
+            candidate = association(key)
+            next unless candidate.kind_of?(FmRest::Spyke::Portal)
+            portals << candidate
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fmrest/spyke/model/attributes.rb

@@ -0,0 +1,198 @@
+module FmRest
+  module Spyke
+    module Model
+      module Attributes
+        extend ::ActiveSupport::Concern
+
+        include ::ActiveModel::Dirty
+        include ::ActiveModel::ForbiddenAttributesProtection
+
+        included do
+          # Keep mod_id as a separate, custom accessor
+          attr_accessor :mod_id
+
+          # Prevent the creation of plain (no prefix/suffix) attribute methods
+          # when calling ActiveModels' define_attribute_method, otherwise it
+          # will define an `attribute` method which overrides the one provided
+          # by Spyke
+          self.attribute_method_matchers.shift
+
+          # ActiveModel::Dirty methods for id
+          define_attribute_method(:id)
+
+          # Keep track of attribute mappings so we can get the FM field names
+          # for changed attributes
+          class_attribute :mapped_attributes, instance_writer: false,
+                                              instance_predicate: false,
+                                              default: ::ActiveSupport::HashWithIndifferentAccess.new.freeze
+
+          class << self; private :mapped_attributes=; end
+        end
+
+        class_methods do
+          # Similar to Spyke::Base.attributes, but allows defining attribute
+          # methods that map to FM attributes with different names.
+          #
+          # Example:
+          #
+          #   class Person < Spyke::Base
+          #     include FmRest::Spyke::Model
+          #
+          #     attributes first_name: "FstName", last_name: "LstName"
+          #   end
+          #
+          #   p = Person.new
+          #   p.first_name = "Jojo"
+          #   p.attributes # => { "FstName" => "Jojo" }
+          #
+          def attributes(*attrs)
+            if attrs.length == 1 && attrs.first.kind_of?(Hash)
+              attrs.first.each { |from, to| _fmrest_define_attribute(from, to) }
+            else
+              attrs.each { |attr| _fmrest_define_attribute(attr, attr) }
+            end
+          end
+
+          private
+
+          # Override Spyke::Base.new_or_return (private), called whenever
+          # loading records from the HTTP API, so we can reset dirty info on
+          # freshly loaded records
+          #
+          # See: https://github.com/balvig/spyke/blob/master/lib/spyke/http.rb
+          #
+          def new_or_return(attributes_or_object, *_)
+            # In case of an existing Spyke object return it as is so that we
+            # don't accidentally remove dirty data from associations
+            return super if attributes_or_object.is_a?(::Spyke::Base)
+            super.tap { |record| record.clear_changes_information }
+          end
+
+          def _fmrest_attribute_methods_container
+            @fmrest_attribute_methods_container ||= Module.new.tap { |mod| include mod }
+          end
+
+          def _fmrest_define_attribute(from, to)
+            # We use a setter here instead of injecting the hash key/value pair
+            # directly with #[]= so that we don't change the mapped_attributes
+            # hash on the parent class. The resulting hash is frozen for the
+            # same reason.
+            self.mapped_attributes = mapped_attributes.merge(from => to).freeze
+
+            _fmrest_attribute_methods_container.module_eval do
+              define_method(from) do
+                attribute(to)
+              end
+
+              define_method(:"#{from}=") do |value|
+                send("#{from}_will_change!") unless value == send(from)
+                set_attribute(to, value)
+              end
+            end
+
+            # Define ActiveModel::Dirty's methods
+            define_attribute_method(from)
+          end
+        end
+
+        def id=(value)
+          id_will_change! unless value == id
+          super
+        end
+
+        def save(*_args)
+          super.tap do |r|
+            next unless r.present?
+            changes_applied
+            portals.each(&:parent_changes_applied)
+          end
+        end
+
+        def reload
+          super.tap { |r| clear_changes_information }
+        end
+
+        # Override to_params to return FM Data API's expected JSON format, and
+        # including only modified fields
+        #
+        def to_params
+          params = { fieldData: changed_params_not_embedded_in_url }
+          params[:modId] = mod_id if mod_id
+
+          portal_data = serialize_portals
+          params[:portalData] = portal_data unless portal_data.empty?
+
+          params
+        end
+
+        # ActiveModel::Dirty since version 5.2 assumes that if there's an
+        # @attributes instance variable set we must be using ActiveRecord, so
+        # we override the instance variable name used by Spyke to avoid issues.
+        #
+        # TODO: Submit a pull request to Spyke so this isn't needed
+        #
+        def attributes
+          @_spyke_attributes
+        end
+
+        # In addition to the comments above on `attributes`, this also adds
+        # support for forbidden attributes
+        #
+        def attributes=(new_attributes)
+          @_spyke_attributes ||= ::Spyke::Attributes.new(scope.params)
+          use_setters(sanitize_for_mass_assignment(new_attributes)) if new_attributes && !new_attributes.empty?
+        end
+
+        protected
+
+        def serialize_for_portal(portal)
+          params =
+            changed_params.except(:id).transform_keys do |key|
+              "#{portal.attribute_prefix}::#{key}"
+            end
+
+          params[:recordId] = id if id
+          params[:modId] = mod_id if mod_id
+
+          params
+        end
+
+        private
+
+        def serialize_portals
+          portal_data = {}
+
+          portals.each do |portal|
+            portal.each do |portal_record|
+              next unless portal_record.changed?
+              portal_params = portal_data[portal.portal_key] ||= []
+              portal_params << portal_record.serialize_for_portal(portal)
+            end
+          end
+
+          portal_data
+        end
+
+        def changed_params
+          attributes.to_params.slice(*mapped_changed)
+        end
+
+        def changed_params_not_embedded_in_url
+          params_not_embedded_in_url.slice(*mapped_changed)
+        end
+
+        def mapped_changed
+          mapped_attributes.values_at(*changed)
+        end
+
+        # Use known mapped_attributes for inspect
+        #
+        def inspect_attributes
+          mapped_attributes.except(primary_key).map do |k, v|
+            "#{k}: #{attribute(v).inspect}"
+          end.join(', ')
+        end
+      end
+    end
+  end
+end