filemaker 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da908ea60c24ec21422e5405e5c18e149825bb78
-  data.tar.gz: cf777449498d727f9c15ab765f5e610b292d0f8d
+  metadata.gz: 2d84b6982396ee09d4e78ae0d12be8fbb4ca3b69
+  data.tar.gz: 8a758a58c2b0462e8b34ec246b6aae68b70ca750
 SHA512:
-  metadata.gz: f6d6523f795649e9f2b09cc66ce21fff013586713a677b002734ffbc03eb3d5cdec949198764361d594c896851d1c7000f58e2adb28c76293091cd37b9acc029
-  data.tar.gz: 2b44e3649cfce1a9fa65ce5d7264f717ede0c86f63eafd695b9370deebd14f4870d2d5eb626860317e9cd5013e7f579cfa4bf64bd81125bd3ca7c38c1a49eda0
+  metadata.gz: cd8c34c33807e773c6f3bff976e1b095e35dd18e89e877da8f905af484d3d78b3765f6ac32c8770048f24ed993a3f24428b86a6de342cd79e439d377e586516f
+  data.tar.gz: cf8aa8ec4943ff7497387d5aa5f61c0a29b598dfa15a1d85f3cdbbdfd935ef732a75b9ac9b2110467c5f2afff09c671dd80464efee01856d637335e3f8ffbe53

data/README.md

@@ -21,28 +21,30 @@ Ensure you have Web Publishing Engine (XML Publishing) enabled. Please turn on S
 Configuration for initializing a server:
 
 * `host` - IP or hostname
-* `ssl` - `{ 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](https://github.com/lostisland/faraday/wiki/Setting-up-SSL-certificates)
 * `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)
+* `log` - A choice of `:simple`, `:curl` and `:curl_auth`. 
 
 ```ruby
 server = Filemaker::Server.new do |config|
-  config.host     = 'localhost'
-  config.account  = ENV['FILEMAKER_ACCOUNT']
-  config.password = ENV['FILEMAKER_PASSWORD']
-  config.ssl      = { verify: false }
-  config.log      = :curl
+  config.host         = ENV['FILEMAKER_HOST']
+  config.account_name = ENV['FILEMAKER_ACCOUNT_NAME']
+  config.password     = ENV['FILEMAKER_PASSWORD']
+  config.ssl          = { verify: false }
+  config.log          = :curl
 end
 
-server.databases.all                   # Using -dbnames
-server.database['candidates'].layouts  # Using -layoutnames and -db=candidates
+server.databases.all                      # Using -dbnames
+server.database['candidates'].layouts.all # Using -layoutnames and -db=candidates
+server.database['candidates'].scripts.all # Using -scriptnames and -db=candidates
 
 api = server.db['candidates'].lay['profile']
 api = server.db['candidates']['profile']
 api = server.database['candidates'].layout['profile']
 ```
 
-Once you are able to grab the `api`, you are golden and can make request to read/write to FileMaker API.
+Once you are able to grab the `api`, you are golden and can make requests to read/write to FileMaker API.
 
 ## Using the API
 
@@ -61,25 +63,31 @@ Most API will be smart enough to reject invalid query parameters if passed in in
 
 ## Using Filemaker::Model
 
-If you want ActiveModel-like access with a decent query DSL like `where`, `find`, `all`, you can include `Filemaker::Model` to your model. Your Rails form will work as well as JSON serialization.
+If you want ActiveModel-like access with a decent query DSL like `where`, `find`, `in`, you can include `Filemaker::Model` to your model. Your Rails form will work as well as JSON serialization.
 
 ```ruby
 class Job
   include Filemaker::Model
 
-  server :default # Taken from filemaker.yml config file
   database :jobs
   layout :job
+  
+  paginates_per 50
 
-  string :title, :requirements
-  datetime :created_at, :published_at
+  # Taken from filemaker.yml config file, default to :default
+  # Only use registry if you have multiple FileMaker servers you want to connect
+  registry :read_slave
+
+  string   :job_id, fm_name: 'JobOrderID', id: true
+  string   :title, :requirements
+  datetime :created_at
+  datetime :published_at, fm_name: 'ModifiedDate'
+  money    :salary
 
   validates :title, presence: true
 
-  def as_json(options = {})
-    options[:except] ||= [:created_at]
-    super(options)
-  end
+  belongs_to :company
+  has_many :applicants, class_name: 'JobApplication', reference_key: 'job_id'
 end
 ```
 
@@ -89,11 +97,114 @@ end
 development:
   default:
     host: localhost
