dm-filemaker-adapter 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTEzN2JmZDA1YjA0Yzg0ZjcxMjllNDkxZDQxM2E4NTE0NzhjYzEwZA==
+    NzA1ZDIzZGI0NWJkMDFmNjIyM2Q2NGMwMTQxZWM3MGMwYWU2ZDM0Mg==
   data.tar.gz: !binary |-
-    YmI3MzhmYWEyODk0MjYwNzNlOTI0NGNhYTJhMWFiYjU1MjA4YjM4OA==
+    M2M4OWE4Nzc1NmMyYTViNmI1NzAwZTFmNDlkNDUyZGY3MDAxMGJkOQ==
 SHA512:
   metadata.gz: !binary |-
-    NjBiZTQxMmFiOWEzYmMxYWUwNzkxOTcyM2QzNThlMDgyMGJjMDA1OTNmYWNi
-    OGU0MmM2YTI4Yzc0Y2YxMDI2MGVmMDRiZGEwYTUyYzYzMjMwOGFiYzU2ZTAz
-    M2JhNzRmODE0ZjkwZGM4ZDBhZGIxNTM4YzIwYzNhNzEwM2VjZDk=
+    Y2RmYTdjNjg2YzgwNTFkYzc1ODUyMTAyOThkMzc1ZDIwYTk0ZDA1ZTI1ZDhi
+    ZDRhODFhMjNlNzJhOGNjOTM0YmNkNmQyZjczYzdhMWU0NmVlNjcyM2Y4OTgz
+    NjQ1MDI1M2U1NDZkNzY5NmMxYzkzNDJjYTk4NTg4MGQ2YTFmYmQ=
   data.tar.gz: !binary |-
-    MTRjNDRhYWM3NzkxMjkzNTkwOGQ1N2M0ZmNiYzdkYWU0NGJhMDMyZTc3Njgx
-    MmQzYzNlODE2M2UzMWFlOWQ4Y2M0OTYzOTA4NWI0OGZkNTQ2YTdkZjZlMGE1
-    MDllNzgxMDBhNzMxMzc0ZTNkM2U3MTg2NjQzNmQ4Mzk0N2I5ODM=
+    YWI2ZjRhM2Q5MmYzOTdhOWM3NmNjNjM3ZDJlNzU1OGY4ZDZhYjQ2ZGMyNWM1
+    NjBlZGJkOWJmNDA1N2NlYTI0OGQ0M2FmODgzZGNjNGI4NTQ4MzVhN2IxYmQw
+    OTRmNjhkNzMyMmVmODFjZTI2NTFmODI1OGFiOTgyNmIwMDVlMjU=

data/README.md

@@ -2,7 +2,7 @@
 
 A Filemaker adapter for DataMapper, allowing DataMapper to use Filemaker Server as a datastore.
 
