restful_objects 0.0.7 → 0.0.8

data/lib/restful_objects/domain_model/mixins/object_base.rb

@@ -1,161 +1,205 @@
-module RestfulObjects
-  module ObjectBase
-    attr_accessor :is_service, :title
-
-    def initialize
-      super
-      @deleted    = false
-      @is_service = self.class.ancestors.include? RestfulObjects::Service
-      @title      = "#{self.class.name} (#{object_id})"
-      rs_register_in_model
-      rs_type.collections.each_value { |collection| instance_variable_set "@#{collection.id}".to_sym, Array.new }
-      on_after_create if respond_to?(:on_after_create)
-    end
+module RestfulObjects::ObjectBase
+  attr_accessor :ro_title
 
-    def rs_register_in_model
-      rs_model.register_object(self) unless @is_service
-    end
+  HTTP_OK = 200
 
-    def rs_model
-      RestfulObjects::DomainModel.current
-    end
+  def initialize
+    super
+    @ro_deleted    = false
+    @ro_is_service = self.class.ancestors.include?(RestfulObjects::Service)
+    @ro_title      = "#{self.class.name} (#{object_id})"
 
-    def rs_type
-      rs_model.types[self.class.name]
+    ro_domain_model.register_object(self) unless @ro_is_service
+    ro_domain_type.collections.each_value do |collection|
+      instance_variable_set("@#{collection.id}".to_sym, Array.new)
     end
+    on_after_create if respond_to?(:on_after_create)
+  end
 
-    def get_representation
-      [200,
-       { 'Content-Type' =>
-           "application/json;profile=\"urn:org.restfulobjects:repr-types/object\";x-ro-domain-type=\"#{rs_type.id}\"" },
-       representation.to_json]
-    end
+  def ro_domain_model
+    RestfulObjects::DomainModel.current
+  end
 
-    def put_properties_and_get_representation(json)
-      properties = JSON.parse(json)
-      properties.each do |property, container|
-        raise 'property not exists' unless rs_model.types[self.class.name].properties.include?(property)
-        raise 'read-only property' if rs_model.types[self.class.name].properties[property].read_only
-        set_property_value(property, container['value'])
-        on_after_update if respond_to?(:on_after_update)
-      end
-      [200,
-       { 'Content-Type' =>
-           "application/json;profile=\"urn:org.restfulobjects:repr-types/object\";x-ro-domain-type=\"#{rs_type.id}\"" },
-       representation(false).to_json]
-    end
+  def ro_domain_type
+    @ro_domain_type ||= ro_domain_model.types[self.class.name]
+  end
 
-    def rs_instance_id
-      object_id
-    end
+  def ro_is_service?
+    @ro_is_service
+  end
 
-    def representation(include_self_link = true)
-      representation = {
-        'instanceId' => object_id.to_s,
-        'serviceId' => self.class.name,
-        'title' => title,
-        'members' => generate_members,
-        'links' => [ link_to(:described_by, "/domain-types/#{self.class.name}", :domain_type) ],
-        'extensions' => rs_type.metadata
-      }
+  def ro_instance_id
+    object_id
+  end
 
-      unless is_service
-        representation.delete('serviceId')
-        representation['links'] << link_to(:self, "/objects/#{self.class.name}/#{object_id}", :object) if include_self_link
-      else
-        representation.delete('instanceId')
-        representation['links'] << link_to(:self, "/services/#{self.class.name}", :object) if include_self_link
-      end
+  def ro_delete
+    on_before_delete if respond_to?(:on_before_delete)
+    @ro_deleted = true
+    on_after_delete if respond_to?(:on_after_delete)
+    {}.to_json
+  end
 
-      representation
-    end
+  def ro_deleted?
+    @ro_deleted
+  end
+
+  def ro_get_representation_response
+    [HTTP_OK, { 'Content-Type' => ro_content_type_for_object(ro_domain_type.id) }, ro_get_representation.to_json]
+  end
 
-    def generate_members
-      if is_service
-        actions_members
+  def encode_value(value, type, property_name = '')
+    return nil if value.nil?
+    case type
+      when :string
+        value.to_s
+      when :int
+        value.to_i
+      when :bool
+        value.to_s
+      when :decimal
+        value.to_f
+      when :date
+        value.strftime('%Y-%m-%d')
+      when :blob
+        Base64.encode64(value).strip
       else
