restful_objects 0.0.7 → 0.0.8

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

@@ -1,36 +1,30 @@
-module RestfulObjects
-  module ObjectMacros
-    def property(name, type, options = {})
-      RestfulObjects::DomainModel.current.types[self.name].register_property(name.to_s, type, options)
-      if options[:read_only]
-        self.class_eval { attr_reader name }
-      else
-        if not options[:max_length]
-          self.class_eval { attr_accessor name }
-        else
-          self.class_eval do
-            attr_reader name
+module RestfulObjects::ObjectMacros
+  def property(name, type, options = {})
+    RestfulObjects::DomainModel.current.types[self.name].register_property(name.to_s, type, options)
 
-            define_method "#{name}=".to_sym do |value|
-              raise "string max length exceeded" if value && value.length > options[:max_length]
-              instance_variable_set("@#{name}".to_sym, value)
-            end
-          end
+    define_method(name) do
+      instance_variable_get("@#{name}")
+    end
+
+    unless options[:read_only]
+      define_method("#{name}=") do |value|
+        if options[:max_length] && value && value.length > options[:max_length]
+          raise ArgumentError.new("string max length exceeded")
         end
+        instance_variable_set("@#{name}", value)
       end
     end
+  end
 
-    def collection(name, type, options = {})
-      type = type.name if type.is_a? Class
+  def collection(name, type, options = {})
+    type = type.name if type.is_a?(Class)
 
-      RestfulObjects::DomainModel.current.types[self.name].register_collection(name.to_s, type, options)
+    RestfulObjects::DomainModel.current.types[self.name].register_collection(name.to_s, type, options)
 
-      self.class_eval { attr_reader name }
-    end
+    attr_reader(name)
+  end
 
-    def action(name, options = {})
-      RestfulObjects::DomainModel.current.types[self.name].register_action(name.to_s, options)
-    end
+  def action(name, options = {})
+    RestfulObjects::DomainModel.current.types[self.name].register_action(name.to_s, options)
   end
 end
-

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

@@ -1,124 +1,111 @@
-module RestfulObjects
-  module ObjectProperties
-    def properties_members
-      members = {}
-      rs_type.properties.each do |name, property|
-        members[name] = {
-          'memberType' => 'property',
-          'value' => get_property_value(name),
+module RestfulObjects::ObjectProperties
+  HTTP_OK = 200
+  HTTP_NOT_FOUND = 404
+
+  def ro_get_property_metadata(name)
+    ro_domain_type.properties[name]
+  end
+
+  def ro_get_property_response(name)
+    name     = String(name)
+    property = ro_domain_type.properties[name]
+    return [HTTP_NOT_FOUND, { 'Warning' => "No such property #{name}" }, ''] unless property
+
+    representation = {
+      name =>
+        { 'value' => ro_get_property_as_json(name),
           'links' => [
-            link_to(:details, "/objects/#{self.class.name}/#{object_id}/properties/#{name}", :object_property, property: name)
-          ],
+            link_to(:self, "/objects/#{ro_domain_type.id}/#{ro_instance_id}/properties/#{name}", :object_property),
+            link_to(:up, "/objects/#{ro_domain_type.id}/#{ro_instance_id}", :object) ],
           'extensions' => property.metadata
         }
+    }
 
-        if property.read_only
-          members[name]['disabledReason'] = property.disabled_reason
+    unless property.read_only
+      representation[name]['links'] << link_to(:modify,
+                                               "/objects/#{ro_domain_type.id}/#{ro_instance_id}/properties/#{name}",
+                                               :object_property,
+                                               { property: name, method: 'PUT', arguments: { 'value' => nil } })
+      representation[name]['links'] << link_to(:clear,
+                                               "/objects/#{ro_domain_type.id}/#{ro_instance_id}/properties/#{name}",
+                                               :object_property,
+                                               { property: name, method: 'DELETE'})
+      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
-          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 property_description(name).is_reference
-              choices_json = choices.map { |object| object.get_property_rel_representation(name) }
-            else
-              choices_json = choices.map { |value| decode_value(value, property_type(name)) }
-            end
-            members[name]['choices'] = choices_json
-          end
+          choices_json = choices.map { |value| decode_value(value, ro_get_property_metadata(name).return_type) }
         end
