fmrest-core 0.13.0

data/lib/fmrest-core.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "fmrest"

data/lib/fmrest-spyke.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "fmrest/spyke"

data/lib/fmrest.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday_middleware"
+
+require "fmrest/version"
+require "fmrest/connection_settings"
+require "fmrest/errors"
+
+module FmRest
+  autoload :V1,         "fmrest/v1"
+  autoload :TokenStore, "fmrest/token_store"
+  autoload :Spyke,      "fmrest/spyke"
+
+  class << self
+    attr_accessor :token_store
+
+    def default_connection_settings=(settings)
+      @default_connection_settings = ConnectionSettings.wrap(settings, skip_validation: true)
+    end
+
+    def default_connection_settings
+      @default_connection_settings || ConnectionSettings.new({}, skip_validation: true)
+    end
+
+    def config=(connection_hash)
+      warn "[DEPRECATION] `FmRest.config=` is deprecated, use `FmRest.default_connection_settings=` instead"
+      self.default_connection_settings = connection_hash
+    end
+
+    def config
+      warn "[DEPRECATION] `FmRest.config` is deprecated, use `FmRest.default_connection_settings` instead"
+      default_connection_settings
+    end
+  end
+end

data/lib/fmrest/connection_settings.rb

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

@@ -0,0 +1,30 @@
+# 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/string_date.rb

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

data/lib/fmrest/token_store.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FmRest
+  module TokenStore
+    autoload :Base,         "fmrest/token_store/base"
+    autoload :Memory,       "fmrest/token_store/memory"
+    autoload :Null,         "fmrest/token_store/null"
+    autoload :ActiveRecord, "fmrest/token_store/active_record"
+    autoload :Moneta,       "fmrest/token_store/moneta"
+    autoload :Redis,        "fmrest/token_store/redis"
+  end
+end

data/lib/fmrest/token_store/active_record.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "fmrest/token_store/base"
+require "active_record"
+
+module FmRest
+  module TokenStore
+    # Heavily inspired by Moneta's ActiveRecord store:
+    #
+    #   https://github.com/minad/moneta/blob/master/lib/moneta/adapters/activerecord.rb
+    #
+    class ActiveRecord < Base
+      DEFAULT_TABLE_NAME = "fmrest_session_tokens".freeze
+
+      @connection_lock = ::Mutex.new
+      class << self
+        attr_reader :connection_lock
+      end
+
+      attr_reader :connection_pool, :model
+
+      delegate :with_connection, to: :connection_pool
+
+      def initialize(options = {})
+        super
+
+        @connection_pool = ::ActiveRecord::Base.connection_pool
+
+        create_table
+
+        @model = Class.new(::ActiveRecord::Base)
+        @model.table_name = table_name
+      end
+
+      def delete(key)
+        model.where(scope: key).delete_all
+      end
+
+      def load(key)
+        model.where(scope: key).pluck(:token).first
+      end
+
+      def store(key, value)
+        record = model.find_or_initialize_by(scope: key)
+        record.token = value
+        record.save!
+        value
+      end
+
+      private
+
+      def create_table
+        with_connection do |conn|
+          return if conn.table_exists?(table_name)
+
+          # Prevent multiple connections from attempting to create the table simultaneously.
+          self.class.connection_lock.synchronize do
+            conn.create_table(table_name, id: false) do |t|
+              t.string :scope, null: false
+              t.string :token, null: false
+              t.datetime :updated_at
+            end
+            conn.add_index(table_name, :scope, unique: true)
+            conn.add_index(table_name, [:scope, :token])
+          end
+        end
+      end
+
+      def table_name
+        options[:table_name] || DEFAULT_TABLE_NAME
+      end
+    end
+  end
+end