restful_objects 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmE0NjFmNDUzNmFiODQ4MGM5YTNkZDUxZmNlM2EwOGQyZjExZmRiYg==
+  data.tar.gz: !binary |-
+    MDk2MDgzNTRkNWU5OGQ0YTlhYmJjMmNmNjIyOTBhZTc2NzJlYjFmMQ==
+SHA512:
+  metadata.gz: !binary |-
+    NTc2M2UyZGRiOTVmMzA5ZjU3M2Q4MGFiY2M3MzNiNTM2MWMzNDJkNDNkMDJl
+    ODU1ZjUwZGQ1MzFlMGQ2ZDIwZGY3NGY2Mzk4YjI4N2RiZDdjY2M3N2I1MDY5
+    ZmViODRjMjk0M2ZkMzEwMzUxMmIzODgzMmE4OGQ2YTQwMTNlOTQ=
+  data.tar.gz: !binary |-
+    NjA5OGE5YzYwYzFiMWNjYTBjYmEyMjZjYzljNzE0OGRiYTNmMjY1MGY5OTE0
+    ZDg5ZGJmMWE3MWQ2MzM0NTNmZDBmMTM3ZGE5NGZlMzQyMWNhZmJhNjQxYTAw
+    MTU4MDI5YzIyZDJjN2Y5NWE0OTE3OGIwMGM2NGZlM2YyOGU4MWE=

data/lib/restful_objects/action_description.rb

@@ -0,0 +1,82 @@
+module RestfulObjects
+  class ActionDescription
+    include LinkGenerator
+
+    attr_reader :id, :kind_result_type, :result_type, :parameters
+    attr_accessor :friendly_name, :description, :member_order, :disabled_reason
+
+    def initialize(id, result_type, domain_type, parameters = {}, options = {})
+      @id = id
+
+      if result_type == :void
+        result_type = [:void, :void]
+      elsif result_type.is_a?(Symbol)
+        result_type = [:scalar, result_type]
+      end
+      raise "result type should be a symbol or an array" if not result_type.is_a?(Array)
+      raise "result type kind '#{result_type.last}' unssuported" if
+        not [:void, :scalar, :object, :proto_object, :list].include?(result_type.first)
+      @kind_result_type = result_type.first
+      @result_type = result_type.last
+      case @kind_result_type
+        when :scalar
+          raise "result type for scalar '#{result_type.last}' unssuported" if
+            not [:string, :int, :decimal, :date, :blob].include?(@result_type)
+        when :object, :proto_object, :list
+          raise "result type should be a class or a string with a class name" if
+            not (@result_type.is_a?(Class) || @result_type.is_a?(String))
+      end
+
+      @parameters = ParameterDescriptionList.new
+      parameters.each { |name, definition| @parameters.add(name, definition) }
+
+      @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] || ''
+    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' => {}
+      }
+
+      representation['friendlyName'] = friendly_name if friendly_name
+      representation['description'] = description if description
+
+      representation.to_json
+    end
+
+    def metadata
+      result = { 'friendlyName' => friendly_name,
+                 'description' => description,
+                 'returnType' => result_type,
+                 'hasParams' => has_params,
+                 'memberOrder' => member_order }
+    end
+
+    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
+end

data/lib/restful_objects/action_list.rb

@@ -0,0 +1,17 @@
+module RestfulObjects
+  class ActionList
+    extend Forwardable
+
+    def initialize(domain_type)
+      @actions = Hash.new
+      @domain_type = domain_type
+    end
+
+    def add(id, result_type, parameters = {}, options = {})
+      options[:member_order] ||= count + 1
+      @actions[id] = ActionDescription.new(id, result_type, @domain_type, parameters, options)
+    end
+
+    def_delegators :@actions, :[], :each, :include?, :count, :empty?
+  end
+end

data/lib/restful_objects/collection_description.rb

@@ -0,0 +1,47 @@
+module RestfulObjects
+  class CollectionDescription
+    include LinkGenerator
+    attr_reader :id, :type, :read_only
+    attr_accessor :friendly_name, :description, :plural_form, :member_order, :disabled_reason
+
+    def initialize(id, type, domain_type, options = {})
+      @id = id
+      @type = type
+      @domain_type = domain_type
+      @read_only = options[:read_only].nil? ? false : options[:read_only]
+      @disabled_reason = options[:disabled_reason] || 'read only collection' if read_only
+      @friendly_name = options[:friendly_name] || id
+      @description = options[:description] || id
+      @plural_form = options[:plural_form]
+      @member_order = options[:member_order]
+    end
+
+    def get_representation
+      representation = {
+        'id' => id,
+        'memberOrder' => member_order,
+        'links' => [
+          link_to(:self, "/domain-types/#{@domain_type}/collections/#{@id}", :collection_description),
+          link_to(:up, "/domain-types/#{@domain_type}", :domain_type),
+          link_to(:return_type, "/domain-types/list", :domain_type),
+          link_to(:element_type, "/domain-types/#{@type}", :domain_type)
+        ],
+        'extensions' => metadata
+      }
+
+      representation['friendlyName'] = friendly_name if friendly_name
+      representation['description'] = description if description
+
+      representation.to_json
+    end
+
+    def metadata
+      { 'friendlyName' => friendly_name,
+        'description' => description,
+        'returnType' => 'list',
+        'elementType' => type,
+        'memberOrder' => member_order,
+        'pluralForm' => plural_form }
+    end
+  end
+end