-        properties_members.merge(collections_members.merge(actions_members))
-      end
+        if value.respond_to?(:ro_property_relation_representation, true)
+          value.ro_property_relation_representation(property_name)
+        else
+          raise "encode_value unsupported property type: #{type}"
+        end
     end
+  end
 
-    def get_property_rel_representation(property_name)
-      representation = link_to(:value, "/objects/#{self.class.name}/#{object_id}", :object, property: property_name)
-      representation['title'] = @title
-      representation
+  def decode_value(value, type)
+    return nil if value.nil?
+    case type
+      when :string
+        value.to_s
+      when :int
+        value.to_i
+      when :bool
+        if [true, 'true'].include?(value)
+          true
+        elsif [false, 'false'].include?(value)
+          false
+        else
+          raise ArgumentError.new "invalid boolean value: #{value}"
+        end
+      when :decimal
+        Float(value)
+      when :date
+        Date.parse(value)
+      when :blob
+        Base64.decode64(value)
+      else
+        raise "decode_value unsupported property type: #{type}"
     end
+  end
 
-    def rs_delete
-      on_before_delete if respond_to?(:on_before_delete)
-      @deleted = true
-      on_after_delete if respond_to?(:on_after_delete)
-      {}.to_json
-    end
+  def ro_relative_url
+    "/objects/#{self.class.name}/#{self.object_id}"
+  end
 
-    def deleted?
-      @deleted
-    end
+  def ro_absolute_url
+    "#{ro_domain_model.base_url}#{ro_relative_url}"
+  end
 
-    def encode_value(value, type, property_name = '')
-      return nil if value.nil?
-      case type
-        when :string
-          value.to_s
-        when :int
-          value.to_i
-        when :bool
-          value.to_s
-        when :decimal
-          value.to_f
-        when :date
-          value.strftime('%Y-%m-%d')
-        when :blob
-          Base64.encode64(value).strip
-        else
-          if value.respond_to?(:get_property_rel_representation)
-            value.get_property_rel_representation(property_name)
-          else
-            raise "encode_value unsupported property type: #{type}"
-          end
-      end
+  def get_self_link
+    link_to(:self, ro_relative_url, :object)
+  end
+
+  protected
+
+  def ro_get_representation(include_self_link = true)
+    result = {
+      'title' => ro_title,
+      'members' => ro_generate_members,
+      'links' => [ link_to(:described_by, "/domain-types/#{ro_domain_type.id}", :domain_type) ],
+      'extensions' => ro_domain_type.metadata }
+    if ro_is_service?
+      result['serviceId'] = ro_domain_type.id
+      result['links'] << link_to(:self, "/services/#{ro_domain_type.id}", :object) if include_self_link
+    else
+      result['instanceId'] = ro_instance_id.to_s
+      result['links'] << link_to(:self, "/objects/#{ro_domain_type.id}/#{ro_instance_id}", :object) if include_self_link
+    end
+    result
+  end
+
+  def ro_generate_members
+    if ro_is_service?
+      actions_members
+    else
+      ro_properties_members.merge(collections_members.merge(actions_members))
     end
+  end
 
-    def decode_value(value, type)
-      return nil if value.nil?
-      case type
-        when :string
-          value.to_s
-        when :int
-          value.to_i
-        when :bool
-          if [true, 'true'].include?(value)
-            true
-          elsif [false, 'false'].include?(value)
-            false
+  def ro_property_relation_representation(property_name)
+    representation = link_to(:value, "/objects/#{self.class.name}/#{object_id}", :object, property: property_name)
+    representation['title'] = ro_title
+    representation
+  end
+
+  def ro_properties_members
+    members = {}
+    ro_domain_type.properties.each do |name, property|
+      members[name] = {
+        'memberType' => 'property',
+        'value' => ro_get_property_as_json(name),
+        'links' => [
+          link_to(:details, "/objects/#{self.class.name}/#{object_id}/properties/#{name}", :object_property, property: name)
+        ],
+        'extensions' => property.metadata
+      }
+
+      if property.read_only
+        members[name]['disabledReason'] = property.disabled_reason
+      else
+        if self.respond_to?("#{name}_choices")
+          choices = self.send("#{name}_choices")
+          raise "value returned by #{name}_choices method should be an Array" unless choices.is_a?(Array)
+          if ro_get_property_metadata(name).is_reference
+            choices_json = choices.map { |object| object.ro_property_relation_representation(name) }
           else