+        representation[name]['choices'] = choices_json
       end
-      members
+    else
+      representation[name]['disabledReason'] = property.disabled_reason
     end
 
-    def get_property_as_json(property)
-      property = property.to_s if property.is_a?(Symbol)
-      raise "Property not exists" if not rs_model.types[self.class.name].properties.include?(property)
-
-      representation = {
-        property =>
-          { 'value' => get_property_value(property),
-            'links' => [
-              link_to(:self, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property),
-              link_to(:up, "/objects/#{self.class.name}/#{object_id}", :object) ],
-            'extensions' => rs_model.types[self.class.name].properties[property].metadata
-          }
-      }
-
-      if not rs_model.types[self.class.name].properties[property].read_only then
-        representation[property]['links'].concat [
-          link_to(:modify, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property,
-            { property: property, method: 'PUT', arguments: { 'value' => nil } }),
-          link_to(:clear, "/objects/#{self.class.name}/#{object_id}/properties/#{property}", :object_property,
-            { property: property, method: 'DELETE'} ) ]
+    [HTTP_OK, { 'Content-Type' => ro_content_type_for_property }, representation.to_json]
+  end
 
-        if self.respond_to?("#{property}_choices")
-          choices = self.send("#{property}_choices")
-          raise "value returned by #{property}_choices method should be an Array" unless choices.is_a?(Array)
-          if property_description(property).is_reference
-            choices_json = choices.map { |object| object.get_property_rel_representation(property) }
-          else
-            choices_json = choices.map { |value| decode_value(value, property_type(property)) }
-          end
-          representation[property]['choices'] = choices_json
-        end
-      else
-        representation[property]['disabledReason'] =
-          rs_model.types[self.class.name].properties[property].disabled_reason
-      end
+  def ro_put_property_and_get_response(name, input)
+    name     = String(name)
+    property = ro_domain_type.properties[name]
+    return [HTTP_NOT_FOUND, { 'Warning' => "No such property #{name}" }, ''] unless property
+    return [HTTP_FORBIDDEN, { 'Warning' => "Read-only property #{name}" }, ''] if property.read_only
 
-      representation.to_json
-    end
+    ro_set_property_as_json(name, JSON.parse(input)['value'])
+    on_after_update if respond_to?(:on_after_update)
 
-    def put_property_as_json(property, json)
-      property = property.to_s if property.is_a?(Symbol)
-      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
+    ro_get_property_response(name)
+  end
 
-      value = JSON.parse(json)['value']
-      set_property_value(property, value)
+  def ro_put_multiple_properties_and_get_response(input)
+    properties = JSON.parse(input)
+    properties.each do |name, value|
+      raise 'property not exists' unless ro_domain_type.properties.include?(name)
+      raise 'read-only property' if ro_domain_type.properties[name].read_only
+      ro_set_property_as_json(name, value['value'])
       on_after_update if respond_to?(:on_after_update)
-      get_property_as_json(property)
     end
+    [HTTP_OK, { 'Content-Type' => ro_content_type_for_object(ro_domain_type.id) }, ro_get_representation(false).to_json]
+  end
 
-    def clear_property(property)
-      raise "property not exists" if not rs_model.types[self.class.name].properties.include?(property)
-      raise "read-only property" if rs_model.types[self.class.name].properties[property].read_only
-
-      send("#{property}=".to_sym, nil)
-      on_after_update if respond_to?(:on_after_update)
-      get_property_as_json(property)
+  def ro_clear_property_and_get_response(name)
+    name = String(name)
+    if !ro_get_property_metadata(name)
+      return [HTTP_NOT_FOUND, { 'Warning' => "No such property #{name}" }, '']
+    elsif ro_get_property_metadata(name).read_only
+      return [HTTP_FORBIDDEN, { 'Warning' => "Read-only property #{name}" }, '']
     end
 
-    def property_description(property)
-      rs_model.types[self.class.name].properties[property]
-    end
+    send("#{name}=", nil)
 
-    def property_type(property)
-      rs_model.types[self.class.name].properties[property].return_type
-    end
+    on_after_update if respond_to?(:on_after_update)
+    return ro_get_property_response(name)
+  end
 
-    def get_property_value(property)
-      encode_value(send(property.to_sym), property_type(property), property)
-    end
+  protected
 
