filemaker 0.0.1

data/lib/filemaker/layout.rb

@@ -0,0 +1,38 @@
+module Filemaker
+  class Layout
+    include Api
+
+    # @return [String] layout name
+    attr_reader :name
+
+    # @return [Filemaker::Server] the server
+    attr_reader :server
+
+    # @return [String] the database
+    attr_reader :database
+
+    def initialize(name, server, database)
+      @name = name
+      @server = server
+      @database = database
+    end
+
+    def default_params
+      { '-db' => database.name, '-lay' => name }
+    end
+
+    # @return [Filemaker::Resultset]
+    def perform_request(action, args, options)
+      response, params = server
+        .perform_request(:post, action, default_params.merge(args), options)
+
+      Filemaker::Resultset.new(server, response.body, params)
+    end
+
+    private
+
+    def valid_options(options, *keys)
+      options.keys.each { |key| options.delete(key) unless keys.include?(key) }
+    end
+  end
+end

data/lib/filemaker/metadata/field.rb

@@ -0,0 +1,71 @@
+require 'date'
+require 'bigdecimal'
+
+module Filemaker
+  module Metadata
+    class Field
+      # @return [String] name of the field
+      attr_reader :name
+
+      # @return [String] one of 'text', 'number', 'date', 'time',
+      # 'timestamp', or 'container'
+      attr_reader :data_type
+
+      # @return [String] one of 'normal', 'calculation', or 'summary'
+      attr_reader :field_type
+
+      # @return [Integer] how many times the <data> repeats
+      attr_reader :repeats
+
+      # @return [Boolean] indicates if field is required or not
+      attr_reader :required
+
+      # @return [Boolean] whether it is a global field
+      attr_reader :global
+
+      def initialize(definition, resultset)
+        @name       = definition['name']
+        @data_type  = definition['result']
+        @field_type = definition['type']
+        @repeats    = definition['max-repeat'].to_i
+        @global     = convert_to_boolean(definition['global'])
+        @required   = convert_to_boolean(definition['not-empty'])
+        @resultset  = resultset
+      end
+
+      def coerce(value)
+        value = value.to_s.strip
+        return nil if value.empty?
+
+        case data_type
+        when 'number'
+          BigDecimal.new(value)
+        when 'date'
+          # date_format likely will be '%m/%d/%Y', but if we got '19/8/2014',
+          # then `strptime` will raise invalid date error
+          Date.strptime(value, @resultset.date_format)
+          # Date.strptime(Date.parse(value).strftime(@resultset.date_format), @resultset.date_format)
+        when 'time'
+          DateTime.strptime("1/1/-4712 #{value}", @resultset.timestamp_format)
+        when 'timestamp'
+          DateTime.strptime(value, @resultset.timestamp_format)
+        when 'container'
+          URI.parse("#{@resultset.server.host}#{value}")
+        else
+          value
+        end
+      rescue Exception => e
+        msg = "Could not coerce #{value} due to #{e.message}"
+        raise Filemaker::Error::CoerceError, msg
+      end
+
+      private
+
+      # 'yes' != 'no' => true
+      # 'no'  != 'no' => false
+      def convert_to_boolean(value)
+        value != 'no'
+      end
+    end
+  end
+end

data/lib/filemaker/record.rb

@@ -0,0 +1,64 @@
+module Filemaker
+  class Record < HashWithIndifferentAndCaseInsensitiveAccess
+    # @return [String] modification ID
+    attr_reader :mod_id
+
+    # @return [String] record ID that is used for -edit and -delete
+    attr_reader :record_id
+
+    # @return [Hash] additional nested records
+    attr_reader :portals
+
+    def initialize(record, resultset, portal_table_name = nil)
+      @mod_id    = record['mod-id']
+      @record_id = record['record-id']
+      @portals   = HashWithIndifferentAndCaseInsensitiveAccess.new
+
+      record.xpath('field').each do |field|
+        # `field` is Nokogiri::XML::Element
+        field_name = field['name']
+        # Right now, I do not want to mess with the field name
+        # field_name.gsub!(Regexp.new(portal_table_name + '::'), '')
+        #   \if portal_table_name
+        datum = []
+
+        metadata_fields = if portal_table_name
+                            resultset.portal_fields[portal_table_name]
+                          else
+                            resultset.fields
+                          end
+
+        field.xpath('data').each do |data|
+          datum.push(metadata_fields[field_name].coerce(data.inner_text))
+        end
+
+        self[field_name] = normalize_data(datum)
+      end
+
+      build_portals(record.xpath('relatedset'), resultset)
+    end
+
+    private
+
+    def build_portals(relatedsets, resultset)
+      return if relatedsets.empty?
+
+      relatedsets.each do |relatedset|
+        # `relatedset` is Nokogiri::XML::Element
+        table_name = relatedset['table']
+        records    = []
+
+        relatedset.xpath('record').each do |record|
+          records << self.class.new(record, resultset, table_name)
+        end
+
+        @portals[table_name] = records
+      end
+    end
+
+    def normalize_data(datum)
+      return nil if datum.empty?
+      (datum.size == 1) ? datum.first : datum
+    end
+  end
+end

