fmrest 0.10.0 → 0.13.0

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/container_field"
-
-module FmRest
-  module Spyke
-    module Model
-      module ContainerFields
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-          def container(name, options = {})
-            field_name = options[:field_name] || name
-
-            define_method(name) do
-              @container_fields ||= {}
-              @container_fields[name.to_sym] ||= ContainerField.new(self, field_name)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module GlobalFields
-        extend ::ActiveSupport::Concern
-
-        FULLY_QUALIFIED_FIELD_NAME_MATCHER = /\A[^:]+::[^:]+\Z/.freeze
-
-        class_methods do
-          def set_globals(values_hash)
-            connection.patch(FmRest::V1.globals_path, {
-              globalFields: normalize_globals_hash(values_hash)
-            })
-          end
-
-          private
-
-          def normalize_globals_hash(hash)
-            hash.each_with_object({}) do |(k, v), normalized|
-              if v.kind_of?(Hash)
-                v.each do |k2, v2|
-                  normalized["#{k}::#{k2}"] = v2
-                end
-                next
-              end
-
-              unless FULLY_QUALIFIED_FIELD_NAME_MATCHER === k.to_s
-                raise ArgumentError, "global fields must be given in fully qualified format (table name::field name)"
-              end
-
-              normalized[k] = v
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/relation"
-
-module FmRest
-  module Spyke
-    module Model
-      module Http
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-
-          # Override Spyke's request method to keep a thread-local copy of the
-          # last request's metadata, so that we can access things like script
-          # execution results after a save, etc.
-
-
-          def request(*args)
-            super.tap do |r|
-              Thread.current[last_request_metadata_key] = r.metadata
-            end
-          end
-
-          def last_request_metadata(key: last_request_metadata_key)
-            Thread.current[key]
-          end
-
-          private
-
-          def last_request_metadata_key
-            "#{to_s}.last_request_metadata"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/relation"
-require "fmrest/spyke/validation_error"
-
-module FmRest
-  module Spyke
-    module Model
-      module Orm
-        extend ::ActiveSupport::Concern
-
-        included do
-          # Allow overriding FM's default limit (by default it's 100)
-          class_attribute :default_limit, instance_accessor: false, instance_predicate: false
-
-          class_attribute :default_sort, instance_accessor: false, instance_predicate: false
-
-          # Whether to raise an FmRest::APIError::NoMatchingRecordsError when a
-          # _find request has no results
-          class_attribute :raise_on_no_matching_records, instance_accessor: false, instance_predicate: false
-        end
-
-        class_methods do
-          # Methods delegated to FmRest::Spyke::Relation
-          delegate :limit, :offset, :sort, :order, :query, :omit, :portal,
-                   :portals, :includes, :with_all_portals, :without_portals,
-                   :script, :find_one, :first, :any, :find_some,
-                   :find_in_batches, :find_each, to: :all
-
-          def all
-            # Use FmRest's Relation instead of Spyke's vanilla one
-            current_scope || Relation.new(self, uri: uri)
-          end
-
-          # Extended fetch to allow properly setting limit, offset and other
-          # options, as well as using the appropriate HTTP method/URL depending
-          # on whether there's a query present in the current scope, e.g.:
-          #
-          #     Person.query(first_name: "Stefan").fetch # POST .../_find
-          #
-          def fetch
-            if current_scope.has_query?
-              scope = extend_scope_with_fm_params(current_scope, prefixed: false)
-              scope = scope.where(query: scope.query_params)
-              scope = scope.with(FmRest::V1::find_path(layout))
-            else
-              scope = extend_scope_with_fm_params(current_scope, prefixed: true)
-            end
-
-            previous, self.current_scope = current_scope, scope
-
-            # The DAPI returns a 401 "No records match the request" error when
-            # nothing matches a _find request, so we need to catch it in order
-            # to provide sane behavior (i.e. return an empty resultset)
-            begin
-              current_scope.has_query? ? scoped_request(:post) : super
-            rescue FmRest::APIError::NoMatchingRecordsError => e
-              raise e if raise_on_no_matching_records
-              ::Spyke::Result.new({})
-            end
-          ensure
-            self.current_scope = previous
-          end
-
-          # API-error-raising version of #create
-          #
-          def create!(attributes = {})
-            new(attributes).tap(&:save!)
-          end
-
-          def execute_script(script_name, param: nil)
-            params = {}
-            params = {"script.param" => param} unless param.nil?
-            request(:get, FmRest::V1::script_path(layout, script_name), params)
-          end
-
-          private
-
-          def extend_scope_with_fm_params(scope, prefixed: false)
-            prefix = prefixed ? "_" : nil
-
-            where_options = {}
-
-            where_options["#{prefix}limit"] = scope.limit_value if scope.limit_value
-            where_options["#{prefix}offset"] = scope.offset_value if scope.offset_value
-
-            if scope.sort_params.present?
-              where_options["#{prefix}sort"] =
-                prefixed ? scope.sort_params.to_json : scope.sort_params
-            end
-
-            unless scope.included_portals.nil?
-              where_options["portal"] =
-                prefixed ? scope.included_portals.to_json : scope.included_portals
-            end
-
-            if scope.portal_params.present?
-              scope.portal_params.each do |portal_param, value|
-                where_options["#{prefix}#{portal_param}"] = value
-              end
-            end
-
-            if scope.script_params.present?
-              where_options.merge!(scope.script_params)
-            end
-
-            scope.where(where_options)
-          end
-        end
-
-        # Overwrite Spyke's save to provide a number of features:
-        #
-        # * Validations
-        # * Data API scripts execution
-        # * Refresh of dirty attributes
-        #
-        def save(options = {})
-          callback = persisted? ? :update : :create
-
-          return false unless perform_save_validations(callback, options)
-          return false unless perform_save_persistence(callback, options)
-
-          true
-        end
-
-        def save!(options = {})
-          save(options.merge(raise_validation_errors: true))
-        end
-
-        # Overwrite Spyke's destroy to provide Data API script execution
-        #
-        def destroy(options = {})
-          # For whatever reason the Data API wants the script params as query
-          # string params for DELETE requests, making this more complicated
-          # than it should be
-          script_query_string = if options.has_key?(:script)
-                                  "?" + Faraday::Utils.build_query(FmRest::V1.convert_script_params(options[:script]))
-                                else
-                                  ""
-                                end
-
-          self.attributes = delete(uri.to_s + script_query_string)
-        end
-
-        # API-error-raising version of #update
-        #
-        def update!(new_attributes, options = {})
-          self.attributes = new_attributes
-          save!(options)
-        end
-
-        def reload(options = {})
-          scope = self.class
-          scope = scope.script(options[:script]) if options.has_key?(:script)
-          reloaded = scope.find(id)
-          self.attributes = reloaded.attributes
-          self.mod_id = reloaded.mod_id
-        end
-
-        # ActiveModel 5+ implements this method, so we only needed if we're in
-        # the older AM4
-        if ActiveModel::VERSION::MAJOR == 4
-          def validate!(context = nil)
-            valid?(context) || raise_validation_error
-          end
-        end
-
-        private
-
-        def perform_save_validations(context, options)
-          return true if options[:validate] == false
-          options[:raise_validation_errors] ? validate!(context) : validate(context)
-        end
-
-        def perform_save_persistence(callback, options)
-          run_callbacks :save do
-            run_callbacks(callback) do
-
-              begin
-                send self.class.method_for(callback), build_params_for_save(options)
-
-              rescue APIError::ValidationError => e
-                if options[:raise_validation_errors]
-                  raise e
-                else
-                  return false
-                end
-              end
-
-            end
-          end
-
-          true
-        end
-
-        def build_params_for_save(options)
-          to_params.tap do |params|
-            if options.has_key?(:script)
-              params.merge!(FmRest::V1.convert_script_params(options[:script]))
-            end
-          end
-        end
-
-        # Overwrite ActiveModel's raise_validation_error to use our own class
-        #
-        def raise_validation_error # :doc:
-          raise(ValidationError.new(self))
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Serialization
-        FM_DATE_FORMAT = "%m/%d/%Y"
-        FM_DATETIME_FORMAT = "#{FM_DATE_FORMAT} %H:%M:%S"
-
-        # Override Spyke's to_params to return FM Data API's expected JSON
-        # format, and including only modified fields
-        #
-        def to_params
-          params = {
-            fieldData: serialize_values!(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
-
-        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
-
-          serialize_values!(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_not_embedded_in_url
-          params_not_embedded_in_url.slice(*mapped_changed)
-        end
-
-        # Modifies the given hash in-place encoding non-string values (e.g.
-        # dates) to their string representation when appropriate.
-        #
-        def serialize_values!(params)
-          params.transform_values! do |value|
-            case value
-            when DateTime, Time, FmRest::StringDateTime
-              convert_datetime_timezone(value.to_datetime).strftime(FM_DATETIME_FORMAT)
-            when Date, FmRest::StringDate
-              value.strftime(FM_DATE_FORMAT)
-            else
-              value
-            end
-          end
-
-          params
-        end
-
-        def convert_datetime_timezone(dt)
-          case fmrest_config.fetch(:timezone, nil)
-          when :utc, "utc"
-            dt.new_offset(0)
-          when :local, "local"
-            dt.new_offset(FmRest::V1.local_offset_for_datetime(dt))
-          when nil
-            dt
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Uri
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-          # Accessor for FM layout (helps with building the URI)
-          #
-          def layout(layout = nil)
-            @layout = layout if layout
-            @layout ||= model_name.name
-          end
-
-          # Extend uri acccessor to default to FM Data schema
-          #
-          def uri(uri_template = nil)
-            if @uri.nil? && uri_template.nil?
-              return FmRest::V1.record_path(layout) + "(/:id)"
-            end
-
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fmrest/spyke/portal.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    # Extend Spyke's HasMany association with custom options
-    #
-    class Portal < ::Spyke::Associations::HasMany
-      def initialize(*args)
-        super
-
-        # Portals are always embedded, so no special URI
-        @options[:uri] = ""
-      end
-
-      def portal_key
-        return @options[:portal_key] if @options[:portal_key]
-        name
-      end
-
-      def attribute_prefix
-        @options[:attribute_prefix] || portal_key
-      end
-
-      def parent_changes_applied
-        each do |record|
-          record.changes_applied
-          # Saving portal data doesn't provide new modIds for the
-          # portal records, so we clear them instead. We can still save
-          # portal data without a mod_id (it's optional in FM Data API)
-          record.mod_id = nil
-        end
-      end
-
-      private
-
-      # Spyke::Associations::HasMany#initialize calls primary_key to build the
-      # default URI, which causes a NameError, so this is here just to prevent
-      # that. We don't care what it returns as we override the URI with nil
-      # anyway
-      def primary_key; end
-
-      # Make sure the association doesn't try to fetch records through URI
-      def uri; nil; end
-
-      def embedded_data
-        parent.attributes[portal_key]
-      end
-
-      def add_to_parent(record)
-        find_some << record
-        record
-      end
-    end
-  end
-end