ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm/utilities/fmresultset.rb

@@ -1,153 +0,0 @@
-module Rfm
-
-	# Methods to help translate xml_mini document into Rfm/Filemaker objects.
-	module Fmresultset
-		def self.extended(obj)
-		  obj.instance_variable_set :@root, obj
-		  obj.extend Resultset
-		end
-			
-	  module Resultset
-	
-	    def error
-	    	self['fmresultset']['error']['code'].to_i
-			end      
-	       
-	    def datasource
-	      self['fmresultset']['datasource']
-	    end
-	    
-	    def meta
-	    	self['fmresultset']['metadata']
-	    end
-	    
-	    def resultset
-	    	self['fmresultset']['resultset']
-	    end
-	      
-	    def date_format
-	    	Rfm.convert_date_time_format(datasource['date-format'].to_s)
-	  	end
-	  	
-	    def time_format
-	    	Rfm.convert_date_time_format(datasource['time-format'].to_s)
-	    end
-	    
-	    def timestamp_format
-	    	Rfm.convert_date_time_format(datasource['timestamp-format'].to_s)
-	    end
-	
-	    def foundset_count
-	    	resultset['count'].to_s.to_i
-	    end
-	    	
-	    def total_count
-	    	datasource['total-count'].to_s.to_i
-	    end
-	    	
-	    def table
-	    	datasource['table']
-			end
-	    
-	    def records
-	      resultset['record'].rfm_force_array.rfm_extend_members(Record)
-	    end
-	
-	    
-	    def fields
-	    	meta['field-definition'].rfm_force_array.rfm_extend_members(Field)
-	    end
-	    
-	    def portals
-		    meta['relatedset-definition'].rfm_force_array.rfm_extend_members(RelatedsetDefinition)
-	    end
-	
-		end
-		
-		module Field
-			def name
-				self['name']
-			end
-			
-			def result
-	    	self['result']
-	    end
-	    
-	    def type
-	    	self['type']
-	    end
-	    
-	    def max_repeats
-	    	self['max-repeats']
-	    end
-	    
-	    def global
-	    	self['global']	
-	    end
-		end
-		
-		module RelatedsetDefinition
-			def table
-				self['table']
-			end
-			
-			def fields
-				self['field-definition'].rfm_force_array.rfm_extend_members(Field)
-			end
-		end
-		
-		module Record	
-			def columns
-				self['field'].rfm_force_array.rfm_extend_members(Column)
-			end
-			
-			def record_id
-				self['record-id']
-			end
-			
-			def mod_id
-				self['mod-id']
-			end
-			
-			def portals
-				self['relatedset'].rfm_force_array.rfm_extend_members(Relatedset)
-			end
-		end
-			
-		module Column
-			def name
-				self['name']
-			end
-			
-			def data
-				self['data'].rfm_force_array.collect{|d| d['__content__']}
-			end
-		end
-		
-		module Relatedset
-			def table
-				self['table']
-			end
-			
-			def count
-				self['count']
-			end
-			
-			def records
-				self['record'].rfm_force_array.rfm_extend_members(Record)
-			end
-		end
-	
-	end
-    
-	def convert_date_time_format(fm_format)
-	  fm_format.gsub!('MM', '%m')
-	  fm_format.gsub!('dd', '%d')
-	  fm_format.gsub!('yyyy', '%Y')
-	  fm_format.gsub!('HH', '%H')
-	  fm_format.gsub!('mm', '%M')
-	  fm_format.gsub!('ss', '%S')
-	  fm_format
-	end
-    
-end

data/lib/rfm/utilities/xml_parser.rb

