fmrest-spyke 0.13.0

data/lib/fmrest-spyke.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "fmrest/spyke"

data/lib/fmrest/spyke.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+begin
+  require "spyke"
+rescue LoadError => e
+  e.message << " (Did you include Spyke in your Gemfile?)" unless e.message.frozen?
+  raise e
+end
+
+require "fmrest"
+require "fmrest/spyke/spyke_formatter"
+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,9 @@
+# frozen_string_literal: true
+
+module FmRest
+  module Spyke
+    class Base < ::Spyke::Base
+      include FmRest::Spyke::Model
+    end
+  end
+end

data/lib/fmrest/spyke/container_field.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FmRest
+  module Spyke
+    class ContainerField
+
+      # @return [String] the name of the container field
+      attr_reader :name
+
+      # @param base [FmRest::Spyke::Base] the record this container belongs to
+      # @param name [Symbol] the name of the container field
+      def initialize(base, name)
+        @base = base
+        @name = name
+      end
+
+      # @return [String] the URL for the container
+      def url
+        @base.attributes[name]
+      end
+
+      # @return (see FmRest::V1::ContainerFields#fetch_container_data)
+      def download
+        FmRest::V1.fetch_container_data(url, @base.class.connection)
+      end
+
+      # @param filename_or_io [String, IO] a path to the file to upload or an
+      #   IO object
+      # @param options [Hash]
+      # @option options [Integer] :repetition (1) The repetition to pass to the
+      #   upload URL
+      # @option (see FmRest::V1::ContainerFields#upload_container_data)
+      def upload(filename_or_io, options = {})
+        raise ArgumentError, "Record needs to be saved before uploading to a container field" unless @base.persisted?
+
+        response =
+          FmRest::V1.upload_container_data(
+            @base.class.connection,
+            upload_path(options[:repetition] || 1),
+            filename_or_io,
+            options
+          )
+
+        # Update mod id on record
+        @base.__mod_id = response.body[:data][:__mod_id]
+
+        true
+      end
+
+      private
+
+      # @param repetition [Integer]
+      # @return [String] the path for uploading a file to the container
+      def upload_path(repetition)
+        FmRest::V1.container_field_path(@base.class.layout, @base.__record_id, name, repetition)
+      end
+    end
+  end
+end

