rfm 0.2.0 → 1.0.0

data/lib/rfm_error.rb

@@ -1,25 +1,252 @@
+require "set"
+
+# These classes wrap the filemaker error codes. FileMakerError is the base class of this hierarchy.
+# 
+# One could get a FileMakerError by doing:
+#   err = Rfm::Error::FileMakerError.getError(102)
+# 
+# The above code would return a FieldMissingError instance. Your could use this instance to raise that appropriate
+# exception:
+# 
+#   raise err 
+# 
+# You could access the specific error code by accessing:
+#   
+#   err.code
+#   
+# Author::    Mufaddal Khumri
+# Copyright:: Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumri
+# License::   See MIT-LICENSE for details
 module Rfm::Error
-  class FileMakerError < Exception
-    def self.instance(error_code)
-      case error_code
-        when 101 then return RecordMissingError.new
-        when 102 then return FieldMissingError.new
-        when 104 then return RelationshipMissingError.new
-        when 105 then return LayoutMissingError.new
-        else return FileMakerError.new
+  
+  class RfmError < StandardError
+  end
+  
+  class CommunicationError < RfmError
+  end
+  
+  class ParameterError < RfmError
+  end
+  
+  class AuthenticationError < RfmError
+  end
+  
+  # Base class for all FileMaker errors
+  class FileMakerError < RfmError
+    attr_accessor :code
+    
+    # Default filemaker error message map
+    @@default_messages = {}
+    
+    # This method instantiates and returns the appropriate FileMakerError object depending on the error code passed to it. It
+    # also accepts an optional message.
+    def self.getError(code, message = nil)
+      if @@default_messages == nil or @@default_messages.size == 0
+        (0..99).each{|i| @@default_messages[i] = 'SystemError occurred.'}
+        (100..199).each{|i| @@default_messages[i] = 'MissingError occurred.'}
+        @@default_messages[102] = 'FieldMissingError occurred.'
+        @@default_messages[104] = 'ScriptMissingError occurred.'
+        @@default_messages[105] = 'LayoutMissingError occurred.'
+        @@default_messages[106] = 'TableMissingError occurred.'
+        (200..299).each{|i| @@default_messages[i] = 'SecurityError occurred.'}
+        @@default_messages[200] = 'RecordAccessDeniedError occurred.'
+        @@default_messages[201] = 'FieldCannotBeModifiedError occurred.'
+        @@default_messages[202] = 'FieldAccessIsDeniedError occurred.'
+        (300..399).each{|i| @@default_messages[i] = 'ConcurrencyError occurred.'}
+        @@default_messages[301] = 'RecordInUseError occurred.'
+        @@default_messages[302] = 'TableInUseError occurred.'
+        @@default_messages[306] = 'RecordModIdDoesNotMatchError occurred.'
+        (400..499).each{|i| @@default_messages[i] = 'GeneralError occurred.'}
+        @@default_messages[401] = 'NoRecordsFoundError occurred.'
+        (500..599).each{|i| @@default_messages[i] = 'ValidationError occurred.'}
+        @@default_messages[500] = 'DateValidationError occurred.'
+        @@default_messages[501] = 'TimeValidationError occurred.'
+        @@default_messages[502] = 'NumberValidationError occurred.'
+        @@default_messages[503] = 'RangeValidationError occurred.'
+        @@default_messages[504] = 'UniqueValidationError occurred.'
+        @@default_messages[505] = 'ExistingValidationError occurred.'
+        @@default_messages[506] = 'ValueListValidationError occurred.'
+        @@default_messages[507] = 'ValidationCalculationError occurred.'
+        @@default_messages[508] = 'InvalidFindModeValueError occurred.'
+        @@default_messages[511] = 'MaximumCharactersValidationError occurred.'
+        (800..899).each{|i| @@default_messages[i] = 'FileError occurred.'}
+        @@default_messages[802] = 'UnableToOpenFileError occurred.'
+      end 
+      
+      message = @@default_messages[code] if message == nil || message.strip == ''
+      message += " (FileMaker Error ##{code})"
+      
+      if 0 <= code and code <= 99
+        err = SystemError.new(message)
+      elsif 100 <= code and code <= 199
+        if code == 101
+          err = RecordMissingError.new(message)
+        elsif code == 102
+          err = FieldMissingError.new(message)
+        elsif code == 104
+          err = ScriptMissingError.new(message)
+        elsif code == 105
+          err = LayoutMissingError.new(message)
+        elsif code == 106
+          err = TableMissingError.new(message)
+        else
+          err = MissingError.new(message)
+        end
+      elsif 200 <= code and code <= 299
+        if code == 200
+          err = RecordAccessDeniedError.new(message)
+        elsif code == 201
+          err = FieldCannotBeModifiedError.new(message)
+        elsif code == 202
+          err = FieldAccessIsDeniedError.new(message)
+        else
+          err = SecurityError.new(message)
+        end
+      elsif 300 <= code and code <= 399
+        if code == 301
+          err = RecordInUseError.new(message)
+        elsif code == 302
+          err = TableInUseError.new(message)
+        elsif code == 306
+          err = RecordModIdDoesNotMatchError.new(message)
+        else
+          err = ConcurrencyError.new(message)
+        end
+      elsif 400 <= code and code <= 499
+        if code == 401
+          err = NoRecordsFoundError.new(message)
+        else
+          err = GeneralError.new(message)
+        end
+      elsif 500 <= code and code <= 599
+        if code == 500
+          err = DateValidationError.new(message)
+        elsif code == 501
+          err = TimeValidationError.new(message)
+        elsif code == 502
+          err = NumberValidationError.new(message)
+        elsif code == 503
+          err = RangeValidationError.new(message)
+        elsif code == 504
+          err = UniqueValidationError.new(message)
+        elsif code == 505
+          err = ExistingValidationError.new(message)
+        elsif code == 506
+          err = ValueListValidationError.new(message)
+        elsif code == 507
+          err = ValidationCalculationError.new(message)
+        elsif code == 508
+          err = InvalidFindModeValueError.new(message)
+        elsif code == 511
+          err = MaximumCharactersValidationError.new(message)
+        else
+          err = ValidationError.new(message)
+        end
+      elsif 800 <= code and code <= 899
+        if code == 802
+          err = UnableToOpenFileError.new(message)
+        else
+          err = FileError.new(message)
+        end
+      else 
+        # called for code == -1 or any other code not handled above.
+        err = UnknownError.new(message)
       end
