filemaker 0.0.19 → 1.0.0

data/lib/filemaker/model/fields.rb

@@ -19,18 +19,6 @@ module Filemaker
     module Fields
       extend ActiveSupport::Concern
 
-      TYPE_MAPPINGS = {
-        string:     String,
-        text:       String,
-        date:       Date,
-        datetime:   DateTime,
-        money:      BigDecimal,
-        number:     BigDecimal,
-        integer:    Integer,
-        email:      Filemaker::Model::Types::Email,
-        object:     Filemaker::Model::Types::Attachment
-      }.freeze
-
       included do
         class_attribute :fields, :identity
         self.fields = {}
@@ -41,7 +29,7 @@ module Filemaker
       def apply_defaults
         attribute_names.each do |name|
           field = fields[name]
-          attributes[name] = field.default_value
+          instance_variable_set("@#{name}", field.default_value)
         end
       end
 
@@ -53,50 +41,65 @@ module Filemaker
         fields.values.map(&:fm_name)
       end
 
+      def attributes
+        fields.keys.each_with_object({}) do |field, hash|
+          # Attributes must be strings, not symbols - See
+          # http://api.rubyonrails.org/classes/ActiveModel/Serialization.html
+          hash[field.to_s] = instance_variable_get("@#{field}")
+
+          # If we use public_send(field) will encounter Stack Too Deep
+        end
+      end
+
       module ClassMethods
         def attribute_names
           fields.keys
         end
 
-        TYPE_MAPPINGS.each_key do |type|
+        Filemaker::Model::Type.registry.each_key do |type|
           define_method(type) do |*args|
-            # TODO: It will be good if we can accept lambda also
             options = args.last.is_a?(Hash) ? args.pop : {}
             field_names = args
 
             field_names.each do |name|
-              add_field(name, TYPE_MAPPINGS[type.to_sym], options)
+              add_field(name, Filemaker::Model::Type.registry[type], options)
               create_accessors(name)
             end
           end
         end
 
         def add_field(name, type, options)
-          name = name.to_s
+          name = name.to_s.freeze
           fields[name] = Filemaker::Model::Field.new(name, type, options)
           self.identity = fields[name] if options[:identity]
         end
 
         def create_accessors(name)
-          name = name.to_s # Normalize it so ActiveModel::Serialization can work
+          # Normalize it so ActiveModel::Serialization can work
+          name = name.to_s
 
           define_attribute_methods name
 
           # Reader
           define_method(name) do
-            attributes[name]
+            instance_variable_get("@#{name}")
           end
 
           # Writer - We try to map to the correct type, if not we just return
           # original.
           define_method("#{name}=") do |value|
-            public_send("#{name}_will_change!") unless value == attributes[name]
-            attributes[name] = fields[name].coerce(value, self.class)
+            new_value = fields[name].serialize_for_update(value)
+
+            public_send("#{name}_will_change!") \
+              if new_value != public_send(name)
+
+            instance_variable_set("@#{name}", new_value)
           end
 
           # Predicate
           define_method("#{name}?") do
-            attributes[name] == true || attributes[name].present?
+            # See ActiveRecord::AttributeMethods::Query implementation
+            public_send(name) == true || public_send(name).present?
           end
         end
 

data/lib/filemaker/model/pagination.rb

@@ -7,6 +7,7 @@ module Filemaker
         chains << :page
         @_page = positive_page(value.to_i)
         update_skip
+        all
       end
 
       def per(value)

data/lib/filemaker/model/persistable.rb

@@ -28,6 +28,7 @@ module Filemaker
           options = {}
           yield options if block_given?
           resultset = api.new(fm_attributes, options)
+          changes_applied
           replace_new_data(resultset)
         end
         self
@@ -71,18 +72,17 @@ module Filemaker
 
       # If value is nil, we convert to empty string so it will get pick up by
       # `fm_attributes`
-      def assign_attributes(new_attributes)
-        return if new_attributes.blank?
+      # def assign_attributes(new_attributes)
+      #   return if new_attributes.blank?
 
-        new_attributes.each_pair do |key, value|
-          next unless respond_to?("#{key}=")
+      #   new_attributes.each_pair do |key, value|
+      #     next unless respond_to?("#{key}=")
 
-          public_send("#{key}=", (value || ''))
-        end
-      end
+      #     public_send("#{key}=", (value || ''))
+      #   end
+      # end
 
       def reload!
-        reset_changes
         resultset = api.find(record_id)
         replace_new_data(resultset)
         self

data/lib/filemaker/model/selectable.rb

@@ -69,7 +69,7 @@ module Filemaker
           @selector ||= {}
 
           criterion = if operator == 'bw'
-                        klass.with_model_fields(criterion, false)
+                        klass.with_model_fields(criterion, use_query: false)
                       else
                         klass.with_model_fields(criterion)
                       end

data/lib/filemaker/model/type.rb

