module Lanes::Concerns::ExportMethods::ClassMethods

Public Instance Methods

delegate_and_export( *names ) click to toggle source

Convenience method to create a Rails delegation and export the resulting method @example

class Foo < Lanes::Model
      belongs_to :bar
      delegate_and_export :bar_name, :optional=>false
end

foo = Foo.new
foo.bar_name #=> calls foo.bar.name
Foo.has_exported_method?( :bar_name )  #=> true
lanes_to_json( foo ) #=> will first load the bar association, then
                       call foo.bar_name and include it's result in the JSON
# File lib/lanes/concerns/export_methods.rb, line 43
def delegate_and_export( *names )
    options = names.extract_options!
    names.each do | name |
        target,field = name.to_s.split(/_(?=[^_]+(?: |$))| /)
        delegate_and_export_field( target, field, optional: options[:optional], limit: options[:limit] )
    end
end
delegate_and_export_field( target, field, optional: true, limit: nil ) click to toggle source

For situations where the delegate_and_export method guesses wrong on the association and field names @param target [Association] association to delegate to @param field [Symbol] method on Association to call @param optional [Boolean] should the method be called and results included all the time,

or only if specifically requested

@param limit [Symbol referring to a method, lambda] restrict to Users for whom true is returned @example

class PoLine < Lanes::Model
      belongs_to :purchase_order
      delegate_and_export :purchase_order_visible_id
end

would generate a method “purchase_order_visible_id“ that would call “purchase_order_visible.id“ This would do the right thing:

class PoLine < Lanes::Model
      belongs_to :purchase_order
      delegate_and_export_field :purchase_order, :visible_id
end
# File lib/lanes/concerns/export_methods.rb, line 68
def delegate_and_export_field( target, field, optional: true, limit: nil )
    delegate field, to: target, prefix: target, allow_nil: true
    self.export_methods( "#{target}_#{field}", { depends: target.to_sym,
                                                 optional: optional,
                                                 limit: limit } )
end
export_methods( *method_names ) click to toggle source

Called by a model to export methods to the API An exported method will be called and it's results returned along with the models JSON representation. @option options [Boolean] :optional if false, the method will always be called and included @option options [Symbol, Array of Symbols] :depends name(s) of associations that should

be pre-loaded before calling method. Intended to prevent N+1 queries
# File lib/lanes/concerns/export_methods.rb, line 22
def export_methods( *method_names )
    method_names.flatten!
    options = method_names.extract_options!
    self.exported_methods ||= {}
    method_names.map do | name |
        exported_methods[ name.to_sym] = options
    end
end
exported_method_dependancies( requested_methods ) click to toggle source

Retrieve the list of dependent associations for the given methods Also includes methods that were exported as “optional: false“ @param requested_methods [Array] methods that the user has requested be executed and added to the JSON payload @return [Array] list of associations that should be included in query

# File lib/lanes/concerns/export_methods.rb, line 88
def exported_method_dependancies( requested_methods )
    requested_methods.map!(&:to_sym)
    return [] if self.exported_methods.blank?
    depends = self.exported_methods.each_with_object(Array.new) do | kv, result |
        ( export, options ) = kv
        if options[:depends] && ( false == options[:optional] || requested_methods.include?(export) )
            result << options[:depends]
        end
    end
    depends.uniq
end
has_exported_method?( name, user ) click to toggle source

Check if the method can be called by user

# File lib/lanes/concerns/export_methods.rb, line 76
def has_exported_method?( name, user )
    if self.exported_methods && ( method_options = self.exported_methods[ name.to_sym ] )
        return evaluate_export_limit( user, :method, name, method_options[:limit] )
    else
        return false
    end
end