+    account_name: ENV['FILEMAKER_ACCOUNT_NAME']
+    password: ENV['FILEMAKER_PASSWORD']
     ssl: true
+    log: :curl
+
+  read_slave:
+    host: ...
+    ssl: { verify: false }
+
+production:
+  default:
+    host: example.com
+    ssl: { ca_path: '/secret/path' }
 ```
 
 ## Query DSL
 
+### Using -find
+
+```ruby
+Model.where(gender: 'male', age: '< 50')    # Default -lop=and
+Model.where(gender: 'male').or(age: '< 50') # -lop=or
+Model.where(gender: 'male').not(age: 40)    # age.op=neq
+
+# Supply a block to configure additional options like
+# -script, -script.prefind, -lay.response, etc
+Model.where(gender: 'male').or(age: '< 50') do |option|
+  option[:script] = ['RemoveDuplicates', 20]
+end
+
+Model.where(gender: 'male').or(name: 'Lee').not(age: '=40')
+
+# Comparison operator
+
+Model.equals(candidate_id: '123')         # { candidate_id: '=123' }
+Model.contains(name: 'Chong')             # { name: '*Chong*' }
+Model.begins_with(salary: '2000...4000')  # ??
+Model.ends_with(name: 'Yong')             # { name: '*Yong' }
+Model.gt(age: 20)
+Model.gte(age: 20)
+Model.lt(age: 20)
+Model.lte(age: 20)
+Model.not(name: 'Bob')
+```
+
+### Using -findquery
+
+OR broadens the found set and AND narrows it
+
+```ruby
+# (q0);(q1)
+# (Singapore) OR (Malaysia)
+Model.in(nationality: %w(Singapore Malaysia))
+
+# (q0,q1)
+# Essentially the same as:
+# Model.where(nationality: 'Singapore', age: 30)
+Model.in(nationality: 'Singapore', age: 30)
+
+# (q0);(q1);(q2);(q3)
+Model.in({ nationality: %w(Singapore Malaysia) }, { age: [20, 30] })
+
+# (q0,q2);(q1,q2)
+# (Singapore AND male) OR (Malaysia AND male)
+Model.in(nationality: %w(Singapore Malaysia), gender: 'male')
+
+# !(q0);!(q1)
+# NOT(Singapore) OR NOT(Malaysia)
+Model.not_in(nationality: %w(Singapore Malaysia))
+
+# !(q0,q1)
+Model.not_in(name: 'Lee', age: '< 40')
+
+# !(q0);!(q1)
+# Must be within an array of hashes
+Model.not_in([{ name: 'Lee' }, { age: '< 40' }])
+
+# (q0);(q1);!(q2,q3)
+Model.in(nationality: %w(Singapore Malaysia)).not_in(name: 'Lee', age: '< 40')
+```
+
+- [x] Please test the above query with real data to ensure correctness!
+- [x] Please test the comparison operators with keyword as well as applied to value.
+- [x] Test serialization of BigDecimal and other types.
+
+## Pagination
+
+If you have [kaminari](https://github.com/amatsuda/kaminari) in your project's `Gemfile`, `Filemaker::Model` will use it to page through the returned collection.
+
+```ruby
+Job.where(title: 'admin').per(50) # default to page(1)
+Job.where(title: 'admin').page(5) # default to per(25)
+Job.where(title: 'admin').page(2).per(35)
+
+# In your model, you can customize the per_page
+class Job
+  include Filemaker::Model
+
+  database :jobs
+  layout :job
+  
+  paginates_per 50
+
+end
+
+Job.per_page # => 50
+```
+
 ## Credits
 
 This project is heavily inspired by the following Filemaker Ruby effort and several other ORM gems.
@@ -101,6 +212,7 @@ This project is heavily inspired by the following Filemaker Ruby effort and seve
 * [Rfm](https://github.com/lardawge/rfm)
 * [ginjo/rfm](https://github.com/ginjo/rfm)
 * [mongoid](https://github.com/mongoid/mongoid)
+* [origin](https://github.com/mongoid/origin)
 * [elasticsearch-ruby](https://github.com/elasticsearch/elasticsearch-ruby)
 
 ## Contributing

data/filemaker.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'faraday'
   spec.add_runtime_dependency 'typhoeus'
   spec.add_runtime_dependency 'nokogiri'
+  spec.add_runtime_dependency 'activemodel'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/filemaker.rb

@@ -11,3 +11,50 @@ require 'filemaker/record'
 require 'filemaker/layout'
 require 'filemaker/script'
 require 'filemaker/error'
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_model'
+
+require 'filemaker/model/criteria'
+require 'filemaker/model'
+
+require 'yaml'
+
+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)
+    sessions = YAML.load(ERB.new(File.new(path).read).result)[environment.to_s]
+    fail Error::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
+          fail Error::ConfigurationError, 'Missing config.host'
+        end
+
+        config.account_name = value.fetch('account_name') do
+          fail Error::ConfigurationError, 'Missing config.account_name'
+        end
+
+        config.password = value.fetch('password') do
+          fail Error::ConfigurationError, 'Missing config.password'
+        end
+
+        config.ssl = value['ssl'] if value['ssl']
+        config.log = value['log'] if value['log']
+        config.endpoint = value['endpoint'] if value['endpoint']
+      end
+    end
+  end
+
+  def registry
+    @registry ||= {}
+  end
+end
+
+require 'filemaker/railtie' if defined?(Rails)

data/lib/filemaker/api/query_commands/findquery.rb

@@ -6,18 +6,30 @@ module Filemaker
       # query(status: 'open', title: 'web') => (q0,q1)
       # query(status: %w(open closed))      => (q0);(q1)
       #
-      def query(array_hash)
+      def query(array_hash, options = {})
         compound_find = CompoundFind.new(array_hash)
 
         query_hash = compound_find.key_values.merge(
           '-query' => compound_find.key_maps_string
         )
 
-        findquery(query_hash)
+        findquery(query_hash, options)
       end
 
       # Raw -findquery if you want to construct your own.
       def findquery(query_hash, options = {})
+        valid_options(options,
+                      :max,
+                      :skip,
+                      :sortfield,
+                      :sortorder,
+                      :lay_response,
+                      :script,
+                      :script_prefind,
+                      :script_presort,
+                      :relatedsets_filter,
+                      :relatedsets_max)
+
         perform_request('-findquery', query_hash, options)
       end
 
@@ -39,6 +51,10 @@ module Filemaker
           translate_key_maps
         end
 
+        def to_s
+          "#{key_values}, #{key_maps_string}"
+        end
+
         private
 
         def build_key_values(hash)
@@ -65,7 +81,8 @@ module Filemaker
           len = q_tag_array.length
           result = q_tag_array.flatten.combination(len).select do |c|
             q_tag_array.all? { |a| (a & c).size > 0 }
-          end.each { |c| c.unshift('-omit') if omit }
+          end
+          result = result.each { |c| c.unshift('-omit') if omit }
           @key_maps.concat result
         end
 

data/lib/filemaker/configuration.rb

@@ -13,7 +13,7 @@ module Filemaker
 
     %w(host account_name password).each do |name|
       define_method "#{name}_missing?" do
-        (send(name.to_sym) || '').empty?
+        (public_send(name.to_sym) || '').empty?
       end
     end
 

data/lib/filemaker/core_ext/hash.rb

@@ -1,18 +1,3 @@
-class Hash
-  def transform_keys
-    return enum_for(:transform_keys) unless block_given?
-    result = self.class.new
-    each_key do |key|
-      result[yield(key)] = self[key]
-    end
-    result
-  end
-
-  def stringify_keys
-    transform_keys { |key| key.to_s }
-  end
-end
-
 module Filemaker
   class HashWithIndifferentAndCaseInsensitiveAccess < Hash
     def []=(key, value)
@@ -23,6 +8,25 @@ module Filemaker
       super(convert_key(key))
     end
 
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :member?, :key?
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def values_at(*indices)
+      indices.map { |key| self[convert_key(key)] }
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
     protected
 
     def convert_key(key)

data/lib/filemaker/error.rb

@@ -4,6 +4,7 @@ module Filemaker
     class AuthenticationError < StandardError; end
     class ParameterError < StandardError; end
     class CoerceError < StandardError; end
+    class ConfigurationError < StandardError; end
 
     class FilemakerError < StandardError
       attr_reader :code
@@ -35,6 +36,7 @@ module Filemaker
     class ScriptMissingError < MissingError; end
     class LayoutMissingError < MissingError; end
     class TableMissingError < MissingError; end
+    class InvalidFieldError < StandardError; end
 
     class SecurityError < FilemakerError; end
     class RecordAccessDeniedError < SecurityError; end
@@ -68,6 +70,9 @@ module Filemaker
     class UnableToCreateTempFileError < FileError; end
     class UnableToOpenFileError < FileError; end
 
+    class QueryError < StandardError; end
+    class MixedClauseError < QueryError; end
+
     def self.raise_error_by_code(code)
       msg = error_message_by_code(code)
       error_class = find_error_class_by_code(code)

data/lib/filemaker/metadata/field.rb

@@ -43,8 +43,23 @@ module Filemaker
         when 'date'
           # date_format likely will be '%m/%d/%Y', but if we got '19/8/2014',
           # then `strptime` will raise invalid date error
-          Date.strptime(value, @resultset.date_format)
-          # Date.strptime(Date.parse(value).strftime(@resultset.date_format), @resultset.date_format)
+          # Sometimes we can get '27/11 /1981' also :(
+          begin
+            Date.strptime(value, @resultset.date_format)
+          rescue
+            # We could be getting back these date:
+            # '17.12.95', '19/05/99', '27/11 /1981'
+            # '1959-07-03' will be beyong us, so consider returning nil
+            value = value.gsub(/-|\./, '/')
+            split = value.split('/').map(&:strip)
+            split[2] = "19#{split[2]}" if split[2].size == 2
+            value = split.join('/')
+
+            Date.strptime(
+              Date.parse(value)
+                .strftime(@resultset.date_format), @resultset.date_format
+            )
+          end
         when 'time'
           DateTime.strptime("1/1/-4712 #{value}", @resultset.timestamp_format)
         when 'timestamp'
@@ -54,9 +69,10 @@ module Filemaker
         else
           value
         end
-      rescue Exception => e
-        msg = "Could not coerce #{value} due to #{e.message}"
-        raise Filemaker::Error::CoerceError, msg
+      rescue
+        warn "Could not coerce #{value}. Return nil instead."
+        nil
+        # raise Filemaker::Error::CoerceError, msg
       end
 
       private

data/lib/filemaker/model.rb

@@ -0,0 +1,132 @@
+require 'filemaker/model/components'
+
+module Filemaker
+  module Model
+    extend ActiveSupport::Concern
+    include Components
+
+    # @return [Boolean] indicates if this is a new fresh record
+    attr_reader :attributes, :new_record, :record_id, :mod_id
+
+    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)
+      @new_record = true
+      @attributes = {}
+      @relations = {}
+      apply_defaults
+      process_attributes(attrs)
+    end
+
+    def new_record?
+      new_record
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def to_a
+      [self]
+    end
+
+    def id
+      self.class.identity ? identity_id : record_id
+    end
+
+    def identity_id
+      public_send(identity.name) if identity
+    end
+
+    def to_param
+      id.to_s if id
+    end
+
+    def fm_attributes
+      self.class.with_model_fields(attributes)
+    end
+
+    private
+
+    def process_attributes(attrs)
+      attrs ||= {}
+      return if attrs.empty?
+
+      attrs.each_pair do |key, value|
+        public_send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+    module ClassMethods
+      def database(db)
+        self.db = db
+        self.registry_name ||= 'default' unless lay.blank?
+        register
+      end
+
+      def layout(lay)
+        self.lay = lay
+        self.registry_name ||= 'default' unless db.blank?
+        register
+      end
+
+      def registry(name)
+        self.registry_name = (name || 'default').to_s
+        register
+      end
+
+      def register
+        self.server = Filemaker.registry[registry_name]
+        self.api = server.db[db][lay] if server && db && lay
+      end
+
+      # A chance for the model to set it's per_page.
+      def paginates_per(value)
+        self.per_page = value.to_i
+      end
+
+      # Make use of -view to return an array of [name, data_type] for this
+      # model from FileMaker.
+      #
+      # @return [Array] array of [name, data_type]
+      def fm_fields
+        api.view.fields.values.map { |field| [field.name, field.data_type] }
+      end
+
+      # Filter out any fields that do not match model's fields.
+      #
+      # A testing story to tell: when working on `in` query, we have value that
+      # 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)
+        accepted_fields = {}
+
+        criterion.each_pair do |key, value|
+          field = find_field_by_name(key)
+
+          next unless field
+
+          # We do not serialize at this point, as we are still in Ruby-land.
+          # Filemaker::Server will help us serialize into FileMaker format.
+          if value.is_a? Array
+            temp = []
+            value.each do |v|
+              temp << (coerce ? field.coerce(v) : v)
+            end
+
+            accepted_fields[field.fm_name] = temp
+          else
+            accepted_fields[field.fm_name] = \
+              coerce ? field.coerce(value) : value
+          end
+        end
+
+        accepted_fields
+      end
+    end
+  end
+end