data/lib/filemaker/resultset.rb

@@ -0,0 +1,124 @@
+require 'nokogiri'
+require 'filemaker/metadata/field'
+
+module Filemaker
+  class Resultset
+    include Enumerable
+
+    # @return [Array] hold records
+    attr_reader :list
+
+    # @return [Integer] number of records
+    attr_reader :count
+
+    # @return [Integer] total count of the record
+    attr_reader :total_count
+
+    # @return [Hash] representing the top-level non-portal field-definition
+    attr_reader :fields
+
+    # @return [Hash] representing the portal field-definition
+    attr_reader :portal_fields
+
+    # @return [String] Ruby's date format directive
+    attr_reader :date_format
+
+    # @return [String] Ruby's time format directive
+    attr_reader :time_format
+
+    # @return [String] Ruby's date and time format directive
+    attr_reader :timestamp_format
+
+    # @return [Filemaker::Server] the server
+    attr_reader :server
+
+    # @return [Hash] the request params
+    attr_reader :params
+
+    # @return [String] the raw XML for inspection
+    attr_reader :xml
+
+    # @param xml [Filemaker::Server] server
+    # @param xml [String] the XML string from response
+    # @param xml [Hash] the request params used to construct request
+    def initialize(server, xml, params = nil)
+      @list = []
+      @fields = {}
+      @portal_fields = {}
+      @server = server
+      @params = params # Useful for debugging
+
+      doc = Nokogiri::XML(xml).remove_namespaces!
+      @xml = doc.to_xml(indent: 2) # Just want to pretty print it
+
+      error_code = doc.xpath('/fmresultset/error').attribute('code').value.to_i
+      raise_potential_error!(error_code)
+
+      datasource = doc.xpath('/fmresultset/datasource')
+      metadata   = doc.xpath('/fmresultset/metadata')
+      resultset  = doc.xpath('/fmresultset/resultset')
+      records    = resultset.xpath('record')
+
+      @date_format = convert_format(datasource.attribute('date-format').value)
+      @time_format = convert_format(datasource.attribute('time-format').value)
+      @timestamp_format = \
+        convert_format(datasource.attribute('timestamp-format').value)
+
+      @count = resultset.attribute('count').value.to_i
+      @total_count = datasource.attribute('total-count').value.to_i
+
+      build_metadata(metadata)
+      build_records(records)
+    end
+
+    # Delegate to list -> map, filter, reverse, etc
+    def each(*args, &block)
+      list.each(*args, &block)
+    end
+
+    private
+
+    def raise_potential_error!(error_code)
+      return if error_code.zero?
+
+      Filemaker::Error.raise_error_by_code(error_code)
+    end
+
+    def build_metadata(metadata)
+      metadata.xpath('field-definition').each do |definition|
+        @fields[definition['name']] = Metadata::Field.new(definition, self)
+      end
+
+      metadata.xpath('relatedset-definition').each do |relatedset|
+        table_name = relatedset.attribute('table').value
+        p_fields     = {}
+
+        relatedset.xpath('field-definition').each do |definition|
+          # Right now, I do not want to mess with the field name
+          # name = definition['name'].gsub("#{table_name}::", '')
+          name = definition['name']
+          p_fields[name] = Metadata::Field.new(definition, self)
+        end
+
+        @portal_fields[table_name] = p_fields
+      end
+    end
+
+    def build_records(records)
+      records.each do |record|
+        # record is Nokogiri::XML::Element
+        list << Filemaker::Record.new(record, self)
+      end
+    end
+
+    def convert_format(format)
+      format
+        .gsub('MM', '%m')
+        .gsub('dd', '%d')
+        .gsub('yyyy', '%Y')
+        .gsub('HH', '%H')
+        .gsub('mm', '%M')
+        .gsub('ss', '%S')
+    end
+  end
+end

data/lib/filemaker/script.rb

@@ -0,0 +1,9 @@
+module Filemaker
+  class Script
+    def initialize(name, server, database)
+      @name = name
+      @server = server
+      @database = database
+    end
+  end
+end

data/lib/filemaker/server.rb

