fmrest 0.10.1 → 0.13.1

data/lib/fmrest/v1.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/v1/connection"
-require "fmrest/v1/paths"
-require "fmrest/v1/container_fields"
-require "fmrest/v1/utils"
-require "fmrest/v1/dates"
-
-module FmRest
-  module V1
-    DEFAULT_DATE_FORMAT = "MM/dd/yyyy"
-    DEFAULT_TIME_FORMAT = "HH:mm:ss"
-    DEFAULT_TIMESTAMP_FORMAT = "#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}"
-
-    extend Connection
-    extend Paths
-    extend ContainerFields
-    extend Utils
-    extend Dates
-  end
-end

data/lib/fmrest/v1/connection.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module FmRest
-  module V1
-    module Connection
-      BASE_PATH = "/fmi/data/v1/databases"
-
-      # Builds a complete DAPI Faraday connection with middleware already
-      # configured to handle authentication, JSON parsing, logging and DAPI
-      # error handling. A block can be optionally given for additional
-      # middleware configuration
-      #
-      # @option options [String] :username The username for DAPI authentication
-      # @option options [String] :account_name Alias of :username for
-      #   compatibility with Rfm gem
-      # @option options [String] :password The password for DAPI authentication
-      # @option (see #base_connection)
-      # @return (see #base_connection)
-      def build_connection(options = FmRest.default_connection_settings, &block)
-        base_connection(options) do |conn|
-          conn.use RaiseErrors
-          conn.use TokenSession, options
-
-          # The EncodeJson and Multipart middlewares only encode the request
-          # when the content type matches, so we can have them both here and
-          # still play nice with each other, we just need to set the content
-          # type to multipart/form-data when we want to submit a container
-          # field
-          conn.request :multipart
-          conn.request :json
-
-          # Allow overriding the default response middleware
-          if block_given?
-            yield conn, options
-          else
-            conn.use TypeCoercer, options
-            conn.response :json
-          end
-
-          if options[:log]
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          conn.adapter Faraday.default_adapter
-        end
-      end
-
-      # Builds a base Faraday connection with base URL constructed from
-      # connection options and passes it the given block
-      #
-      # @option options [String] :host The hostname for the FM server
-      # @option options [String] :database The FM database name
-      # @option options [String] :ssl SSL options to forward to the Faraday
-      #   connection
-      # @option options [String] :proxy Proxy options to forward to the Faraday
-      #   connection
-      # @return [Faraday] The new Faraday connection
-      def base_connection(options = FmRest.default_connection_settings, &block)
-        host = options.fetch(:host)
-
-        # Default to HTTPS
-        scheme = "https"
-
-        if host.match(/\Ahttps?:\/\//)
-          uri = URI(host)
-          host = uri.hostname
-          host += ":#{uri.port}" if uri.port != uri.default_port
-          scheme = uri.scheme
-        end
-
-        faraday_options = {}
-        faraday_options[:ssl] = options[:ssl] if options.key?(:ssl)
-        faraday_options[:proxy] = options[:proxy] if options.key?(:proxy)
-
-        database = URI.encode_www_form_component(options.fetch(:database))
-
-        Faraday.new(
-          "#{scheme}://#{host}#{BASE_PATH}/#{database}/".freeze,
-          faraday_options,
-          &block
-        )
-      end
-    end
-  end
-end
-
-require "fmrest/v1/token_session"
-require "fmrest/v1/raise_errors"
-require "fmrest/v1/type_coercer"

data/lib/fmrest/v1/container_fields.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module ContainerFields
-      DEFAULT_UPLOAD_CONTENT_TYPE = "application/octet-stream".freeze
-
-      # Given a container field URL it tries to fetch it and returns an IO
-      # object with its body content (see Ruby's OpenURI for how the IO object
-      # is extended with useful HTTP response information).
-      #
-      # This method uses OpenURI instead of Faraday for fetching the actual
-      # container file.
-      #
-      # @raise [FmRest::ContainerFieldError] if any step fails
-      # @param container_field_url [String] The URL to the container to
-      #   download
-      # @param base_connection [Faraday::Connection] An optional Faraday
-      #   connection to use as base settings for the container requests, useful
-      #   if you need to set SSL or proxy settings. If given, this connection
-      #   will not be used directly, but rather a new one with copied SSL and
-      #   proxy options. If omitted, `FmRest.default_connection_settings`'s
-      #   `:ssl` and `:proxy` options will be used instead (if available)
-      # @return [IO] The contents of the container
-      def fetch_container_data(container_field_url, base_connection = nil)
-        require "open-uri"
-
-        begin
-          url = URI(container_field_url)
-        rescue ::URI::InvalidURIError
-          raise FmRest::ContainerFieldError, "Invalid container field URL `#{container_field_url}'"
-        end
-
-        # Make sure we don't try to open anything on the file:/ URI scheme
-        unless url.scheme.match(/\Ahttps?\Z/)
-          raise FmRest::ContainerFieldError, "Container URL is not HTTP (#{container_field_url})"
-        end
-
-        ssl_options = base_connection && base_connection.ssl && base_connection.ssl.to_hash
-        proxy_options = base_connection && base_connection.proxy && base_connection.proxy.to_hash
-
-        conn =
-          Faraday.new(nil,
-            ssl:   ssl_options || FmRest.default_connection_settings[:ssl],
-            proxy: proxy_options || FmRest.default_connection_settings[:proxy]
-          )
-
-        # Requesting the container URL with no cookie set will respond with a
-        # redirect and a session cookie
-        cookie_response = conn.get url
-
-        unless cookie = cookie_response.headers["Set-Cookie"]
-          raise FmRest::ContainerFieldError, "Container field's initial request didn't return a session cookie, the URL may be stale (try downloading it again immediately after retrieving the record)"
-        end
-
-        # Now request the URL again with the proper session cookie using
-        # OpenURI, which wraps the response in an IO object which also responds
-        # to #content_type
-        url.open(faraday_connection_to_openuri_options(conn).merge("Cookie" => cookie))
-      end
-
-      # Handles the core logic of uploading a file into a container field
-      #
-      # @param connection [Faraday::Connection] the Faraday connection to use
-      # @param container_path [String] the path to the container
-      # @param filename_or_io [String, IO] a path to the file to upload or an
-      #   IO object
-      # @param options [Hash]
-      # @option options [String] :content_type (DEFAULT_UPLOAD_CONTENT_TYPE)
-      #   The content type for the uploaded file
-      # @option options [String] :filename The filename to use for the uploaded
-      #   file, defaults to `filename_or_io.original_filename` if available
-      def upload_container_data(connection, container_path, filename_or_io, options = {})
-        content_type = options[:content_type] || DEFAULT_UPLOAD_CONTENT_TYPE
-
-        connection.post do |request|
-          request.url container_path
-          request.headers['Content-Type'] = ::Faraday::Request::Multipart.mime_type
-
-          filename = options[:filename] || filename_or_io.try(:original_filename)
-
-          request.body = { upload: Faraday::UploadIO.new(filename_or_io, content_type, filename) }
-        end
-      end
-
-      private
-
-      # Copies a Faraday::Connection's relevant options to
-      # OpenURI::OpenRead#open format
-      #
-      def faraday_connection_to_openuri_options(conn)
-        openuri_opts = {}
-
-        if !conn.ssl.empty?
-          openuri_opts[:ssl_verify_mode] =
-            conn.ssl.fetch(:verify, true) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-
-          openuri_opts[:ssl_ca_cert] = conn.ssl.cert_store if conn.ssl.cert_store
-        end
-
-        if conn.proxy && !conn.proxy.empty?
-          if conn.proxy.user && conn.proxy.password
-            openuri_opts[:proxy_http_basic_authentication] =
-              [conn.proxy.uri.tap { |u| u.userinfo = ""}, conn.proxy.user, conn.proxy.password]
-          else
-            openuri_opts[:proxy] = conn.proxy.uri
-          end
-        end
-
-        openuri_opts
-      end
-    end
-  end
-end

data/lib/fmrest/v1/dates.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module Dates
-      FM_DATETIME_FORMAT_MATCHER = /MM|mm|dd|HH|ss|yyyy/.freeze
-
-      FM_DATE_TO_STRPTIME_SUBSTITUTIONS = {
-        "MM"   => "%m",
-        "dd"   => "%d",
-        "yyyy" => "%Y",
-        "HH"   => "%H",
-        "mm"   => "%M",
-        "ss"   => "%S"
-      }.freeze
-
-      FM_DATE_TO_REGEXP_SUBSTITUTIONS = {
-        "MM"   => '(?:0[1-9]|1[012])',
-        "dd"   => '(?:0[1-9]|[12][0-9]|3[01])',
-        "yyyy" => '\d{4}',
-        "HH"   => '(?:[01]\d|2[0123])',
-        "mm"   => '[0-5]\d',
-        "ss"   => '[0-5]\d'
-      }.freeze
-
-      def self.extended(mod)
-        mod.instance_eval do
-          @date_strptime = {}
-          @date_regexp = {}
-        end
-      end
-
-      # Converts a FM date-time format to `DateTime.strptime` format
-      #
-      # @param fm_format [String] The FileMaker date-time format
-      # @return [String] The `DateTime.strpdate` equivalent of the given FM
-      #   date-time format
-      def fm_date_to_strptime_format(fm_format)
-        @date_strptime[fm_format] ||=
-          fm_format.gsub(FM_DATETIME_FORMAT_MATCHER, FM_DATE_TO_STRPTIME_SUBSTITUTIONS).freeze
-      end
-
-      # Converts a FM date-time format to a Regexp. This is mostly used a
-      # quicker way of checking whether a FM field is a date field than
-      # Date|DateTime.strptime
-      #
-      # @param fm_format [String] The FileMaker date-time format
-      # @return [Regexp] A reegular expression matching strings in the given FM
-      #   date-time format
-      def fm_date_to_regexp(fm_format)
-        @date_regexp[fm_format] ||= 
-          Regexp.new('\A' + fm_format.gsub(FM_DATETIME_FORMAT_MATCHER, FM_DATE_TO_REGEXP_SUBSTITUTIONS) + '\Z').freeze
-      end
-
-      # Takes a DateTime dt, and returns the correct local offset for that dt,
-      # daylight savings included, in fraction of a day.
-      #
-      # By default, if ActiveSupport's Time.zone is set it will be used instead
-      # of the system timezone.
-      #
-      # @param dt [DateTime] The DateTime to get the offset for
-      # @param zone [nil, String, TimeZone] The timezone to use to calculate
-      #   the offset (defaults to system timezone, or ActiveSupport's Time.zone
-      #   if set)
-      # @return [Rational] The offset in fraction of a day
-      def local_offset_for_datetime(dt, zone = nil)
-        dt = dt.new_offset(0)
-        time = ::Time.utc(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec)
-
-        # Do we have ActiveSupport's TimeZone?
-        time = if time.respond_to?(:in_time_zone)
-                 time.in_time_zone(zone || ::Time.zone)
-               else
-                 time.localtime
-               end
-
-        Rational(time.utc_offset, 86400) # seconds in one day (24*60*60)
-      end
-    end
-  end
-end

data/lib/fmrest/v1/paths.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module FmRest
-  module V1
-    module Paths
-      def session_path(token = nil)
-        url = "sessions"
-        url += "/#{token}" if token
-        url
-      end
-
-      def record_path(layout, id = nil)
-        url = "layouts/#{url_encode(layout)}/records"
-        url += "/#{id}" if id
-        url
-      end
-
-      def container_field_path(layout, id, field_name, field_repetition = 1)
-        url = record_path(layout, id)
-        url += "/containers/#{url_encode(field_name)}"
-        url += "/#{field_repetition}" if field_repetition
-        url
-      end
-
-      def find_path(layout)
-        "layouts/#{url_encode(layout)}/_find"
-      end
-
-      def script_path(layout, script)
-        "layouts/#{url_encode(layout)}/script/#{url_encode(script)}"
-      end
-
-      def globals_path
-        "globals"
-      end
-
-      private
-
-      # Borrowed from ERB::Util
-      def url_encode(s)
-        s.to_s.b.gsub(/[^a-zA-Z0-9_\-.]/n) { |m|
-          sprintf("%%%02X", m.unpack("C")[0])
-        }
-      end
-    end
-  end
-end

data/lib/fmrest/v1/raise_errors.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/errors"
-
-module FmRest
-  module V1
-    # FM Data API response middleware for raising exceptions on API response
-    # errors
-    #
-    # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
-    #
-    class RaiseErrors < Faraday::Response::Middleware
-      # https://fmhelp.filemaker.com/help/17/fmp/en/index.html#page/FMP_Help/error-codes.html
-      ERROR_RANGES = {
-        -1         => APIError::UnknownError,
-        100        => APIError::ResourceMissingError,
-        101        => APIError::RecordMissingError,
-        102..199   => APIError::ResourceMissingError,
-        200..299   => APIError::AccountError,
-        300..399   => APIError::LockError,
-        400        => APIError::ParameterError,
-        401        => APIError::NoMatchingRecordsError,
-        402..499   => APIError::ParameterError,
-        500..599   => APIError::ValidationError,
-        800..899   => APIError::SystemError,
-        1200..1299 => APIError::ScriptError,
-        1400..1499 => APIError::ODBCError
-      }
-
-      def on_complete(env)
-        # Sniff for either straight JSON parsing or Spyke's format
-        if env.body[:metadata] && env.body[:metadata][:messages]
-          check_errors(env.body[:metadata][:messages])
-        elsif env.body["messages"]
-          check_errors(env.body["messages"])
-        end
-      end
-
-      private
-
-      def check_errors(messages)
-        messages.each do |message|
-          error_code = (message["code"] || message[:code]).to_i
-
-          # Code 0 means "No Error"
-          next if error_code.zero?
-
-          error_message = message["message"] || message[:message]
-
-          *, exception_class = ERROR_RANGES.find { |k, v| k === error_code }
-
-          raise (exception_class || APIError).new(error_code, error_message)
-        end
-      end
-    end
-  end
-end

data/lib/fmrest/v1/token_session.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require "fmrest/v1/connection"
-require "fmrest/errors"
-
-module FmRest
-  module V1
-    # FM Data API authentication middleware using the credentials strategy
-    #
-    class TokenSession < Faraday::Middleware
-      class NoSessionTokenSet < FmRest::Error; end
-
-      HEADER_KEY = "Authorization".freeze
-      TOKEN_STORE_INTERFACE = [:load, :store, :delete].freeze
-      LOGOUT_PATH_MATCHER = %r{\A(#{FmRest::V1::Connection::BASE_PATH}/[^/]+/sessions/)[^/]+\Z}.freeze
-
-      # @param app [#call]
-      # @param options [Hash]
-      def initialize(app, options = FmRest.default_connection_settings)
-        super(app)
-        @options = options
-      end
-
-      # Entry point for the middleware when sending a request
-      #
-      def call(env)
-        return handle_logout(env) if is_logout_request?(env)
-
-        set_auth_header(env)
-
-        request_body = env[:body] # After failure env[:body] is set to the response body
-
-        @app.call(env).on_complete do |response_env|
-          if response_env[:status] == 401 # Unauthorized
-            env[:body] = request_body
-            token_store.delete(token_store_key)
-            set_auth_header(env)
-            return @app.call(env)
-          end
-        end
-      end
-
-      private
-
-      def handle_logout(env)
-        token = token_store.load(token_store_key)
-
-        raise NoSessionTokenSet, "Couldn't send logout request because no session token was set" unless token
-
-        env.url.path = env.url.path.gsub(LOGOUT_PATH_MATCHER, "\\1#{token}")
-
-        @app.call(env).on_complete do |response_env|
-          if response_env[:status] == 200
-            token_store.delete(token_store_key)
-          end
-        end
-      end
-
-      def is_logout_request?(env)
-        return false unless env.method == :delete
-        return env.url.path.match?(LOGOUT_PATH_MATCHER)
-      end
-
-      def set_auth_header(env)
-        env.request_headers[HEADER_KEY] = "Bearer #{token}"
-      end
-
-      # Tries to get an existing token from the token store,
-      # otherwise requests one through basic auth,
-      # otherwise raises an exception.
-      #
-      def token
-        token = token_store.load(token_store_key)
-        return token if token
-
-        if token = request_token
-          token_store.store(token_store_key, token)
-          return token
-        end
-
-        # TODO: Make this a custom exception class
-        raise "Filemaker auth failed"
-      end
-
-      # Requests a token through basic auth
-      #
-      def request_token
-        resp = auth_connection.post do |req|
-          req.url V1.session_path
-          req.headers["Content-Type"] = "application/json"
-        end
-        return resp.body["response"]["token"] if resp.success?
-        false
-      end
-
-      # The key to use to store a token, uses the format host:database
-      #
-      def token_store_key
-        @token_store_key ||=
-          begin
-            # Strip the host part to just the hostname (i.e. no scheme or port)
-            host = @options.fetch(:host)
-            host = URI(host).hostname if host =~ /\Ahttps?:\/\//
-            "#{host}:#{@options.fetch(:database)}"
-          end
-      end
-
-      def token_store
-        @token_store ||=
-          begin
-            if TOKEN_STORE_INTERFACE.all? { |method| token_store_option.respond_to?(method) }
-              token_store_option
-            elsif token_store_option.kind_of?(Class)
-              token_store_option.new
-            else
-              require "fmrest/token_store/memory"
-              TokenStore::Memory.new
-            end
-          end
-      end
-
-      def token_store_option
-        @options[:token_store] || FmRest.token_store
-      end
-
-      def auth_connection
-        @auth_connection ||= V1.base_connection(@options) do |conn|
-          username = @options.fetch(:account_name) { @options.fetch(:username) }
-
-          conn.basic_auth username, @options.fetch(:password)
-
-          if @options[:log]
-            conn.response :logger, nil, bodies: true, headers: true
-          end
-
-          conn.response :json
-          conn.adapter Faraday.default_adapter
-        end
-      end
-    end
-  end
-end