fm_store 0.1

data/lib/fm_store/criterion/optional.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module FmStore
+  module Criterion
+    module Optional
+      # Tell FileMaker how many records in the found set to skip.
+      # Use together with +limit+ to page through the records
+      def skip(value = 20)
+        @options[:skip_records] = value
+        self
+      end
+      
+      def limit(value = 20)
+        @options[:max_records] = value
+        self
+      end
+      
+      # +ascend+ or +descend+
+      def order(field_and_orders)
+        sorts = field_and_orders.split(",").map(&:strip)
+        sort_field = []
+        sort_order = []
+        
+        sorts.each do |s|
+          field, order = s.split(" ")
+          order = "asc" unless order
+          
+          fm_name = klass.find_fm_name(field)
+          
+          order = "ascend" if order.downcase == "asc"
+          order = "descend" if order.downcase == "desc"
+          
+          sort_field << fm_name
+          sort_order << order
+        end
+        
+        @options[:sort_field] = sort_field
+        @options[:sort_order] = sort_order
+        
+        self
+      end
+      
+      # logical_operator
+      # modification_id
+    end
+  end
+end

data/lib/fm_store/ext/field.rb

@@ -0,0 +1,20 @@
+module Rfm
+  module Metadata
+    class Field
+      def coerce(value, resultset)
+        return nil if (value.nil? || value.empty?)
+        case self.result
+        when "text"      then value
+        when "number"    then BigDecimal.new(value)
+        when "date"      then Date.strptime(value, resultset.date_format)
+        when "time"      then DateTime.strptime("1/1/-4712 #{value}", "%m/%d/%Y #{resultset.time_format}")
+        when "timestamp" then DateTime.strptime(value, resultset.timestamp_format)
+        when "container" then URI.parse("#{resultset.server.scheme}://#{resultset.server.host_name}:#{resultset.server.port}#{value}")
+        else nil
+        end
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/fm_store/field.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module FmStore
+  class Field
+    attr_reader :name, :type, :fm_name, :searchable, :identity
+    
+    def initialize(name, type, options = {})
+      @name = name
+      @fm_name = options[:fm_name] || name
+      @type = type
+      @searchable = options[:searchable] || false
+      @identity = options[:identity] || false
+    end
+  end
+end

data/lib/fm_store/fields.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module FmStore
+  module Fields
+    extend ActiveSupport::Concern
+    
+    included do
+      class_inheritable_accessor :fields
+      
+      self.fields = {}
+    end
+    
+    module ClassMethods
+      # Defines all the fields that are available from the layout.
+      def field(name, type, options = {})
+        set_field(name.to_s, type, options)
+      end
+      
+      protected
+      
+      def set_field(name, type, options)
+        # We key FileMaker name rather then user specified name
+        fields[options[:fm_name] || name] = Field.new(name, type, options)
+        create_accessors(name)
+      end
+      
+      def create_accessors(name)
+        define_method(name) { instance_variable_get("@#{name}") }
+        define_method("#{name}=") { |value| instance_variable_set("@#{name}", value) }
+        define_method("#{name}?") do
+          attr = instance_variable_get("@#{name}")
+          (@type == Boolean) ? attr == true : attr.present?
+        end
+      end
+    end
+  end
+end

data/lib/fm_store/finders.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module FmStore
+  module Finders
+    
+    # Criteria
+    [:where, :limit, :skip, :order, :exclude, :search, :id, :fm_id].each do |name|
+      define_method(name) do |*args|
+        criteria.send(name, *args)
+      end
+    end
+    
+    [:in, :custom_query].each do |name|
+      define_method(name) do |*args|
+        criteria_query.send(name, *args)
+      end
+    end
+    
+    def criteria
+      Criteria.new(self)
+    end
+    
+    def criteria_query
+      Criteria.new(self, true)
+    end
+    
+    # Will always return an array properly cast to the correct type
+    # def find(hash_or_record_id, options = {})
+    #   where(hash_or_record_id, options)
+    # end
+    
+    def total
+      criteria.paginate(:per_page => 1).total_entries
+    end
+    
+  end
+end

