filemaker 0.0.19 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 267ea79af38848d21b296940abe2e14d3ce53f0f
-  data.tar.gz: 6cdd38cc8b20df9d9a2402635f124b178fd3e6e3
+SHA256:
+  metadata.gz: 90e8d2b8704500b90fa6649ad585301c88f94e420bb34f4cd620a1c7c53abe9d
+  data.tar.gz: 65fff04efa068012d5fcc54a1877c50b15434dde10040ad41a146b3889267f77
 SHA512:
-  metadata.gz: a055b4eca018e965d88265b5719571f1ad079838addf511cb57f625e2e32d9e9cb0f413cd904433d29cb62d52b3736413ee917e7563e14d5dfa9c6d97b6b3530
-  data.tar.gz: 22e268a6b6ceb67adec4d167aefe9771be0d28e7a3728454578d3e8aedc659918605fdf84e724d6e0b8a2f9d0860de368b5bdb3f76ae9cabada1451094c58b5a
+  metadata.gz: a858783d95970eca0e7166f84e494a755885b86674c895574b3563fbfee44f4b2fc8c249a20580062c5c649c9bb9b6812230e7e787235ac5fcdaca396b111810
+  data.tar.gz: 4e5b6d9fc0d0ae3bf85ded1daee20c85e4fbac8d657fbfd4ce56231e8d5ac4a49837c8a41a966d2050d0455fbe302688c43c0181df4bd3bf4c700786bbd0f69f

data/.editorconfig

@@ -0,0 +1,14 @@
+# http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+max_line_length = 0
+trim_trailing_whitespace = false

data/.travis.yml

@@ -1,5 +1,4 @@
 language: ruby
 rvm:
-  - 2.3.0
-  - 2.4.0
+  - 2.5.0
 script: "bundle exec rake"

data/README.md

@@ -23,7 +23,9 @@ Configuration for initializing a server:
 * `host` - IP or hostname
 * `account` - Please use `ENV` variable like `ENV['FILEMAKER_ACCOUNT']`
 * `password` - Please use `ENV` variable like `ENV['FILEMAKER_PASSWORD']`
