rod-rest 0.0.1

data/lib/rod/rest/constants.rb

@@ -0,0 +1,5 @@
+module Rod
+  module Rest
+    VERSION = "0.0.1"
+  end
+end

data/lib/rod/rest/exception.rb

@@ -0,0 +1,8 @@
+module Rod
+  module Rest
+    class MissingResource < RuntimeError; end
+    class APIError < RuntimeError; end
+    class InvalidData < RuntimeError; end
+    class UnknownResource < RuntimeError; end
+  end
+end

data/lib/rod/rest/json_serializer.rb

@@ -0,0 +1,59 @@
+require 'json'
+
+module Rod
+  module Rest
+    class JsonSerializer
+      # Serialize given Rod +object+ to JSON.
+      # The serialized object looks as follows:
+      # {
+      #   rod_id: 1,                            # required +rod_id+
+      #   type: "Car",                          # required +type+
+      #   name: "Mercedes 300",                 # field value
+      #   owner: { rod_id: 1, type: "Person" }  # singular association value
+      #   drivers: { count: 3 }                 # plural association value
+      # }
+      def serialize(object)
+        if object.is_a?(Rod::Model)
+          serialize_rod_object(object)
+        elsif object.respond_to?(:each)
+          serialize_collection(object)
+        else
+          serialize_basic_value(object)
+        end
+      end
+
+      private
+      def serialize_rod_object(object)
+        build_object_hash(object).to_json
+      end
+
+      def serialize_collection(collection)
+        collection.map{|o| build_object_hash(o) }.to_json
+      end
+
+      def serialize_basic_value(value)
+        value.to_json
+      end
+
+      def build_object_hash(object)
+        result = { rod_id: object.rod_id, type: object.class.to_s }
+        resource = object.class
+        resource.fields.each do |field|
+          result[field.name] = object.send(field.name)
+        end
+        resource.singular_associations.each do |association|
+          associated = object.send(association.name)
+          if associated
+            result[association.name] = { rod_id: associated.rod_id, type: associated.class.to_s }
+          else
+            result[association.name] = nil
+          end
+        end
+        resource.plural_associations.each do |association|
+          result[association.name] = { count: object.send(association.name).size }
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rod/rest/metadata.rb

@@ -0,0 +1,38 @@
+module Rod
+  module Rest
+    class Metadata
+      ROD_KEY = /\ARod\b/
+
+      attr_reader :description
+
+      # Initializes the metadata via the options:
+      # * description - text representation of the metadata
+      # * parser - parser used to parse the text representation of the metadata
+      # * resource_metadata_factory - factory used to create metadata for the
+      #   resources
+      def initialize(options={})
+        @description = options.fetch(:description)
+        parser = options[:parser] || JSON
+        @resource_metadata_factory = options[:resource_metadata_factory] || ResourceMetadata
+        @resources = create_resource_descriptions(parser.parse(@description, symbolize_names: true))
+      end
+
+      # Return collection of resource metadata.
+      def resources
+        @resources
+      end
+
+      private
+      def create_resource_descriptions(hash_description)
+        hash_description.map do |name,description|
+          next if restricted_name?(name)
+          @resource_metadata_factory.new(name,description)
+        end.compact
+      end
+
+      def restricted_name?(name)
+        name.to_s =~ ROD_KEY
+      end
+    end
+  end
+end

data/lib/rod/rest/naming.rb

@@ -0,0 +1,20 @@
+require 'active_model/naming'
+
+module Rod
+  module Rest
+    module Naming
+      def plural_resource_name(resource)
+        singular_resource_name(resource).pluralize
+      end
+
+      def singular_resource_name(resource)
+        if resource.respond_to?(:name)
+          name = resource.name
+        else
+          name = resource.to_s
+        end
+        name.gsub("::","_").downcase
+      end
+    end
+  end
+end

data/lib/rod/rest/property_metadata.rb

@@ -0,0 +1,20 @@
+module Rod
+  module Rest
+    class PropertyMetadata
+      attr_reader :name, :symbolic_name
+
+      # Creates new property metadata using the +name+ and +options+.
+      def initialize(name, options)
+        raise ArgumentError.new("nil name") if name.nil?
+        @name = name.to_s
+        @symbolic_name = @name.to_sym
+        @index = options[:index]
+      end
+
+      # Returns true if the property is indexed.
+      def indexed?
+        !! @index
+      end
+    end
+  end
+end