data/lib/restful_objects/collection_list.rb

@@ -0,0 +1,17 @@
+module RestfulObjects
+  class CollectionList
+    extend Forwardable
+
+    def initialize(domain_type)
+      @domain_type = domain_type
+      @collections = Hash.new
+    end
+
+    def add(name, type, options = {})
+      options[:member_order] ||= count + 1
+      @collections[name] = CollectionDescription.new(name, type, @domain_type, options)
+    end
+
+    def_delegators :@collections, :[], :each, :each_key, :each_value, :include?, :count, :empty?, :clear
+  end
+end

data/lib/restful_objects/http_response.rb

@@ -0,0 +1,11 @@
+module RestfulObjects
+  class HttpResponse
+    attr_accessor :body, :content_type, :status
+
+    def initialize(body, content_type, status = 200)
+      @body = body
+      @content_type = content_type
+      @status = status
+    end
+  end
+end

data/lib/restful_objects/link_generator.rb

@@ -0,0 +1,104 @@
+module RestfulObjects
+  module LinkGenerator
+      def link_to(rel, href, type, options = {})
+        link = {
+          'rel' => generate_rel(rel, options),
+          'href' => RestfulObjects::DomainModel.current.base_url + href,
+          'type' => generate_repr_type(type, options[:domain_type], options[:element_type]),
+          'method' => options[:method] || 'GET' }
+
+        link['arguments'] = options[:arguments] if options[:arguments]
+
+        link
+      end
+
+      def generate_rel(rel, options = {})
+        if [:self, :up, :next, :previous, :icon, :help].include?(rel)
+          rel.to_s
+        elsif rel == :described_by
+          'describedby'
+        else
+          if [:action, :action_param, :collection, :delete, :domain_type, :domain_types, :element, :element_type, :persist,
+              :property, :return_type, :services, :update, :user, :version].include?(rel)
+            'urn:org.restfulobjects:rels/' + underscore_to_hyphen_string(rel)
+          else
+            'urn:org.restfulobjects:rels/' +
+              case rel
+                when :add_to
+                  'add-to;collection="' + options[:collection] + '"'
+                when :attachment
+                  'attachment;property="' + options[:property] + '"'
+                when :choice
+                  if options[:property]
+                    'choice;property="' + options[:property] + '"'
+                  elsif options[:action]
+                    'choice;action="' + options[:action] + '"'
+                  elsif options[:param]
+                    'choice;param="' + options[:param] + '"'
+                  else
+                    raise 'option not found for choice rel'
+                  end
+                when :clear
+                  'clear;property="' + options[:property] + '"'
+                when :details
+                  if options[:property]
+                    'details;property="' + options[:property] + '"'
+                  elsif options[:collection]
+                    'details;collection="' + options[:collection] + '"'
+                  elsif options[:action]
+                    'details;action="' + options[:action] + '"'
+                  else
+                    raise 'option not found for details rel'
+                  end
+                when :invoke
+                  if options[:action]
+                    'invoke;action="' + options[:action] + '"'
+                  elsif options[:type_action]
+                    'invoke;typeaction="' + options[:type_action] + '"'
+                  else
+                    raise 'option not found for invoke rel'
+                  end
+                when :modify
+                  'modify;property="' + options[:property] + '"'
+                when :remove_from
+                  'remove-from;collection="' + options[:collection] + '"'
+                when :service
+                  'service;serviceId="' + options[:service_id] + '"'
+                when :value
+                  if options[:property]
+                    'value;property="' + options[:property] + '"'
+                  elsif options[:collection]
+                    'value;collection="' + options[:collection] + '"'
+                  else
+                    raise 'option not found for value rel'
+                  end
+                else
+                  raise "rel invalid: #{rel}"
+              end
+          end
+        end
+      end
+
+      def generate_repr_type(type, domain_type = nil, element_type = nil)
+        valid_repr = [:homepage, :user, :version, :list, :object, :object_property, :object_collection, :object_action,
+         :object_result, :action_result, :type_list, :domain_type, :property_description, :collection_description,
+         :action_description, :action_param_description, :type_action_result, :error, :services]
+
+        raise "repr-type invalid: #{type.to_s}" if not valid_repr.include?(type)
+
+        repr = 'application/json;profile="urn:org.restfulobjects:repr-types/' + underscore_to_hyphen_string(type) + '"'
+
+        if domain_type && [:object, :action].include?(type)
+          repr += ';x-ro-domain-type="' + domain_type + '"'
+        elsif element_type && [:object_collection, :action].include?(type)
+          repr +=';x-ro-element-type="' + element_type + '"'
+        end
+
+        repr
+      end
+
+      def underscore_to_hyphen_string(symbol)
+        symbol.to_s.sub('_', '-')
+      end
+  end
+end