-    def set_property_value(property, value)
-      if property_description(property).is_reference
-        unless value.nil?
-          href_value = value['href']
-          match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
-          raise "invalid property reference format: '#{href_value}'" 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)
-          send "#{property}=".to_sym, rs_model.objects[id]
-        else
-          send "#{property}=".to_sym, nil
-        end
+  def ro_get_property_as_json(name)
+    encode_value(send(name), ro_get_property_metadata(name).return_type, name)
+  end
+
+  def ro_set_property_as_json(name, json)
+    if ro_get_property_metadata(name).is_reference
+      unless json.nil?
+        href_value = json['href']
+        match = Regexp.new(".*/objects/(?<domain-type>\\w*)/(?<object-id>\\d*)").match(href_value)
+        raise "invalid property reference format: '#{href_value}'" if not match
+        domain_type = match['domain-type']
+        id = match['object-id'].to_i
+        raise "value does not exists" if not ro_domain_model.objects.include?(id)
+        raise "domain-type does not exists" if not ro_domain_model.types.include?(domain_type)
+        send "#{name}=".to_sym, ro_domain_model.objects[id]
       else
-        send "#{property}=".to_sym, decode_value(value, property_type(property))
+        send "#{name}=".to_sym, nil
       end
+    else
+      send "#{name}=".to_sym, decode_value(json, ro_get_property_metadata(name).return_type)
     end
   end
 end
-

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

@@ -1,22 +1,14 @@
-module RestfulObjects
-  module Service
-    include LinkGenerator
+module RestfulObjects::Service
+  include RestfulObjects::LinkGenerator
 
-    def self.included(base)
-      RestfulObjects::DomainModel.current.register_type(base.name)
+  def self.included(base)
+    RestfulObjects::DomainModel.current.register_type(base.name)
+    RestfulObjects::DomainModel.current.register_service(base)
 
-      base.class_eval do
-        extend ObjectMacros
-        include ObjectBase
-        include ObjectActions
-
-        def rs_register_in_model
-          # do_nothing
-        end
-      end
-
-      RestfulObjects::DomainModel.current.register_service(base)
+    base.class_eval do
+      extend RestfulObjects::ObjectMacros
+      include RestfulObjects::ObjectBase
+      include RestfulObjects::ObjectActions
     end
   end
 end
-

data/lib/restful_objects/domain_model/types/action_description.rb

@@ -1,100 +1,98 @@
 require_relative 'parameter_description_list'
 
-module RestfulObjects
-  class ActionDescription
-    include LinkGenerator
+class RestfulObjects::ActionDescription
+  include RestfulObjects::LinkGenerator
 
-    attr_reader :id, :kind_result_type, :result_type, :parameters
-    attr_accessor :friendly_name, :description, :member_order, :disabled_reason
+  attr_reader :id, :kind_result_type, :result_type, :parameters
+  attr_accessor :friendly_name, :description, :member_order, :disabled_reason
 
-    def initialize(id, domain_type, options)
-      @id              = id
-      @domain_type     = domain_type
-      @friendly_name   = options[:friendly_name]   || id
-      @description     = options[:description]     || id
-      @member_order    = options[:member_order]    || 0
-      @disabled_reason = options[:disabled_reason] || ''
+  def initialize(id, domain_type, options)
+    @id              = id
+    @domain_type     = domain_type
+    @friendly_name   = options[:friendly_name]   || id
+    @description     = options[:description]     || id
+    @member_order    = options[:member_order]    || 0
+    @disabled_reason = options[:disabled_reason] || ''
 
-      case options[:return_type]
-        when NilClass
+    case options[:return_type]
+      when NilClass
+        @result_type      = :void
+        @kind_result_type = :void
+      when Symbol
+        if options[:return_type] == :void
           @result_type      = :void
           @kind_result_type = :void
