class Unimatrix::Operation

Public Class Methods

new( path, parameters = {} ) click to toggle source
# File lib/unimatrix/operation.rb, line 5
def initialize( path, parameters = {} )
  @path = path
  @parameters = ( parameters || {} ).deep_dup
  @key = nil
end

Public Instance Methods

destroy() click to toggle source
# File lib/unimatrix/operation.rb, line 30
def destroy
  result = nil
  Request.new.tap do | request |
    response = request.destroy( @path, @parameters )
    if response.present?
      result = response.resources
    end
  end
  result
end
include( *arguments ) click to toggle source
# File lib/unimatrix/operation.rb, line 49
def include( *arguments )
  self.spawn( :include => self.normalize_include( *arguments ) )
end
key() click to toggle source
# File lib/unimatrix/operation.rb, line 11
def key
  return @key ||= begin
    result = 0
    query = @parameters.to_param
    if ( @path.present? || @query.present? )
      query = query.split( '&' ).sort.join( '&' )
      addressable = Addressable::URI.new
      addressable.path = @path
      addressable.query = query unless query.blank?
      result = FNV.new.fnv1a_32( addressable.to_s )
    end
    result
  end
end
limit( _limit ) click to toggle source
# File lib/unimatrix/operation.rb, line 41
def limit( _limit )
  self.spawn( count: _limit )
end
offset( _offset ) click to toggle source
# File lib/unimatrix/operation.rb, line 45
def offset( _offset )
  self.spawn( offset: _offset )
end
read( ) { || ... } click to toggle source
# File lib/unimatrix/operation.rb, line 53
def read( &block )
  result = nil
  response = nil
  Request.new.tap do | request |
    request.get( @path, @parameters ).tap do | response |
      if response.is_a?( Error )
        result = response
      else
        result = response.resources
        if block_given?
          case block.arity
            when 0; yield
            when 1; yield result
            when 2; yield result, response
          end
        end
      end
    end
  end
  result
end
read_in_batches( options = {} ) { || ... } click to toggle source
# File lib/unimatrix/operation.rb, line 75
def read_in_batches( options = {}, &block )
  
  total_limit = @parameters[ :count ]
  start = @parameters[ :offset ] || 0
  batch_size = options[ :batch_size ] || 100 

  while total_limit.nil? || start < total_limit
    
    result = nil
    response = nil
    operation = self.limit( batch_size ).offset( start )

    operation.read do | _result, _response |
      result = _result
      response = _response
    end

    unlimited_count = response.body[ '$this' ][ 'unlimited_count' ]
    total_limit = unlimited_count if total_limit.nil? && !unlimited_count.nil?
    start += batch_size

    if block_given?
      case block.arity
        when 0; yield
        when 1; yield result
        when 2; yield result, response
      end
    end
    break if result.nil? || result.size < batch_size
  end

end
where( parameters ) click to toggle source
# File lib/unimatrix/operation.rb, line 26
def where( parameters )
  self.spawn( parameters )
end
write( node, objects ) { || ... } click to toggle source
# File lib/unimatrix/operation.rb, line 108
def write( node, objects, &block )
  result = nil
  Request.new.tap do | request |
  
    serializer = Unimatrix::Serializer.new( objects )
    response = request.post( @path, @parameters, serializer.serialize( node ) )
    if response.present?
      result = response.resources
      if block_given?
        case block.arity
          when 0; yield
          when 1; yield result
          when 2; yield result, response
        end
      end
    end
  end
  result
end

Protected Instance Methods

normalize_include( *arguments ) click to toggle source
# File lib/unimatrix/operation.rb, line 135
           def normalize_include( *arguments )

  includes = {}
  arguments.each do | argument |
    case argument
    when Array
      argument.each do | value  |
        includes.deep_merge!( self.normalize_include( value ) )
      end
    when Hash
      argument.each do | key, value |
        if !includes.include?( key ) || includes[ key ] === true
          includes[ key ] = self.normalize_include( value )
        else
          includes[ key ].deep_merge!( self.normalize_include( value ) )
        end
      end
    else
      includes[ argument ] = true
    end
  end
  includes

end
spawn( parameters ) click to toggle source
# File lib/unimatrix/operation.rb, line 128
           def spawn( parameters  )
  Operation.new(
    @path,
    @parameters.deep_merge( parameters || {} )
  )
end