data/lib/rod/rest/proxy.rb

@@ -0,0 +1,121 @@
+require 'rod/rest/exception'
+
+module Rod
+  module Rest
+    class Proxy
+      # Initialize new Proxy factory based on the +metadata+ and associated with
+      # the +client+, used to fetch the descriptions of the objects.
+      # Options:
+      # * collection_proxy_factory - factory used to create collection proxies
+      #   for plural associations
+      def initialize(metadata,client,options={})
+        @metadata = metadata
+        @client = client
+        @type = @metadata.name
+        @collection_proxy_factory = options[:collection_proxy_factory] || CollectionProxy
+        @klass = build_class(@metadata)
+      end
+
+      # Return new instance of a proxy object based on the +hash+ data.
+      def new(hash)
+        check_id(hash)
+        proxy = @klass.new(hash[:rod_id],@type,@client,@collection_proxy_factory)
+        @metadata.fields.each do |field|
+          check_field(hash,field)
+          proxy.instance_variable_set("@#{field.symbolic_name}",hash[field.symbolic_name])
+        end
+        @metadata.singular_associations.each do |association|
+          check_association(hash,association)
+          proxy.instance_variable_set(association_variable_name(association),hash[association.symbolic_name])
+        end
+        @metadata.plural_associations.each do |association|
+          check_association(hash,association)
+          proxy.instance_variable_set(count_variable_name(association),hash[association.symbolic_name][:count])
+        end
+        proxy
+      end
+
+      private
+      def build_class(metadata)
+        Class.new do
+          attr_reader :type,:rod_id
+
+          def initialize(rod_id,type,client,collection_proxy_factory)
+            @rod_id = rod_id
+            @type = type
+            @client = client
+            @collection_proxy_factory = collection_proxy_factory
+          end
+
+          metadata.fields.each do |field|
+            attr_reader field.symbolic_name
+          end
+
+          metadata.singular_associations.each do |association|
+            class_eval <<-END
+              def #{association.symbolic_name}
+                if defined?(@#{association.name})
+                  return @#{association.name}
+                end
+                @#{association.name} = @client.fetch_object(@_#{association.name}_description)
+              end
+            END
+          end
+
+          metadata.plural_associations.each do |association|
+            class_eval <<-END
+              def #{association.name}
+                @collection_proxy_factory.new(self,"#{association.name}",@_#{association.name}_count,@client)
+              end
+            END
+          end
+        end
+      end
+
+      def check_id(hash)
+        unless hash.has_key?(:rod_id)
+          raise InvalidData.new(missing_rod_id_message(hash))
+        end
+      end
+
+      def check_field(hash,field)
+        unless hash.has_key?(field.symbolic_name)
+          raise InvalidData.new(missing_field_error_message(field,hash))
+        end
+      end
+
+      def check_association(hash,association)
+        unless hash.has_key?(association.symbolic_name)
+          raise InvalidData.new(missing_association_error_message(association,hash))
+        end
+        if !hash[association.symbolic_name].nil? &&  ! Hash === hash[association.symbolic_name]
+          raise InvalidData.new(not_hash_error_message(association,hash[association.symbolic_name]))
+        end
+      end
+
+      def missing_rod_id_message(hash)
+        "The data doesn't have a rod_id #{hash}"
+      end
+
+      def missing_field_error_message(field,hash)
+        "The field '#{field.symbolic_name}' is missing in the hash: #{hash}"
+      end
+
+      def missing_association_error_message(association,hash)
+        "The association '#{association.symbolic_name}' is missing in the hash: #{hash}"
+      end
+
+      def not_hash_error_message(association,value)
+        "The association '#{association.symbolic_name}' is not a hash: #{value}"
+      end
+
+      def association_variable_name(association)
+        "@_#{association.symbolic_name}_description"
+      end
+
+      def count_variable_name(association)
+        "@_#{association.symbolic_name}_count"
+      end
+    end
+  end
+end

data/lib/rod/rest/proxy_factory.rb

@@ -0,0 +1,30 @@
+require 'rod/rest/exception'
+
+module Rod
+  module Rest
+    class ProxyFactory
+      # Creates new proxy factory based on the +metadata+ and using given web
+      # +client+.
+      # Options:
+      # * proxy_class - the class used to create the resource proxy factories.
+      def initialize(metadata,client,options={})
+        proxy_class = options[:proxy_class] || Proxy
+        @proxies = {}
+        metadata.each do |resource_metadata|
+          @proxies[resource_metadata.name] = proxy_class.new(resource_metadata,client)
+        end
+      end
+
+      # Build new object-proxy from the hash-like +object_description+.
+      def build(object_description)
+        check_type(object_description[:type])
+        @proxies[object_description[:type]].new(object_description)
+      end
+
+      private
+      def check_type(type)
+        raise UnknownResource.new(type) unless @proxies.has_key?(type)
+      end
+    end
+  end
+end

data/lib/rod/rest/resource_metadata.rb

@@ -0,0 +1,32 @@
+module Rod
+  module Rest
+    class ResourceMetadata
+      attr_reader :name, :fields, :singular_associations, :plural_associations, :properties, :indexed_properties
+
+      # Create new resource metadata for a resource with +name+ and
+      # +description+. Options:
+      # * +property_factory+ - factory used to create descriptions of the
+      #   properties
+      def initialize(name,description,options={})
+        @name = name.to_s
+        @property_factory = options[:property_factory] || PropertyMetadata
+        @fields = create_properties(description[:fields])
+        @singular_associations = create_properties(description[:has_one])
+        @plural_associations = create_properties(description[:has_many])
+        @properties = @fields + @singular_associations + @plural_associations
+        @indexed_properties = @properties.select{|p| p.indexed? }
+      end
+
+      private
+      def create_properties(description)
+        if  description
+          description.map do |property_description|
+            @property_factory.new(*property_description)
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/rod-rest.gemspec

@@ -0,0 +1,32 @@
+$:.unshift "lib"
+require 'rod/rest/constants'
+
+Gem::Specification.new do |s|
+  s.name = "rod-rest"
+  s.version = Rod::Rest::VERSION
+  s.date = "#{Time.now.strftime("%Y-%m-%d")}"
+  s.required_ruby_version = '= 1.9.2'
+  s.platform    = Gem::Platform::RUBY
+  s.authors = ['Aleksander Pohl']
+  s.email   = ["apohllo@o2.pl"]
+  s.homepage    = "http://github.com/apohllo/rod-rest"
+  s.summary = "REST API for ROD"
+  s.description = "REST API for Ruby Object Database allows for talking to the DB via HTTP."
+
+  s.rubyforge_project = "rod-rest"
+  #s.rdoc_options = ["--main", "README.rdoc"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_path = "lib"
+
+  s.add_dependency("sinatra")
+  s.add_dependency("rod")
+  s.add_dependency("faraday")
+
+  s.add_development_dependency("rack-test")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("rr")
+end
+

data/test/int/end_to_end.rb

@@ -0,0 +1,138 @@
+require 'bundler/setup'
+require 'rod'
+require 'rod/rest'
+require 'rack'
+
+class Database < Rod::Database
+end
+
+class Model < Rod::Model
+  database_class Database
+end
+
+class Car < Model
+  field :brand, :string, index: :hash
+  has_one :owner, class_name: "Person"
+  has_many :drivers, class_name: "Person"
+end
+
+class Person < Model
+  field :name, :string, index: :hash
+  field :surname, :string, index: :hash
+end
+
+module Rod
+  module Rest
+    describe "end-to-end tests" do
+      def verify_person_equality(person1,person2)
+        person1.name.should == person2.name
+        person1.surname.should == person2.surname
+      end
+
+      PATH = "data/end_to_end"
+      SCHUMAHER_NAME = "Michael"
+      SCHUMAHER_SURNAME = "Schumaher"
+      KUBICA_NAME = "Robert"
+      KUBICA_SURNAME = "Kubica"
+      MERCEDES_300_NAME = "Mercedes 300"
+
+      before(:all) do
+        ::Database.instance.create_database(PATH)
+        schumaher = Person.new(name: SCHUMAHER_NAME, surname: SCHUMAHER_SURNAME)
+        schumaher.store
+        kubica = Person.new(name: KUBICA_NAME, surname: KUBICA_SURNAME)
+        kubica.store
+        mercedes_300 = Car.new(brand: MERCEDES_300_NAME, owner: schumaher, drivers: [schumaher,kubica])
+        mercedes_300.store
+        audi_a4 = Car.new(brand: "Audi A4", owner: nil)
+        audi_a4.store
+        ::Database.instance.close_database
+      end
+
+      after(:all) do
+        require 'fileutils'
+        FileUtils.rm_rf(PATH)
+      end
+
+      before do
+        ::Database.instance.open_database(PATH)
+      end
+
+      after do
+        ::Database.instance.close_database
+      end
+
+      example "Schumaher is in the DB" do
+        schumaher = Person.find_by_surname(SCHUMAHER_SURNAME)
+        schumaher.name.should == SCHUMAHER_NAME
+      end
+
+      example "Mercedes 300 is in the DB" do
+        mercedes_300 = Car.find_by_brand(MERCEDES_300_NAME)
+        mercedes_300.owner.should == Person.find_by_surname(SCHUMAHER_SURNAME)
+        mercedes_300.drivers[1].should == Person.find_by_surname(KUBICA_SURNAME)
+      end
+
+      describe "with REST API and client" do
+        let(:client)        { Client.new(http_client: http_client) }
+        let(:http_client)   { Faraday.new(url: "http://localhost:4567") }
+
+        before(:all) do
+          Thread.new { API.start_with_database(::Database.instance,{},logging: nil) }
+          sleep 0.5
+        end
+
+        after(:all) do
+          #Thread.join
+        end
+
+        example "API serves the metadata" do
+          client.metadata.resources.size.should == 3
+          person = client.metadata.resources.find{|r| r.name == "Person" }
+          person.fields.size == 2
+          person.fields.zip(%w{name surname}).each do |field,field_name|
+            field.name.should == field_name
+          end
+          car = client.metadata.resources.find{|r| r.name == "Car" }
+          car.fields.zip(%w{brand}).each do |field,field_name|
+            field.name.should == field_name
+          end
+        end
+
+        example "Schumaher might be retrieved by id" do
+          schumaher_in_rod = Person.find_by_name(SCHUMAHER_NAME)
+          schumaher_via_api = client.find_person(schumaher_in_rod.rod_id)
+          verify_person_equality(schumaher_via_api,schumaher_in_rod)
+        end
+
+        example "Kubica might be retrieved by name" do
+          kubica_in_rod = Person.find_by_name(KUBICA_NAME)
+          kubica_via_api = client.find_people_by_name(KUBICA_NAME).first
+          verify_person_equality(kubica_via_api,kubica_in_rod)
+        end
+
+        example "Mercedes might be retrieved by id" do
+          mercedes_in_rod = Car.find_by_brand(MERCEDES_300_NAME)
+          mercedes_via_api = client.find_car(mercedes_in_rod.rod_id)
+          mercedes_via_api.brand.should == mercedes_in_rod.brand
+        end
+
+        example "Mercedes owner is retrieved properly" do
+          mercedes_in_rod = Car.find_by_brand(MERCEDES_300_NAME)
+          schumaher_in_rod = Person.find_by_name(SCHUMAHER_NAME)
+          mercedes_via_api = client.find_car(mercedes_in_rod.rod_id)
+          verify_person_equality(mercedes_via_api.owner,schumaher_in_rod)
+        end
+
+        example "Mercedes drivers are retrieved properly" do
+          mercedes_in_rod = Car.find_by_brand(MERCEDES_300_NAME)
+          schumaher_in_rod = Person.find_by_name(SCHUMAHER_NAME)
+          kubica_in_rod = Person.find_by_name(KUBICA_NAME)
+          mercedes_via_api = client.find_car(mercedes_in_rod.rod_id)
+          verify_person_equality(mercedes_via_api.drivers[0],schumaher_in_rod)
+          verify_person_equality(mercedes_via_api.drivers[1],kubica_in_rod)
+        end
+      end
+    end
+  end
+end