data/lib/fmrest/spyke/model.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "fmrest/spyke/model/connection"
+require "fmrest/spyke/model/uri"
+require "fmrest/spyke/model/record_id"
+require "fmrest/spyke/model/attributes"
+require "fmrest/spyke/model/serialization"
+require "fmrest/spyke/model/associations"
+require "fmrest/spyke/model/orm"
+require "fmrest/spyke/model/container_fields"
+require "fmrest/spyke/model/global_fields"
+require "fmrest/spyke/model/http"
+require "fmrest/spyke/model/auth"
+
+module FmRest
+  module Spyke
+    module Model
+      extend ::ActiveSupport::Concern
+
+      include Connection
+      include URI
+      include RecordID
+      include Attributes
+      include Serialization
+      include Associations
+      include Orm
+      include ContainerFields
+      include GlobalFields
+      include Http
+      include Auth
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "fmrest/spyke/portal"
+
+module FmRest
+  module Spyke
+    module Model
+      # This module adds portal support to Spyke models.
+      #
+      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 SpykeFormatter
+          class_attribute :portal_options, instance_accessor: false, instance_predicate: false
+
+          # class_attribute supports a :default option since ActiveSupport 5.2,
+          # but we want to support previous versions too so we set the default
+          # manually instead
+          self.portal_options = {}.freeze
+
+          class << self; private :portal_options=; end
+
+          set_callback :save, :after, :remove_marked_for_destruction
+        end
+
+        class_methods do
+          # Based on Spyke's `has_many`, but creates a special Portal
+          # association instead.
+          #
+          # @option :portal_key [String] The key used for the portal in the FM
+          #   Data JSON portalData
+          # @option :attribute_prefix [String] The prefix used for portal
+          #   attributes in the FM Data JSON
+          #
+          # @example
+          #   class Person < FmRest::Spyke::Base
+          #     has_portal :jobs, portal_key: "JobsTable", attribute_prefix: "Job"
+          #   end
+          #
+          def has_portal(name, options = {})
+            create_association(name, Portal, options)
+
+            # Store options for SpykeFormatter 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
+
+        # Spyke override -- 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
+
+        # Spyke override -- Add portals awareness
+        #
+        def reload(*_)
+          super.tap { @loaded_portals = nil }
+        end
+
+        # @return [Array<FmRest::Spyke::Portal>] A collection of portal
+        #   relations for the record
+        #
+        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
+
+        # Signals that this record has been marked for being deleted next time
+        # its parent record is saved (e.g. in a portal association)
+        #
+        # This method is named after ActiveRecord's namesake
+        #
+        def mark_for_destruction
+          @marked_for_destruction = true
+        end
+        alias_method :mark_for_deletion, :mark_for_destruction
+
+        def marked_for_destruction?
+          !!@marked_for_destruction
+        end
+        alias_method :marked_for_deletion?, :marked_for_destruction?
+
+        # Signals that this record has been embedded in a portal so we can make
+        # sure to include it in the next update request
+        #
+        def embedded_in_portal
+          @embedded_in_portal = true
+        end
+
+        def embedded_in_portal?
+          !!@embedded_in_portal
+        end
+
+        # Override ActiveModel::Dirty's method to include clearing
+        # of `@embedded_in_portal` and `@marked_for_destruction`
+        #
+        def changes_applied
+          super
+          @embedded_in_portal = nil
+          @marked_for_destruction = nil
+        end
+
+        # Override ActiveModel::Dirty's method to include awareness
+        # of `@embedded_in_portal`
+        #
+        def changed?
+          super || embedded_in_portal?
+        end
+
+        # Takes care of updating the new portal record's recordIds and modIds.
+        #
+        # Called when saving a record with freshly added portal records, this
+        # method is not meant to be called manually.
+        #
+        # @param [Hash] data The hash containing newPortalData from the DAPI
+        #   response
+        def __new_portal_record_info=(data)
+          data.each do |d|
+            table_name = d[:tableName]
+
+            portal_new_records =
+              portals.detect { |p| p.portal_key == table_name }.select { |r| !r.persisted? }
+
+            # The DAPI provides only one recordId for the entire portal in the
+            # newPortalRecordInfo object. This appears to be the recordId of
+            # the last portal record created, so we assume all portal records
+            # coming before it must have sequential recordIds up to the one we
+            # do have.
+            portal_new_records.reverse_each.with_index do |record, i|
+              record.__record_id = d[:recordId].to_i - i
+
+              # New records get a fresh modId
+              record.__mod_id = 0
+            end
+          end
+        end
+
+        private
+
+        def remove_marked_for_destruction
+          portals.each(&:_remove_marked_for_destruction)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fmrest/spyke/model/orm"
+
+module FmRest
+  module Spyke
+    module Model
+      # Extends Spyke models with support for mapped attributes,
+      # `ActiveModel::Dirty` and forbidden attributes (e.g. Rails'
+      # `params.permit`).
+      #
+      module Attributes
+        extend ::ActiveSupport::Concern
+
+        include Orm # Needed to extend custom save and reload
+
+        include ::ActiveModel::Dirty
+        include ::ActiveModel::ForbiddenAttributesProtection
+
+        included do
+          # 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
+
+          # 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
+
+          # class_attribute supports a :default option since ActiveSupport 5.2,
+          # but we want to support previous versions too so we set the default
+          # manually instead
+          self.mapped_attributes = ::ActiveSupport::HashWithIndifferentAccess.new.freeze
+
+          class << self; private :mapped_attributes=; end
+
+          set_callback :save, :after, :changes_applied_after_save
+        end
+
+        class_methods do
+          # Spyke override
+          #
+          # 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
+
+          # Spyke override (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 do |record|
+              # In ActiveModel 4.x #clear_changes_information is a private
+              # method, so we need to call it with send() in that case, but
+              # keep calling it normally for AM5+
+              if record.respond_to?(:clear_changes_information)
+                record.clear_changes_information
+              else
+                record.send(:clear_changes_information)
+              end
+            end
+          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
+
+        # Spyke override -- Adds AM::Dirty support
+        #
+        def reload(*args)
+          super.tap { |r| clear_changes_information }
+        end
+
+        # Spyke override -- Adds support for forbidden attributes (i.e. Rails'
+        # `params.permit`, etc.)
+        #
+        def attributes=(new_attributes)
+          @spyke_attributes ||= ::Spyke::Attributes.new(scope.params)
+          return unless new_attributes && !new_attributes.empty?
+          use_setters(sanitize_for_mass_assignment(new_attributes))
+        end
+
+        private
+
+        def changed_params
+          attributes.to_params.slice(*mapped_changed)
+        end
+
+        def mapped_changed
+          mapped_attributes.values_at(*changed)
+        end
+
+        # Spyke override (private) -- 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
+
+        def changes_applied_after_save
+          changes_applied
+          portals.each(&:parent_changes_applied)
+        end
+      end
+    end
+  end
+end