-            raise ArgumentError.new "invalid boolean value: #{value}"
+            choices_json = choices.map { |value| decode_value(value, ro_get_property_metadata(name).return_type) }
           end
-        when :decimal
-          Float(value)
-        when :date
-          Date.parse(value)
-        when :blob
-          Base64.decode64(value)
-        else
-          raise "decode_value unsupported property type: #{type}"
+          members[name]['choices'] = choices_json
+        end
       end
     end
+    members
+  end
 
-    def ro_relative_url
-      "/objects/#{self.class.name}/#{self.object_id}"
-    end
-
-    def ro_absolute_url
-      RestfulObjects::DomainModel.current.base_url + ro_relative_url
+  def collections_members
+    members = {}
+    ro_domain_type.collections.each do |name, collection|
+      members[name] = {
+        'memberType' => 'collection',
+        'size' => ro_domain_type.collections.count,
+        'links' => [
+          link_to(:details, "/objects/#{self.class.name}/#{object_id}/collections/#{name}", :object_collection, collection: name)
+        ],
+        'extensions' => collection.metadata
+      }
     end
+    members
+  end
 
-    def get_self_link
-      link_to(:self, ro_relative_url, :object)
+  def actions_members
+    members = {}
+    ro_domain_type.actions.each do |name, action|
+      members[name] = {
+        'memberType' => 'action',
+        'links' => [
+          !ro_is_service? ?
+            link_to(:details, "/objects/#{self.class.name}/#{object_id}/actions/#{name}", :object_action, action: name)
+            :
+            link_to(:details, "/services/#{self.class.name}/actions/#{name}", :object_action, action: name)
+        ],
+        'extensions' => action.metadata
+      }
     end
+    members
   end
 end
-

data/lib/restful_objects/domain_model/mixins/object_collections.rb

@@ -1,85 +1,72 @@
-module RestfulObjects
-  module ObjectCollections
-    def collections_members
-      members = {}
-      rs_type.collections.each do |name, collection|
-        members[name] = {
-          'memberType' => 'collection',
-          'size' => rs_type.collections.count,
-          'links' => [
-            link_to(:details, "/objects/#{self.class.name}/#{object_id}/collections/#{name}", :object_collection, collection: name)
-          ],
-          'extensions' => collection.metadata
-        }
-      end
-      members
-    end
+module RestfulObjects::ObjectCollections
+  HTTP_OK = 200
 
-    def get_collection_as_json(collection)
-      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
+  def ro_get_collection_type(name)
+    ro_domain_type.collections[name]
+  end
 
-      value = []
-      send(collection.to_sym).each do |object|
-        link = link_to(:value, "/objects/#{object.rs_type.id}/#{object.rs_instance_id}", :object, method: 'GET', collection: collection)
-        link['title'] = object.title
-        value << link
-      end
+  def ro_get_collection_response(name)
+    raise "collection not exists" unless ro_get_collection_type(name)
 
-      representation = {
-        'id' => collection,
-        'value' => value,
-        'links' => [
-            link_to(:self, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}", :object_collection),
-            link_to(:up, "/objects/#{rs_type.id}/#{rs_instance_id}", :object)
-          ],
-        'extensions' => rs_type.collections[collection].metadata
-      }
+    value = []
+    send(name).each do |object|
+      link = link_to(:value, "/objects/#{object.ro_domain_type.id}/#{object.ro_instance_id}", :object, method: 'GET', collection: name)
+      link['title'] = object.ro_title
+      value << link
+    end
 
