filemaker 0.0.1 → 0.0.2

data/lib/filemaker/model/persistable.rb

@@ -0,0 +1,96 @@
+module Filemaker
+  module Model
+    module Persistable
+      extend ActiveSupport::Concern
+
+      included do
+        define_model_callbacks :save, :create, :update, :destroy
+      end
+
+      # Call save! but do not raise error.
+      def save
+        save!
+      rescue
+        errors.add(:base) << $! # Does this works?
+        nil
+      end
+
+      def save!
+        run_callbacks :save do
+          new_record? ? create : update
+        end
+      end
+
+      def create
+        return false unless valid?
+
+        run_callbacks :create do
+          options = {}
+          yield options if block_given?
+          resultset = api.new(fm_attributes, options)
+          replace_new_data(resultset)
+        end
+        self
+      end
+
+      def update
+        return false unless valid?
+
+        run_callbacks :update do
+          # Will raise `RecordModificationIdMismatchError` if does not match
+          options = { modid: mod_id } # Always pass in?
+          yield options if block_given?
+          resultset = api.edit(record_id, fm_attributes, options)
+          replace_new_data(resultset)
+        end
+        self
+      end
+
+      def update_attributes(attrs = {})
+        return self if attrs.blank?
+        assign_attributes(attrs)
+        save
+      end
+
+      # Use -delete to remove the record backed by the model.
+      # @return [Filemaker::Model] frozen instance
+      def destroy
+        return if new_record?
+
+        run_callbacks :destroy do
+          options = {}
+          yield options if block_given?
+          api.delete(record_id, options)
+        end
+        freeze
+      end
+      alias_method :delete, :destroy
+
+      def assign_attributes(new_attributes)
+        return if new_attributes.blank?
+        new_attributes.each_pair do |key, value|
+          public_send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      private
+
+      # If you have calculated field from FileMaker, it will be replaced.
+      def replace_new_data(resultset)
+        record = resultset.first
+
+        @new_record = false
+        @record_id = record.record_id
+        @mod_id = record.mod_id
+
+        record.keys.each do |fm_field_name|
+          # record.keys are all lowercase
+          field = self.class.find_field_by_name(fm_field_name)
+          next unless field
+
+          public_send("#{field.name}=", record[fm_field_name])
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/relations.rb