-    end
+      err.code = code
+      return err
+    end    
+  end
+  
+  class UnknownError < FileMakerError  
+  end
+  
+  class SystemError < FileMakerError  
+  end
+  
+  class MissingError < FileMakerError  
+  end
+  
+  class RecordMissingError < MissingError  
+  end
+
+  class FieldMissingError < MissingError  
+  end
+
+  class ScriptMissingError < MissingError  
+  end
+
+  class LayoutMissingError < MissingError  
+  end
+
+  class TableMissingError < MissingError  
+  end
+
+  class SecurityError < FileMakerError  
+  end
+  
+  class RecordAccessDeniedError < SecurityError  
+  end
+
+  class FieldCannotBeModifiedError < SecurityError  
+  end
+
+  class FieldAccessIsDeniedError < SecurityError  
+  end
+  
+  class ConcurrencyError < FileMakerError  
   end
   
-  class RecordMissingError < FileMakerError
+  class RecordInUseError < ConcurrencyError  
+  end
+
+  class TableInUseError < ConcurrencyError  
+  end
+
+  class RecordModIdDoesNotMatchError < ConcurrencyError  
+  end
+
+  class GeneralError < FileMakerError  
+  end
+
+  class NoRecordsFoundError < GeneralError  
+  end
+   
+  class ValidationError < FileMakerError  
+  end 
+
+  class DateValidationError < ValidationError  
+  end
+
+  class TimeValidationError < ValidationError  
   end
   
-  class FieldMissingError < FileMakerError
+  class NumberValidationError < ValidationError  
   end
   
-  class RelationshipMissingError < FileMakerError
+  class RangeValidationError < ValidationError  
+  end
+
+  class UniqueValidationError < ValidationError  
   end
   