-        when Symbol
-          if options[:return_type] == :void
-            @result_type      = :void
-            @kind_result_type = :void
-          else
-            raise "result type for scalar '#{options[:return_type]}' unssuported" unless [:string, :int, :bool, :decimal, :date, :blob].include?(options[:return_type])
-            @result_type      = options[:return_type]
-            @kind_result_type = :scalar
-          end
-        when Hash
-          options[:return_type]
-          if options[:return_type][:object]
-            @result_type      = options[:return_type][:object]
-            @kind_result_type = :object
-          elsif options[:return_type][:proto_object]
-            @result_type      = options[:return_type][:proto_object]
-            @kind_result_type = :proto_object
-          elsif options[:return_type][:list]
-            @result_type      = options[:return_type][:list]
-            @kind_result_type = :list
-          else
-            raise 'invalid return_type: object, proto_object or list key expected'
-          end
-          unless @result_type.is_a?(Class) or @result_type.is_a?(String)
-            raise 'return_type object, proto_object or list value should be a class or a string'
-          end
         else
-          raise 'invalid return_type: symbol or hash expected'
-      end
-
-      @parameters = ParameterDescriptionList.new
-      options[:parameters].each { |name, definition| @parameters.add(name, definition) } if options[:parameters]
+          raise "result type for scalar '#{options[:return_type]}' unssuported" unless [:string, :int, :bool, :decimal, :date, :blob].include?(options[:return_type])
+          @result_type      = options[:return_type]
+          @kind_result_type = :scalar
+        end
+      when Hash
+        options[:return_type]
+        if options[:return_type][:object]
+          @result_type      = options[:return_type][:object]
+          @kind_result_type = :object
+        elsif options[:return_type][:proto_object]
+          @result_type      = options[:return_type][:proto_object]
+          @kind_result_type = :proto_object
+        elsif options[:return_type][:list]
+          @result_type      = options[:return_type][:list]
+          @kind_result_type = :list
+        else
+          raise 'invalid return_type: object, proto_object or list key expected'
+        end
+        unless @result_type.is_a?(Class) or @result_type.is_a?(String)
+          raise 'return_type object, proto_object or list value should be a class or a string'
+        end
+      else
+        raise 'invalid return_type: symbol or hash expected'
     end
 
-    def get_representation
-      representation = {
-        'id' => @id,
-        'hasParams' => has_params,
-        'memberOrder' => @member_order,
-        'parameters' => parameters_list,
-        'links' => [
-          link_to(:self, "/domain-types/#{@domain_type}/actions/#{@id}", :action_description),
-          link_to(:up, "/domain-types/#{@domain_type}", :domain_type),
-          link_to(:return_type, "/domain-types/#{result_type}", :domain_type)
-        ],
-        'extensions' => {}
-      }
+    @parameters = RestfulObjects::ParameterDescriptionList.new
+    options[:parameters].each { |name, definition| @parameters.add(name, definition) } if options[:parameters]
+  end
 
-      representation['friendlyName'] = friendly_name if friendly_name
-      representation['description'] = description if description
+  def get_representation
+    representation = {
+      'id' => @id,
+      'hasParams' => has_params,
+      'memberOrder' => @member_order,
+      'parameters' => parameters_list,
+      'links' => [
+        link_to(:self, "/domain-types/#{@domain_type}/actions/#{@id}", :action_description),
+        link_to(:up, "/domain-types/#{@domain_type}", :domain_type),
+        link_to(:return_type, "/domain-types/#{result_type}", :domain_type)
+      ],
+      'extensions' => {}
+    }
 
-      representation.to_json
-    end
+    representation['friendlyName'] = friendly_name if friendly_name
+    representation['description'] = description if description
 
-    def metadata
-      {
-        'friendlyName' => friendly_name,
-        'description'  => description,
-        'returnType'   => result_type,
-        'hasParams'    => has_params,
-        'memberOrder'  => member_order
-      }
-    end
+    representation.to_json
+  end
 
-    def has_params
-      not @parameters.empty?
-    end
+  def metadata
+    {
+      'friendlyName' => friendly_name,
+      'description'  => description,
+      'returnType'   => result_type,
+      'hasParams'    => has_params,
+      'memberOrder'  => member_order
+    }
+  end
 
-    def parameters_list
-      result = {}
-      parameters.each do |name, parameter|
-        result[name] = {
-          'extension' => parameter.metadata
-        }
-      end
-      result
+  def has_params
+    not @parameters.empty?
+  end
+
+  def parameters_list
+    result = {}
+    parameters.each do |name, parameter|
+      result[name] = {
+        'extension' => parameter.metadata
+      }
     end
+    result
   end
 end