@@ -0,0 +1,31 @@
+require 'filemaker/model/types/text'
+require 'filemaker/model/types/date'
+require 'filemaker/model/types/time'
+require 'filemaker/model/types/big_decimal'
+require 'filemaker/model/types/integer'
+require 'filemaker/model/types/email'
+
+module Filemaker
+  module Model
+    module Type
+      @registry = {}
+
+      class << self
+        attr_accessor :registry
+
+        def register(type_name, klass)
+          registry[type_name] = klass
+        end
+      end
+
+      register(:string, Filemaker::Model::Types::Text)
+      register(:text, Filemaker::Model::Types::Text)
+      register(:date, Filemaker::Model::Types::Date)
+      register(:datetime, Filemaker::Model::Types::Time)
+      register(:money, Filemaker::Model::Types::BigDecimal)
+      register(:number, Filemaker::Model::Types::BigDecimal)
+      register(:integer, Filemaker::Model::Types::Integer)
+      register(:email, Filemaker::Model::Types::Email)
+    end
+  end
+end

data/lib/filemaker/model/types/big_decimal.rb

@@ -0,0 +1,22 @@
+module Filemaker
+  module Model
+    module Types
+      class BigDecimal
+        def self.__filemaker_cast_to_ruby_object(value)
+          return value if value.is_a?(::BigDecimal)
+          BigDecimal(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_update(value)
+          return value if value.is_a?(::BigDecimal)
+          BigDecimal(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_query(value)
+          return value if value.is_a?(::BigDecimal)
+          BigDecimal(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/types/date.rb

@@ -0,0 +1,24 @@
+module Filemaker
+  module Model
+    module Types
+      class Date
+        def self.__filemaker_cast_to_ruby_object(value)
+          return value if value.is_a?(::Date)
+          ::Date.parse(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_update(value)
+          return value if value.is_a?(::Date)
+          ::Date.parse(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_query(value)
+          # If we are doing date range query like
+          # Model.where(date: '12/2018')
+          return value if value.is_a?(::Date) || value.is_a?(String)
+          ::Date.parse(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/types/email.rb

@@ -2,37 +2,19 @@ module Filemaker
   module Model
     module Types
       class Email
-        def initialize(value)
-          # to_s incoming value, this can prevent similar type from
-          # nesting deeply
-          @value = value.nil? ? nil : value.to_s
-        end
-
-        def value
-          email = @value&.strip&.split(%r{,|\(|\/|\s})
+        def self.__filemaker_cast_to_ruby_object(value)
+          email = value&.strip&.split(%r{,|\(|\/|\s})
                   &.reject(&:empty?)&.first&.downcase
                   &.gsub(/[\uFF20\uFE6B\u0040]/, '@')
 
           email&.include?('@') ? email : nil
         end
 
-        def value=(v)
-          self.value = v
-        end
-
-        def to_s
-          value
-        end
-
-        def ==(other)
-          to_s == other.to_s
+        def self.__filemaker_serialize_for_update(value)
+          __filemaker_cast_to_ruby_object(value)
         end
-        alias eql? ==
 
-        # In FileMaker, at-sign is for wildcard query. In order to search for
-        # email, we need to escape at-sign. Note the single-quote escaping!
-        # e.g. 'a@host.com' will become 'a\\@host.com'
-        def to_query
+        def self.__filemaker_serialize_for_query(value)
           value.gsub('@', '\@')
         end
       end

data/lib/filemaker/model/types/integer.rb

@@ -0,0 +1,22 @@
+module Filemaker
+  module Model
+    module Types
+      class Integer
+        def self.__filemaker_cast_to_ruby_object(value)
+          return value if value.is_a?(::Integer)
+          value.to_i
+        end
+
+        def self.__filemaker_serialize_for_update(value)
+          return value if value.is_a?(::Integer)
+          value.to_i
+        end
+
+        def self.__filemaker_serialize_for_query(value)
+          return value if value.is_a?(::Integer)
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/types/text.rb

@@ -0,0 +1,19 @@
+module Filemaker
+  module Model
+    module Types
+      class Text
+        def self.__filemaker_cast_to_ruby_object(value)
+          value.to_s
+        end
+
+        def self.__filemaker_serialize_for_update(value)
+          value.to_s
+        end
+
+        def self.__filemaker_serialize_for_query(value)
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/types/time.rb

@@ -0,0 +1,22 @@
+module Filemaker
+  module Model
+    module Types
+      class Time
+        def self.__filemaker_cast_to_ruby_object(value)
+          return value if value.is_a?(::Time)
+          ::Time.parse(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_update(value)
+          return value if value.is_a?(::Time)
+          ::Time.parse(value.to_s)
+        end
+
+        def self.__filemaker_serialize_for_query(value)
+          return value if value.is_a?(::Time) || value.is_a?(String)
+          ::Time.parse(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/record.rb

@@ -33,7 +33,7 @@ module Filemaker
                           end
 
         field.xpath('data').each do |data|
-          datum.push(metadata_fields[field_name].coerce(data.inner_text))
+          datum.push(metadata_fields[field_name].raw_cast(data.inner_text))
         end
 
         self[field_name] = normalize_data(datum)

data/lib/filemaker/server.rb

@@ -1,29 +1,25 @@
-require 'faraday'
-require 'typhoeus/adapters/faraday'
+require 'typhoeus'
 require 'filemaker/configuration'
 
 module Filemaker
   class Server
     extend Forwardable
 
-    # @return [Faraday::Connection] the HTTP connection
-    attr_reader :connection
-
     # @return [Filemaker::Store::DatabaseStore] the database store
     attr_reader :databases
     alias database databases
     alias db databases
 
-    def_delegators :@config, :host, :url, :ssl, :endpoint, :log
+    def_delegators :@config, :host, :url, :endpoint, :log
     def_delegators :@config, :account_name, :password
+    def_delegators :@config, :ssl_verifypeer, :ssl_verifyhost, :ssl, :timeout
 
-    def initialize(options = {})
+    def initialize
       @config = Configuration.new
       yield @config if block_given?
       raise ArgumentError, 'Missing config block' if @config.not_configurable?
 
       @databases = Store::DatabaseStore.new(self)
-      @connection = get_connection(options)
     end
 
     # @api private
@@ -33,8 +29,8 @@ module Filemaker
     # Also we want to pass in timeout option so we can ignore timeout for really
     # long requests
     #
-    # @return [Array] Faraday::Response and request params Hash
-    def perform_request(method, action, args, options = {})
+    # @return [Array] response and request params Hash
+    def perform_request(action, args, options = {})
       params = serialize_args(args)
                .merge(expand_options(options))
                .merge({ action => '' })
@@ -45,28 +41,36 @@ module Filemaker
       log_action(params)
 
       # yield params if block_given?
-      response = @connection.public_send(method, endpoint, params)
 
-      case response.status
+      response = get_typhoeus_connection(params)
+
+      http_status = "#{response.response_code}:#{response.return_code}"
+
+      case response.response_code
       when 200
         [response, params]
       when 401
         raise Errors::AuthenticationError,
-              "[#{response.status}] Authentication failed."
+              "[#{http_status}] Authentication failed."
       when 0
-        raise Errors::CommunicationError,
-              "[#{response.status}] Empty response."
+        if response.return_code == :operation_timedout
+          raise Errors::HttpTimeoutError,
+                "[#{http_status}] Current timeout value is #{timeout}"
+        else
+          raise Errors::CommunicationError,
+                "[#{http_status}] Empty response."
+        end
       when 404
         raise Errors::CommunicationError,
-              "[#{response.status}] Not found"
+              "[#{http_status}] Not found"
       when 302
         raise Errors::CommunicationError,
-              "[#{response.status}] Redirect not supported"
+              "[#{http_status}] Redirect not supported"
       when 502
         raise Errors::CommunicationError,
-              "[#{response.status}] Bad gateway. Too many records."
+              "[#{http_status}] Bad gateway. Too many records."
       else
-        msg = "Unknown response status = #{response.status}"
+        msg = "Unknown response code = #{http_status}"
         raise Errors::CommunicationError, msg
       end
     end
@@ -77,21 +81,22 @@ module Filemaker
 
     private
 
-    def get_connection(options = {})
-      faraday_options = @config.connection_options.merge(options)
-
-      Faraday.new(@config.url, faraday_options) do |faraday|
-        faraday.request :url_encoded
-        faraday.headers[:user_agent] = \
-          "filemaker-ruby-#{Filemaker::VERSION}".freeze
-        faraday.basic_auth @config.account_name, @config.password
-
-        # The order of the middleware is important, so adapter must be the last
-        faraday.adapter :typhoeus
-      end
+    def get_typhoeus_connection(body)
+      request = Typhoeus::Request.new(
+        "#{url}#{endpoint}",
+        method: :post,
+        ssl_verifypeer: ssl_verifypeer,
+        ssl_verifyhost: ssl_verifyhost,
+        userpwd: "#{account_name}:#{password}",
+        body: body,
+        timeout: timeout || 0
+      )
+
+      request.run
     end
 
     # {"-db"=>"mydb", "-lay"=>"mylay", "email"=>"a@b.com", "updated_at": Date}
+    # Take Ruby type and serialize into a form FileMaker can understand
     def serialize_args(args)
       return {} if args.nil?
 
@@ -103,8 +108,6 @@ module Filemaker
           args[key] = value.strftime('%m/%d/%Y')
         when Time
           args[key] = value.strftime('%H:%M')
-        when Filemaker::Model::Types::Email
-          args[key] = value.to_query
         else
           # Especially for range operator (...), we want to output as String
           args[key] = value.to_s
@@ -196,10 +199,9 @@ module Filemaker
       curl_ssl_option = ''
       auth            = ''
 
-      curl_ssl_option = ' -k' if ssl.is_a?(Hash) && !ssl.fetch(:verify) { true }
+      curl_ssl_option = ' -k' unless ssl_verifypeer
 
-      auth = " -H 'Authorization: #{@connection.headers['Authorization']}'" if \
-        has_auth
+      auth = " -u #{account_name}:[FILTERED]" if has_auth
 
       # warn 'Pretty print like so: `curl XXX | xmllint --format -`'
       warn "curl -XGET '#{full_url}'#{curl_ssl_option} -i#{auth}"