lardawge-rfm 1.4.1.2 → 1.4.2

data/.gitignore

@@ -0,0 +1,8 @@
+*.sw?
+.DS_Store
+.document
+local_testing
+coverage
+rdoc
+pkg
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+
+rvm:
+ - 1.8.7
+ - 1.9.2
+ - 1.9.3
+ - 2.0.0
+ - ree

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+## 1.4.2
+  
+### enhancements
+  * Make nil default on fields with no value.
+    
+    ```ruby
+    record.john #=> "" 
+    record.john #=> nil
+    ```
+
+## 1.4.1.2
+
+### bug fixes
+  * Pointing out why testing is soooooo important when refactoring... Found a bug in getter/setter method in Rfm::Record
+
+## 1.4.1.1
+
+### bug fixes
+  * Inadvertently left out an attr_reader for server from resultset effecting container urls.
+
+## 1.4.1
+
+### enhancements
+  * Changed Server#do_action to Server#connect.
+  * XML Parsing is now done via xpath which significantly speeds up parsing.
+  * Changes to accessor method names for Resultset#portals Resultset#fields to Resultset#portal_meta and Resultset#field_meta to better describe what you get back.
+  * Added an option to load portal records which defaults to false. This significantly speeds up load time when portals are present on the layout.
+
+    ```ruby
+    # This will fetch all records with portal records attached.
+    result = fm_server('layout').find({:username => "==#{username}"}, {:include_portals => true})      
+
+    result.first.portals # return an empty hash if incude_portals is not true
+    ```
+    
+  * Internal file restructuring. Some classes have changed but it should be nothing a developer would use API wise. Please let me know if it is.
+  * Removed Layout#value_lists && Layout#field_controls. Will put back in if the demand is high. Needs a major refactor and different placement if it goes back in. Was broken so it didn't seem to be used by many devs.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in lardawge-rfm.gemspec
+gemspec

data/{README.rdoc → README.md}

@@ -1,211 +1,259 @@
-= Rfm
+# Rfm
 