-      if not rs_model.types[self.class.name].collections[collection].read_only then
-        add_to_link = link_to(:add_to, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}",
-                              :object_collection, method: 'PUT', collection: collection)
-        add_to_link['arguments'] = { 'value' => nil }
-        remove_from_link = link_to(:remove_from, "/objects/#{rs_type.id}/#{rs_instance_id}/collections/#{collection}",
-                                   :object_collection, method: 'DELETE', collection: collection)
-        remove_from_link['arguments'] = { 'value' => nil }
-        representation['links'].concat [ add_to_link, remove_from_link ]
-      else
-        representation['disabledReason'] =
-          rs_model.types[self.class.name].collections[collection].disabled_reason
-      end
+    representation = {
+      'id' => name,
+      'value' => value,
+      'links' => [
+          link_to(:self, "/objects/#{ro_domain_type.id}/#{ro_instance_id}/collections/#{name}", :object_collection),
+          link_to(:up, "/objects/#{ro_domain_type.id}/#{ro_instance_id}", :object)
+        ],
+      'extensions' => ro_get_collection_type(name).metadata
+    }
 
-      representation.to_json
+    unless ro_get_collection_type(name).read_only
+      add_to_link = link_to(:add_to, "/objects/#{ro_domain_type.id}/#{ro_instance_id}/collections/#{name}",
+                            :object_collection, method: 'PUT', collection: name)
+      add_to_link['arguments'] = { 'value' => nil }
+      remove_from_link = link_to(:remove_from, "/objects/#{ro_domain_type.id}/#{ro_instance_id}/collections/#{name}",
+                                 :object_collection, method: 'DELETE', collection: name)
+      remove_from_link['arguments'] = { 'value' => nil }
+      representation['links'].concat [ add_to_link, remove_from_link ]
+    else
+      representation['disabledReason'] = ro_get_collection_type(name).disabled_reason
     end
 
-    def add_to_collection(collection, json)
-      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
-      href_value = JSON.parse(json)['value']['href']
-      match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
-      raise "Invalid request format" if not match
-      domain_type = match['domain-type']
-      id = match['object-id'].to_i
-      raise "Value does not exists" if not rs_model.objects.include?(id)
-      raise "Domain-type does not exists" if not rs_model.types.include?(domain_type)
+    [HTTP_OK, { 'Content-Type' => ro_content_type_for_object_collection(ro_get_collection_type(name).type) }, representation.to_json]
+  end
 
-      send(collection.to_sym).push(rs_model.objects[id])
+  def ro_add_to_collection_and_get_response(name, json)
+    raise "collection not exists" unless ro_get_collection_type(name)
+    href_value = JSON.parse(json)['value']['href']
+    match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
+    raise "Invalid request format" if not match
+    domain_type = match['domain-type']
+    id = match['object-id'].to_i
+    raise "Value does not exists" unless ro_domain_model.objects.include?(id)
+    raise "Domain-type does not exists" unless ro_domain_model.types.include?(domain_type)
 
-      get_collection_as_json(collection)
-    end
+    send(name).push(ro_domain_model.objects[id])
 
-    def delete_from_collection(collection, json)
-      raise "collection not exists" if not rs_model.types[self.class.name].collections.include?(collection)
-      href_value = JSON.parse(json)['value']['href']
-      match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
-      raise "Invalid request format" if not match
-      domain_type = match['domain-type']
-      id = match['object-id'].to_i
-      raise "Value does not exists" if not rs_model.objects.include?(id)
-      raise "Domain-type does not exists" if not rs_model.types.include?(domain_type)
+    return ro_get_collection_response(name)
+  end
 
-      send(collection.to_sym).delete(rs_model.objects[id])
+  def ro_delete_from_collection_and_get_response(name, json)
+    raise "collection not exists" unless ro_get_collection_type(name)
+    href_value = JSON.parse(json)['value']['href']
+    match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
+    raise "Invalid request format" if not match
+    domain_type = match['domain-type']
+    id = match['object-id'].to_i
+    raise "Value does not exists" unless ro_domain_model.objects.include?(id)
+    raise "Domain-type does not exists" unless ro_domain_model.types.include?(domain_type)
 
-      get_collection_as_json(collection)
-    end
+    send(name).delete(ro_domain_model.objects[id])
+
+    return ro_get_collection_response(name)
   end
 end
-