fmrest 0.10.0 → 0.13.0

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

data/lib/fmrest/token_store.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module TokenStore
-  end
-end

data/lib/fmrest/token_store/active_record.rb

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

data/lib/fmrest/token_store/base.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module TokenStore
-    class Base
-      attr_reader :options
-
-      def initialize(options = {})
-        @options = options
-      end
-
-      def load(key)
-        raise "Not implemented"
-      end
-
-      def store(key, value)
-        raise "Not implemented"
-      end
-
-      def delete(key)
-        raise "Not implemented"
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/memory.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-
-module FmRest
-  module TokenStore
-    class Memory < Base
-      def initialize(*args)
-        super
-        @tokens = {}
-      end
-
-      def delete(key)
-        @tokens.delete(key)
-      end
-
-      def load(key)
-        @tokens[key]
-      end
-
-      def store(key, value)
-        @tokens[key] = value
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/moneta.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-require "moneta"
-
-module FmRest
-  module TokenStore
-    class Moneta < Base
-      DEFAULT_ADAPTER = :Memory
-      DEFAULT_PREFIX = "fmrest-token:".freeze
-
-      attr_reader :moneta
-
-      # @param options [Hash]
-      #   Options to pass to `Moneta.new`
-      # @option options [Symbol] :adapter (:Memory)
-      #   The Moneta adapter to use
-      # @option options [String] :prefix (DEFAULT_PREFIX)
-      #   The prefix to use for keys
-      def initialize(options = {})
-        options = options.dup
-        super(options)
-        adapter = options.delete(:adapter) || DEFAULT_ADAPTER
-        options[:prefix] ||= DEFAULT_PREFIX
-        @moneta = ::Moneta.new(adapter, options)
-      end
-
-      def load(key)
-        moneta[key]
-      end
-
-      def delete(key)
-        moneta.delete(key)
-      end
-
-      def store(key, value)
-        moneta[key] = value
-      end
-    end
-  end
-end

data/lib/fmrest/token_store/redis.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/token_store/base"
-require "redis" unless defined?(MockRedis)
-
-module FmRest
-  module TokenStore
-    class Redis < Base
-      DEFAULT_PREFIX = "fmrest-token:".freeze
-
-      STORE_OPTIONS = [:redis, :prefix].freeze
-
-      def initialize(options = {})
-        super
-        @redis = @options[:redis] || ::Redis.new(options_for_redis)
-        @prefix = @options[:prefix] || DEFAULT_PREFIX
-      end
-
-      def load(key)
-        @redis.get(prefix_key(key))
-      end
-
-      def store(key, value)
-        @redis.set(prefix_key(key), value)
-        value
-      end
-
-      def delete(key)
-        @redis.del(prefix_key(key))
-      end
-
-      private
-
-      def options_for_redis
-        @options.dup.tap do |options|
-          STORE_OPTIONS.each { |opt| options.delete(opt) }
-        end
-      end
-
-      def prefix_key(key)
-        "#{@prefix}#{key}"
-      end
-    end
-  end
-end