data/lib/restful_objects/model.rb

@@ -0,0 +1,79 @@
+module RestfulObjects
+  class DomainModel
+    include LinkGenerator
+
+    attr_accessor :base_url, :compatible_mode
+    attr_reader :metadata_schema, :version, :user, :types, :services, :objects
+
+    def self.current
+      @current ||= DomainModel.new
+    end
+
+    def self.current=(value)
+      @current = value
+    end
+
+    def initialize
+      @base_url = 'http://localhost'
+      @metadata_schema = :selectable
+      @compatible_mode = false
+      @user = User.new(@base_url, 'anonymous')
+      @types = TypeList.new
+      @services = ServiceList.new(@base_url)
+      @objects = ObjectList.new(@base_url)
+    end
+
+    def get_homepage
+      { 'links' => [
+          link_to(:self, '/', :homepage),
+          link_to(:user, '/user', :user),
+          link_to(:services, '/services', :list),
+          link_to(:version, '/version', :version),
+          link_to(:domain_types, '/domain-types', :type_list)
+        ],
+       'extensions' => {}
+      }.to_json
+    end
+
+    def get_version
+      { 'links' => [
+          link_to(:self, '/version', :version),
+          link_to(:up, '/', :homepage),
+        ],
+        'specVersion' => '1.0',
+        'optionalCapabilities' => {
+          'blobsClobs' => true,
+          'deleteObjects' => true,
+          'domainModel' => metadata_schema.to_s,
+          'protoPersistentObjects' => true,
+          'validateOnly' => false
+        },
+        'extensions' => {}
+      }.to_json
+    end
+
+    def get_user
+      @user.get_as_json
+    end
+
+    def get_services
+      services.get_list
+    end
+
+    def metadata_schema=(value)
+      if not [:simple, :formal, :selectable].include?(value)
+        raise "invalid metadata schema, choose :simple, :formal or :selectable"
+      end
+      @metadata_schema = value
+    end
+
+    def reset
+      @base_url = 'http://localhost'
+      @user = nil
+      @types.clear
+      @services.clear
+      @objects.clear
+    end
+  end
+end
+

data/lib/restful_objects/object.rb

@@ -0,0 +1,132 @@
+require 'bigdecimal'
+require 'base64'
+
+module RestfulObjects
+  module Object
+    include LinkGenerator
+
+    def self.included(base)
+      RestfulObjects::DomainModel.current.types.add(base.name)
+
+      base.class_eval do
+        extend ObjectMacros
+        include ObjectBase
+        include ObjectProperties
+        include ObjectCollections
+        include ObjectActions
+      end
+    end
+  end
+
+  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
+
+    def rs_register_in_model
+      rs_model.objects.register(self) if not @is_service
+    end
+
+    def rs_model
+      RestfulObjects::DomainModel.current
+    end
+
+    def rs_type
+      rs_model.types[self.class.name]
+    end
+
+    def get_representation
+      HttpResponse.new(representation.to_json,
+                       'application/json;profile="urn:org.restfulobjects:repr-types/object";x-ro-domain-type="' + rs_type.id + '"')
+    end
+
+    def rs_instance_id
+      object_id
+    end
+
+    def representation
+      representation = {
+        'title' => title,
+        'members' => generate_members,
+        'links' => [ link_to(:described_by, "/domain-types/#{self.class.name}", :domain_type) ],
+        'extensions' => rs_type.metadata
+      }
+
+      if not is_service
+        representation['instanceId'] = object_id.to_s
+        representation['links'] << link_to(:self, "/objects/#{self.class.name}/#{object_id}", :object)
+      else
+        representation['serviceId'] = self.class.name
+        representation['links'] << link_to(:self, "/services/#{self.class.name}", :object)
+      end
+
+      representation
+    end
+
+    def generate_members
+      if is_service
+        actions_members
+      else
+        properties_members.merge(collections_members.merge(actions_members))
+      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
+    end
+
+    def deleted?
+      @deleted
+    end
+
+    def encode_value(value, type)
+      return nil if value.nil?
+      case type
+        when :string
+          value.to_s
+        when :int
+          value.to_i
+        when :decimal
+          value.to_f
+        when :date
+          value.strftime('%Y-%m-%d')
+        when :blob
+          Base64.encode64(value).strip
+        else
+          raise "encode_value unsupported property type: #{type}"
+      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 :decimal
+          Float(value)
+        when :date
+          Date.parse(value)
+        when :blob
+          Base64.decode64(value)
+        else
+          raise "decode_value unsupported property type: #{type}"
+      end
+    end
+
+    def get_self_link
+      link_to(:self, "/objects/#{self.class.name}/#{self.object_id}", :object)
+    end
+  end
+end