filemaker 0.0.1 → 0.0.2

data/lib/filemaker/model/builder.rb

@@ -0,0 +1,52 @@
+module Filemaker
+  module Model
+    module Builder
+      module_function
+
+      # Given an array of resultset, build out the exact same number of model
+      # objects.
+      def collection(resultset, klass)
+        models = []
+
+        resultset.each do |record|
+          object = klass.new
+
+          object.instance_variable_set('@new_record', false)
+          object.instance_variable_set('@record_id', record.record_id)
+          object.instance_variable_set('@mod_id', record.mod_id)
+
+          record.keys.each do |fm_field_name|
+            # record.keys are all lowercase
+            field = klass.find_field_by_name(fm_field_name)
+            next unless field
+
+            object.public_send("#{field.name}=", record[fm_field_name])
+          end
+
+          models << object
+        end
+
+        models
+      end
+
+      def single(resultset, klass)
+        record = resultset.first
+        object = klass.new
+
+        object.instance_variable_set('@new_record', false)
+        object.instance_variable_set('@record_id', record.record_id)
+        object.instance_variable_set('@mod_id', record.mod_id)
+
+        record.keys.each do |fm_field_name|
+          # record.keys are all lowercase
+          field = klass.find_field_by_name(fm_field_name)
+          next unless field
+
+          object.public_send("#{field.name}=", record[fm_field_name])
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/filemaker/model/components.rb

@@ -0,0 +1,25 @@
+require 'filemaker/model/fields'
+require 'filemaker/model/findable'
+require 'filemaker/model/relations'
+require 'filemaker/model/persistable'
+
+module Filemaker
+  module Model
+    module Components
+      extend ActiveSupport::Concern
+
+      included do
+        extend Findable
+        extend ActiveModel::Callbacks
+      end
+
+      include ActiveModel::Model
+      include ActiveModel::Serializers::JSON
+      include ActiveModel::Serializers::Xml
+      include ActiveModel::Validations::Callbacks
+      include Fields
+      include Relations
+      include Persistable
+    end
+  end
+end

data/lib/filemaker/model/criteria.rb

@@ -0,0 +1,101 @@
+require 'filemaker/model/selectable'
+require 'filemaker/model/optional'
+require 'filemaker/model/builder'
+require 'filemaker/model/pagination'
+
+module Filemaker
+  module Model
+    # Criteria encapsulates query arguments and options to represent a single
+    # query. It has convenient query DSL like +where+ and +in+ to represent both
+    # -find and -findquery FileMaker query. On top of that you can negate any
+    # query with the +not+ clause to omit selection.
+    class Criteria
+      include Enumerable
+      include Selectable
+      include Optional
+      include Pagination
+
+      # @return [Filemaker::Model] the class of the model
+      attr_reader :klass
+
+      # @return [Hash. Array] represents the query arguments
+      attr_reader :selector
+
+      # @return [Hash] options like skip, limit and order
+      attr_reader :options
+
+      # @return [Array] keep track of where clause and in clause to not mix them
+      attr_reader :chains
+
+      def initialize(klass)
+        @klass    = klass
+        @options  = {}
+        @chains   = []
+        @_page    = 1
+      end
+
+      def to_s
+        "#{selector}, #{options}"
+      end
+
+      def each
+        execute.each { |record| yield record } if block_given?
+      end
+
+      def first
+        limit(1).execute.first
+      end
+
+      def all
+        execute
+      end
+
+      def limit?
+        !options[:max].nil?
+      end
+
+      # The count this criteria is capable of returning
+      #
+      # @return [Integer] the count
+      def count
+        limit(0)
+        if chains.include?(:where)
+          klass.api.find(selector, options).count
+        elsif chains.include?(:in)
+          klass.api.query(selector, options).count
+        else
+          klass.api.findall(options).count
+        end
+      end
+
+      protected
+
+      def execute
+        resultset = []
+        paginated = chains.include?(:page)
+
+        if chains.include?(:where)
+          # Use -find
+          resultset = klass.api.find(selector, options)
+        elsif chains.include?(:in)
+          # Use -findquery
+          resultset = klass.api.query(selector, options)
+        else
+          # Use -findall
+          limit(1) unless limit?
+          resultset = klass.api.findall(options)
+        end
+
+        models = Filemaker::Model::Builder.collection(resultset, klass)
+
+        if defined?(Kaminari) && paginated
+          Kaminari.paginate_array(models, resultset.count)
+            .page(@_page)
+            .per(options[:max])
+        else
+          models
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/field.rb

@@ -0,0 +1,38 @@
+module Filemaker
+  module Model
+    class Field
+      attr_reader :name, :type, :default_value, :fm_name
+
+      def initialize(name, type, options = {})
+        @name = name
+        @type = type
+        @default_value = coerce(options.fetch(:default) { nil })
+
+        # We need to downcase because Filemaker::Record is
+        # HashWithIndifferentAndCaseInsensitiveAccess
+        @fm_name = (options.fetch(:fm_name) { name }).to_s.downcase
+      end
+
+      # From FileMaker to Ruby
+      def coerce(value)
+        return nil if value.nil?
+
+        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
+          Date.parse(value.to_s)
+        elsif @type == DateTime
+          return value if value.is_a? DateTime
+          DateTime.parse(value.to_s)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/fields.rb