@@ -0,0 +1,72 @@
+require 'filemaker/model/relations/belongs_to'
+require 'filemaker/model/relations/has_many'
+
+module Filemaker
+  module Model
+    # Model relationships such as has_many, belongs_to, and has_portal.
+    module Relations
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :relations
+      end
+
+      module ClassMethods
+        def has_many(name, options = {})
+          relate_collection(Relations::HasMany, name, options)
+        end
+
+        def belongs_to(name, options = {})
+          relate_single(Relations::BelongsTo, name, options)
+        end
+
+        def has_portal(name, options = {})
+          Relations::HasPortal.new(self, name, options)
+        end
+
+        protected
+
+        # Get the single model and cache it to `relations`
+        def relate_single(type, name, options)
+          name = name.to_s
+
+          # Reader
+          #
+          # @example Reload the record
+          #   job.company(true)
+          define_method(name) do |force_reload = false|
+            if force_reload
+              @relations[name] = type.new(self, name, options)
+            else
+              @relations[name] ||= type.new(self, name, options)
+            end
+          end
+
+          # Writer
+          #
+          # TODO: What happen if `object` is brand new? We would want to save
+          # the child as well as the parent. We need to wait for the child to
+          # save and return the identity ID, then we update the parent's
+          # reference_key.
+          define_method("#{name}=") do |object|
+            params = { "#{name}_id" => object.public_send("#{name}_id") }
+            update_attributes(params)
+          end
+
+          # Creator
+          # define_method("create_#{name}") do |attrs = {}|
+          # end
+        end
+
+        # For collection, we will return criteria and not cache anything.
+        def relate_collection(type, name, options)
+          name = name.to_s
+
+          define_method(name) do
+            type.new(self, name, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/relations/belongs_to.rb

@@ -0,0 +1,30 @@
+require 'filemaker/model/relations/proxy'
+
+module Filemaker
+  module Model
+    module Relations
+      class BelongsTo < Proxy
+        def initialize(owner, name, options)
+          super(owner, name, options)
+          build_target
+        end
+
+        def reference_key
+          options.fetch(:reference_key) { "#{@name}_id" }
+        end
+
+        protected
+
+        def build_target
+          key_value = owner.public_send(reference_key.to_sym)
+
+          if key_value.blank?
+            @target = nil
+          else
+            @target = target_class.where(reference_key => "=#{key_value}").first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/relations/has_many.rb

@@ -0,0 +1,79 @@
+require 'filemaker/model/relations/proxy'
+
+module Filemaker
+  module Model
+    module Relations
+      class HasMany < Proxy
+        def initialize(owner, name, options)
+          super(owner, name, options)
+          build_target
+        end
+
+        # If no reference_key, we will use owner's identity field. If there is
+        # no identity, we will...??
+        def reference_key
+          options.fetch(:reference_key) { owner.identity.name }
+        end
+
+        # Append a model or array of models to the relation. Will set the owner
+        # ID to the children.
+        #
+        # @example Append a model
+        #   job.applicants << applicant
+        #
+        # @example Array of models
+        #   job.applicants << [applicant_a, applicant_b, applicant_c]
+        #
+        # @param [Filemaker::Model, Array<Filemaker::Model>] *args
+        def <<(*args)
+          docs = args.flatten
+          return concat(docs) if docs.size > 1
+          if (doc = docs.first)
+            create(doc)
+          end
+          self
+        end
+        alias_method :push, :<<
+
+        # def concat(docs)
+        #   # TODO: Find out how to do batch insert in FileMaker
+        # end
+
+        # Build a single model. The owner will be linked, but the record will
+        # not be saved.
+        #
+        # @example Append a model
+        #   job.applicants.build(name: 'Bob')
+        #   job.save
+        #
+        # @param [Hash] attrs The attributes for the fields
+        #
+        # @return [Filemaker::Model] the actual model
+        def build(attrs = {})
+          attrs.merge!(owner.identity.name => owner.identity_id) if \
+            owner.identity_id
+          target_class.new(attrs)
+        end
+
+        # Same as `build`, except that it will be saved automatically.
+        #
+        # @return [Filemaker::Model] the actual saved model
+        def create(attrs = {})
+          build(attrs).save
+        end
+
+        protected
+
+        def build_target
+          key_value = owner.public_send(reference_key.to_sym)
+
+          if key_value.blank?
+            @target = nil # Or should we return empty array?
+          else
+            @target = target_class.where(reference_key => "=#{key_value}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/relations/proxy.rb

@@ -0,0 +1,35 @@
+module Filemaker
+  module Model
+    module Relations
+      # A proxy is a class to send all unknown methods to it's target. The
+      # target here will be the eventual associated model.
+      class Proxy
+        instance_methods.each do |method|
+          undef_method(method) unless
+            method =~ /(^__|^send|^object_id|^respond_to|^tap|^extend)/
+        end
+
+        attr_accessor :owner, :target, :options
+
+        # @param [Filemaker::Layout] owner The instance of the model
+        # @param [String] name The relationship name
+        # @param [Hash] options Relationship options
+        def initialize(owner, name, options)
+          @owner = owner
+          @name = name
+          @options = options
+          @class_name = options.fetch(:class_name) { name.to_s.classify }
+        end
+
+        def target_class
+          return @class_name if @class_name.is_a?(Class)
+          @class_name.constantize
+        end
+
+        def method_missing(name, *args, &block)
+          target.send(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/selectable.rb

@@ -0,0 +1,146 @@
+module Filemaker
+  module Model
+    module Selectable
+      # Find records based on query hash.
+      #
+      # @param [Hash] criterion Hash criterion
+      #
+      # @return [Filemaker::Model::Criteria]
+      def where(criterion)
+        fail Filemaker::Error::MixedClauseError,
+             "Can't mix 'where' with 'in'." if chains.include?(:in)
+        chains.push(:where)
+
+        @selector ||= {}
+        selector.merge!(klass.with_model_fields(criterion))
+        yield options if block_given?
+        self
+      end
+
+      # Find records based on model ID. If passed a hash, will use `where`.
+      # On the last resort, if we seriously can't find using `where`, we find
+      # it thru the `recid`. Is this a good design? We will see in production.
+      # Performance note: 2 HTTP requests if going that last resort route.
+      #
+      # @example Find by model ID.
+      #   Model.find('CAID324')
+      #
+      # @example Find with a Hash. This will delegate to `where`.
+      #   Model.find(name: 'Bob', salary: 4000)
+      #
+      # @param [Integer, String, Hash] criterion
+      #
+      # @return [Filemaker::Model::Criteria, Filemaker::Model]
+      def find(criterion)
+        return where(criterion) if criterion.is_a? Hash
+
+        # Find using model ID (may not be the -recid)
+        id = criterion.to_s.gsub(/\A=*/, '=') # Always append '=' for ID
+
+        # If we are finding with ID, we just limit to one and return
+        # immediately. Last resort is to use the recid to find.
+        where(klass.identity.name => id).first || recid(criterion)
+      end
+
+      # Using FileMaker's internal ID to find the record.
+      def recid(id)
+        return nil if id.blank?
+
+        @selector ||= {}
+        selector['-recid'] = id
+        chains.push(:where)
+        first
+      end
+
+      %w(eq cn bw ew gt gte lt lte neq).each do |operator|
+        define_method(operator) do |criterion, &block|
+          fail Filemaker::Error::MixedClauseError,
+               "Can't mix 'where' with 'in'." if chains.include?(:in)
+          chains.push(operator.to_sym)
+          chains.push(:where) unless chains.include?(:where) # Just one time
+          @selector ||= {}
+
+          if operator == 'bw'
+            criterion = klass.with_model_fields(criterion, false)
+          else
+            criterion = klass.with_model_fields(criterion)
+          end
+
+          criterion.each_key do |key|
+            selector["#{key}.op"] = operator
+          end
+
+          selector.merge!(criterion)
+
+          # Inside define_method, we cannot have yield or block_given?, so we
+          # just use &block
+          block.call(options) if block
+          self
+        end
+      end
+
+      alias_method :equals, :eq
+      alias_method :contains, :cn
+      alias_method :begins_with, :bw
+      alias_method :ends_with, :ew
+      alias_method :not, :neq
+
+      # Find records based on FileMaker's compound find syntax.
+      #
+      # @example Find using a single hash
+      #   Model.in(nationality: %w(Singapore Malaysia))
+      #
+      # @example Find using an array of hashes
+      #   Model.in([{nationality: %w(Singapore Malaysia)}, {age: [20, 30]}])
+      #
+      # @param [Hash, Array]
+      #
+      # @return [Filemaker::Model::Criteria]
+      def in(criterion, negating = false)
+        fail Filemaker::Error::MixedClauseError,
+             "Can't mix 'in' with 'where'." if chains.include?(:where)
+        chains.push(:in)
+        @selector ||= []
+
+        become_array(criterion).each do |hash|
+          accepted_hash = klass.with_model_fields(hash)
+          accepted_hash.merge!('-omit' => true) if negating
+          @selector << accepted_hash
+        end
+
+        yield options if block_given?
+        self
+      end
+
+      # Simply append '-omit' => true to all criteria
+      def not_in(criterion)
+        self.in(criterion, true)
+      end
+
+      # Used with `where` to specify how the queries are combined. Default is
+      # 'and', so you won't find any `and` method.
+      #
+      # @example Mix with where to 'or' query
+      #   Model.where(name: 'Bob').or(age: '50')
+      #
+      # @param [Hash] criterion Hash criterion
+      #
+      # @return [Filemaker::Model::Criteria]
+      def or(criterion)
+        fail Filemaker::Error::MixedClauseError,
+             "Can't mix 'or' with 'in'." if chains.include?(:in)
+        @selector ||= {}
+        selector.merge!(klass.with_model_fields(criterion))
+        options[:lop] = 'or'
+        yield options if block_given?
+        self
+      end
+
+      private
+
+      def become_array(value)
+        value.is_a?(Array) ? value : [value]
+      end
+    end
+  end
+end