fmrest 0.10.0 → 0.13.0

data/lib/fmrest/spyke.rb

@@ -1,21 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    class Base < ::Spyke::Base
-      include FmRest::Spyke::Model
-    end
-
-    class << self
-      def Base(config = nil)
-        warn "[DEPRECATION] Inheriting from `FmRest::Spyke::Base(config)` is deprecated and will be removed, inherit from `FmRest::Spyke::Base` (without arguments) and use `fmrest_config=` instead"
-
-        if config
-          return Class.new(::FmRest::Spyke::Base) do
-                   self.fmrest_config = config
-                 end
-        end
-
-        ::FmRest::Spyke::Base
-      end
-    end
-  end
-end

data/lib/fmrest/spyke/container_field.rb

@@ -1,59 +0,0 @@
-# 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.id, name, repetition)
-      end
-    end
-  end
-end

data/lib/fmrest/spyke/model.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/model/connection"
-require "fmrest/spyke/model/uri"
-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 Attributes
-      include Serialization
-      include Associations
-      include Orm
-      include ContainerFields
-      include GlobalFields
-      include Http
-      include Auth
-
-      included do
-        # @return [Integer] the record's modId
-        attr_accessor :mod_id
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-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 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
-        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 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
-
-        # 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

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/spyke/model/orm"
-
-module FmRest
-  module Spyke
-    module Model
-      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
-
-          # 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
-
-          # 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
-        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 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)
-            raise ArgumentError, "attribute name `id' is reserved for the recordId" if from.to_s == "id"
-
-            # 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 reload(*args)
-          super.tap { |r| clear_changes_information }
-        end
-
-        def save(*args)
-          super.tap { |r| changes_applied_after_save if r }
-        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
-
-        private
-
-        def changed_params
-          attributes.to_params.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
-
-        def changes_applied_after_save
-          changes_applied
-          portals.each(&:parent_changes_applied)
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Auth
-        extend ::ActiveSupport::Concern
-
-        class_methods do
-          # Logs out the database session for this model (and other models
-          # using the same credentials).
-          #
-          # @raise [FmRest::V1::TokenSession::NoSessionTokenSet] if no session
-          #   token was set (and no request is sent).
-          def logout!
-            connection.delete(FmRest::V1.session_path("dummy-token"))
-          end
-
-          # Logs out the database session for this model (and other models
-          # using the same credentials). Unlike `logout!`, no exception is
-          # raised in case of missing session token.
-          #
-          # @return [Boolean] Whether the logout request was sent (it's only
-          #   sent if a session token was previously set)
-          def logout
-            logout!
-            true
-          rescue FmRest::V1::TokenSession::NoSessionTokenSet
-            false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    module Model
-      module Connection
-        extend ActiveSupport::Concern
-
-        included do
-          class_attribute :fmrest_config, instance_writer: false, instance_predicate: false
-
-          # Overrides the fmrest_config reader created by class_attribute so we
-          # can default set the default at call time.
-          #
-          # This method gets overwriten in subclasses if self.fmrest_config= is
-          # called.
-          define_singleton_method(:fmrest_config) do
-            FmRest.default_connection_settings
-          end
-
-          class_attribute :faraday_block, instance_accessor: false, instance_predicate: false
-          class << self; private :faraday_block, :faraday_block=; end
-
-          # FM Data API expects PATCH for updates (Spyke's default was PUT)
-          self.callback_methods = { create: :post, update: :patch }.freeze
-        end
-
-        class_methods do
-          def connection
-            super || fmrest_connection
-          end
-
-          # Sets a block for injecting custom middleware into the Faraday
-          # connection. Example usage:
-          #
-          #     class MyModel < FmRest::Spyke::Base
-          #       faraday do |conn|
-          #         # Set up a custom logger for the model
-          #         conn.response :logger, MyApp.logger, bodies: true
-          #       end
-          #     end
-          #
-          def faraday(&block)
-            self.faraday_block = block
-          end
-
-          private
-
-          def fmrest_connection
-            @fmrest_connection ||=
-              begin
-                config = fmrest_config
-
-                FmRest::V1.build_connection(config) do |conn|
-                  faraday_block.call(conn) if faraday_block
-
-                  # Pass the class to SpykeFormatter's initializer so it can have
-                  # access to extra context defined in the model, e.g. a portal
-                  # where name of the portal and the attributes prefix don't match
-                  # and need to be specified as options to `portal`
-                  conn.use FmRest::Spyke::SpykeFormatter, self
-
-                  conn.use FmRest::V1::TypeCoercer, config
-
-                  # FmRest::Spyke::JsonParse expects symbol keys
-                  conn.response :json, parser_options: { symbolize_names: true }
-                end
-              end
-          end
-        end
-      end
-    end
-  end
-end