Class: Jinx::JavaProperty

Inherits:
Property show all
Defined in:
lib/jinx/metadata/java_property.rb

Overview

The attribute metadata for an introspected Java property.

Constant Summary

Constants inherited from Property

Property::SUPPORTED_FLAGS

Instance Attribute Summary collapse

Attributes inherited from Property

#accessors, #attribute, #declarer, #flags, #type

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Property

#clear_inverse, #deep_copy, #dependent_flag_set, #derived_inverse, #dup_content, #flag_supported?, #inverse, #inverse=, #inverse_property, #owner_flag_set, #qualify, #reader, #restrict, #restrict_flags, #restriction?, #set_flag, #set_restricted_declarer, #to_s, #writer

Methods included from PropertyCharacteristics

#bidirectional?, #bidirectional_java_association?, #collection?, #dependent?, #derived?, #disjoint?, #domain?, #independent?, #java_property?, #mandatory?, #many_to_many?, #nondomain?, #owner?, #restriction?, #unidirectional?, #unidirectional_java_dependent?

Constructor Details

#initialize(pd, declarer, restricted_type = nil) ⇒ JavaProperty

Creates a Ruby Property symbol corresponding to the given Ruby Java class wrapper klazz and Java property_descriptor.

The property name is the lower-case, underscore property descriptor name with the alterations described in to_attribute_symbol and Class#unocclude_reserved_method.

The property type is inferred as follows:

  • If the property descriptor return type is a primitive Java type, then that type is returned.
  • If the return type is a parameterized collection, then the parameter type is returned.
  • If the return type is an unparameterized collection, then this method infers the type from the property name, e.g. +StudyProtocolCollection+type is inferred as StudyProtocol by stripping the Collection suffix, capitalizing the prefix and looking for a class of that name in the Metadata#domain_module.
  • Otherwise, this method returns Java::Javalang::Object.

The optional restricted_type argument restricts the property to a subclass of the declared property type.

Raises:

  • (ArgumentError) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/jinx/metadata/java_property.rb', line 34

def initialize(pd, declarer, restricted_type=nil)
  symbol = create_standard_attribute_symbol(pd, declarer)
  super(symbol, declarer, restricted_type)
  @property_descriptor = pd
  # deficient Java introspector does not recognize 'is' prefix for a Boolean property
  rm = declarer.property_read_method(pd)
  raise ArgumentError.new("Property does not have a read method: #{declarer.qp}.#{pd.name}") unless rm
  rdr = rm.name.to_sym
  unless declarer.method_defined?(rdr) then
    rdr = "is#{rdr.to_s.capitalize_first}".to_sym
    unless declarer.method_defined?(rdr) then
      raise ArgumentError.new("Reader method not found for #{declarer} property #{pd.name}")
    end
  end
  unless pd.write_method then
    raise ArgumentError.new("Property does not have a write method: #{declarer.qp}.#{pd.name}")
  end
  wtr = pd.write_method.name.to_sym
  unless declarer.method_defined?(wtr) then
    raise ArgumentError.new("Writer method not found for #{declarer} property #{pd.name}")
  end
  @java_accessors = [rdr, wtr]
  @java_wrapper_class = Class.to_ruby(pd.property_type)
  qualify(:collection) if collection_java_class?
  @type = infer_type
end

Instance Attribute Details

#java_accessors ⇒ Object (readonly)

This property's Java property [reader, writer] accessors, e.g. [:getActivityStatus, :setActivityStatus].



15
16
17
 
# File 'lib/jinx/metadata/java_property.rb', line 15

def java_accessors
  @java_accessors
end

#java_wrapper_class ⇒ Object (readonly)

This property's Java property descriptor type JRuby class wrapper.



9
10
11
 
# File 'lib/jinx/metadata/java_property.rb', line 9

def java_wrapper_class
  @java_wrapper_class
end

#property_descriptor ⇒ Object (readonly)

This property's Java property descriptor.



12
13
14
 
# File 'lib/jinx/metadata/java_property.rb', line 12

def property_descriptor
  @property_descriptor
end

Class Method Details

.to_attribute_symbol(property_name) ⇒ Object

Returns a lower-case, underscore symbol for the given property_name. A name ending in 'Collection' is changed to a pluralization.

Examples:

JavaProperty.to_attribute_symbol('specimenEventCollection') #=> :specimen_events



76
77
78
79
80
81
82
83
 
# File 'lib/jinx/metadata/java_property.rb', line 76

def self.to_attribute_symbol(property_name)
  name = if property_name =~ /(.+)Collection$/ then
    property_name[0...-'Collection'.length].pluralize.underscore
  else
    property_name.underscore
  end
  name.to_sym