@@ -0,0 +1,197 @@
+require 'faraday'
+require 'typhoeus/adapters/faraday'
+require 'filemaker/configuration'
+
+module Filemaker
+  class Server
+    extend Forwardable
+
+    # @return [Faraday::Connection] the HTTP connection
+    attr_reader :connection
+
+    # @return [Filemaker::Store::DatabaseStore] the database store
+    attr_reader :databases
+    alias_method :database, :databases
+    alias_method :db, :databases
+
+    def_delegators :@config, :host, :url, :ssl, :endpoint
+    def_delegators :@config, :account_name, :password
+
+    def initialize(options = {})
+      @config = Configuration.new
+      yield @config if block_given?
+      fail ArgumentError if @config.not_configurable?
+
+      @databases = Store::DatabaseStore.new(self)
+      @connection = get_connection(options)
+    end
+
+    # @api private
+    # Mostly used by Filemaker::Api
+    # TODO: There must be tracing/instrumentation. CURL etc.
+    # Or performance metrics?
+    # Also we want to pass in timeout option so we can ignore timeout for really
+    # long requests
+    #
+    # @return [Array] Faraday::Response and request params Hash
+    def perform_request(method, action, args, options = {})
+      params = serialize_args(args)
+        .merge(expand_options(options))
+        .merge({ action => '' })
+
+      # Serialize the params for submission
+      params = params.stringify_keys
+
+      log_action(params)
+
+      # yield params if block_given?
+      response = @connection.__send__(method, endpoint, params)
+
+      case response.status
+      when 200 then [response, params]
+      when 401 then fail Error::AuthenticationError, 'Auth failed.'
+      when 0   then fail Error::CommunicationError, 'Empty response.'
+      when 404 then fail Error::CommunicationError, 'HTTP 404 Not Found'
+      when 302 then fail Error::CommunicationError, 'Redirect not supported'
+      else
+        msg = "Unknown response status = #{response.status}"
+        fail Error::CommunicationError, msg
+      end
+    end
+
+    def handler_names
+      @connection.builder.handlers.map(&:name)
+    end
+
+    private
+
+    def get_connection(options = {})
+      faraday_options = @config.connection_options.merge(options)
+
+      Faraday.new(@config.url, faraday_options) do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter :typhoeus
+        faraday.headers[:user_agent] = \
+          "filemaker-ruby-#{Filemaker::VERSION}".freeze
+        faraday.basic_auth @config.account_name, @config.password
+      end
+    end
+
+    def serialize_args(args)
+      return {} if args.nil?
+
+      args.each do |key, value|
+        case value
+        when Date     then args[key] = value.strftime('%m/%d/%Y')
+        when DateTime then args[key] = value.strftime('%m/%d/%Y %H:%M:%S')
+        when Time     then args[key] = value.strftime('%H:%M')
+        else
+          args[key] = value.to_s
+        end
+      end
+
+      args
+    end
+
+    def expand_options(options)
+      expanded = {}
+      options.each do |key, value|
+        case key
+        when :max
+          expanded['-max'] = value
+        when :skip
+          expanded['-skip'] = value
+        when :sortfield
+          if value.is_a? Array
+            msg = 'Too many sortfield, limit=9'
+            fail(Filemaker::Error::ParameterError, msg) if value.size > 9
+            value.each_index do |index|
+              expanded["-sortfield.#{index + 1}"] = value[index]
+            end
+          else
+            expanded['-sortfield.1'] = value
+          end
+        when :sortorder
+          if value.is_a? Array
+            # Use :sortfield as single source of truth for array size
+            msg = 'Too many sortorder, limit=9'
+            fail(Filemaker::Error::ParameterError, msg) if value.size > 9
+            options[:sortfield].each_index do |index|
+              expanded["-sortorder.#{index + 1}"] = value[index] || 'ascend'
+            end
+          else
+            expanded['-sortorder.1'] = value
+          end
+        when :lay_response
+          expanded['-lay.response'] = value
+        when :lop
+          expanded['-lop'] = value
+        when :modid
+          expanded['-modid'] = value
+        when :relatedsets_filter
+          expanded['-relatedsets.filter'] = value
+        when :relatedsets_max
+          expanded['-relatedsets.max'] = value
+        when :delete_related
+          expanded['-delete.related'] = value
+        when :script
+          if value.is_a? Array
+            expanded['-script'] = value[0]
+            expanded['-script.param'] = value[1]
+          else
+            expanded['-script'] = value
+          end
+        when :script_prefind
+          if value.is_a? Array
+            expanded['-script.prefind'] = value[0]
+            expanded['-script.prefind.param'] = value[1]
+          else
+            expanded['-script.prefind'] = value
+          end
+        when :script_presort
+          if value.is_a? Array
+            expanded['-script.presort'] = value[0]
+            expanded['-script.presort.param'] = value[1]
+          else
+            expanded['-script.presort'] = value
+          end
+        end
+      end
+
+      expanded
+    end
+
+    def log_action(params)
+      case @config.log
+      when :simple    then log_simple(params)
+      when :curl      then log_curl(params)
+      when :curl_auth then log_curl(params, true)
+      else
+        return
+      end
+    end
+
+    def log_curl(params, has_auth = false)
+      full_url = "#{url}#{endpoint}?#{log_params(params)}"
+      curl_ssl_option, auth = '', ''
+
+      curl_ssl_option = ' -k' if ssl.is_a?(Hash) && !ssl.fetch(:verify) { true }
+
+      auth = " -H 'Authorization: #{@connection.headers['Authorization']}'" if \
+        has_auth
+
+      warn 'Pretty print like so: `curl XXX | xmllint --format -`'
+      warn "curl -XGET '#{full_url}'#{curl_ssl_option} -i#{auth}"
+    end
+
+    def log_simple(params)
+      warn "#{endpoint}?#{log_params(params)}"
+    end
+
+    def log_params(params)
+      params.map do |key, value|
+        "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+      end.join('&')
+    end
+  end
+end