module FXF

¶ ↑

FXF

Constants

SCALARS: Scalar object types. These are all the data types in JSON except for hashes and arrays.
VERSION: version 1.0

Public Class Methods

generate(struct, opts={}) click to toggle source

Generates a FXF JSON string.

# File lib/fxf.rb, line 17
def self.generate(struct, opts={})
        # $tm.hrm
        rv = {}
        self.generate_object(rv, struct)
        rv = {'root'=>rv.keys[0], 'objects'=>rv}
        
        # return JSON
        if opts['pretty']
                return JSON.pretty_generate(rv)
        else
                return JSON.generate(rv)
        end
end

parse(fxf) click to toggle source

Parses an FXF string and returns the structure it defines.

# File lib/fxf.rb, line 41
def self.parse(fxf)
        parser = FXF::Parser.new(fxf)
        return parser.parse()
end

Private Class Methods

generate_object(rv, obj) click to toggle source

# File lib/fxf.rb, line 62
def self.generate_object(rv, obj)
        # $tm.hrm
        key = obj.object_id.to_s
        
        # add to rv
        if not rv.has_key?(key)
                # scalar
                if SCALARS.include?(obj.class)
                        rv[key] = obj
                        
                # hash
                elsif obj.is_a?(Hash)
                        hsh = rv[key] = {}
                        
                        obj.each do |k, v|
                                hsh[k] = self.generate_object(rv, v)
                        end
                        
                # array
                elsif obj.is_a?(Array)
                        arr = rv[key] = []
                        
                        obj.each do |v|
                                arr.push self.generate_object(rv, v)
                        end
                        
                # to_fxf
                elsif obj.respond_to?('to_fxf')
                        dfn = {}
                        dfn['class'] = obj.class.to_s
                        dfn['details'] = obj.to_fxf()
                        object_dfn rv, key, 'custom', dfn
                        
                # standard class
                elsif translator = FXF::Standard::TO_FXF[obj.class.to_s]
                        dfn = translator.call(obj)
                        object_dfn rv, key, 'standard', dfn
                
                # else unknown class
                else
                        # build details
                        details = {}
                        
                        # string
                        if obj.respond_to?('to_s')
                                details['str'] = obj.to_s
                        end
                        
                        # buid definition
                        dfn = {}
                        dfn['scope'] = 'unrecognized'
                        dfn['class'] = obj.class.to_s
                        dfn['details'] = details
                        
                        # store
                        rv[key] = [dfn]
                end
        end
        
        # return
        return key
end

object_dfn(rv, key, scope, dfn) click to toggle source

# File lib/fxf.rb, line 132
def self.object_dfn(rv, key, scope, dfn)
        # $tm.hrm
        export = {}
        rv[key] = [export]
        export['scope'] = scope
        export['class'] = dfn['class']
        export['details'] = {}
        
        # add object references
        if dfn['details']
                if dfn['details'].is_a?(Hash)
                        dfn['details'].each do |k, v|
                                export['details'][k] = self.generate_object(rv, v)
                        end
                else
                        raise 'custom-object-details-must-be-hash'
                end
        end
end