fmrest 0.12.0 → 0.13.0

data/lib/fmrest/spyke/spyke_formatter.rb

@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "ostruct"
-
-module FmRest
-  module Spyke
-    # Metadata class to be passed to Spyke::Collection#metadata
-    class Metadata < Struct.new(:messages, :script, :data_info)
-      alias_method :scripts, :script
-    end
-
-    class DataInfo < OpenStruct
-      def total_record_count; totalRecordCount; end
-      def found_count; foundCount; end
-      def returned_count; returnedCount; end
-    end
-
-    # Response Faraday middleware for converting FM API's response JSON into
-    # Spyke's expected format
-    class SpykeFormatter < ::Faraday::Response::Middleware
-      SINGLE_RECORD_RE = %r(/records/\d+\z).freeze
-      MULTIPLE_RECORDS_RE = %r(/records\z).freeze
-      CONTAINER_RE = %r(/records/\d+/containers/[^/]+/\d+\z).freeze
-      FIND_RECORDS_RE = %r(/_find\b).freeze
-      SCRIPT_REQUEST_RE = %r(/script/[^/]+\z).freeze
-
-      VALIDATION_ERROR_RANGE = 500..599
-
-      # @param app [#call]
-      # @param model [Class<FmRest::Spyke::Base>]
-      def initialize(app, model)
-        super(app)
-        @model = model
-      end
-
-      # @param env [Faraday::Env]
-      def on_complete(env)
-        return unless env.body.is_a?(Hash)
-
-        json = env.body
-
-        case
-        when single_record_request?(env)
-          env.body = prepare_single_record(json)
-        when multiple_records_request?(env), find_request?(env)
-          env.body = prepare_collection(json)
-        when create_request?(env), update_request?(env), delete_request?(env), container_upload_request?(env)
-          env.body = prepare_save_response(json)
-        when execute_script_request?(env)
-          env.body = build_base_hash(json)
-        else
-          # Attempt to parse unknown requests too
-          env.body = build_base_hash(json)
-        end
-      end
-
-      private
-
-      # @param json [Hash]
-      # @return [Hash] the response in Spyke format
-      def prepare_save_response(json)
-        response = json[:response]
-
-        data = {}
-        data[:__mod_id] = response[:modId] if response[:modId]
-        data[:__record_id] = response[:recordId].to_i if response[:recordId]
-
-        build_base_hash(json, true).merge!(data: data)
-      end
-
-      # (see #prepare_save_response)
-      def prepare_single_record(json)
-        data =
-          json[:response][:data] &&
-          prepare_record_data(json[:response][:data].first)
-
-        build_base_hash(json).merge!(data: data)
-      end
-
-      # (see #prepare_save_response)
-      def prepare_collection(json)
-        data =
-          json[:response][:data] &&
-          json[:response][:data].map { |record_data| prepare_record_data(record_data) }
-
-        build_base_hash(json).merge!(data: data)
-      end
-
-      # @param json [Hash]
-      # @param include_errors [Boolean]
-      # @return [FmRest::Spyke::Metadata] the skeleton structure for a
-      #   Spyke-formatted response
-      def build_base_hash(json, include_errors = false)
-        {
-          metadata: Metadata.new(
-            prepare_messages(json),
-            prepare_script_results(json),
-            prepare_data_info(json)
-          ).freeze,
-          errors: include_errors ? prepare_errors(json) : {}
-        }
-      end
-
-      # @param json [Hash]
-      # @return [Array<OpenStruct>] the skeleton structure for a
-      #   Spyke-formatted response
-      def prepare_messages(json)
-        return [] unless json[:messages]
-        json[:messages].map { |m| OpenStruct.new(m).freeze }.freeze
-      end
-
-      # @param json [Hash]
-      # @return [OpenStruct] the script(s) execution results for Spyke metadata
-      #   format
-      def prepare_script_results(json)
-        results = {}
-
-        [:prerequest, :presort].each do |s|
-          if json[:response][:"scriptError.#{s}"]
-            results[s] = OpenStruct.new(
-              result: json[:response][:"scriptResult.#{s}"],
-              error:  json[:response][:"scriptError.#{s}"]
-            ).freeze
-          end
-        end
-
-        if json[:response][:scriptError]
-          results[:after] = OpenStruct.new(
-            result: json[:response][:scriptResult],
-            error:  json[:response][:scriptError]
-          ).freeze
-        end
-
-        results.present? ? OpenStruct.new(results).freeze : nil
-      end
-
-      # @param json [Hash]
-      # @return [OpenStruct] the script(s) execution results for
-      #   Spyke metadata format
-      def prepare_data_info(json)
-        data_info = json[:response] && json[:response][:dataInfo]
-
-        return nil unless data_info.present?
-
-        DataInfo.new(data_info).freeze
-      end
-
-      # @param json [Hash]
-      # @return [Hash] the errors hash in Spyke format
-      def prepare_errors(json)
-        # Code 0 means "No Error"
-        # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
-        return {} if json[:messages][0][:code].to_i == 0
-
-        json[:messages].each_with_object(base: []) do |message, hash|
-          # Only include validation errors
-          next unless VALIDATION_ERROR_RANGE.include?(message[:code].to_i)
-
-          hash[:base] << "#{message[:message]} (#{message[:code]})"
-        end
-      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>
-      #     }
-      #
-      # @param json_data [Hash]
-      # @return [Hash] the record data in Spyke format
-      def prepare_record_data(json_data)
-        out = { __record_id: json_data[:recordId].to_i, __mod_id: json_data[:modId] }
-        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" }
-      #       ]
-      #     }
-      #
-      # @param json_portal_data [Hash]
-      # @return [Hash] the portal data in Spyke format
-      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 = { __record_id: portal_fields[:recordId].to_i }
-              attributes[:__mod_id] = portal_fields[:modId] 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, "").to_sym] = v
-              end
-
-              attributes
-            end
-        end
-      end
-
-      # @param env [Faraday::Env]
-      # @return [Boolean]
-      def single_record_request?(env)
-        env.method == :get && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      # (see #single_record_request?)
-      def multiple_records_request?(env)
-        env.method == :get && env.url.path.match(MULTIPLE_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def find_request?(env)
-        env.method == :post && env.url.path.match(FIND_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def update_request?(env)
-        env.method == :patch && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      # (see #single_record_request?)
-      def create_request?(env)
-        env.method == :post && env.url.path.match(MULTIPLE_RECORDS_RE)
-      end
-
-      # (see #single_record_request?)
-      def container_upload_request?(env)
-        env.method == :post && env.url.path.match(CONTAINER_RE)
-      end
-
-      # (see #single_record_request?)
-      def delete_request?(env)
-        env.method == :delete && env.url.path.match(SINGLE_RECORD_RE)
-      end
-
-      def execute_script_request?(env)
-        env.method == :get && env.url.path.match(SCRIPT_REQUEST_RE)
-      end
-    end
-  end
-end

data/lib/fmrest/spyke/validation_error.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module Spyke
-    # ActiveModel 4 doesn't include a ValidationError class, which we want to
-    # raise when model.validate! fails.
-    #
-    # In order to break the least amount of code that uses AM5+, while still
-    # supporting AM4 we use this proxy class that inherits from
-    # AM::ValidationError if it's there, or reimplements it otherwise
-    if defined?(::ActiveModel::ValidationError)
-      class ValidationError < ::ActiveModel::ValidationError; end
-    else
-      class ValidationError < StandardError
-        attr_reader :model
-
-        def initialize(model)
-          @model = model
-          errors = @model.errors.full_messages.join(", ")
-          super("Invalid model: #{errors}")
-        end
-      end
-    end
-  end
-end

data/lib/fmrest/string_date.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-
-module FmRest
-  # Gotchas:
-  #
-  # 1.
-  #
-  #   Date === <StringDate instance> # => false
-  #
-  # The above can affect case conditions, as trying to match a StringDate
-  # with:
-  #
-  #   case obj
-  #   when Date
-  #     ...
-  #
-  # ...will not work.
-  #
-  # Instead one must specify the FmRest::StringDate class:
-  #
-  #   case obj
-  #   when Date, FmRest::StringDate
-  #     ...
-  #
-  # 2.
-  #
-  # StringDate#eql? only matches other strings, not dates.
-  #
-  # This could affect hash indexing when a StringDate is used as a key.
-  #
-  # TODO: Verify the above
-  #
-  # 3.
-  #
-  # StringDate#succ and StringDate#next return a String, despite Date#succ
-  # and Date#next also existing.
-  #
-  # Workaround: Use StringDate#next_day or strdate + 1
-  #
-  # 4.
-  #
-  # StringDate#to_s returns the original string, not the Date string
-  # representation.
-  #
-  # Workaround: Use strdate.to_date.to_s
-  #
-  # 5.
-  #
-  # StringDate#hash returns the hash for the string (important when using
-  # a StringDate as a hash key)
-  #
-  # 6.
-  #
-  # StringDate#as_json returns the string
-  #
-  # Workaround: Use strdate.to_date.as_json
-  #
-  # 7.
-  #
-  # Equality with Date is not reciprocal:
-  #
-  #   str_date == date #=> true
-  #   date == str_date #=> false
-  #
-  # NOTE: Potential workaround: Inherit StringDate from Date instead of String
-  #
-  # 8.
-  #
-  # Calling string transforming methods (e.g. .upcase) returns a StringDate
-  # instead of a String.
-  #
-  # NOTE: Potential workaround: Inherit StringDate from Date instead of String
-  #
-  class StringDate < String
-    DELEGATE_CLASS = ::Date
-
-    class InvalidDate < ArgumentError; end
-
-    class << self
-      def strptime(str, date_format, *_)
-        begin
-          date = self::DELEGATE_CLASS.strptime(str, date_format)
-        rescue ArgumentError
-          raise InvalidDate
-        end
-
-        new(str, date)
-      end
-    end
-
-    def initialize(str, date, **str_args)
-      raise ArgumentError, "str must be of class String" unless str.is_a?(String)
-      raise ArgumentError, "date must be of class #{self.class::DELEGATE_CLASS.name}" unless date.is_a?(self.class::DELEGATE_CLASS)
-
-      super(str, **str_args)
-
-      @delegate = date
-
-      freeze
-    end
-
-    def is_a?(klass)
-      klass == ::Date || super
-    end
-    alias_method :kind_of?, :is_a?
-
-    def to_date
-      @delegate
-    end
-
-    def to_datetime
-      @delegate.to_datetime
-    end
-
-    def to_time
-      @delegate.to_time
-    end
-
-    # ActiveSupport method
-    def in_time_zone(*_)
-      @delegate.in_time_zone(*_)
-    end
-
-    def inspect
-      "#<#{self.class.name} #{@delegate.inspect} - #{super}>"
-    end
-
-    def <=>(oth)
-      return @delegate <=> oth if oth.is_a?(::Date) || oth.is_a?(Numeric)
-      super
-    end
-
-    def +(val)
-      return @delegate + val if val.kind_of?(Numeric)
-      super
-    end
-
-    def <<(val)
-      return @delegate << val if val.kind_of?(Numeric)
-      super
-    end
-
-    def ==(oth)
-      return @delegate == oth if oth.kind_of?(::Date) || oth.kind_of?(Numeric)
-      super
-    end
-    alias_method :===, :==
-
-    def upto(oth, &blk)
-      return @delegate.upto(oth, &blk) if oth.kind_of?(::Date) || oth.kind_of?(Numeric)
-      super
-    end
-
-    def between?(a, b)
-      return @delegate.between?(a, b) if [a, b].any? {|o| o.is_a?(::Date) || o.is_a?(Numeric) }
-      super
-    end
-
-    private
-
-    def respond_to_missing?(name, include_private = false)
-      @delegate.respond_to?(name, include_private)
-    end
-
-    def method_missing(method, *args, &block)
-      @delegate.send(method, *args, &block)
-    end
-  end
-
-  class StringDateTime < StringDate
-    DELEGATE_CLASS = ::DateTime
-
-    def is_a?(klass)
-      klass == ::DateTime || super
-    end
-    alias_method :kind_of?, :is_a?
-
-    def to_date
-      @delegate.to_date
-    end
-
-    def to_datetime
-      @delegate
-    end
-  end
-
-  module StringDateAwareness
-    def _parse(v, *_)
-      if v.is_a?(StringDateTime)
-        return { year: v.year, mon: v.month, mday: v.mday, hour: v.hour, min: v.min, sec: v.sec, sec_fraction: v.sec_fraction, offset: v.offset }
-      end
-      if v.is_a?(StringDate)
-        return { year: v.year, mon: v.month, mday: v.mday }
-      end
-      super
-    end
-
-    def parse(v, *_)
-      if v.is_a?(StringDate)
-        return self == ::DateTime ? v.to_datetime : v.to_date
-      end
-      super
-    end
-
-    # Overriding case equality method so that it returns true for
-    # `FmRest::StringDate` instances
-    #
-    # Calls superclass method
-    #
-    def ===(other)
-      super || other.is_a?(StringDate)
-    end
-
-    def self.enable(classes: [Date, DateTime])
-      classes.each { |klass| klass.singleton_class.prepend(self) }
-    end
-  end
-end