-  class LayoutMissingError < FileMakerError
+  class ExistingValidationError < ValidationError  
+  end
+
+  class ValueListValidationError < ValidationError  
+  end
+
+  class ValidationCalculationError < ValidationError  
+  end
+
+  class InvalidFindModeValueError < ValidationError  
+  end
+
+  class MaximumCharactersValidationError < ValidationError  
+  end
+
+  class FileError < FileMakerError  
+  end 
+
+  class UnableToOpenFileError < FileError  
   end
-end
+end

data/lib/rfm_factory.rb

@@ -1,5 +1,12 @@
-module Rfm::Factory
-  class DbFactory < Hash
+# The classes in this module are used internally by RFM and are not intended for outside
+# use.
+#
+# Author::    Geoff Coffey  (mailto:gwcoffey@gmail.com)
+# Copyright:: Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumri
+# License::   See MIT-LICENSE for details
+
+module Rfm::Factory # :nodoc: all
+  class DbFactory < Rfm::Util::CaseInsensitiveHash
   
     def initialize(server)
       @server = server
@@ -12,7 +19,7 @@ module Rfm::Factory
     
     def all
       if !@loaded
-        Rfm::Result::ResultSet.new(@server, @server.do_action('-dbnames', {}).body).each {|record|
+        Rfm::Result::ResultSet.new(@server, @server.do_action(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body).each {|record|
           name = record['DATABASE_NAME']
           self[name] = Rfm::Database.new(name, @server) if self[name] == nil
         }
@@ -23,7 +30,7 @@ module Rfm::Factory
 
   end
   
-  class LayoutFactory < Hash
+  class LayoutFactory < Rfm::Util::CaseInsensitiveHash
   
     def initialize(server, database)
       @server = server
@@ -37,7 +44,7 @@ module Rfm::Factory
     
     def all
       if !@loaded
-        Rfm::Result::ResultSet.new(@server, @server.do_action('-layoutnames', {"-db" => @database.name}).body).each {|record|
+        Rfm::Result::ResultSet.new(@server, @server.do_action(@server.state[:account_name], @server.state[:password], '-layoutnames', {"-db" => @database.name}).body).each {|record|
           name = record['LAYOUT_NAME']
           self[name] = Rfm::Layout.new(name, @database) if self[name] == nil
         }
@@ -48,7 +55,7 @@ module Rfm::Factory
 
   end
 
-  class ScriptFactory < Hash
+  class ScriptFactory < Rfm::Util::CaseInsensitiveHash
   
     def initialize(server, database)
       @server = server
@@ -62,7 +69,7 @@ module Rfm::Factory
     
     def all
       if !@loaded
-        Rfm::Result::ResultSet.new(@server, @server.do_action('-scriptnames', {"-db" => @database.name}).body).each {|record|
+        Rfm::Result::ResultSet.new(@server, @server.do_action(@server.state[:account_name], @server.state[:password], '-scriptnames', {"-db" => @database.name}).body).each {|record|
           name = record['SCRIPT_NAME']
           self[name] = Rfm::Script.new(name, @database) if self[name] == nil
         }

data/lib/rfm_result.rb

@@ -1,15 +1,70 @@
+# This module includes classes that represent FileMaker data. When you communicate with FileMaker
+# using, ie, the Layout object, you typically get back ResultSet objects. These contain Records,
+# which in turn contain Fields, Portals, and arrays of data.
+#
+# Author::    Geoff Coffey  (mailto:gwcoffey@gmail.com)
+# Copyright:: Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumri
+# License::   See MIT-LICENSE for details
 require 'bigdecimal'
 require 'date'
 
 module Rfm::Result
   
+  # The ResultSet object represents a set of records in FileMaker. It is, in every way, a real Ruby
+  # Array, so everything you expect to be able to do with an Array can be done with a ResultSet as well.
+  # In this case, the elements in the array are Record objects.
+  #
+  # Here's a typical example, displaying the results of a Find:
+  #
+  #   myServer = Rfm::Server.new(...)
+  #   results = myServer["Customers"]["Details"].find("First Name" => "Bill")
+  #   results.each {|record|
+  #     puts record["First Name"]
+  #     puts record["Last Name"]
+  #     puts record["Email Address"]
+  #   }
+  #
+  # =Attributes
+  #
+  # The ResultSet object has several useful attributes:
+  #
+  # * *server* is the server object this ResultSet came from
+  #
+  # * *fields* is a hash with field names for keys and Field objects for values; it provides 
+  #   metadata about the fields in the ResultSet
+  #
+  # * *portals* is a hash with table occurrence names for keys and arrays of Field objects for values;
+  #   it provides metadata about the portals in the ResultSet and the Fields on those portals
+
   class ResultSet < Array
+    
+    # Initializes a new ResultSet object. You will probably never do this your self (instead, use the Layout
+    # object to get various ResultSet obejects).
+    #
+    # If you feel so inclined, though, pass a Server object, and some +fmpxmlresult+ compliant XML in a String.
+    #
+    # =Attributes
+    #
+    # The ResultSet object includes several useful attributes:
+    #
+    # * *fields* is a hash (with field names for keys and Field objects for values). It includes an entry for
+    #   every field in the ResultSet. Note: You don't use Field objects to access _data_. If you're after 
+    #   data, get a Record object (ResultSet is an array of records). Field objects tell you about the fields
+    #   (their type, repetitions, and so forth) in case you find that information useful programmatically.
+    #
+    #   Note: keys in the +fields+ hash are downcased for convenience (and [] automatically downcases on 
+    #   lookup, so it should be seamless). But if you +each+ a field hash and need to know a field's real
+    #   name, with correct case, do +myField.name+ instead of relying on the key in the hash.
+    #
+    # * *portals* is a hash (with table occurrence names for keys and Field objects for values). If your
+    #   layout contains portals, you can find out what fields they contain here. Again, if it's the data you're
+    #   after, you want to look at the Record object.
     def initialize(server, fmresultset, layout = nil)
       @server = server
       @resultset = nil
       @layout = layout
-      @fields = {}
-      @portals = {}
+      @fields = Rfm::Util::CaseInsensitiveHash.new
+      @portals = Rfm::Util::CaseInsensitiveHash.new
       @date_format = nil
       @time_format = nil
       @timestamp_format = nil
@@ -19,7 +74,9 @@ module Rfm::Result
       
       # check for errors
       error = root.elements['error'].attributes['code'].to_i
-      raise "Error #{error} occurred while processing the request" if error != 0 && (error != 401 || @server.state[:raise_on_401])
+      if error != 0 && (error != 401 || @server.state[:raise_on_401])
+        raise Rfm::Error::FileMakerError.getError(error) 
+      end
       
       # ascertain date and time formats
       datasource = root.elements['datasource']
@@ -52,7 +109,7 @@ module Rfm::Result
       }
     end  
         
-    attr_reader :server, :fields, :portals, :date_format, :time_format, :timestamp_format
+    attr_reader :server, :fields, :portals, :date_format, :time_format, :timestamp_format, :layout
     
     private
     
@@ -62,7 +119,108 @@ module Rfm::Result
     
   end
   
-  class Record < Hash
+  # The Record object represents a single FileMaker record. You typically get them from ResultSet objects.
+  # For example, you might use a Layout object to find some records:
+  #
+  #   results = myLayout.find({"First Name" => "Bill"})
+  #
+  # The +results+ variable in this example now contains a ResultSet object. ResultSets are really just arrays of
+  # Record objects (with a little extra added in). So you can get a record object just like you would access any 
+  # typical array element:
+  #
+  #   first_record = results[0]
+  #
+  # You can find out how many record were returned:
+  #
+  #   record_count = results.size
+  #
+  # And you can of course iterate:
+  # 
+  #   results.each (|record|
+  #     // you can work with the record here
+  #   )
+  #
+  # =Accessing Field Data
+  #
+  # You can access field data in the Record object in two ways. Typically, you simply treat Record like a hash
+  # (because it _is_ a hash...I love OOP). Keys are field names:
+  # 
+  #   first = myRecord["First Name"]
+  #   last = myRecord["Last Name"]
+  #
+  # If your field naming conventions mean that your field names are also valid Ruby symbol named (ie: they contain only
+  # letters, numbers, and underscores) then you can treat them like attributes of the record. For example, if your fields
+  # are called "first_name" and "last_name" you can do this:
+  #
+  #   first = myRecord.first_name
+  #   last = myRecord.last_name
+  #
+  # Note: This shortcut will fail (in a rather mysterious way) if your field name happens to match any real attribute
+  # name of a Record object. For instance, you may have a field called "server". If you try this:
+  # 
+  #   server_name = myRecord.server
+  # 
+  # you'll actually set +server_name+ to the Rfm::Server object this Record came from. This won't fail until you try
+  # to treat it as a String somewhere else in your code. It is also possible a future version of Rfm will include
+  # new attributes on the Record class which may clash with your field names. This will cause perfectly valid code
+  # today to fail later when you upgrade. If you can't stomach this kind of insanity, stick with the hash-like
+  # method of field access, which has none of these limitations. Also note that the +myRecord[]+ method is probably
+  # somewhat faster since it doesn't go through +method_missing+.
+  #
+  # =Accessing Repeating Fields
+  #
+  # If you have a repeating field, RFM simply returns an array:
+  #
+  #   val1 = myRecord["Price"][0]
+  #   val2 = myRecord["Price"][1]
+  #
+  # In the above example, the Price field is a repeating field. The code puts the first repetition in a variable called 
+  # +val1+ and the second in a variable called +val2+.
+  #
+  # =Accessing Portals
+  #
+  # If the ResultSet includes portals (because the layout it comes from has portals on it) you can access them
+  # using the Record::portals attribute. It is a hash with table occurrence names for keys, and arrays of Record
+  # objects for values. In other words, you can do this:
+  #
+  #   myRecord.portals["Orders"].each {|record|
+  #     puts record["Order Number"]
+  #   }
+  #
+  # This code iterates through the rows of the _Orders_ portal.
+  # 
+  # =Field Types and Ruby Types
+  #
+  # RFM automatically converts data from FileMaker into a Ruby object with the most reasonable type possible. The 
+  # type are mapped thusly:
+  #
+  # * *Text* fields are converted to Ruby String objects
+  # 
+  # * *Number* fields are converted to Ruby BigDecimal objects (the basic Ruby numeric types have
+  #   much less precision and range than FileMaker number fields)
+  #
+  # * *Date* fields are converted to Ruby Date objects
+  #
+  # * *Time* fields are converted to Ruby DateTime objects (you can ignore the date component)
+  #
+  # * *Timestamp* fields are converted to Ruby DateTime objects
+  #
+  # * *Container* fields are converted to Ruby URI objects
+  #
+  # =Attributes
+  #
+  # In addition to +portals+, the Record object has these useful attributes:
+  #
+  # * *record_id* is FileMaker's internal identifier for this record (_not_ any ID field you might have
+  #   in your table); you need a +record_id+ to edit or delete a record
+  #
+  # * *mod_id* is the modification identifier for the record; whenever a record is modified, its +mod_id+
+  #   changes so you can tell if the Record object you're looking at is up-to-date as compared to another
+  #   copy of the same record
+  class Record < Rfm::Util::CaseInsensitiveHash
+    
+    # Initializes a Record object. You really really never need to do this yourself. Instead, get your records
+    # from a ResultSet object.
     def initialize(row_element, resultset, fields, layout, portal=nil)
       @record_id = row_element.attributes['record-id']
       @mod_id = row_element.attributes['mod-id']
@@ -86,7 +244,7 @@ module Rfm::Result
         end
       }
       
-      @portals = {}
+      @portals = Rfm::Util::CaseInsensitiveHash.new
       row_element.each_element('relatedset') { |relatedset|
         table = relatedset.attributes['table']
         records = []
@@ -101,22 +259,52 @@ module Rfm::Result
     
     attr_reader :record_id, :mod_id, :portals
 
+    # Saves local changes to the Record object back to Filemaker. For example:
+    #
+    #   myLayout.find({"First Name" => "Bill"}).each(|record|
+    #     record["First Name"] = "Steve"
+    #     record.save
+    #   )
+    #
+    # This code finds every record with _Bill_ in the First Name field, then changes the first name to 
+    # Steve.
+    #
+    # Note: This method is smart enough to not bother saving if nothing has changed. So there's no need
+    # to optimize on your end. Just save, and if you've changed the record it will be saved. If not, no
+    # server hit is incurred.
     def save
       self.merge(@layout.edit(self.record_id, @mods)[0]) if @mods.size > 0
       @mods.clear
     end
 
+    # Like Record::save, except it fails (and raises an error) if the underlying record in FileMaker was
+    # modified after the record was fetched but before it was saved. In other words, prevents you from
+    # accidentally overwriting changes someone else made to the record.
     def save_if_not_modified
       self.merge(@layout.edit(@record_id, @mods, {:modification_id => @mod_id})[0]) if @mods.size > 0
       @mods.clear
     end
     
-    def []=(name, value)
-      return super if !@loaded
+    # Gets the value of a field from the record. For example:
+    #
+    #   first = myRecord["First Name"]
+    #   last = myRecord["Last Name"]
+    #
+    # This sample puts the first and last name from the record into Ruby variables.
+    #
+    # You can also update a field:
+    #
+    #   myRecord["First Name"] = "Sophia"
+    #
+    # When you do, the change is noted, but *the data is not updated in FileMaker*. You must call
+    # Record::save or Record::save_if_not_modified to actually save the data.
+    def []=(pname, value)
+      return super if !@loaded # this just keeps us from getting mods during initialization
+      name = pname
       if self[name] != nil
         @mods[name] = val
       else
-        raise "No such field: #{name}"
+        raise Rfm::Error::ParameterError.new("You attempted to modify a field called '#{name}' on the Rfm::Record object, but that field does not exist.")
       end
     end
     
@@ -139,7 +327,67 @@ module Rfm::Result
     end
   end
   
+  # The Field object represents a single FileMaker field. It *does not hold the data* in the field. Instead,
+  # it serves as a source of metadata about the field. For example, if you're script is trying to be highly
+  # dynamic about its field access, it may need to determine the data type of a field at run time. Here's
+  # how:
+  #
+  #   field_name = "Some Field Name"
+  #   case myRecord.fields[field_name].result
+  #   when "text"
+  #     # it is a text field, so handle appropriately
+  #   when "number"
+  #     # it is a number field, so handle appropriately
+  #   end
+  #
+  # =Attributes
+  #
+  # The Field object has the following attributes useful attributes:
+  #
+  # * *name* is the name of the field
+  #
+  # * *result* is the data type of the field; possible values include:
+  #   * text
+  #   * number
+  #   * date
+  #   * time
+  #   * timestamp
+  #   * container
+  #
+  # * *type* any of these:
+  #   * normal (a normal data field)
+  #   * calculation
+  #   * summary
+  #
+  # * *max_repeats* is the number of repetitions (1 for a normal field, more for a repeating field)
+  #
+  # * *global* is +true+ is this is a global field, *false* otherwise
+  #
+  # Note: Field types match FileMaker's own values, but the terminology differs. The +result+ attribute
+  # tells you the data type of the field, regardless of whether it is a calculation, summary, or normal
+  # field. So a calculation field whose result type is _timestamp_ would have these attributes:
+  #
+  # * result: timestamp
+  # * type: calculation
+  #
+  # * *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:
+  #
+  #   controls = [myField.control].flatten
+  #   controls.each {|control|
+  #     # do something with the control here
+  #   }
+  #
+  # 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
+    
+    # Initializes a field object. You'll never need to do this. Instead, get your Field objects from
+    # ResultSet::fields
     def initialize(result_set, field)
       @result_set = result_set
       @name = field.attributes['name']
@@ -147,10 +395,19 @@ module Rfm::Result
       @type = field.attributes['type']
       @max_repeats = field.attributes['max-repeats']
       @global = field.attributes['global']
+      
+      @laded = false
     end
     
-    attr_reader :name, :type, :max_repeats, :global
+    attr_reader :name, :result, :type, :max_repeats, :global
+
+    def control
+      @result_set.layout.field_controls[@name]
+    end
 
+    # 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)
       return nil if (value == nil || value == '') && @result != "text"
       case @result
@@ -165,7 +422,7 @@ module Rfm::Result
       when "timestamp"
         return DateTime.strptime(value, @result_set.timestamp_format)
       when "container"
-        return URI.parse("http://#{@result_set.server.host_name}:#{@result_set.server.port}#{value}")
+        return URI.parse("#{@result_set.server.scheme}://#{@result_set.server.host_name}:#{@result_set.server.port}#{value}")
       end
     end
   end