end

Instance Method Details

#collection_java_class? ⇒ Boolean (private)

Returns whether this property's Java type is Iterable.

Returns:

  • (Boolean) —

    whether this property's Java type is Iterable



103
104
105
106
 
# File 'lib/jinx/metadata/java_property.rb', line 103

def collection_java_class?
  # Test whether the JRuby wrapper class or module is an Iterable.
  @java_wrapper_class < Java::JavaLang::Iterable
end

#create_standard_attribute_symbol(pd, klass) ⇒ String (private)

Returns the lower-case, underscore symbol for the given property descriptor.

Parameters:

  • pd —

    the Java property descriptor

  • klass (Class) —

    the declarer

Returns:

  • (String) —

    the lower-case, underscore symbol for the given property descriptor



90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/jinx/metadata/java_property.rb', line 90

def create_standard_attribute_symbol(pd, klass)
  propname = pd.name
  name = propname.underscore
  renamed = klass.unocclude_reserved_method(pd)
  if renamed then
    logger.debug { "Renamed #{klass.qp} reserved Ruby method #{name} to #{renamed}." }
    renamed
  else
    JavaProperty.to_attribute_symbol(propname)
  end
end

#generic_parameter_type ⇒ Class? (private)

Returns the domain type of this property's property descriptor Collection generic type argument, or nil if none.

Returns:

  • (Class, nil) —

    the domain type of this property's property descriptor Collection generic type argument, or nil if none



124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/jinx/metadata/java_property.rb', line 124

def generic_parameter_type
  method = @property_descriptor.readMethod || return
  gtype = method.genericReturnType
  return unless Java::JavaLangReflect::ParameterizedType === gtype
  atypes = gtype.actualTypeArguments
  return unless atypes.size == 1
  atype = atypes[0]
  klass = Class.to_ruby(atype)
  logger.debug { "Inferred #{declarer.qp} #{self} domain type #{klass.qp} from generic parameter #{atype.name}." } if klass
  klass
end

#infer_collection_type ⇒ Class (private)

Returns the domain type for this property's Java Collection property descriptor. If the property type is parameterized by a single domain class, then that generic type argument is the domain type. Otherwise, the type is inferred from the property name as described in #infer_collection_type_from_name.

Returns:

  • (Class) —

    this property's Ruby type



118
119
120
 
# File 'lib/jinx/metadata/java_property.rb', line 118

def infer_collection_type
   generic_parameter_type or infer_collection_type_from_name or Java::JavaLang::Object
end

#infer_collection_type_from_name ⇒ Class (private)

Returns the domain type for this property's collection Java property descriptor name. By convention, Jinx domain collection propertys often begin with a domain type name and end in 'Collection'. This method strips the Collection suffix and checks whether the prefix is a domain class.

For example, the type of the property named distributionProtocolCollection is inferred as DistributionProtocol by stripping the Collection suffix, capitalizing the prefix and looking for a class of that name in this classifier's domain_module.

Returns:

  • (Class) —

    the collection item type



147
148
149
150
151
152
153
154
155
156
 
# File 'lib/jinx/metadata/java_property.rb', line 147

def infer_collection_type_from_name
  # the property name
  pname = @property_descriptor.name
  # The potential class name is the capitalized property name without a 'Collection' suffix.
  cname = pname.capitalize_first.sub(/Collection$/, '')
  jname = [@declarer.parent_module, cname].join('::')
  klass = eval jname rescue nil
  if klass then logger.debug { "Inferred #{declarer.qp} #{self} collection domain type #{klass.qp} from the property name." } end
  klass
end

#infer_type ⇒ Class (private)

Returns the type for the specified klass property descriptor pd as described in #initialize.

Returns:

  • (Class) —

    the type for the specified klass property descriptor pd as described in #initialize



109
110
111
 
# File 'lib/jinx/metadata/java_property.rb', line 109

def infer_type
  collection? ? infer_collection_type : @java_wrapper_class
end

#java_reader ⇒ Symbol

Returns the JRuby wrapper method for the Java property reader.

Returns:

  • (Symbol) —

    the JRuby wrapper method for the Java property reader



62
63
64
 
# File 'lib/jinx/metadata/java_property.rb', line 62

def java_reader
  java_accessors.first
end

#java_writer ⇒ Symbol

Returns the JRuby wrapper method for the Java property writer.

Returns:

  • (Symbol) —

    the JRuby wrapper method for the Java property writer



67
68
69
 
# File 'lib/jinx/metadata/java_property.rb', line 67

def java_writer
  java_accessors.last
end