@@ -0,0 +1,80 @@
+require 'filemaker/model/field'
+
+module Filemaker
+  module Model
+    module Fields
+      extend ActiveSupport::Concern
+
+      TYPE_MAPPINGS = {
+        string: String,
+        date: Date,
+        datetime: DateTime,
+        money: BigDecimal,
+        integer: Integer,
+        number: BigDecimal
+      }
+
+      included do
+        class_attribute :fields, :identity
+        self.fields = {}
+      end
+
+      def apply_defaults
+        attribute_names.each do |name|
+          field = fields[name]
+          attributes[name] = field.default_value
+        end
+      end
+
+      def attribute_names
+        self.class.attribute_names
+      end
+
+      def fm_names
+        fields.values.map(&:fm_name)
+      end
+
+      module ClassMethods
+        def attribute_names
+          fields.keys
+        end
+
+        %w(string date datetime money integer number).each 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)
+              create_accessors(name)
+            end
+          end
+        end
+
+        def add_field(name, type, options)
+          fields[name] = Filemaker::Model::Field.new(name, type, options)
+          self.identity = fields[name] if options[:identity]
+        end
+
+        def create_accessors(name)
+          define_method(name) { attributes[name] }
+          define_method("#{name}=") do |value|
+            attributes[name] = fields[name].coerce(value)
+          end
+          define_method("#{name}?") do
+            attributes[name] == true || attributes[name].present?
+          end
+        end
+
+        # Find FileMaker's real name given either the attribute name or the real
+        # FileMaker name.
+        def find_field_by_name(name)
+          fields.values.find do |f|
+            f.name == name.to_sym || f.fm_name == name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/filemaker/model/findable.rb

@@ -0,0 +1,35 @@
+module Filemaker
+  module Model
+    module Findable
+      delegate \
+        :limit,
+        :skip,
+        :order,
+        :find,
+        :first,
+        :recid,
+        :in,
+        :not_in,
+        :or,
+        :eq,
+        :cn,
+        :bw,
+        :ew,
+        :gt,
+        :gte,
+        :lt,
+        :lte,
+        :neq,
+        :equals,
+        :contains,
+        :begins_with,
+        :ends_with,
+        :not,
+        :where, to: :criteria
+
+      def criteria
+        Criteria.new(self)
+      end
+    end
+  end
+end

data/lib/filemaker/model/optional.rb

@@ -0,0 +1,69 @@
+module Filemaker
+  module Model
+    module Optional
+      # Number of records to skip. For pagination.
+      #
+      # @param [Integer] value The number to skip.
+      #
+      # @return [Filemaker::Model::Criteria]
+      def skip(value)
+        return self if value.nil?
+        options[:skip] = value.to_i
+        yield options if block_given?
+        self
+      end
+
+      # Limit the number of records returned.
+      #
+      # @param [Integer] value The number of records to return.
+      #
+      # @return [Filemaker::Model::Criteria]
+      def limit(value)
+        return self if value.nil?
+        options[:max] = value.to_i
+        yield options if block_given?
+        self
+      end
+
+      # Order the records. Model field name will be converted to real FileMaker
+      # field name.
+      #
+      # @example Sort is position aware!
+      #   criteria.order('name desc, email')
+      #
+      # @param [String] value The sorting string
+      #
+      # @return [Filemaker::Model::Criteria]
+      def order(value)
+        return self if value.nil?
+        sortfield = []
+        sortorder = []
+        sort_spec = value.split(',').map(&:strip)
+
+        sort_spec.each do |spec|
+          fieldname, direction = spec.split(' ')
+          direction = 'asc' unless direction
+
+          field = klass.find_field_by_name(fieldname)
+
+          next unless field
+
+          direction = 'ascend' if direction.downcase == 'asc'
+          direction = 'descend' if direction.downcase == 'desc'
+
+          sortfield << field.fm_name
+          sortorder << direction
+        end
+
+        unless sortfield.empty?
+          options[:sortfield] = sortfield
+          options[:sortorder] = sortorder
+        end
+
+        yield options if block_given?
+
+        self
+      end
+    end
+  end
+end

data/lib/filemaker/model/pagination.rb

@@ -0,0 +1,41 @@
+module Filemaker
+  module Model
+    module Pagination
+      # Calling `page` will trigger pagination.
+      def page(value)
+        chains << :page
+        @_page = value.to_i
+        update_skip
+      end
+
+      def per(value)
+        limit(value)
+        update_skip
+      end
+
+      # A simple getter to retrieve the current page value. If no one set it up
+      # through the `page(4)` way, then at least it defaults to 1.
+      def __page
+        @_page || 1
+      end
+
+      # A simple getter to retrieve the limit value. It will default to
+      # Model.per_page
+      #
+      # Will have stacklevel too deep if we have `per(nil)`. Somehow, the
+      # `per_page` must be set either at the `Model.per_page`,
+      # `Kaminari.config.default_per_page`, or right here where I just throw a
+      # 25 value at it.
+      def __per
+        per(klass.per_page || 25) unless limit?
+        options[:max]
+      end
+
+      def update_skip
+        skip = (__page - 1) * __per
+        skip(skip) unless skip.zero?
+        self
+      end
+    end
+  end
+end