-* `ssl` - Use `{ verify: false }` if you are using FileMaker's unsigned certificate. You can also pass a hash which will be forwarded to Faraday directly like `ssl: { client_cert: '', client_key: '', ca_file: '', ca_path: '/path/to/certs', cert_store: '' }`. See [Setting up SSL certificates on the Faraday wiki](https://github.com/lostisland/faraday/wiki/Setting-up-SSL-certificates)
+* `ssl` - Use `{ verify: false }` if you are using FileMaker's unsigned certificate.
+* `ssl_verifypeer` - Default to `false`
+* `ssl_verifyhost` - Default to `0`
 * `log` - A choice of `simple`, `curl` and `curl_auth`.
 
 ```ruby
@@ -69,15 +71,26 @@ If you want ActiveModel-like access with a decent query DSL like `where`, `find`
 
 The following data type mappings can be used to register the fields:
 
-* `string` - `String`
-* `text` - `String`
-* `integer` - `Integer`
-* `number` - `BigDecimal`
-* `money` - `BigDecimal`
-* `date` - `Date`
-* `datetime` - `DateTime`
+* `string` - `Filemaker::Model::Types::Text`
+* `text` - `Filemaker::Model::Types::Text`
+* `integer` - `Filemaker::Model::Types::Integer`
+* `number` - `Filemaker::Model::Types::BigDecimal`
+* `money` - `Filemaker::Model::Types::BigDecimal`
+* `date` - `Filemaker::Model::Types::Date`
+* `datetime` - `Filemaker::Model::Types::Time`
 * `email` - `Filemaker::Model::Types::Email`
-* `object` - `Filemaker::Model::Types::Attachment`
+
+You can create your own custom type by providing these 3 class methods:
+
+* `__filemaker_cast_to_ruby_object`
+* `__filemaker_serialize_for_update`
+* `__filemaker_serialize_for_query`
+
+And register it with:
+
+```ruby
+Filemaker::Model::Type.register(:fast_string, FastStringType)
+```
 
 If the field name has spaces, you can use `fm_name` to identify the real FileMaker field name.
 
@@ -107,7 +120,6 @@ class Job
   datetime :created_at
   datetime :published_at, fm_name: 'ModifiedDate'
   money    :salary
-  object   :attachment
 
   validates :title, presence: true
 
@@ -125,6 +137,8 @@ development:
     account_name: <%= ENV['FILEMAKER_ACCOUNT_NAME'] %>
     password: <%= ENV['FILEMAKER_PASSWORD'] %>
     ssl: true
+    ssl_verifypeer: false
+    ssl_verifyhost: 0
     log: curl
 
   read_slave:

data/filemaker.gemspec

@@ -18,17 +18,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'faraday'
   spec.add_runtime_dependency 'typhoeus'
   spec.add_runtime_dependency 'nokogiri', '~> 1.7'
   spec.add_runtime_dependency 'activemodel'
   spec.add_runtime_dependency 'globalid'
-  spec.add_runtime_dependency 'mimemagic'
-  spec.add_runtime_dependency 'mime-types'
 
   spec.add_development_dependency 'bundler', '~> 1.13'
   spec.add_development_dependency 'rake', '~> 12.0'
-  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rspec', '~> 3.7'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'pry-byebug'
 end

data/lib/filemaker.rb

@@ -17,39 +17,37 @@ require 'active_support/core_ext'
 require 'active_model'
 require 'globalid'
 
+require 'filemaker/model/type'
 require 'filemaker/model/criteria'
 require 'filemaker/model'
 
 require 'yaml'
 
+Typhoeus::Config.user_agent = "filemaker-ruby-#{Filemaker::VERSION}".freeze
+
 module Filemaker
   module_function
 
   # Based on the environment, register the server so we only ever have one
   # instance of Filemaker::Server per named session. The named session will be
   # defined at the `filemaker.yml` config file.
-  def load!(path, environment = nil)
+  def load!(path, environment = :development)
     file_string = ERB.new(File.new(path).read).result
     sessions = YAML.safe_load(file_string)[environment.to_s]
     raise Errors::ConfigurationError, 'Environment wrong?' if sessions.nil?
 
     sessions.each_pair do |key, value|
-      registry[key] = Filemaker::Server.new do |config|
-        config.host = value.fetch('host') do
-          raise Errors::ConfigurationError, 'Missing config.host'
-        end
-
-        config.account_name = value.fetch('account_name') do
-          raise Errors::ConfigurationError, 'Missing config.account_name'
-        end
-
-        config.password = value.fetch('password') do
-          raise Errors::ConfigurationError, 'Missing config.password'
-        end
+      registry[key] = Filemaker::Server.new do |c|
+        c.host           = value['host']
+        c.account_name   = value['account_name']
+        c.password       = value['password']
 
-        config.ssl = value['ssl'] if value['ssl']
-        config.log = value['log'] if value['log']
-        config.endpoint = value['endpoint'] if value['endpoint']
+        c.ssl            = value['ssl'] if value['ssl']
+        c.ssl_verifypeer = value['ssl_verifypeer'] if value['ssl_verifypeer']
+        c.ssl_verifyhost = value['ssl_verifyhost'] if value['ssl_verifyhost']
+        c.log            = value['log'] if value['log']
+        c.endpoint       = value['endpoint'] if value['endpoint']
+        c.timeout        = value['timeout'] if value['timeout']
       end
     end
   end

data/lib/filemaker/configuration.rb

@@ -1,10 +1,15 @@
 module Filemaker
   class Configuration
-    attr_accessor :host, :account_name, :password, :ssl, :endpoint
+    attr_accessor :host, :account_name, :password, :endpoint
+    attr_accessor :ssl_verifypeer, :ssl_verifyhost, :ssl
+    attr_accessor :timeout
     attr_accessor :log
 
     def initialize
       @endpoint = '/fmi/xml/fmresultset.xml'
+      @timeout = 0
+      @ssl_verifypeer = false
+      @ssl_verifyhost = 0
     end
 
     def not_configurable?

data/lib/filemaker/errors.rb

@@ -5,6 +5,7 @@ module Filemaker
     class ParameterError < StandardError; end
     class CoerceError < StandardError; end
     class ConfigurationError < StandardError; end
+    class HttpTimeoutError < StandardError; end
 
     class FilemakerError < StandardError
       attr_reader :code

data/lib/filemaker/layout.rb

@@ -24,13 +24,12 @@ module Filemaker
     # @return [Filemaker::Resultset]
     def perform_request(action, args, options)
       response, params = server.perform_request(
-        :post,
         action,
         default_params.merge(args),
         options
       )
 
-      Filemaker::Resultset.new(server, response.body, params)
+      Filemaker::Resultset.new(server, response.response_body, params)
     end
 
     private

data/lib/filemaker/metadata/field.rb

@@ -38,13 +38,15 @@ module Filemaker
         value.delete('$,')
       end
 
-      def coerce(value)
+      # Raw XML data `inner_text` into Ruby native object as best we can based
+      # on its built-in metadata's data_type
+      def raw_cast(value)
         value = value.to_s.strip
         return nil if value.empty?
 
         case data_type
         when 'number'
-          BigDecimal.new(remove_decimal_mark(value))
+          BigDecimal(remove_decimal_mark(value))
         when 'date'
           # date_format likely will be '%m/%d/%Y', but if we got '19/8/2014',
           # then `strptime` will raise invalid date error
@@ -76,8 +78,8 @@ module Filemaker
         else
           value
         end
-      rescue StandardError
-        warn "Could not coerce #{name}: #{value}"
+      rescue StandardError => e
+        warn "Could not coerce #{name}: #{value} due to #{e.message}"
         value
       end
 

data/lib/filemaker/model.rb

@@ -5,20 +5,22 @@ module Filemaker
     extend ActiveSupport::Concern
     include Components
 
-    # @return [Boolean] indicates if this is a new fresh record
-    attr_reader :attributes, :new_record, :record_id, :mod_id, :portals
+    attr_reader :new_record, :record_id, :mod_id, :portals
 
     included do
       class_attribute :db, :lay, :registry_name, :server, :api, :per_page
       self.per_page = Kaminari.config.default_per_page if defined?(Kaminari)
     end
 
-    def initialize(attrs = nil)
+    def initialize(attributes = {})
+      # We did not manage to use `ActiveModel::AttributeAssignment`
+      # super
+
       @new_record = true
-      @attributes = {}
       @relations = {}
       apply_defaults
-      process_attributes(attrs)
+      process_attributes(attributes)
+      clear_changes_information
     end
 
     def new_record?
@@ -34,7 +36,7 @@ module Filemaker
     end
 
     def model_key
-      @model_cache_key ||= self.class.model_name.cache_key
+      @model_key ||= self.class.model_name.cache_key
     end
 
     def cache_key
@@ -53,7 +55,7 @@ module Filemaker
     end
 
     def to_param
-      id.to_s if id
+      id&.to_s
     end
 
     def fm_attributes
@@ -65,17 +67,19 @@ module Filemaker
       changed.each do |attr_name|
         dirty[attr_name] = attributes[attr_name]
       end
-      self.class.with_model_fields(dirty)
+
+      # We need to use serialize_for_update instead
+      self.class.with_model_fields(dirty, use_query: false)
     end
 
     private
 
-    def process_attributes(attrs)
-      attrs ||= {}
-      return if attrs.empty?
+    def process_attributes(attributes)
+      return if attributes.empty?
 
-      attrs.each_pair do |key, value|
-        public_send("#{key}=", value) if respond_to?("#{key}=")
+      attributes.each_pair do |key, value|
+        setter = :"#{key}="
+        public_send(setter, value) if respond_to?(setter)
       end
     end
 
@@ -125,7 +129,7 @@ module Filemaker
       # is an array. Without the test and expectation setup, debugging the
       # output will take far longer to realise. This reinforce the belief that
       # TDD is in fact a valuable thing to do.
-      def with_model_fields(criterion, coerce = true)
+      def with_model_fields(criterion, use_query: true)
         accepted_fields = {}
 
         criterion.each_pair do |key, value|
@@ -140,13 +144,20 @@ module Filemaker
           if value.is_a? Array
             temp = []
             value.each do |v|
-              temp << (coerce ? field.coerce(v) : v)
+              temp << if use_query
+                        field.serialize_for_query(v)
+                      else
+                        field.serialize_for_update(v)
+                      end
             end
 
             accepted_fields[field.fm_name] = temp
           else
-            accepted_fields[field.fm_name] = \
-              coerce ? field.coerce(value) : value
+            accepted_fields[field.fm_name] = if use_query
+                                               field.serialize_for_query(value)
+                                             else
+                                               field.serialize_for_update(value)
+                                             end
           end
         end
 

data/lib/filemaker/model/batches.rb

@@ -2,11 +2,22 @@ module Filemaker
   module Model
     module Batches
       def in_batches(batch_size: 200, options: {})
+        output = []
+        total = self.in(options).count
+        pages = (total / batch_size.to_f).ceil
+        1.upto(pages) do |page|
+          output.concat self.in(options).per(batch_size).page(page)
+        end
+
+        output
+      end
+
+      def where_batches(batch_size: 200, options: {})
         output = []
         total = where(options).count
         pages = (total / batch_size.to_f).ceil
         1.upto(pages) do |page|
-          output.concat where(options).per(batch_size).page(page).all
+          output.concat where(options).per(batch_size).page(page)
         end
 
         output

data/lib/filemaker/model/builder.rb

@@ -24,12 +24,17 @@ module Filemaker
         record.each_key do |fm_field_name|
           # record.keys are all lowercase
           field = object.class.find_field_by_name(fm_field_name)
+
+          # Do not bother with undefined field, we don't necessarily need all
+          # FM's fields
           next unless field
 
-          object.attributes[field.name] = field.coerce(
-            record[fm_field_name],
-            object.class
-          )
+          setter = :"#{field.name}="
+          value = field.cast(record[fm_field_name])
+          object.public_send(setter, value)
+
+          # So after hydrating, we do not say it was dirty
+          object.clear_changes_information
         end
 
         object

data/lib/filemaker/model/components.rb

@@ -15,11 +15,19 @@ module Filemaker
         extend ActiveModel::Callbacks
       end
 
+      # Includes Naming, Translation, Validations, Conversion and
+      # AttributeAssignment
       include ActiveModel::Model
+
       include ActiveModel::Dirty
       include ActiveModel::Serializers::JSON
+
+      # Provide before/after_validation
       include ActiveModel::Validations::Callbacks
+
+      # A global URI good for background job processing
       include GlobalID::Identification
+
       include Fields
       include Relations
       include Persistable

data/lib/filemaker/model/field.rb

@@ -1,6 +1,3 @@
-require 'filemaker/model/types/email'
-require 'filemaker/model/types/attachment'
-
 module Filemaker
   module Model
     class Field
@@ -9,52 +6,50 @@ module Filemaker
       def initialize(name, type, options = {})
         @name = name
         @type = type
-        @default_value = coerce(options.fetch(:default) { nil })
+        @default_value = serialize_for_update(options.fetch(:default) { nil })
 
         # We need to downcase because Filemaker::Record is
         # HashWithIndifferentAndCaseInsensitiveAccess
-        @fm_name = (options.fetch(:fm_name) { name }).to_s.downcase
+        @fm_name = (options.fetch(:fm_name) { name }).to_s.downcase.freeze
+      end
+
+      # Will delegate to the underlying @type for casting
+      # From raw input to Ruby type
+      def cast(value)
+        return value if skip_modifying_value(value)
+        @type.__filemaker_cast_to_ruby_object(value)
+      rescue StandardError => e
+        warn "[#{e.message}] Could not cast: #{name}=#{value}"
+        value
       end
 
-      # From FileMaker to Ruby.
-      #
-      # If the value is `==` (match empty) or `=*` (match record), then we will
-      # skip coercion.
-      #
-      # Date and DateTime will be special. If the value is a String, the query
-      # may be '2016', '3/2016' or '3/24/2016' for example.
-      def coerce(value, klass = nil)
-        return nil if value.nil?
-        return value if value =~ /^==|=\*/
-        return value if value =~ /(\.\.\.)/
+      # Convert to Ruby type situable for making FileMaker update
+      # For attr_writer
+      def serialize_for_update(value)
+        return value if skip_modifying_value(value)
+        @type.__filemaker_serialize_for_update(value)
+      rescue StandardError => e
+        warn "[#{e.message}] Could not serialize for update: #{name}=#{value}"
+        value
+      end
 
-        if @type == String
-          value.to_s
-        elsif @type == Integer
-          value.to_i
-        elsif @type == BigDecimal
-          BigDecimal.new(value.to_s)
-        elsif @type == Date
-          return value if value.is_a? Date
-          return value.to_s if value.is_a? String
-          Date.parse(value.to_s)
-        elsif @type == DateTime
-          return value if value.is_a? DateTime
-          return value.to_s if value.is_a? String
-          DateTime.parse(value.to_s)
-        elsif @type == Filemaker::Model::Types::Email
-          return value if value.is_a? Filemaker::Model::Types::Email
-          Filemaker::Model::Types::Email.new(value)
-        elsif @type == Filemaker::Model::Types::Attachment
-          return value if value.is_a? Filemaker::Model::Types::Attachment
-          Filemaker::Model::Types::Attachment.new(value, klass)
-        else
-          value
-        end
+      # Convert to Ruby type situable for making FileMaker query
+      def serialize_for_query(value)
+        return value if skip_modifying_value(value)
+        @type.__filemaker_serialize_for_query(value)
       rescue StandardError => e
-        warn "[#{e.message}] Could not coerce #{name}: #{value}"
+        warn "[#{e.message}] Could not serialize for query: #{name}=#{value}"
         value
       end
+
+      # Doc why we skip it!
+      # TODO - we may need to customize it for query and update. For example
+      # query will bypass `==`, but update do not need to care.
+      def skip_modifying_value(value)
+        return true if value.nil?
+        return true if value =~ /^==|=\*/
+        return true if value =~ /(\.\.\.)/
+      end
     end
   end
 end