@@ -1,124 +0,0 @@
-module Rfm
-	module XmlParser
-
-		extend Config
-		config :parent=>'Rfm::Config'
-		
-		extend self
-		
-		# Backend definitions & configurations
-		BACKENDS = ActiveSupport::OrderedHash.new
-		
-		BACKENDS[:jdom]					= {:require=>'jdom',			:class =>	'JDOM'}
-
-		BACKENDS[:oxsax]				= {:require=>'ox',	  :class =>	proc{
-																# Ox module is part of Rfm, not XmlMini,
-																# and needs to be handed manually to XmlMini.
-																require File.join(File.dirname(__FILE__), '../xml_mini/ox_sax.rb')
-																ActiveSupport::XmlMini_OxSAX}}
-
-		BACKENDS[:libxml]				= {:require=>'libxml',		:class =>	'LibXML'}
-
-		BACKENDS[:libxmlsax]		= {:require=>'libxml',		:class =>	'LibXMLSAX'}
-
-		BACKENDS[:nokogirisax]	= {:require=>'nokogiri',	:class =>	proc{ActiveSupport::VERSION; 'NokogiriSAX'}}
-
-		BACKENDS[:nokogiri]			= {:require=>'nokogiri',	:class =>	'Nokogiri'}
-
-		BACKENDS[:hpricot]			= {:require=>'hpricot',	  :class =>	proc{
-																# Hpricot module is part of Rfm, not XmlMini,
-																# and needs to be handed manually to XmlMini.
-																require File.join(File.dirname(__FILE__), '../xml_mini/hpricot.rb')
-																ActiveSupport::XmlMini_Hpricot}}
-
-		BACKENDS[:rexml]				= {:require=>'rexml/document',	:class=>'REXML'}
-
-		BACKENDS[:rexmlsax]			= {:require=>'rexml/parsers/sax2parser',	  :class =>	proc{
-																# Rexmlsax module is part of Rfm, not XmlMini,
-																# and needs to be handed manually to XmlMini.
-																require File.join(File.dirname(__FILE__), '../xml_mini/rexml_sax.rb')
-																ActiveSupport::XmlMini_REXMLSAX}}
-		
-		
-		# Main parsing method.
-		# Options
-		#		:namespace => false   # strip out namespace (default)
-		#		:parser    => :libxml, :libxmlsax, :nokogirisax, :nokogiri, :hpricot, :rexml
-		#		:parser    => CustomParsingModule  # see ActiveSupport::XmlMini
-		def new(string_or_file, opts={})
-			string_or_file.gsub!(/xmlns=\"[^\"]*\"/,'') if (string_or_file.class == String and opts[:namespace] == false)
-			unless opts[:parser] and get_backend_from_hash(opts[:parser]).to_s != self.backend.to_s
-				warn "XmlParser default: #{ActiveSupport::XmlMini.backend.to_s}" if get_config[:log_parser] == true
-				ActiveSupport::XmlMini.parse(string_or_file)
-			else
-				warn "XmlParser backend: #{get_backend_from_hash(opts[:parser]).to_s}" if get_config[:log_parser] == true
-				ActiveSupport::XmlMini.with_backend(get_backend_from_hash(opts[:parser])) {ActiveSupport::XmlMini.parse(string_or_file)}
-			end
-		end
-		
-		# Creates new hash with #new, plus extends the hash with result-dependent translation class.
-		def parse(string_or_file, opts={})
-			doc = new(string_or_file, opts)
-			case true
-				when doc.has_key?('fmresultset') ; doc.extend(Fmresultset)
-				when doc.has_key?('FMPXMLRESULT') ; doc.extend(Fmpxmlresult)
-				when doc.has_key?('FMPDSORESULT') ; doc.extend(Fmpdsoresult)
-				when doc.has_key?('FMPXMLLAYOUT') ; doc.extend(Fmpxmllayout)
-				else doc
-			end
-		end
-				
-		# Shortcut to XmlMini config getter.
-		# If a parameter is passed, it will be used to get the local backend description
-		# from the BACKENDS hash, instead of the XmlMini backend.
-		def backend(name=nil)
-			return ActiveSupport::XmlMini.backend unless name
-			get_backend_from_hash(name)
-		end
-		
-		# Shortcut to XmlMini config setter.
-		def backend=(name)
-			if name.is_a? Symbol
-				set_backend_via_hash(name)
-			else
-				ActiveSupport::XmlMini.backend = name
-			end
-		end
-		
-	private
-		
-		# Given name, return backend config from BACKENDS, including any preloading.
-		# Will raise LoadError if can't load backend.
-		def get_backend_from_hash(name)
-				backend_hash = BACKENDS[name.to_sym]
-				require backend_hash[:require]
-				backend_hash[:class].is_a?(Proc) ? backend_hash[:class].call : backend_hash[:class]
-		end
-		
-		# Set XmlMini backend, given symbol matching one of the BACKENDS.
-		def set_backend_via_hash(name)
-			ActiveSupport::XmlMini.backend = get_backend_from_hash(name)
-		end
-		
-		# Select the best backend from BACKENDS, returns backend config.
-		def decide_backend
-			string_or_class = catch(:done) do
-				BACKENDS.keys.each do |name|
-					begin
-						result = get_backend_from_hash name
-						throw(:done, result)
-					rescue LoadError, StandardError
-					end
-				end
-			end
-		end
-				
-		# Set XmlMini backend when this file loads.
-		begin
-			self.backend = get_backend_from_hash(get_config[:parser])
-		rescue
-			self.backend = decide_backend
-		end
-		
-	end # XmlParser
-end # Rfm

data/lib/rfm/xml_mini/hpricot.rb

@@ -1,133 +0,0 @@
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/object/blank'
-require 'stringio'
-
-module ActiveSupport
-  module XmlMini_Hpricot
-    extend self
-
-    CONTENT_KEY = '__content__'.freeze
-
-    # Parse an XML Document string or IO into a simple hash
-    #
-    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
-    # and uses the defaults from Active Support.
-    #
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        silence_warnings { require 'hpricot' } unless defined?(Hpricot)
-        doc = Hpricot.XML(data)
-
-        if doc.root
-          merge_element!({}, doc.root)
-        else
-          raise Hpricot::ParseError,
-            "The document #{doc.to_s.inspect} does not have a valid root"
-        end
-      end
-    end
-
-    private
-      # Convert an XML element and merge into the hash
-      #
-      # hash::
-      #   Hash to merge the converted element into.
-      # element::
-      #   XML element to merge into hash
-      def merge_element!(hash, element)
-        merge!(hash, element.name, collapse(element)) if element.respond_to? :name
-      end
-
-      # Actually converts an XML document element into a data structure.
-      #
-      # element::
-      #   The document element to be collapsed.
-      def collapse(element)
-        hash = get_attributes(element)
-
-        if element.respond_to? :children
-          element.each_child {|child| merge_element!(hash, child) unless child.text? }
-          merge_texts!(hash, element) unless empty_content?(element)
-          hash
-        else
-          merge_texts!(hash, element)
-        end
-      end
-
-      # Merge all the texts of an element into the hash
-      #
-      # hash::
-      #   Hash to add the converted element to.
-      # element::
-      #   XML element whose texts are to be merged into the hash
-      def merge_texts!(hash, element)
-        unless element.respond_to? :children and element.children[0].text?
-          hash
-        else
-          # must use value to prevent double-escaping
-          texts = ''
-          #element.texts.each { |t| texts << t.value }
-          #texts << element.children[0].to_s
-          element.each_child { |child| texts << child.inner_text }
-          merge!(hash, CONTENT_KEY, texts)
-          texts
-        end
-      end
-
-      # Adds a new key/value pair to an existing Hash. If the key to be added
-      # already exists and the existing value associated with key is not
-      # an Array, it will be wrapped in an Array. Then the new value is
-      # appended to that Array.
-      #
-      # hash::
-      #   Hash to add key/value pair to.
-      # key::
-      #   Key to be added.
-      # value::
-      #   Value to be associated with key.
-      def merge!(hash, key, value)
-        if hash.has_key?(key)
-          if hash[key].instance_of?(Array)
-            hash[key] << value
-          else
-            hash[key] = [hash[key], value]
-          end
-        elsif value.instance_of?(Array)
-          hash[key] = [value]
-        else
-          hash[key] = value
-        end
-        hash
-      end
-
-      # Converts the attributes array of an XML element into a hash.
-      # Returns an empty Hash if node has no attributes.
-      #
-      # element::
-      #   XML element to extract attributes from.
-      def get_attributes(element)
-        attributes = {}
-        element.attributes.to_hash.each { |n,v| attributes[n] = v } if element.respond_to? :attributes
-        attributes
-      end
-
-      # Determines if a document element has text content
-      #
-      # element::
-      #   XML element to be checked.
-      def empty_content?(element)
-        #element.texts.join.blank?
-        element.children.nil? #or element.children[0].to_s.blank?
-      end
-  end
-end

data/lib/rfm/xml_mini/ox_sax.rb

@@ -1,91 +0,0 @@
-begin
-  require 'ox'
-rescue LoadError => e
-  $stderr.puts "You don't have Ox installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require 'active_support/core_ext/object/blank'
-require 'stringio'
-
-# = XmlMini Ox implementation using a SAX-based parser
-# This Ox Sax parser was lifted directly from multi_xml gem.
-module ActiveSupport
-  module XmlMini_OxSAX
-
-    extend self
-    
-    def parse_error
-      Exception
-    end
-
-    def parse(io)
-      if !io.respond_to?(:read)
-        io = StringIO.new(io || '')
-      end
-      handler = Handler.new
-      ::Ox.sax_parse(handler, io, :convert_special => true)
-      handler.doc
-    end
-
-
-
-    class Handler
-      attr_accessor :stack
-
-      def initialize()
-        @stack = []
-      end
-      
-      def doc
-        @stack[0]
-      end
-
-      def attr(name, value)
-        unless @stack.empty?
-          append(name, value)
-        end
-      end
-
-      def text(value)
-        append('__content__', value)
-      end
-
-      def cdata(value)
-        append('__content__', value)
-      end
-
-      def start_element(name)
-        if @stack.empty?
-          @stack.push(Hash.new)
-        end
-        h = Hash.new
-        append(name, h)
-        @stack.push(h)
-      end
-
-      def end_element(name)
-        @stack.pop()
-      end
-
-      def error(message, line, column)
-        raise Exception.new("#{message} at #{line}:#{column}")
-      end
-
-      def append(key, value)
-        key = key.to_s
-        h = @stack.last
-        if h.has_key?(key)
-          v = h[key]
-          if v.is_a?(Array)
-            v << value
-          else
-            h[key] = [v, value]
-          end
-        else
-          h[key] = value
-        end
-      end
-
-    end # Handler
-  end
-end