fmrest 0.11.0 → 0.14.0

data/lib/fmrest/connection_settings.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  # Wrapper class for connection settings hash, with a number of purposes:
-  #
-  # * Provide indifferent access (base hash can have either string or symbol
-  #   keys)
-  # * Method access
-  # * Default values
-  # * Basic validation
-  # * Normalization (e.g. aliased settings)
-  # * Useful error messages
-  class ConnectionSettings
-    class MissingSetting < ArgumentError; end
-
-    PROPERTIES = %i(
-      host
-      database
-      username
-      password
-      token
-      token_store
-      autologin
-      ssl
-      proxy
-      log
-      coerce_dates
-      date_format
-      timestamp_format
-      time_format
-      timezone
-    ).freeze
-
-    # NOTE: password intentionally left non-required since it's only really
-    # needed when no token exists, and should only be required when logging in
-    REQUIRED = %i(
-      host
-      database
-    ).freeze
-
-    DEFAULT_DATE_FORMAT = "MM/dd/yyyy"
-    DEFAULT_TIME_FORMAT = "HH:mm:ss"
-    DEFAULT_TIMESTAMP_FORMAT = "#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}"
-
-    DEFAULTS = {
-      autologin:        true,
-      log:              false,
-      date_format:      DEFAULT_DATE_FORMAT,
-      time_format:      DEFAULT_TIME_FORMAT,
-      timestamp_format: DEFAULT_TIMESTAMP_FORMAT,
-      coerce_dates:     false
-    }.freeze
-
-    def self.wrap(settings, skip_validation: false)
-      if settings.kind_of?(self)
-        settings.validate unless skip_validation
-        return settings
-      end
-      new(settings, skip_validation: skip_validation)
-    end
-
-    def initialize(settings, skip_validation: false)
-      @settings = settings.to_h.dup
-      normalize
-      validate unless skip_validation
-    end
-
-    PROPERTIES.each do |p|
-      define_method(p) do
-        get(p)
-      end
-
-      define_method("#{p}!") do
-        r = get(p)
-        raise MissingSetting, "Missing required setting: `#{p}'" if r.nil?
-        r
-      end
-
-      define_method("#{p}?") do
-        !!get(p)
-      end
-    end
-
-    def [](key)
-      raise ArgumentError, "Unknown setting `#{key}'" unless PROPERTIES.include?(key.to_sym)
-      get(key)
-    end
-
-    def to_h
-      PROPERTIES.each_with_object({}) do |p, h|
-        v = get(p)
-        h[p] = v unless v == DEFAULTS[p]
-      end
-    end
-
-    def merge(other, **keyword_args)
-      other = self.class.wrap(other, skip_validation: true)
-      self.class.new(to_h.merge(other.to_h), **keyword_args)
-    end
-
-    def validate
-      missing = REQUIRED.select { |r| get(r).nil? }.map { |m| "`#{m}'" }
-      raise MissingSetting, "Missing required setting(s): #{missing.join(', ')}" unless missing.empty?
-
-      unless username? || token?
-        raise MissingSetting, "A minimum of `username' or `token' are required to be able to establish a connection"
-      end
-    end
-
-    private
-
-    def get(key)
-      return @settings[key.to_sym] if @settings.has_key?(key.to_sym)
-      return @settings[key.to_s] if @settings.has_key?(key.to_s)
-      DEFAULTS[key.to_sym]
-    end
-
-    def normalize
-      if !get(:username) && account_name = get(:account_name)
-        @settings[:username] = account_name
-      end
-    end
-  end
-end

data/lib/fmrest/errors.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  class Error < StandardError; end
-
-  class APIError < Error
-    attr_reader :code
-
-    def initialize(code, message = nil)
-      @code = code
-      super("FileMaker Data API responded with error #{code}: #{message}")
-    end
-  end
-
-  class APIError::UnknownError < APIError; end         # error code -1
-  class APIError::ResourceMissingError < APIError; end # error codes 100..199
-  class APIError::RecordMissingError < APIError::ResourceMissingError; end
-  class APIError::AccountError < APIError; end         # error codes 200..299
-  class APIError::LockError < APIError; end            # error codes 300..399
-  class APIError::ParameterError < APIError; end       # error codes 400..499
-  class APIError::NoMatchingRecordsError < APIError::ParameterError; end
-  class APIError::ValidationError < APIError; end      # error codes 500..599
-  class APIError::SystemError < APIError; end          # error codes 800..899
-  class APIError::InvalidToken < APIError; end         # error code 952
-  class APIError::MaximumDataAPICallsExceeded < APIError; end # error code 953
-  class APIError::ScriptError < APIError; end          # error codes 1200..1299
-  class APIError::ODBCError < APIError; end            # error codes 1400..1499
-
-  class ContainerFieldError < Error; end
-end

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