-This version of rfm is a significant upgrade to rfm in a few ways. First and most important (to me anyway) is it allows for the use of secure connections and certificate files.
-Rfm 1.0.0 is broken in that way and does not allow for this. Second it has a few bug fixes that were never pushed to rfm 1.0.0. Last but not least is that the xml parser is
-switched to nokogiri which is a huge speed improvement over REXML (used in rfm 1.0.0) on large datasets.
+[![Build Status](https://travis-ci.org/lardawge/rfm.png?branch=master)](https://travis-ci.org/lardawge/rfm)
+[![Code Quality](https://codeclimate.com/badge.png)](https://codeclimate.com/github/lardawge/rfm)
+[![Still Maintained](http://stillmaintained.com/lardawge/rfm.png)](http://stillmaintained.com/lardawge/rfm)
 
-Rfm was primarily designed by Six Fried Rice co-founder Geoff Coffey.
+## Installation
 
-Other lead contributors:
+Terminal:
 
-- Mufaddal Khumri helped architect Rfm in the most ruby-like way possible. He also contributed the outstanding error handling code and a comprehensive hierarchy of error classes.
-- Atsushi Matsuo was an early Rfm tester, and provided outstanding feedback, critical code fixes, and a lot of web exposure.
-- Jesse Antunes helped ensure that Rfm is stable and functional.
-- Larry Sprock added ssl support and switched the xml parser to a much faster Nokogiri.
+```bash
+gem install lardawge-rfm
+```
 
-Rdoc location: http://rdoc.info/projects/lardawge/rfm
-
-== Installation
-
-Run the following if you haven't already:
-
-  gem sources -a http://gemcutter.org
-	
-Followed by:
+Once the gem is installed, you can use rfm in your ruby scripts by requiring it:
 
-  gem install lardawge-rfm
+```ruby
+require 'rubygems'
+require 'rfm'
+```
+### In Rails >= 3.0
 
-Once the gem is installed, you can use rfm in your ruby scripts by requiring it:
+In the Gemfile:
 
-  require 'rubygems'
-  require 'rfm'
+```ruby
+gem 'lardawge-rfm'
+```
 
-== Connecting
+## Connecting
 
 IMPORTANT:SSL and Certificate verification are on by default. Please see Server#new in rdocs for explanation and setup.
 You connect with the Rfm::Server object. This little buddy will be your window into FileMaker data.
 
-  require 'rfm/rfm'
+```ruby
+require 'rfm/rfm'
 
-  my_server = Rfm::Server.new(
-    :host => 'myservername',
-    :username => 'user',
-    :password => 'pw',
-    :ssl => false
-  )
+my_server = Rfm::Server.new(
+  :host => 'myservername',
+  :username => 'user',
+  :password => 'pw',
+  :ssl => false
+)
+```
 
 if your web publishing engine runs on a port other than 80, you can provide the port number as well:
 
-  my_server = Rfm::Server.new(
-    :host => 'myservername',
-    :username => 'user',
-    :password => 'pw',
-    :port => 8080, 
-    :ssl => false
-  )
+```ruby
+my_server = Rfm::Server.new(
+  :host => 'myservername',
+  :username => 'user',
+  :password => 'pw',
+  :port => 8080, 
+  :ssl => false
+)
+```
 
-== Databases and Layouts
+## Databases and Layouts
 
 All access to data in FileMaker's XML interface is done through layouts, and layouts live in databases. The Rfm::Server object has a collection of databases called 'db'. So to get ahold of a database called "My Database", you can do this:
 
-  my_db = my_server.db["My Database"]
+```ruby
+my_db = my_server.db["My Database"]
+```
 
 As a convenience, you can do this too:
 
-  my_db = my_server["My Database"]
+```ruby
+my_db = my_server["My Database"]
+```
 
 Finally, if you want to introspect the server and find out what databases are available, you can do this:
 
-  all_dbs = my_server.db.all
+```ruby
+all_dbs = my_server.db.all
+```
 
 In any case, you get back Rfm::Database objects. A database object in turn has a property called "layout":
 
-  my_layout = my_db.layout["My Layout"]
+```ruby
+my_layout = my_db.layout["My Layout"]
+```
 
 Again, for convenience:
 
-  my_layout = my_db["My Layout"]
+```ruby
+my_layout = my_db["My Layout"]
+```
 
 And to get them all:
 
-  all_layouts = my_db.layout.all
+```ruby
+all_layouts = my_db.layout.all
+```
 
 Bringing it all together, you can do this to go straight from a server to a specific layout:
 
-  my_layout = my_server["My Database"]["My Layout"]
+```ruby
+my_layout = my_server["My Database"]["My Layout"]
+```
 
-NOTE: for the ruby experts, Rfm::Server#db is an Rfm::Factory::DatabaseFactory object, which is just a fancied up Hash. So anything you can do with a hash, you can also do with my_server.db. The same goes for my_db.layouts, which is an Rfm::Factory::LayoutFactory.
-
-
-== Working with Layouts
+## Working with Layouts
 
 Once you have a layout object, you can start doing some real work. To get every record from the layout:
 
-  my_layout.all   # be careful with this
+```ruby
+my_layout.all   # be careful with this
+```
 
 To get a random record:
 
-  my_layout.any
+```ruby
+my_layout.any
+```
 
 To find every record with "Arizona" in the "State" field:
 
-  my_layout.find({"State" => "Arizona"})
+```ruby
+my_layout.find({"State" => "Arizona"})
+```
 
 To add a new record with my personal info:
 
-  my_layout.create({
-    :first_name => "Geoff",
-    :last_name => "Coffey",
-    :email => "gwcoffey@gmail.com"}
-  )
+```ruby
+my_layout.create({
+  :first_name => "Geoff",
+  :last_name => "Coffey",
+  :email => "gwcoffey@gmail.com"}
+)
+```
 
 Notice that in this case I used symbols instead of strings for the hash keys. The API will accept either form, so if your field names don't have whitespace or punctuation, you might prefer the symbol notation.
 
 To edit the record whos recid (filemaker internal record id) is 200:
 
-  my_layout.edit(200, {:first_name => 'Mamie'})
+```ruby
+my_layout.edit(200, {:first_name => 'Mamie'})
+```
 
 Note: See the "Record Objects" section below for more on editing records.
 
 To delete the record whose recid is 200:
 
-  my_layout.delete(200)
+```ruby
+my_layout.delete(200)
+```
 
 All of these methods return an Rfm::Result::ResultSet object (see below), and every one of them takes an optional parameter (the very last one) with additional options. For example, to find just a page full of records, you can do this:
 
-  my_layout.find({:state => "AZ"}, {:max_records => 10, :skip_records => 100})
+```ruby
+my_layout.find({:state => "AZ"}, {:max_records => 10, :skip_records => 100})
+```
 
 For a complete list of the available options, see the "expand_options" method in the Rfm::Server object in the file named rfm_command.rb.
 
 Finally, if filemaker returns an error when executing any of these methods, an error will be raised in your ruby script. There is one exception to this, though. If a find results in no records being found (FileMaker error # 401) I just ignore it and return you a ResultSet with zero records in it. If you prefer an error in this case, add :raise_on_401 => true to the options you pass the Rfm::Server when you create it.
 
 
-== ResultSet and Record Objects
+## ResultSet and Record Objects
 
 Any method on the Layout object that returns data will return a ResultSet object. Rfm::Result::ResultSet is a subclass of Array, so first and foremost, you can use it like any other array:
 
-  my_result = my_layout.any
-  my_result.size  # returns '1'
-  my_result[0]    # returns the first record (an Rfm::Result::Record object)
+```ruby
+my_result = my_layout.any
+my_result.size  # returns '1'
+my_result[0]    # returns the first record (an Rfm::Result::Record object)
+```
 
 The ResultSet object also tells you information about the fields and portals in the result. ResultSet#fields and ResultSet#portals are both standard ruby hashes, with strings for keys. The fields hash has Rfm::Result::Field objects for values. The portals hash has another hash for its values. This nested hash is the fields on the portal. This would print out all the field names:
 
-  my_result.fields.each { |name, field| puts name }
+```ruby
+my_result.fields.each { |name, field| puts name }
+```
 
 This would print out the tables each portal on the layout is associated with. Below each table name, and indented, it will print the names of all the fields on each portal.
 
-  my_result.portals.each { |table, fields|
-    puts "table: #{table}"
-    fields.each { |name, field| puts "\t#{name}"}
-  }
+```ruby
+my_result.portals.each { |table, fields|
+  puts "table: #{table}"
+  fields.each { |name, field| puts "\t#{name}"}
+}
+```
 
 But most importantly, the ResultSet contains record objects. Rfm::Result::Record is a subclass of Hash, so it can be used in many standard ways. This code would print the value in the 'first_name' field in the first record of the ResultSet:
 
-  my_record = my_result[0]
-  puts my_record["first_name"]
+```ruby
+my_record = my_result[0]
+puts my_record["first_name"]
+```
 
 As a convenience, if your field names are valid ruby method names (ie, they don't have spaces or odd punctuation in them), you can do this instead:
 
-  puts my_record.first_name
+```ruby
+puts my_record.first_name
+```
 
 Since ResultSets are arrays and Records are hashes, you can take advantage of Ruby's wonderful expressiveness. For example, to get a comma-separated list of the full names of all the people in California, you could do this:
 
-  my_layout.find({:state => 'CA'}).collect {|rec| "#{rec.first_name} #{rec.last_name}"}.join(", ")
+```ruby
+my_layout.find(:state => 'CA').collect {|rec| "#{rec.first_name} #{rec.last_name}"}.join(", ")
+```
 
 Record objects can also be edited:
 
-  my_record.first_name = 'Isabel'
+```ruby
+my_record.first_name = 'Isabel'
+```
 
 Once you have made a series of edits, you can save them back to the database like this:
 
-  my_record.save
+```ruby
+my_record.save
+```
 
 The save operation causes the record to be reloaded from the database, so any changes that have been made outside your script will also be picked up after the save.
 
 If you want to detect concurrent modification, you can do this instead:
 
-  my_record.save_if_not_modified
+```ruby
+my_record.save_if_not_modified
+```
 
 This version will refuse to update the database and raise an error if the record was modified after it was loaded but before it was saved.
 
 Record objects also have portals. While the portals in a ResultSet tell you about the tables and fields the portals show, the portals in a Record have the actual data. For example, if an Order record has Line Item records, you could do this:
 
-  my_order = order_layout.any[0]  # the [0] is important!
-  my_lines = my_order.portals["Line Items"]
+```ruby
+my_order = order_layout.any[0]  # the [0] is important!
+my_lines = my_order.portals["Line Items"]
+```
 
 At the end of the previous block of code, my_lines is an array of Record objects. In this case, they are the records in the "Line Items" portal for the particular order record. You can then operate on them as you would any other record. 
 
 NOTE: Fields on a portal have the table name and the "::" stripped off of their names if they belong to the table the portal is tied to. In other words, if our "Line Items" portal includes a quantity field and a price field, you would do this:
 
-  my_lines[0]["Quantity"]
-  my_lines[0]["Price"]
+```ruby
+my_lines[0]["Quantity"]
+my_lines[0]["Price"]
+```
 
 You would NOT do this:
 
-  my_lines[0]["Line Items::Quantity"]
-  my_lines[0]["Line Items::Quantity"]
+```ruby
+my_lines[0]["Line Items::Quantity"]
+my_lines[0]["Line Items::Quantity"]
+```
 
 My feeling is that the table name is redundant and cumbersome if it is the same as the portal's table. This is also up for debate.
 
 Again, you can string things together with Ruby. This will calculate the total dollar amount of the order:
- 
-  total = 0.0
-  my_order.portals["Line Items"].each {|line| total += line.quantity * line.price}
 
-I intend to add a 'delete' method to the Record class as well, but I haven't done this yet. Finally, should you be able to create new records using the Record class? I'm not sure...lots of points to consider on this.
+```ruby
+total = 0.0
+my_order.portals["Line Items"].each {|line| total += line.quantity * line.price}
+```
 
-
-== Data Types
+## Data Types
 
 FileMaker's field types are coerced to Ruby types thusly:
 
@@ -228,7 +276,7 @@ Finally, container fields will come back as URI objects. You can:
 
 Specifically, the URI refers to the _contents_ of the container field. When accessed, the file, picture, or movie in the field will be downloaded.
 
-== Troubleshooting
+## Troubleshooting
 
 There are two cheesy methods to help track down problems. When you create a server object, you can provide two additional optional parameters:
 
@@ -240,16 +288,16 @@ When this is 'true' your script will dump the actual response it got from FileMa
 
 So, for an annoying, but detailed load of output, make a connection like this:
 
-  my_server = Rfm::Server.new(
-    :host => 'myservername',
-    :username => 'user',
-    :password => 'pw',
-    :log_actions => true,
-    :log_responses => true
-  )
-
-These options will change in the future. They're only there now as a quick-easy way for me to track down problems. I'm open to suggestions for what kind of login options will make sense in the final release.
+```ruby
+my_server # Rfm::Server.new(
+  :host #> 'myservername',
+  :username #> 'user',
+  :password #> 'pw',
+  :log_actions #> true,
+  :log_responses #> true
+)
+```
 
-== Copyright
+## Copyright
 
-Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumr. See LICENSE for details.
+Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumr. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/lardawge-rfm.gemspec

@@ -0,0 +1,29 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "lardawge-rfm"
+  s.version     = Rfm::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Geoff Coffey", "Mufaddal Khumri", "Atsushi Matsuo", "Larry Sprock"]
+  s.email       = ["larry@lucidbleu.com"]
+  s.homepage    = "https://github.com/lardawge/rfm"
+  s.licenses    = ["MIT"]
+  s.summary     = %q{Ruby to Filemaker adapter}
+  s.description = %q{Rfm brings your FileMaker data to Ruby. Now your Ruby scripts and Rails applications can talk directly to your FileMaker server.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "nokogiri"
+  s.add_dependency "addressable"
+
+  s.add_development_dependency "rspec", ["~> 2.12.0"]
+  s.add_development_dependency "mocha", ["~> 0.13.0"]
+  s.add_development_dependency "rake"
+
+end
+

data/lib/rfm.rb

@@ -1,8 +1,11 @@
-path = File.expand_path(File.dirname(__FILE__))
-$:.unshift(path) unless $:.include?(path)
-
-require path + '/rfm/utilities/case_insensitive_hash'
-require path + '/rfm/utilities/factory'
+# encoding: utf-8
+require 'rfm/utilities/case_insensitive_hash'
+require 'rfm/utilities/factory'
+require 'rfm/error'
+require 'rfm/server'
+require 'rfm/database'
+require 'rfm/layout'
+require 'rfm/resultset'
 
 module Rfm
   
@@ -10,10 +13,4 @@ module Rfm
   class ParameterError      < StandardError; end
   class AuthenticationError < StandardError; end
 
-  autoload :Error,     'rfm/error'
-  autoload :Server,    'rfm/server'
-  autoload :Database,  'rfm/database'
-  autoload :Layout,    'rfm/layout'
-  autoload :Resultset, 'rfm/resultset'
-  
-end
+end

data/lib/rfm/database.rb

@@ -59,6 +59,9 @@ module Rfm
   # * *state* is a hash of all server options used to initialize this server
   class Database
   
+    attr_reader :server, :name, :account_name, :password, :layout, :script
+    attr_writer :account_name, :password
+
     # Initialize a database object. You never really need to do this. Instead, just do this:
     # 
     #   myServer = Rfm::Server.new(...)
@@ -74,9 +77,6 @@ module Rfm
       @script = Rfm::Factory::ScriptFactory.new(server, self)
     end
     
-    attr_reader :server, :name, :account_name, :password, :layout, :script
-    attr_writer :account_name, :password
-
     # Access the Layout object representing a layout in this database. For example:
     #
     #   myDatabase['Details']
@@ -93,4 +93,4 @@ module Rfm
     end
 
   end
-end
+end

data/lib/rfm/layout.rb

@@ -120,6 +120,8 @@ module Rfm
   
   class Layout
     
+    attr_reader :name, :db
+
     # Initialize a layout object. You never really need to do this. Instead, just do this:
     # 
     #   myServer = Rfm::Server.new(...)
@@ -138,8 +140,6 @@ module Rfm
       @db = db
     end
     
-    attr_reader :name, :db
-    
     # Returns a ResultSet object containing _every record_ in the table associated with this layout.
     def all(options = {})
       get_records('-findall', {}, options)
@@ -209,14 +209,14 @@ module Rfm
     
     private
     
-    def get_records(action, extra_params = {}, options = {})
-      include_portals = options[:include_portals] ? options.delete(:include_portals) : nil
-      xml_response = @db.server.connect(@db.account_name, @db.password, action, params.merge(extra_params), options).body
-      Rfm::Resultset.new(@db.server, xml_response, self, include_portals)
+    def get_records(action, params = {}, options = {})
+      include_portals = options.delete(:include_portals)
+      xml_response = db.server.connect(action, default_params.merge(params), options)
+      Rfm::Resultset.new(db.server, xml_response.body, self, include_portals)
     end
     
-    def params
-      {"-db" => @db.name, "-lay" => self.name}
+    def default_params
+      {"-db" => db.name, "-lay" => self.name}
     end
   end
-end
+end

data/lib/rfm/metadata/field.rb

@@ -45,7 +45,7 @@ module Rfm
     #
     # * *control& is a FieldControl object representing the sytle and value list information associated
     #   with this field on the layout.
-    # 
+    #
     # Note: Since a field can sometimes appear on a layout more than once, +control+ may be an Array.
     # If you don't know ahead of time, you'll need to deal with this. One easy way is:
     #
@@ -56,11 +56,11 @@ module Rfm
     #
     # The code above makes sure the control is always an array. Typically, though, you'll know up front
     # if the control is an array or not, and you can code accordingly.
-    
+
     class Field
-      
+
       attr_reader :name, :result, :type, :max_repeats, :global
-      
+
       # Initializes a field object. You'll never need to do this. Instead, get your Field objects from
       # ResultSet::fields
       def initialize(field)
@@ -70,8 +70,8 @@ module Rfm
         @max_repeats = field['max-repeats']
         @global      = field['global']
       end
-    
-      # Coerces the text value from an +fmresultset+ document into proper Ruby types based on the 
+
+      # Coerces the text value from an +fmresultset+ document into proper Ruby types based on the
       # type of the field. You'll never need to do this: Rfm does it automatically for you when you
       # access field data through the Record object.
       def coerce(value, resultset)
@@ -82,12 +82,12 @@ module Rfm
         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}")
+        when "container" then URI.parse("#{resultset.server.uri.scheme}://#{resultset.server.uri.host}:#{resultset.server.uri.port}#{value}")
         else nil
         end
-        
+
       end
-      
+
     end
   end
-end
+end

data/lib/rfm/record.rb

@@ -191,26 +191,38 @@ module Rfm
     # Record::save or Record::save_if_not_modified to actually save the data.
     def []=(name, value)
       return super unless @loaded
-      raise Rfm::ParameterError, "You attempted to modify a field does not exist." unless self[name]
+      raise Rfm::ParameterError, 
+        "You attempted to modify the field :#{name} which does not exist in the current Filemaker layout." unless self.key?(name)
       @mods[name] = value
     end
-    
+
+    alias :_original_hash_reader :[]
+    def [](value)
+      read_attribute(value)
+    end
+
     def respond_to?(symbol, include_private = false)
-      return true if self[symbol.to_s]
+      return true if self.include?(symbol.to_s)
       super
     end
-    
+
     private
-    
-      def method_missing (symbol, *attrs, &block)
+
+      def read_attribute(key)
+        raise NoMethodError, 
+          "#{key} does not exist as a field in the current Filemaker layout." unless key?(key)
+        _original_hash_reader(key)
+      end
+
+      def method_missing(symbol, *attrs, &block)
         method = symbol.to_s
-        return self[method] if self.include?(method) 
+        return read_attribute(method) if self.key?(method)
       
-        if method =~ /(=)$/ && self.has_key?($`)
+        if method =~ /(=)$/ && self.key?($`)
           return @mods[$`] = attrs.first
         end
         super
       end
     
   end
-end
+end

data/lib/rfm/server.rb

@@ -1,5 +1,6 @@
 require 'net/https'
-require 'cgi'
+require 'addressable/uri'
+
 module Rfm
   # This class represents a single FileMaker server. It is initialized with basic
   # connection information, including the hostname, port number, and default database
@@ -107,7 +108,9 @@ module Rfm
   # * *name* is the name of this database
   # * *state* is a hash of all server options used to initialize this server
   class Server
-    #
+
+    attr_reader :db, :state, :uri
+
     # To create a Server object, you typically need at least a host name:
     # 
     #   myServer = Rfm::Server.new({:host => 'my.host.com'})
@@ -192,7 +195,6 @@ module Rfm
     #            :root_cert_name => 'example.pem'
     #            :root_cert_path => '/usr/cert_file/'
     #            })
-    
     def initialize(options)
       @state = {
         :host => 'localhost',
@@ -203,21 +205,16 @@ module Rfm
         :root_cert_path => '/',
         :account_name => '',
         :password => '',
-        :log_actions => false,
-        :log_responses => false,
+        :log_actions => nil,
+        :log_responses => nil,
         :warn_on_redirect => true,
-        :raise_on_401 => false
+        :raise_on_401 => nil
       }.merge(options)
-    
-      @state.freeze
-    
-      @host_name = @state[:host]
-      @scheme = @state[:ssl] ? "https" : "http"
-      @port = @state[:ssl] && options[:port].nil? ? 443 : @state[:port]
-    
-      @db = Rfm::Factory::DbFactory.new(self)
+
+      @uri = Addressable::URI.parse("#{scheme}://#{state[:host]}:#{port}")
+      @db  = Rfm::Factory::DbFactory.new(self)
     end
-    
+
     # Access the database object representing a database on the server. For example:
     #
     #   myServer['Customers']
@@ -233,9 +230,7 @@ module Rfm
     def [](dbname)
       self.db[dbname]
     end
-    
-    attr_reader :db, :host_name, :port, :scheme, :state
-    
+
     # Performs a raw FileMaker action. You will generally not call this method directly, but it
     # is exposed in case you need to do something "under the hood."
     # 
@@ -263,70 +258,78 @@ module Rfm
     #     },
     #     { :max_records => 20 }
     #   )
-    def connect(account_name, password, action, args, options = {})
+    def connect(action, args, options = {})
       post = args.merge(expand_options(options)).merge({action => ''})
-      http_fetch(@host_name, @port, "/fmi/xml/fmresultset.xml", account_name, password, post)
+      http_fetch("/fmi/xml/fmresultset.xml", post)
     end
-    
+
     def load_layout(layout)
       post = {'-db' => layout.db.name, '-lay' => layout.name, '-view' => ''}
-      http_fetch(@host_name, @port, "/fmi/xml/FMPXMLLAYOUT.xml", layout.db.account_name, layout.db.password, post)
+      http_fetch("/fmi/xml/FMPXMLLAYOUT.xml", post)
     end
-    
+
     private
-    
-      def http_fetch(host_name, port, path, account_name, password, post_data, limit=10)
+
+      def http_fetch(path, post_data, limit=10)
         raise Rfm::CommunicationError.new("While trying to reach the Web Publishing Engine, RFM was redirected too many times.") if limit == 0
     
-        if @state[:log_actions] == true
-          qs = post_data.collect{|key,val| "#{CGI::escape(key.to_s)}=#{CGI::escape(val.to_s)}"}.join("&")
-          warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs}"
-        end
+        uri.path = path
+        uri.query_values = post_data
+        warn uri.to_s if state[:log_actions]
     
-        request = Net::HTTP::Post.new(path)
-        request.basic_auth(account_name, password)
+        request = Net::HTTP::Post.new(uri.path)
+        request.basic_auth(state[:account_name], state[:password])
         request.set_form_data(post_data)
     
-        response = Net::HTTP.new(host_name, port)
+        response = Net::HTTP.new(uri.host, uri.port)
     
-        if @state[:ssl]
+        if state[:ssl]
           response.use_ssl = true
-          if @state[:root_cert]
+          if state[:root_cert]
             response.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            response.ca_file = File.join(@state[:root_cert_path], @state[:root_cert_name])
+            response.ca_file = File.join(state[:root_cert_path], state[:root_cert_name])
           else
             response.verify_mode = OpenSSL::SSL::VERIFY_NONE
           end
         end
     
         response = response.start { |http| http.request(request) }
-        if @state[:log_responses] == true
+        if state[:log_responses]
           response.to_hash.each { |key, value| warn "#{key}: #{value}" }
           warn response.body
         end
-    
+
+        parse_response(response, limit)
+      end
+
+      def parse_response(response, limit)
         case response
         when Net::HTTPSuccess
           response
         when Net::HTTPRedirection
-          if @state[:warn_on_redirect]
-            warn "The web server redirected to " + response['location'] + 
-            ". You should revise your connection hostname or fix your server configuration if possible to improve performance."
+          if state[:warn_on_redirect]
+            warn "The web server redirected to #{response['location']}.
+                 You should revise your connection hostname or fix your server configuration if possible to improve performance."
           end
-          newloc = URI.parse(response['location'])
-          http_fetch(newloc.host, newloc.port, newloc.request_uri, account_name, password, post_data, limit - 1)
+
+          newloc = Addressable::URI.parse(response['location'])
+          uri.host = newloc.host
+          uri.port = newloc.port
+          http_fetch(newloc.path, newloc.query_values, limit-1)
         when Net::HTTPUnauthorized
-          msg = "The account name (#{account_name}) or password provided is not correct (or the account doesn't have the fmxml extended privilege)."
+          msg = "The account name (#{state[:account_name]}) or password provided is not correct
+                (or the account doesn't have the fmxml extended privilege)."
           raise Rfm::AuthenticationError.new(msg)
         when Net::HTTPNotFound
           msg = "Could not talk to FileMaker because the Web Publishing Engine is not responding (server returned 404)."
           raise Rfm::CommunicationError.new(msg)
         else
-          msg = "Unexpected response from server: #{response.code} (#{response.class.to_s}). Unable to communicate with the Web Publishing Engine."
+          msg = "Unexpected response from server: #{response.code} (#{response.class.to_s}).
+                Unable to communicate with the Web Publishing Engine."
           raise Rfm::CommunicationError.new(msg)
         end
       end
-    
+
       def expand_options(options)
         result = {}
         options.each do |key,value|
@@ -382,6 +385,22 @@ module Rfm
         end
         return result
       end
+
+      def scheme
+        if state[:ssl]
+          "https"
+        else
+          "http"
+        end
+      end
+
+      def port
+        if state[:ssl] && state[:port] == 80
+          443
+        else
+          state[:port]
+        end
+      end
     
   end
-end
+end

data/lib/rfm/utilities/factory.rb

@@ -20,7 +20,7 @@ module Rfm
       
       def all
         if !@loaded
-          Rfm::Result::ResultSet.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body).each {|record|
+          Rfm::Result::ResultSet.new(@server, @server.connect('-dbnames', {}).body).each {|record|
             name = record['DATABASE_NAME']
             self[name] = Rfm::Database.new(name, @server) if self[name] == nil
           }
@@ -45,7 +45,7 @@ module Rfm
       
       def all
         if !@loaded
-          Rfm::Result::ResultSet.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-layoutnames', {"-db" => @database.name}).body).each {|record|
+          Rfm::Result::ResultSet.new(@server, @server.connect('-layoutnames', {"-db" => @database.name}).body).each {|record|
             name = record['LAYOUT_NAME']
             self[name] = Rfm::Layout.new(name, @database) if self[name] == nil
           }
@@ -70,7 +70,7 @@ module Rfm
       
       def all
         if !@loaded
-          Rfm::Result::ResultSet.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-scriptnames', {"-db" => @database.name}).body).each {|record|
+          Rfm::Result::ResultSet.new(@server, @server.connect('-scriptnames', {"-db" => @database.name}).body).each {|record|
             name = record['SCRIPT_NAME']
             self[name] = Rfm::Script.new(name, @database) if self[name] == nil
           }
@@ -81,4 +81,4 @@ module Rfm
     
     end
   end
-end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Rfm
+  VERSION = '1.4.2'
+end

data/spec/rfm/record_spec.rb

@@ -24,12 +24,20 @@ describe Rfm::Record do
       @record.instance_variable_get(:@mods)['tester'].should eql('green')
     end
     
-    it "raises an Rfm::ParameterError if a key is used that does not exist" do
+    it "raises an Rfm::ParameterError if a value is set on a key that does not exist" do
       @record.instance_variable_set(:@loaded, true)
-      
+
       ex = rescue_from { @record['tester2'] = 'error' }
       ex.class.should eql(Rfm::ParameterError)
-      ex.message.should eql('You attempted to modify a field does not exist.')
+      ex.message.should eql('You attempted to modify the field :tester2 which does not exist in the current Filemaker layout.')
+    end
+    
+    it "raises an NoMethodError if a key is used that does not exist" do
+      @record.instance_variable_set(:@loaded, true)
+
+      ex = rescue_from { @record['tester2'] }
+      ex.class.should eql(NoMethodError)
+      ex.message.should eql('tester2 does not exist as a field in the current Filemaker layout.')
     end
     
   end
@@ -80,4 +88,4 @@ describe Rfm::Record do
     end
 
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'bundler/setup'
+require 'logger'
 require 'rfm'
-require 'spec'
-require 'spec/autorun'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |c|
+  c.mock_with :mocha
 end
 
 def rescue_from(&block)

metadata

@@ -1,16 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: lardawge-rfm
-version: !ruby/object:Gem::Version 
-  hash: 127
-  prerelease: false
-  segments: 
-  - 1
-  - 4
-  - 1
-  - 2
-  version: 1.4.1.2
+version: !ruby/object:Gem::Version
+  version: 1.4.2
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Geoff Coffey
 - Mufaddal Khumri
 - Atsushi Matsuo
@@ -18,34 +12,105 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-07-09 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-description: Rfm brings your FileMaker data to Ruby. Now your Ruby scripts and Rails applications can talk directly to your FileMaker server.
-email: http://groups.google.com/group/rfmcommunity
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rfm brings your FileMaker data to Ruby. Now your Ruby scripts and Rails
+  applications can talk directly to your FileMaker server.
+email:
+- larry@lucidbleu.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
 - LICENSE
-- README.rdoc
-files: 
+- README.md
+- Rakefile
+- lardawge-rfm.gemspec
 - lib/rfm.rb
 - lib/rfm/database.rb
 - lib/rfm/error.rb
@@ -57,48 +122,37 @@ files:
 - lib/rfm/server.rb
 - lib/rfm/utilities/case_insensitive_hash.rb
 - lib/rfm/utilities/factory.rb
-- LICENSE
-- README.rdoc
+- lib/version.rb
 - spec/rfm/error_spec.rb
 - spec/rfm/record_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
-homepage: http://sixfriedrice.com/wp/products/rfm/
-licenses: []
-
+homepage: https://github.com/lardawge/rfm
+licenses:
+- MIT
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --main
-- README.rdoc
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Ruby to Filemaker adapter
-test_files: 
+test_files:
 - spec/rfm/error_spec.rb
 - spec/rfm/record_spec.rb
 - spec/spec_helper.rb
+has_rdoc: