Class: AppEngine::DubyDatastorePlugin

Inherits:

Object

• Object
• AppEngine::DubyDatastorePlugin

Defined in:

lib/mirah_model/datastore.rb

Defined Under Namespace

Classes: ModelState

Constant Summary

TypeMap =

{
  'Category' => 'String',
  'Email' => 'String',
  'Link' => 'String',
  'PhoneNumber' => 'String',
  'PostalAddress' => 'String',
  'Text' => 'String',
  'Blob' => 'byte[]',
  'ShortBlob' => 'byte[]',
  'Rating' => 'int',
  'Long' => 'long',
  'Double' => 'double',
  'Boolean' => 'boolean'
}

Primitives =

['Long', 'Double', 'Boolean', 'Rating']

Boxes =

{
  'int' => 'Integer',
  'boolean' => 'Boolean',
  'long' => 'Long',
  'double' => 'Double',
}

Defaults =

{
  'Rating' => '0',
  'Long' => 'long(0)',
  'Double' => '0.0',
  'Boolean' => 'false',
  'Blob' => 'byte[].cast(nil)',
  'ShortBlob' => 'byte[].cast(nil)',
}

Conversions =

{
  'Category' => 'getCategory',
  'Email' => 'getEmail',
  'Link' => 'getValue',
  'PhoneNumber' => 'getNumber',
  'PostalAddress' => 'getAddress',
  'Text' => 'getValue',
  'Blob' => 'getBytes',
  'ShortBlob' => 'getBytes',
  'Long' => 'longValue',
  'Double' => 'doubleValue',
  'Boolean' => 'booleanValue',
  'Rating' => 'getRating',
}

Class Method Summary

• .add_property(name, type, transformer, fcall) ⇒ Object
• .find_class(node) ⇒ Object
• .from_datastore(type, value) ⇒ Object
• .maybe_box(duby_type, value) ⇒ Object
• .reset ⇒ Object
• .to_datastore(type, value) ⇒ Object

Class Method Details

.add_property(name, type, transformer, fcall) ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 289

def self.add_property(name, type, transformer, fcall)
  if transformer.state != @state
    reset
    @state = transformer.state
  end
  parent = fcall.parent
  name = name.literal
  type = type.name
  type = 'Long' if type == 'Integer'

  result = Duby::AST::ScopedBody.new(parent, fcall.position) {[]}
  result.static_scope = fcall.scope.static_scope
  klass = find_class(parent)
  unless @models[klass]
    @models[klass] = ModelState.new(
        transformer, klass, parent, fcall.position, result)
  end
  model = @models[klass]

  duby_type = TypeMap.fetch(type, type)
  coercion = "coerce_" + duby_type.downcase.sub("[]", "s")

  if duby_type == 'List'
    model.extend_query(<<-EOF)
      def #{name}(value:Object)
        returns :void
        _query.addFilter("#{name}", _eq_op, value)
      end
    EOF
  else
    model.extend_query(<<-EOF)
      def #{name}(value:#{duby_type})
        returns :void
        _query.addFilter("#{name}", _eq_op, #{to_datastore(type, 'value')})
      end
    EOF
  end
  temp = transformer.tmp

  model.extend_read(<<-EOF)
    #{temp} = e.getProperty("#{name}")
    @#{name} = #{from_datastore(type, temp)}
  EOF

  model.extend_save(<<-EOF)
    e.setProperty("#{name}", #{to_datastore(type, '@' + name)})
  EOF

  model.extend_update(<<-EOF)
    self.#{name} = properties.get("#{name}") if properties.containsKey("#{name}")
  EOF

  model.extend_get_properties(<<-EOF)
    result.put("#{name}", #{maybe_box(duby_type, 'self.' + name)})
  EOF

  result << model.eval(parent, <<-EOF)
    def #{name}
      @#{name}
    end

    def #{name}=(value:#{duby_type})
      @#{name} = value
    end

    def #{name}=(value:Object)
      self.#{name} = #{coercion}(value)
    end
  EOF

  result
end

.find_class(node) ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 262

def self.find_class(node)
  node = node.parent until Duby::AST::ClassDefinition === node
  node
end

.from_datastore(type, value) ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 277

def self.from_datastore(type, value)
  duby_type = TypeMap[type]
  if duby_type
    default = Defaults.fetch(type, "#{duby_type}(nil)")
    conversion = Conversions[type]
    "(#{value} ? #{type}(#{value}).#{conversion} : #{default})"
  else
    "#{type}(#{value})"
  end
end

.maybe_box(duby_type, value) ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 362

def self.maybe_box(duby_type, value)
  if Boxes.include?(duby_type)
    "#{Boxes[duby_type]}.valueOf(#{value})"
  else
    value
  end
end

.reset ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 370

def self.reset
  @models = {}
end

.to_datastore(type, value) ⇒ Object

# File 'lib/mirah_model/datastore.rb', line 267

def self.to_datastore(type, value)
  if Primitives.include?(type)
    "#{type}.new(#{value})"
  elsif TypeMap.include?(type)
    "(#{value} ? #{type}.new(#{value}) : nil)"
  else
    value
  end
end