fmrest 0.10.0 → 0.13.0

data/lib/fmrest/v1/token_store/active_record.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-warn "FmRest::V1::TokenStore::ActiveRecord is deprecated, use FmRest::TokenStore::ActiveRecord instead"
-
-require "fmrest/token_store/active_record"
-
-module FmRest
-  module V1
-    module TokenStore
-      ActiveRecord = ::FmRest::TokenStore::ActiveRecord
-    end
-  end
-end

data/lib/fmrest/v1/token_store/memory.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-warn "FmRest::V1::TokenStore::Memory is deprecated, use FmRest::TokenStore::Memory instead"
-
-require "fmrest/token_store/memory"
-
-module FmRest
-  module V1
-    module TokenStore
-      Memory = ::FmRest::TokenStore::Memory
-    end
-  end
-end

data/lib/fmrest/v1/type_coercer.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/string_date"
-
-module FmRest
-  module V1
-    class TypeCoercer < Faraday::Response::Middleware
-      # We use this date to represent a FileMaker time for consistency with
-      # ginjo-rfm
-      JULIAN_ZERO_DAY = "-4712/1/1"
-
-      COERCE_HYBRID = [:hybrid, "hybrid", true].freeze
-      COERCE_FULL = [:full, "full"].freeze
-
-      # @param app [#call]
-      # @param options [Hash]
-      def initialize(app, options = FmRest.default_connection_settings)
-        super(app)
-        @options = options
-      end
-
-      def on_complete(env)
-        return unless enabled?
-        return unless env.body.kind_of?(Hash)
-
-        data = env.body.dig("response", "data") || env.body.dig(:response, :data)
-
-        return unless data
-
-        data.each do |record|
-          field_data = record["fieldData"] || record[:fieldData]
-          portal_data = record["portalData"] || record[:portalData]
-
-          coerce_fields(field_data)
-
-          portal_data.try(:each_value) do |portal_records|
-            portal_records.each do |pr|
-              coerce_fields(pr)
-            end
-          end
-        end
-      end
-
-      private
-
-      def coerce_fields(hash)
-        hash.each do |k, v|
-          next unless v.is_a?(String)
-          next if k == "recordId" || k == :recordId || k == "modId" || k == :modId
-
-          if quick_check_timestamp(v)
-            begin
-              hash[k] = coerce_timestamp(v)
-              next
-            rescue ArgumentError
-            end
-          end
-
-          if quick_check_date(v)
-            begin
-              hash[k] = date_class.strptime(v, date_strptime_format)
-              next
-            rescue ArgumentError
-            end
-          end
-
-          if quick_check_time(v)
-            begin
-              hash[k] = datetime_class.strptime("#{JULIAN_ZERO_DAY} #{v}", time_strptime_format)
-              next
-            rescue ArgumentError
-            end
-          end
-        end
-      end
-
-      def coerce_timestamp(str)
-        str_timestamp = DateTime.strptime(str, datetime_strptime_format)
-
-        if local_timezone?
-          # Change the DateTime to the local timezone, keeping the same
-          # time and just modifying the timezone
-          offset = FmRest::V1.local_offset_for_datetime(str_timestamp)
-          str_timestamp = str_timestamp.new_offset(offset) - offset
-        end
-
-        if datetime_class == StringDateTime
-          str_timestamp = StringDateTime.new(str, str_timestamp)
-        end
-
-        str_timestamp
-      end
-
-      def date_class
-        @date_class ||=
-          case coerce_dates
-          when *COERCE_HYBRID
-            StringDate
-          when *COERCE_FULL
-            Date
-          end
-      end
-
-      def datetime_class
-        @datetime_class ||=
-          case coerce_dates
-          when *COERCE_HYBRID
-            StringDateTime
-          when *COERCE_FULL
-            DateTime
-          end
-      end
-
-      def date_fm_format
-        @options[:date_format] || DEFAULT_DATE_FORMAT
-      end
-
-      def timestamp_fm_format
-        @options[:timestamp_format] || DEFAULT_TIMESTAMP_FORMAT
-      end
-
-      def time_fm_format
-        @options[:time_format] || DEFAULT_TIME_FORMAT
-      end
-
-      def date_strptime_format
-        FmRest::V1.fm_date_to_strptime_format(date_fm_format)
-      end
-
-      def datetime_strptime_format
-        FmRest::V1.fm_date_to_strptime_format(timestamp_fm_format)
-      end
-
-      def time_strptime_format
-        @time_strptime_format ||=
-          "%Y/%m/%d " + FmRest::V1.fm_date_to_strptime_format(time_fm_format)
-      end
-
-      # We use a string length test, followed by regexp match test to try to
-      # identify date fields. Benchmarking shows this should be between 1 and 3
-      # orders of magnitude faster for fails (i.e. non-dates) than just using
-      # Date.strptime.
-      #
-      #                       user     system      total        real
-      # strptime:         0.268496   0.000962   0.269458 (  0.270865)
-      # re=~:             0.024872   0.000070   0.024942 (  0.025057)
-      # re.match?:        0.019745   0.000095   0.019840 (  0.020058)
-      # strptime fail:    0.141309   0.000354   0.141663 (  0.142266)
-      # re=~ fail:        0.031637   0.000095   0.031732 (  0.031872)
-      # re.match? fail:   0.011249   0.000056   0.011305 (  0.011375)
-      # length fail:      0.007177   0.000024   0.007201 (  0.007222)
-      #
-      # NOTE: The faster Regexp#match? was introduced in Ruby 2.4.0, so we
-      # can't really rely on it being available
-      if //.respond_to?(:match?)
-        def quick_check_timestamp(v)
-          v.length == timestamp_fm_format.length && FmRest::V1::fm_date_to_regexp(timestamp_fm_format).match?(v)
-        end
-
-        def quick_check_date(v)
-          v.length == date_fm_format.length && FmRest::V1::fm_date_to_regexp(date_fm_format).match?(v)
-        end
-
-        def quick_check_time(v)
-          v.length == time_fm_format.length && FmRest::V1::fm_date_to_regexp(time_fm_format).match?(v)
-        end
-      else
-        def quick_check_timestamp(v)
-          v.length == timestamp_fm_format.length && FmRest::V1::fm_date_to_regexp(timestamp_fm_format) =~ v
-        end
-
-        def quick_check_date(v)
-          v.length == date_fm_format.length && FmRest::V1::fm_date_to_regexp(date_fm_format) =~ v
-        end
-
-        def quick_check_time(v)
-          v.length == time_fm_format.length && FmRest::V1::fm_date_to_regexp(time_fm_format) =~ v
-        end
-      end
-
-      def local_timezone?
-        @local_timezone ||= @options.fetch(:timezone, nil).try(:to_sym) == :local
-      end
-
-      def coerce_dates
-        @options.fetch(:coerce_dates, false)
-      end
-
-      alias_method :enabled?, :coerce_dates
-    end
-  end
-end