data/lib/fm_store/layout.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+module FmStore
+  module Layout
+    extend ActiveSupport::Concern
+
+    included do
+      include FmStore::Components
+      self.include_root_in_json = false
+
+      cattr_accessor :layout, :database
+
+      attr_reader :new_record, :record_id, :mod_id
+
+      define_model_callbacks :create, :save, :update, :validation, :destroy
+    end
+
+    module ClassMethods
+      def set_layout(layout)
+        self.layout = layout
+      end
+
+      def set_database(database)
+        self.database = database
+      end
+
+      # Calling self.fields will ideally match here
+      # See FieldControl
+      def fm_fields
+        conn = Connection.establish_connection(self)
+        rs = conn.any.first.keys.inspect
+      end
+
+      # Return the real FileMaker, nil otherwise
+      def find_fm_name(attribute_name)
+        if fields.has_key?(attribute_name)
+          return attribute_name
+        else
+          f = fields.find { |a| a.last.name == attribute_name }
+
+          f.last.fm_name if f
+        end
+      end
+
+      def find_fm_type(attribute_name)
+        f = fields.find { |a| a.last.name == attribute_name }
+
+        f.last.type if f
+      end
+
+      def searchable_fields
+        fields.map(&:last).select(&:searchable).map(&:name)
+      end
+
+      def identity
+        fields.map(&:last).find(&:identity).try(:fm_name) || "-recid"
+      end
+
+      # Drop-down, for example
+      # http://host/fmi/xml/FMPXMLLAYOUT.xml?-db=jobs+&-lay=jobs&-view=
+      def value_lists
+        conn = Connection.establish_connection(self)
+        conn.value_lists
+      end
+
+      def first
+        limit(1).first
+      end
+    end
+
+    def initialize(attributes = {})
+      @associations = {}
+      @new_record = true
+      process(attributes)
+    end
+
+    def fm_attributes
+      attrs = {}
+
+      fields.each do |fm_attr, field|
+        ivar = send("#{field.name}")
+
+        type = field.type
+
+        if type == Date
+          ivar = ivar.strftime("%m/%d/%Y") if ivar
+        elsif type == DateTime
+          ivar = ivar.strftime("%m/%d/%Y %H:%M:%S") if ivar
+        elsif type == Time
+          ivar = ivar.strftime("%H:%M") if ivar
+        end
+
+        # case ivar
+        # when Date
+        #   ivar = ivar.strftime("%m/%d/%Y")
+        # when DateTime
+        #   ivar = ivar.strftime("%m/%d/%Y %H:%M:%S")
+        # when Time
+        #   ivar = ivar.strftime("%H:%M")
+        # end
+
+        attrs[fm_attr] = ivar if ivar # ignore nil attributes
+      end
+
+      attrs
+    end
+
+    def attributes
+      @attributes = {}
+
+      fields.each do |fm_attr, field|
+        ivar = send("#{field.name}")
+        @attributes[field.name] = ivar
+      end
+
+      return @attributes
+    end
+
+    def reload
+      @associations = {}
+      self.class.id(id)
+    end
+
+    def id
+      self.class.identity == "-recid" ? @record_id : send(self.class.fields[self.class.identity].name)
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def to_param
+      id.to_s if id
+    end
+
+    # Require by ActiveModel
+    def to_model
+      self
+    end
+
+    def to_key
+      id if id
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    protected
+
+    def process(attributes)
+      attributes.each do |k, v|
+        send("#{k}=", v) if respond_to?(k)
+      end
+    end
+  end
+end

data/lib/fm_store/paging.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module FmStore
+  module Paging
+    def paginate(opts = {})
+      options[:max_records] = opts[:per_page] || 30
+      
+      if opts[:page]
+        options[:skip_records] = (opts[:page].to_i - 1) * options[:max_records].to_i
+      end
+      
+      collection = execute(true)
+      
+      WillPaginate::Collection.create(page, per_page, count) do |pager|
+        pager.replace(collection)
+      end
+    end
+    
+    def page
+      skips, limits = options[:skip_records], options[:max_records]
+      (skips && limits) ? (skips + limits) / limits : 1
+    end
+    
+    def per_page
+      (options[:max_records] || 30).to_i
+    end
+  end
+end

data/lib/fm_store/persistence.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+module FmStore
+  module Persistence
+    extend ActiveSupport::Concern
+
+    # The place where all the persistence took place, like insert, update
+    module ClassMethods
+      def create(attributes = {})
+
+      end
+    end
+
+    # Instance methods
+    def save
+      create_or_update
+    end
+
+    def update_attributes(attributes = {})
+      if valid?
+        attrs = {}
+
+        attributes.each do |field, value|
+          field = field.to_s
+
+          fm_name = self.class.find_fm_name(field)
+          type = self.class.find_fm_type(field)
+
+          if fm_name
+            if type == Date
+              if value.blank?
+                value = '' # clear the date
+              else
+                value = value.strftime("%m/%d/%Y")
+              end
+            elsif type == DateTime
+              if value.blank?
+                value = ''
+              else
+                value = value.strftime("%m/%d/%Y %H:%M:%S")
+              end
+            elsif type == Time
+              if value.blank?
+                value = ''
+              else
+                value = value.strftime("%H:%M")
+              end
+            end
+
+            attrs[fm_name] = value
+          end
+        end
+
+        run_callbacks(:save) do
+          conn = Connection.establish_connection(self.class)
+          result = conn.edit(@record_id, attrs)
+
+          return FmStore::Builders::Single.build(result, self.class)
+        end;self # just in case
+      else
+        false
+      end
+    end
+
+    # Throws Rfm::Error::RecordAccessDeniedError if no permission to delete
+    def destroy
+      run_callbacks(:destroy) do
+        unless @record_id.nil?
+          conn = Connection.establish_connection(self.class)
+          conn.delete(@record_id)
+        end
+      end
+    end
+
+    alias :delete :destroy
+
+    protected
+
+    # Will always return +self+
+    def create_or_update
+      result = new_record? ? create : update
+    end
+
+    def create
+      if valid?
+        run_callbacks(:save) do
+          conn = Connection.establish_connection(self.class)
+          result = conn.create(self.fm_attributes)
+
+          @record_id = result[0].record_id
+          @new_record = false
+        end; self
+      else
+        false
+      end
+    end
+
+    def update
+      if valid?
+        run_callbacks(:save) do
+          conn = Connection.establish_connection(self.class)
+          result = conn.edit(@record_id, self.fm_attributes)
+        end; self
+      else
+        false
+      end
+    end
+
+  end
+end