-dm-filemaker-adapter uses the ginjo-rfm gem as the backend command and xml parser. Ginjo-rfm is a full featured filemaker-ruby adapter that exposes most of Filemaker's xml interface functionality in ruby. dm-filemaker-adapter doesn't tap into all of rfm's features, but rather, it provides DataMapper the ability to use Filemaker Server as a backend datastore. All of the basic functionality of DataMapper's CRUD interface is supported, including compound queries and OR queries (using Filemaker's -findquery command), query operators like :field.gt=>..., lazy-loading where possible, first & last record, aggregate queries, ranges, field mapping, and more.
+dm-filemaker-adapter uses the ginjo-rfm gem as the backend command and xml parser. Ginjo-rfm is a full featured filemaker-ruby adapter that exposes most of Filemaker's xml interface functionality in ruby. dm-filemaker-adapter doesn't tap into all of rfm's features, but rather, dm-filemaker-adapter provides DataMapper the ability to use Filemaker Server as a backend datastore. All of the basic functionality of DataMapper's CRUD interface is supported, including compound queries and 'or' queries (using Filemaker's -findquery command), query operators like :field.gt=>..., lazy-loading where possible, first & last record, aggregate queries, ranges, field mapping, and more.
 
 ## Installation
 
@@ -20,6 +20,8 @@ Or install it yourself as:
 
 ## Usage
 
+    # ruby
+
     DB_CONFIG = {
       adapter:            'filemaker',
       host:               'my.server.com',
@@ -32,25 +34,56 @@ Or install it yourself as:
     
     class User
       include DataMapper::Resource
-      storage_names[:default] = 'user_xml'  # This is your filemaker layout for the user table.
+      storage_names[:default] = 'user_xml'  # This is the name of a filemaker layout representing the table you're modeling.
 
       # Property & field names in this list must be lowercase, regardless of what they are in Filemaker.
 
-      property :userid, String, :key=>true, :required=>false
-      property :email, String
-      property :login, String, :field=>'username'
-      property :updated, DateTime, :field=>'updated_at'
+      property :id, Serial
+      property :username, String, :length => 128, :unique => true, :required => true,
+        :default => lambda {|r,v| r.instance_variable_get :@email}
+      property :email, String, :length => 128, :unique => true, :required => true, :format=>:email_address
+      property :updated_at, DateTime, :field=>'modification_timestamp'
       property :encrypted_password, BCryptPassword
     end
 
     DataMapper.finalize
 
-    User.get 'usr1035'
-    User.first :email => 'wbr'
-    User.all :updated.gt => 3.days.ago
-    
-    
-    
-    
+
+
+    # create records
+      User.create(:email => 'abc@company.com', :username => 'abc')
+
+    # get a specific user id
+      User.get '1035'
+
+    # first record that matches exactly 'name'
+      User.first :username => 'name'
+
+    # all records updated since 3 days ago
+      User.all :updated.gt => Time.now-3*24*60*60
+
+    # records 10 thru 20, ordered by :id (the range is resolved by filemaker, before records are returned!)
+      User.all(:order => :id)[10..20]
+
+    # use the union operator to create 2 find requests in a filemaker 'OR' operation
+      User.all(:email => 'abc@company.com', :activated_at.gt => '1/1/1980') | \
+      User.all(:username => 'abc', :activated_at.gt => '1/1/1980')
+
+    # which gets translated to the filemaker query
+      User.find [
+        {:email => 'abc@company.com', :activated_at => '>1/1/1980'},
+        {:username => 'abc', :activated_at.gt => '>1/1/1980'}
+      ]
+
+    # use the intersection operator to combine multiple search criteria in a filemaker 'AND' operation
+      User.all(:email => 'abc@company.com', :activated_at.gt => '1/1/2015') & \
+      User.all(:email => 'abc@company.com', :activated_at.lt => '5/1/2015')
+
+    # you can also write this as
+      User.all(:email => 'abc@company.com', :activated_at.gt => '1/1/2015', :activated_at.lt => '5/1/2015')
     
+    # both of the above get translated to the filemaker query
+      User.find(:email => 'abc@company.com', :activated_at => '>1/1/2015 <5/1/2015')
+
+
 

data/lib/dm-filemaker-adapter.rb

@@ -1,7 +1,5 @@
 require 'dm-core'
 require 'dm-core/adapters/abstract_adapter'
+require 'rfm'
 require "dm-filemaker-adapter/version"
 require 'dm-filemaker-adapter/adapter'
-require 'rfm'
-
-

data/lib/dm-filemaker-adapter/adapter.rb

@@ -1,35 +1,6 @@
 # Property & field names in dm-filemaker-adapter models must be declared lowercase, regardless of what they are in FMP.
-
+require 'dm-filemaker-adapter/core_patches'
 module DataMapper
-  [Resource, Model, Adapters]
-  
-  # All this to tack on class and instance methods to the model/resource.
-  module Resource
-    class << self
-      alias_method :included_orig, :included
-      def included(klass)
-        included_orig(klass)
-        if klass.repository.adapter.to_s[/filemaker/i]
-          klass.instance_eval do
-            extend repository.adapter.class::ModelMethods
-            include repository.adapter.class::ResourceMethods
-          end
-        end
-      end
-    end
-  end
-  
-  module Model
-    #attr_accessor :last_query
-    alias_method :finalize_orig, :finalize
-    def finalize(*args)
-      property :record_id, Integer, :lazy=>false
-      property :mod_id, Integer, :lazy=>false
-      finalize_orig
-    end
-  end
-
-
 
   module Adapters
   
@@ -37,24 +8,6 @@ module DataMapper
       @fmresultset_template_path = File.expand_path('../dm-fmresultset.yml', __FILE__).to_s
       class << self; attr_accessor :fmresultset_template_path; end
       VERSION = DataMapper::FilemakerAdapter::VERSION
-    
-    
-      ###  UTILITY METHODS  ###
-    
-      # Class methods extended onto model.
-      module ModelMethods
-        def layout
-          Rfm.layout(storage_name, repository.adapter.options.symbolize_keys)
-        end
-      end
-      
-      # Instance methods included in model.
-      module ResourceMethods
-        def layout
-          model.layout
-        end
-      end
-  
 
 
       ###  ADAPTER CORE METHODS  ###
@@ -74,10 +27,10 @@ module DataMapper
       #
       # @api semipublic
       def create(resources)
-        #resources[0].model.last_query = resources
+        resources[0].model.last_query = resources
         counter = 0
         resources.each do |resource|
-          fm_params = fmp_attributes resource.dirty_attributes
+          fm_params = prepare_fmp_attributes(resource.dirty_attributes)
           rslt = layout(resource.model).create(fm_params, :template=>self.class.fmresultset_template_path)
           merge_fmp_response(resource, rslt[0])
           counter +=1
@@ -104,12 +57,14 @@ module DataMapper
       # end
       #
       def read(query)
-        #query.model.last_query = query
+        query.model.last_query = query
         #y query
         _layout = layout(query.model)
-        opts = fmp_options(query)
+        opts = query.fmp_options
+        #puts "FMP OPTIONS #{opts.inspect}"
         opts[:template] = self.class.fmresultset_template_path
-        prms = fmp_query(query.conditions) #.to_set.first)
+        prms = query.to_fmp_query
+        #puts "ADAPTER#read fmp_query built: #{prms.inspect}"
         rslt = prms.empty? ? _layout.all(opts) : _layout.find(prms, opts)
         rslt.dup.each_with_index(){|r, i| rslt[i] = r.to_h}
         rslt
@@ -118,12 +73,12 @@ module DataMapper
       # Takes a query and returns number of matched records.
       # An empty query will return the total record count
       def aggregate(query)
-        #query.model.last_query = query
+        query.model.last_query = query
         #y query
         _layout = layout(query.model)
-        opts = fmp_options(query)
+        opts = query.fmp_options
         opts[:template] = self.class.fmresultset_template_path
-        prms = fmp_query(query.conditions) #.to_set.first)
+        prms = fmp_query(query.conditions)
         #[prms.empty? ? _layout.all(:max_records=>0).foundset_count : _layout.count(prms)]
         [prms.empty? ? _layout.view.total_count : _layout.count(prms)]
       end
@@ -145,8 +100,8 @@ module DataMapper
       #
       # @api semipublic
       def update(attributes, collection)
-        #collection[0].model.last_query = [attributes, collection]
-        fm_params = fmp_attributes(attributes)
+        collection[0].model.last_query = [attributes, collection]
+        fm_params = prepare_fmp_attributes(attributes)
         counter = 0
         collection.each do |resource|
           rslt = layout(resource.model).edit(resource.record_id, fm_params, :template=>self.class.fmresultset_template_path)
@@ -182,89 +137,41 @@ module DataMapper
       
 
 
-      ###  ADAPTER HELPER METHODS  ###
+      ###  ADAPTER HELPER METHODS & UTILITIES ###
 
       # Create fmp layout object from model object.
       def layout(model)
         #Rfm.layout(model.storage_name, options.symbolize_keys)   #query.repository.adapter.options.symbolize_keys)
         model.layout
       end
-      
-      # Convert dm query object to fmp query params (hash)
-      def fmp_query(input)
-        #puts "CONDITIONS input #{input.class.name} (#{input})"
-        if input.class.name[/OrOperation/]
-          input.operands.collect {|o| fmp_query o}
-        elsif input.class.name[/AndOperation/]
-          h = Hash.new
-          input.operands.each do |k,v|
-            r = fmp_query(k)
-            #puts "CONDITIONS operand #{r}"
-            if r.is_a?(Hash)
-              h.merge!(r)
-            else
-              h=r
-              break
-            end
-          end
-          h
-        elsif input.class.name[/NullOperation/] || input.nil?
-          {}
-        else
-          #puts "FMP_QUERY OPERATION #{input.class}"
-          val = input.loaded_value
 
-          if val.to_s != ''
-          
-            operation = input.class.name
-            operator = case
-            when operation[/EqualTo/]; '='
-            when operation[/GreaterThan/]; '>'
-            when operation[/LessThan/]; '<'
-            when operation[/Like/]; ''
-            when operation[/Null/]; ''
-            else ''
-            end
-          
-            val = val._to_fm if val.respond_to? :_to_fm
-            {input.subject.field.to_s => "#{operator}#{val}"}
-          else
-            {}
-          end
-        end
-      end
-      
-      
-      # Convert dm attributes hash to regular hash
-      # TODO: Should the result be string or symbol keys?
-      def fmp_attributes(attributes)
-        #puts "ATTRIBUTES"
-        y attributes
-        fm_params = Hash.new
-        attributes.to_h.each do |k,v|
-          fm_params[k.field] = v.respond_to?(:_to_fm) ? v._to_fm : v
-        end
-        # fm_params = Hash.new
-        # resource.dirty_attributes.each do |a,v|
-        #   fm_params[a.field] = v.respond_to?(:_to_fm) ? v._to_fm : v
-        # end
-        fm_params
-      end
-      
-      # Get fmp options hash from query
-      def fmp_options(query)
-        fm_options = {}
-        fm_options[:skip_records] = query.offset if query.offset
-        fm_options[:max_records] = query.limit if query.limit
-        if query.order
-          fm_options[:sort_field] = query.order.collect do |ord|
-            ord.target.field
-          end
-          fm_options[:sort_order] = query.order.collect do |ord|
-            ord.operator.to_s + 'end'
-          end
-        end
-        fm_options
+      def prepare_fmp_attributes(attributes, *args)
+      	options = args.last.is_a?(Hash) ? args.pop : {}
+      	prepend, append = options[:prepend], options[:append]
+      	fm_attributes = {}
+      	#puts "PREPARE FMP ATTRIBUTES"
+      	#y attributes
+      	attributes_as_fields(attributes).each do |key, val|
+      		#puts "EACH ATTRIBUTE class #{val.class}"
+      		#puts "EACH ATTRIBUTE value #{val}"
+      		new_val = val && [val.is_a?(Fixnum) ? val : val.dup].flatten.inject([]) do |r, v|
+      			#puts "INJECTING v"
+      			#puts v
+      			new_v = v.respond_to?(:_to_fm) ? v._to_fm : v
+      			#puts "CONVERTING VAL #{new_val} TO STRING"
+      			new_v = new_v.to_s
+      			#puts "PREPENDING #{new_v} with '#{prepend}'"
+      			new_v.prepend prepend if prepend rescue nil
+      			new_v.append append if append rescue nil
+      			r << new_v
+      		end
+      		#puts "NEW_VAL"
+      		#puts new_val
+      		fm_attributes[key] = (new_val && new_val.size < 2) ? new_val[0] : new_val
+      	end
+      	#puts "FM_ATTRIBUTES"
+      	#puts fm_attributes
+      	fm_attributes
       end
             
       def merge_fmp_response(resource, record)
@@ -281,40 +188,30 @@ module DataMapper
       #   field
       # end
             
-
-      protected :fmp_query, :fmp_attributes, :fmp_options, :merge_fmp_response
+      protected :merge_fmp_response   #,:fmp_options, :prepare_fmp_attributes, :fmp_operator,:fmp_query
+      
+      
+      
+      ###  LOADED WHEN RESOURCES ARE INCLUDED  ###
+      
+      # Class methods extended onto model subclass.
+      module ModelMethods
+        def layout
+          @layout ||= Rfm.layout(storage_name, repository.adapter.options.symbolize_keys)
+        end
+        
+        # Not how to do this. Doesn't work anywhere I've tried it:
+				#extend Forwardable
+				#def_delegators :layout, *layout.class.instance_methods.select {|m| m.to_s[/^[a-z]/]}
+      end
+      
+      # Instance methods included in model.
+      module ResourceMethods
+        def layout
+          model.layout
+        end
+      end
 
     end # FilemakerAdapter
   end # Adapters
 end # DataMapper
-
-class Time
-  def _to_fm
-    d = strftime('%m/%d/%Y') unless Date.today == Date.parse(self.to_s)
-    t = strftime('%T')
-    d ? "#{d} #{t}" : t
-  end
-end # Time
-
-class DateTime
-  def _to_fm
-    d = strftime('%m/%d/%Y')
-    t =strftime('%T')
-    "#{d} #{t}"
-  end
-end # Time
-
-class Timestamp
-  def _to_fm
-    d = strftime('%m/%d/%Y')
-    t =strftime('%T')
-    "#{d} #{t}"
-  end
-end # Time
-
-class Date
-  def _to_fm
-    strftime('%m/%d/%Y')
-  end
-end # Time
-

data/lib/dm-filemaker-adapter/core_patches.rb

@@ -0,0 +1,144 @@
+class Time
+  def _to_fm
+    d = strftime('%m/%d/%Y') #unless Date.today == Date.parse(self.to_s)
+    t = strftime('%T')
+    d ? "#{d} #{t}" : t
+  end
+end # Time
+
+class DateTime
+  def _to_fm
+    d = strftime('%m/%d/%Y')
+    t =strftime('%T')
+    "#{d} #{t}"
+  end
+end # Time
+
+class Timestamp
+  def _to_fm
+    d = strftime('%m/%d/%Y')
+    t =strftime('%T')
+    "#{d} #{t}"
+  end
+end # Time
+
+class Date
+  def _to_fm
+    strftime('%m/%d/%Y')
+  end
+end # Time
+
+
+module DataMapper
+  [Adapters, Model, Query, Resource]
+  
+  # All this to tack on class and instance methods to the model/resource.
+  module Resource
+    class << self
+      alias_method :included_orig, :included
+      def included(klass)
+        included_orig(klass)
+        if klass.repository.adapter.to_s[/filemaker/i]
+          klass.instance_eval do
+            extend repository.adapter.class::ModelMethods
+            include repository.adapter.class::ResourceMethods
+          end
+        end
+      end
+    end
+  end
+  
+  module Model
+    attr_accessor :last_query
+    alias_method :finalize_orig, :finalize
+    def finalize(*args)
+      property :record_id, Integer, :lazy=>false
+      property :mod_id, Integer, :lazy=>false
+      finalize_orig
+    end
+  end
+  
+  class Query
+		# Convert dm query conditions to fmp query params (hash)
+	  def to_fmp_query(input=self.conditions)
+	    #puts "FMP_QUERY input #{input.class.name}"
+	    rslt = if input.class.name[/OrOperation/]
+	    	#puts "FMP_QUERY OrOperation #{input.class}"
+	      input.operands.collect do |o|
+	      	r = to_fmp_query o
+	      	#puts "FMP_QUERY or-operation operand #{r}"
+	      	r
+	      end
+	    elsif input.class.name[/AndOperation/]
+	    	#puts "FMP_QUERY AndOperation input class #{input.class}"
+	    	#puts "FMP_QUERY AndOperation input value #{input.inspect}"
+	    	out = {}
+	      input.operands.each do |k,v|
+	      	#puts "FMP_QUERY and-operation pre-process operand key:val #{k}:#{v}"
+	        r = to_fmp_query(k).to_hash
+	        #puts "FMP_QUERY and-operation post-process operand #{r}"
+	        if r.is_a?(Hash)
+	        	#puts "FMP_QUERY and-operation operand is a hash"
+	        	# Filemaker can't have the same field twice in a single find request,
+	        	# but we can mash the two conditions together in a way that FMP can use.
+	          out.merge!(r){|k, oldv, newv| "#{oldv} #{newv}"}
+	        else
+	        	#puts "FMP_QUERY and-operation operand is NOT a hash"
+	          out = r
+	          break
+	        end
+	      end
+	      out
+	    elsif input.class.name[/NullOperation/] || input.nil?
+	      #puts "FMP_QUERY NullOperation #{input.class}"
+	      {}
+	    else
+	      #puts "FMP_QUERY else input class #{input.class}"
+	      #puts "FMP_QUERY else input value #{input.inspect}"
+	      #puts "FMP_QUERY else-options #{self.options.inspect}"
+	      #prepare_fmp_attributes({input.subject=>input.value}, :prepend=>fmp_operator(input.class.name))
+	      value = (
+	      	self.options[input.keys[0]] ||
+	      	self.options[input.subject.name] ||
+	      	self.options.find{|o,v| o.respond_to?(:target) && o.target.to_s == input.subject.name.to_s}[1] ||
+	      	input.value
+	      ) rescue input.value   #(puts "ERROR #{$!}"; input.value)
+	      #puts "FMP_QUERY else-value #{value}"
+	      repository.adapter.prepare_fmp_attributes({input.subject=>value}, :prepend=>fmp_operator(input.class.name))
+	    end
+	    #puts "FMP_QUERY output #{rslt.inspect}"
+	    rslt
+	  end # to_fmp_query
+	  
+		# Convert operation class to operator string
+		def fmp_operator(operation)
+		  case
+		  when operation[/GreaterThanOrEqualTo/]; '>='
+		  when operation[/LessThanOrEqualTo/]; '<='
+		  when operation[/GreaterThan/]; '>'
+		  when operation[/LessThan/]; '<'
+		  when operation[/EqualTo/]; '=='
+		  when operation[/Like/];
+		  when operation[/Null/];
+		  else nil
+		  end
+		end
+
+    # Get fmp options hash from query
+    def fmp_options(query=self)
+      fm_options = {}
+      fm_options[:skip_records] = query.offset if query.offset
+      fm_options[:max_records] = query.limit if query.limit
+      if query.order
+        fm_options[:sort_field] = query.order.collect do |ord|
+          ord.target.field
+        end
+        fm_options[:sort_order] = query.order.collect do |ord|
+          ord.operator.to_s + 'end'
+        end
+      end
+      fm_options
+    end	  
+    
+  end # Query
+end # DataMapper

data/lib/dm-filemaker-adapter/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
 	module FilemakerAdapter
-	  VERSION = "0.0.1"
+	  VERSION = "0.0.2"
 	end
 end

data/spec/dm-filemaker-adapter/adapter_spec.rb

@@ -1,11 +1,172 @@
 require 'spec_helper'
 
-describe DataMapper::Adapters::FilemakerAdapter do
-  it 'has a version number' do
-    expect(DataMapper::Adapters::FilemakerAdapter::VERSION).not_to be nil
-  end
-
-  it 'does something useful' do
-    expect(true).to eq(true)
-  end
-end
+# Rspec Issues (maybe not bugs, but certainly not expected behavior!).
+#
+# expect/allow_any_instance_of does not work with block form of arguments in '...to receive(:message) do |args|
+# The args will always just be the instance object.
+#
+# and_call_original breaks block form of expect.
+#
+
+# Shared Example examples:
+# RSpec.shared_examples "#to_fmp_query" do
+# 	it 'Receives dm query conditions and returns fmp query' do
+# 		allow_any_instance_of(Rfm::Layout).to receive(:find).and_return(Rfm::Resultset.allocate)
+# 		expect_any_instance_of(DataMapper::Query).to receive(:to_fmp_query).at_least(:once).and_call_original
+# 		query.inspect
+# 	end
+# end
+#
+# context "with simple .all query" do
+# 	include_examples "#to_fmp_query" do
+# 		let(:query){User.all(:id=>1)}
+# 	end
+# end
+
+describe DataMapper do
+	before :each do
+		DataMapper.setup(:default, 'filemaker://user:pass@hostname.com/DatabaseName')
+		class ::User
+			include DataMapper::Resource
+			property :id, Serial
+			property :email, String
+			property :username, String
+			property :activated_at, DateTime
+			
+			has n, :orders
+		end
+		class ::Order
+			include DataMapper::Resource
+			property :id, Serial
+			property :total, Decimal
+			
+			belongs_to :user
+		end
+		DataMapper.finalize
+	end
+
+	describe DataMapper::Adapters::FilemakerAdapter do
+
+	  it 'Has a version number' do
+	    expect(DataMapper::Adapters::FilemakerAdapter::VERSION).not_to be nil
+	  end
+	
+	  it 'Does something useful' do
+	    expect(true).to eq(true)
+	  end
+	  
+	  it 'Supports model classes' do
+	  	expect(User.ancestors.include?(DataMapper::Adapters::FilemakerAdapter::ResourceMethods)).to eq(true)
+	  end
+	  
+	  it 'Acts as dm database adapter for model repository' do
+	  	expect(User.repository.adapter.class).to eq(DataMapper::Adapters::FilemakerAdapter)
+	  end
+	  
+	  
+	  
+	  # THESE ARE ALL WRONG. They should process and return real data, instead of returning canned 'safe' responses with rspec mocking.
+	  # Use .and_call_original to allow expected methods to run their original purpose.
+	  # See https://github.com/rspec/rspec-mocks.
+	  describe '#read' do
+	  	it 'Receives dm query object with conditions' do
+	  		#expect_any_instance_of(DataMapper::Adapters::FilemakerAdapter).to receive(:read).and_return(Rfm::Resultset.allocate)
+				expect(User.repository.adapter).to receive(:read) do |query|
+					expect(query.class).to eq(DataMapper::Query)
+					expect(query.conditions.first.subject.field).to eq('id')
+					expect(query.conditions.first.value).to eq(1)
+				end.and_return(Rfm::Resultset.allocate)
+				User.all(:id=>1).inspect
+	  	end
+	  end  
+	  
+	end # datamapper-adapters-filemaker
+	
+	describe DataMapper::Query do
+	  
+	  describe '#to_fmp_query' do
+	  	# I'm passing in the example here, so we can use the metadata to construct
+	  	# streamlined tests for a variety of query inputs to the to_fmp_query method.
+	  	before(:each) do |example|
+	  		
+	  		# Not really needed yet, but helpful if calls go into Rfm.
+				allow_any_instance_of(Rfm::Layout).to receive(:find).and_return(Rfm::Resultset.allocate)
+				#expect_any_instance_of(DataMapper::Query).to receive(:to_fmp_query).at_least(:once).and_call_original
+				
+				# Capture the query object passed to the adapter#read method
+				expect(DataMapper.repository.adapter).to receive(:read) do |query|
+					#puts "QUERY #{query}"
+					#puts "Self within before/expect block #{self}"
+					@query = query
+					#puts @query.conditions.to_yaml
+					# TODO: See rspec mocks docs for how to pass control to the original method and get a result back right here.
+					# hint - it does something like this: @original_method = adapter.method(:to_fmp_query); @original_method.call(query)
+					[]
+				end
+				
+				# Possible helpful meta info for each example.
+				#puts "EXAMPLE INSTANCE VARS #{example.instance_variables.inspect}"
+				#
+				# Uses the desription of the example as the user query code,
+				# and uses the block of the example as the expected to_fmp_query result.
+				# Also replaces the description with more informative info, including the expected result.
+				#
+				@name = example.description.dup
+				@block = example.instance_variable_get(:@example_block)
+				@expected_result = @block.call
+				example.description.replace "#{@name} should return #{@expected_result}"
+				# Runs the query to get the query object.
+				eval(@name.to_s).inspect
+				@fmp_query = @query.to_fmp_query
+				# All of the above, so we can do this.
+				expect(@fmp_query).to eq(@expected_result)
+			end
+			
+			context "Simple .all" do
+				it('User.all'){ {} }
+			end
+			
+			context "Simple .first plus less-than comparison on time" do
+				it('User.first(:id=>1)') { {'id' => '==1'} }
+				it('User.first(:activated_at.lt=>"1/1/2015 00:00:00")') { {"activated_at"=>"<01/01/2015 00:00:00"} }
+			end
+			
+			context "Compound OR with simple comparison on integer" do
+				it('(User.all(:id=>1) | User.all(:id=>2))') { [{"id"=>"==1"}, {"id"=>"==2"}] }
+			end
+			
+			context "Simple .all containing duplicate keys with differing operators" do
+				it('User.all(:id.gt=>1, :id.lt=>5)') { {"id"=>">1 <5"} }
+			end
+			
+			context "Compound AND operation" do
+				it('(User.all(:id=>1) & User.all(:email=>"some_email"))') { {"id"=>"==1", "email"=>"==some_email"} }
+			end
+			
+			context "Simple implied .in operation" do
+				it('User.all(:id=>[1, 3, 5, 9])') { {"id"=>["1", "3", "5", "9"]} }
+			end
+			
+			context "Compound OR with dup keys with differing operators and .gte comparison" do
+				it("(User.all(:username=>'uname', :activated_at.gt=>Time.parse('1970-01-01 00:00:00')) | User.all(:email.like=>'uname', :activated_at.gte=>Time.parse('1970-03-01 00:00:00')))"){
+					[{"username"=>"==uname", "activated_at"=>">01/01/1970 00:00:00"}, {"email"=>"uname", "activated_at"=>">=03/01/1970 00:00:00"}]
+				}
+			end
+			
+			context "Compound AND with dup keys for a date range with .gte and .lte comparison" do
+				it('User.all(:activated_at.gte=>Time.parse("2015-01-01 00:00:00")) & User.all(:activated_at.lte=>Time.parse("2015-03-01 00:00:00"))') {
+					{"activated_at"=>">=01/01/2015 00:00:00 <=03/01/2015 00:00:00"}
+				}
+			end
+			# TODO: test field-name-translation
+			# TODO: test all other operator possibilities
+			
+			# This tests nested associational query, which dm-filemaker-adapter cannot yet do.
+			#it('User.all(:email=>"something@dot.com", :orders=>{:total.gt=>10.0})') {{}}
+			
+	  
+	  end	#to_fmp_query
+	
+	end # datamapper-query
+	
+end # datamapper

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dm-filemaker-adapter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - William Richardson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-16 00:00:00.000000000 Z
+date: 2015-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: data_mapper
@@ -96,6 +96,7 @@ files:
 - dm-filemaker-adapter.gemspec
 - lib/dm-filemaker-adapter.rb
 - lib/dm-filemaker-adapter/adapter.rb
+- lib/dm-filemaker-adapter/core_patches.rb
 - lib/dm-filemaker-adapter/dm-fmresultset.yml
 - lib/dm-filemaker-adapter/version.rb
 - spec/dm-filemaker-adapter/adapter_spec.rb