data/lib/fmrest/v1/utils.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module Utils
-      VALID_SCRIPT_KEYS = [:prerequest, :presort, :after].freeze
-
-      # Converts custom script options to a hash with the Data API's expected
-      # JSON script format.
-      #
-      # If script_options is a string or symbol it will be passed as the name
-      # of the script to execute (after the action, e.g. save).
-      #
-      # If script_options is an array the first element will be the name of the
-      # script to execute (after the action) and the second element (if any)
-      # will be its param value.
-      #
-      # If script_options is a hash it will expect to contain one or more of
-      # the following keys: :prerequest, :presort, :after
-      #
-      # Any of those keys should contain either a string/symbol or array, which
-      # will be treated as described above, except for their own script
-      # execution order (prerequest, presort or after action).
-      #
-      # Examples:
-      #
-      #     convert_script_params("My Script")
-      #     # => { "script": "My Script" }
-      #
-      #     convert_script_params(["My Script", "the param"])
-      #     # => { "script": "My Script", "script.param": "the param" }
-      #
-      #     convert_script_params(after: "After Script", prerequest: "Prerequest Script")
-      #     # => { "script": "After Script", "script.prerequest": "Prerequest Script" }
-      #
-      #     convert_script_params(presort: ["Presort Script", "foo"], prerequest: "Prerequest Script")
-      #     # => {
-      #     #      "script.presort": "After Script",
-      #     #      "script.presort.param": "foo",
-      #     #      "script.prerequest": "Prerequest Script"
-      #     #    }
-      #
-      def convert_script_params(script_options)
-        params = {}
-
-        case script_options
-        when String, Symbol
-          params[:script] = script_options.to_s
-
-        when Array
-          params.merge!(convert_script_arguments(script_options))
-
-        when Hash
-          script_options.each_key do |key|
-            next if VALID_SCRIPT_KEYS.include?(key)
-            raise ArgumentError, "Invalid script option #{key.inspect}"
-          end
-
-          if script_options.has_key?(:prerequest)
-            params.merge!(convert_script_arguments(script_options[:prerequest], :prerequest))
-          end
-
-          if script_options.has_key?(:presort)
-            params.merge!(convert_script_arguments(script_options[:presort], :presort))
-          end
-
-          if script_options.has_key?(:after)
-            params.merge!(convert_script_arguments(script_options[:after]))
-          end
-        end
-
-        params
-      end
-
-
-      private
-
-      def convert_script_arguments(script_arguments, suffix = nil)
-        base = suffix ? "script.#{suffix}".to_sym : :script
-
-        {}.tap do |params|
-          case script_arguments
-          when String, Symbol
-            params[base] = script_arguments.to_s
-          when Array
-            params[base] = script_arguments.first.to_s
-            params["#{base}.param".to_sym] = script_arguments[1] if script_arguments[1]
-          else
-            raise ArgumentError, "Script arguments are expected as a String, Symbol or Array"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fmrest/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  VERSION = "0.10.0"
-end