rod-rest 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+.bundle

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format doc

data/.ruby-version

@@ -0,0 +1 @@
+1.9.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+gemspec
+
+gem 'rod', :git => 'git://github.com/apohllo/rod.git', :tag => 'v0.7.2.4'

data/Gemfile.lock

@@ -0,0 +1,69 @@
+GIT
+  remote: git://github.com/apohllo/rod.git
+  revision: 35949856fa6e54980b59c9d1317f99fb2cee71c9
+  tag: v0.7.2.4
+  specs:
+    rod (0.7.2.4)
+      RubyInline (>= 3.10.0, < 4.0.0)
+      activemodel (~> 3.2.2)
+      bsearch (>= 1.5.0, < 1.6.0)
+      english (>= 0.5.0, < 0.6.0)
+
+PATH
+  remote: .
+  specs:
+    rod-rest (0.0.1)
+      faraday
+      rod
+      sinatra
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    RubyInline (3.12.2)
+      ZenTest (~> 4.3)
+    ZenTest (4.9.5)
+    activemodel (3.2.17)
+      activesupport (= 3.2.17)
+      builder (~> 3.0.0)
+    activesupport (3.2.17)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    bsearch (1.5.0)
+    builder (3.0.4)
+    diff-lcs (1.2.4)
+    english (0.5.0)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    i18n (0.6.9)
+    multi_json (1.8.4)
+    multipart-post (2.0.0)
+    rack (1.5.2)
+    rack-protection (1.5.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rr (1.1.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    sinatra (1.4.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rack-test
+  rod!
+  rod-rest!
+  rr
+  rspec

data/Rakefile

@@ -0,0 +1,21 @@
+task :default => ["test:spec", "test:int"]
+
+namespace :test do
+  desc "Specs"
+  task :spec do
+    sh "rspec test/spec/api.rb"
+    sh "rspec test/spec/client.rb"
+    sh "rspec test/spec/proxy.rb"
+    sh "rspec test/spec/collection_proxy.rb"
+    sh "rspec test/spec/json_serializer.rb"
+    sh "rspec test/spec/metadata.rb"
+    sh "rspec test/spec/resource_metadata.rb"
+    sh "rspec test/spec/property_metadata.rb"
+    sh "rspec test/spec/proxy_factory.rb"
+  end
+
+  desc "Integration tests" 
+  task :int do
+    sh "rspec test/int/end_to_end.rb"
+  end
+end

data/Readme.md

@@ -0,0 +1,3 @@
+# rod-rest
+
+REST API for [Ruby Object Database](https://github.com/apohllo/rod)

data/lib/rod/rest.rb

@@ -0,0 +1,14 @@
+require 'faraday'
+
+require 'rod/rest/naming'
+require 'rod/rest/api'
+require 'rod/rest/client'
+require 'rod/rest/proxy'
+require 'rod/rest/collection_proxy'
+require 'rod/rest/constants'
+require 'rod/rest/exception'
+require 'rod/rest/json_serializer'
+require 'rod/rest/metadata'
+require 'rod/rest/property_metadata'
+require 'rod/rest/resource_metadata'
+require 'rod/rest/proxy_factory'

data/lib/rod/rest/api.rb

@@ -0,0 +1,100 @@
+require 'sinatra/base'
+require 'rod/rest/naming'
+
+module Rod
+  module Rest
+    class API < Sinatra::Base
+      class << self
+        include Naming
+
+        # Build API for a given +resource+.
+        # Options:
+        # * +:resource_name+ - the name of the resource (resource.name by default)
+        # * +:serializer+ - the serializer used to serialize the ROD objects
+        #   (instance of JsonSerializer by default)
+        def build_api_for(resource,options={})
+          serializer = options[:serializer] || JsonSerializer.new
+          resource_name = options[:resource_name] || plural_resource_name(resource)
+          get "/#{resource_name}" do
+            if params.empty?
+              serializer.serialize({count: resource.count})
+            elsif params.size == 1
+              name, value = params.first
+              if resource.respond_to?("find_all_by_#{name}")
+                serializer.serialize(resource.send("find_all_by_#{name}",value))
+              else
+                status 404
+                serializer.serialize(nil)
+              end
+            else
+              status 404
+              serializer.serialize(nil)
+            end
+          end
+
+          get "/#{resource_name}/:id" do
+            object = resource.find_by_rod_id(params[:id].to_i)
+            if object
+              serializer.serialize(object)
+            else
+              status 404
+              serializer.serialize(nil)
+            end
+          end
+
+          resource.plural_associations.each do |property|
+            get "/#{resource_name}/:id/#{property.name}" do
+              object = resource.find_by_rod_id(params[:id].to_i)
+              if object
+                serializer.serialize({count: object.send("#{property.name}_count") })
+              else
+                status 404
+                serializer.serialize(nil)
+              end
+            end
+
+            get "/#{resource_name}/:id/#{property.name}/:index" do
+              object = resource.find_by_rod_id(params[:id].to_i)
+              if object
+                related_object = object.send(property.name)[params[:index].to_i]
+                if related_object
+                  serializer.serialize(related_object)
+                else
+                  status 404
+                  serializer.serialize(nil)
+                end
+              else
+                status 404
+                serializer.serialize(nil)
+              end
+            end
+          end
+        end
+
+        # Build metadata API for the given +metadata+.
+        # Options:
+        # * +:serializer+ - the serializer used to serialize the ROD objects
+        def build_metadata_api(metadata,options={})
+          serializer = options[:serializer] || JSON
+          get "/metadata" do
+            serializer.dump(metadata)
+          end
+        end
+
+        # Start the API for the +database+.
+        # Options:
+        # * +resource_serializer+ - serializer used for resources
+        # * +metadata_serializer+ - serializer used for metadata
+        # +web_options+ are passed to Sinatra run! method.
+        def start_with_database(database,options={},web_options={})
+          build_metadata_api(database.metadata,serializer: options[:metadata_serializer])
+          database.send(:classes).each do |resource|
+            next if database.special_class?(resource)
+            build_api_for(resource,serializer: options[:resource_serializer])
+          end
+          run!(web_options)
+        end
+      end
+    end
+  end
+end

data/lib/rod/rest/client.rb

@@ -0,0 +1,215 @@
+require 'active_model/naming'
+
+require 'rod/rest/exception'
+require 'rod/rest/naming'
+
+module Rod
+  module Rest
+    class Client
+      include Naming
+
+      # Options:
+      # * http_client - library used to talk via HTTP (e.g. Faraday)
+      # * parser - parser used to parse the incoming data (JSON by default)
+      # * factory - factory class used to build the proxy objects
+      # * url_encoder - encoder used to encode URL strings (CGI by default)
+      # * metadata - metadata describing the remote database (optional - it is
+      #   retrieved via the API if not given; in that case metadata_factory must
+      #   be provided).
+      # * metadata_factory - factory used to build the metadata (used only if
+      #   metadata was not provided).
+      def initialize(options={})
+        @web_client = options.fetch(:http_client)
+        @parser = options[:parser] || JSON
+        @proxy_factory_class = options[:factory] || ProxyFactory
+        @url_encoder = options[:url_encoder] || CGI
+
+        @metadata = options[:metadata]
+        if @metadata
+          configure_with_metadata(@metadata)
+        else
+          @metadata_factory = options[:metadata_factory] || Metadata
+        end
+      end
+
+      # Returns the Database metadata.
+      def metadata
+        return @metadata unless @metadata.nil?
+        @metadata = fetch_metadata
+        configure_with_metadata(@metadata)
+        @metadata
+      end
+
+      # Fetch the object from the remote API. The method requires the stub of
+      # the object to be proviede, i.e. a hash containing its +rod_id+ and
+      # +type+, e.g. {rod_id: 1, type: "Car"}.
+      def fetch_object(object_stub)
+        check_stub(object_stub)
+        check_method(object_stub)
+        __send__(primary_finder_method_name(object_stub[:type]),object_stub[:rod_id])
+      end
+
+      # Fetch object related via the association to the +subject+.
+      # The association name is +association_name+ and the object returned is
+      # the +index+-th element in the collection.
+      def fetch_related_object(subject,association_name,index)
+        check_subject_and_association(subject,association_name)
+        __send__(association_method_name(subject.type,association_name),subject.rod_id,index)
+      end
+
+      # Overrided in order to fetch the metadata when it was not provided in the
+      # constructor.
+      def method_missing(*args)
+        unless @metadata.nil?
+          super
+        end
+        @metadata = fetch_metadata
+        configure_with_metadata(@metadata)
+        self.send(*args)
+      end
+
+      private
+      def fetch_metadata
+        response = @web_client.get(metadata_path())
+        if response.status != 200
+          raise APIError.new(no_metadata_error())
+        end
+        @metadata = @metadata_factory.new(description: response.body)
+      end
+
+      def configure_with_metadata(metadata)
+        define_counters(metadata)
+        define_finders(metadata)
+        define_relations(metadata)
+        @factory = @proxy_factory_class.new(metadata.resources,self)
+      end
+
+      def define_counters(metadata)
+        metadata.resources.each do |resource|
+          self.define_singleton_method("#{plural_resource_name(resource)}_count") do
+            get_parsed_response(resource_path(resource))[:count]
+          end
+          resource.plural_associations.each do |association|
+            self.define_singleton_method(association_count_method_name(resource,association.name)) do |id|
+              get_parsed_response(association_count_path(resource,id,association.name))[:count]
+            end
+          end
+        end
+      end
+
+      def define_finders(metadata)
+        metadata.resources.each do |resource|
+          self.define_singleton_method(primary_finder_method_name(resource)) do |id|
+            @factory.build(get_parsed_response(primary_resource_finder_path(resource,id)))
+          end
+          resource.indexed_properties.each do |property|
+            self.define_singleton_method(finder_method_name(resource,property.name)) do |value|
+              get_parsed_response(resource_finder_path(resource,property.name,value)).map{|hash| @factory.build(hash) }
+            end
+          end
+        end
+      end
+
+      def define_relations(metadata)
+        metadata.resources.each do |resource|
+          resource.plural_associations.each do |association|
+            self.define_singleton_method(association_method_name(resource,association.name)) do |id,index|
+              @factory.build(get_parsed_response(association_path(resource,association.name,id,index)))
+            end
+          end
+        end
+      end
+
+      def get_parsed_response(path)
+        result = @web_client.get(path)
+        check_status(result,path)
+        @parser.parse(result.body,symbolize_names: true)
+      end
+
+      def check_status(response,path)
+        case response.status
+        when 200
+          return
+        when 404
+          raise MissingResource.new(path)
+        else
+          raise APIError.new(path)
+        end
+      end
+
+      def check_stub(object_stub)
+        unless object_stub.has_key?(:rod_id) && object_stub.has_key?(:type)
+          raise APIError.new(invalid_stub_error(object_stub))
+        end
+      end
+
+      def check_method(object_stub)
+        unless self.respond_to?(primary_finder_method_name(object_stub[:type]))
+          raise APIError.new(invalid_method_error(primary_finder_method_name(object_stub[:type])))
+        end
+      end
+
+      def check_subject_and_association(subject,association_name)
+        unless self.respond_to?(association_method_name(subject.type,association_name))
+          raise APIError.new(invalid_method_error(association_method_name(subject.type,association_name)))
+        end
+      end
+
+      def resource_path(resource)
+        "/#{plural_resource_name(resource)}"
+      end
+
+      def primary_resource_finder_path(resource,id)
+        "/#{plural_resource_name(resource)}/#{id}"
+      end
+
+      def resource_finder_path(resource,property_name,value)
+        "/#{plural_resource_name(resource)}#{finder_query(property_name,value)}"
+      end
+
+      def association_count_path(resource,id,association_name)
+        "/#{plural_resource_name(resource)}/#{id}/#{association_name}"
+      end
+
+      def association_path(resource,association_name,id,index)
+        "/#{plural_resource_name(resource)}/#{id}/#{association_name}/#{index}"
+      end
+
+      def metadata_path
+        "/metadata"
+      end
+
+      def primary_finder_method_name(resource)
+        "find_#{singular_resource_name(resource)}"
+      end
+
+      def finder_method_name(resource,property_name)
+        "find_#{plural_resource_name(resource)}_by_#{property_name}"
+      end
+
+      def association_count_method_name(resource,association_name)
+        "#{singular_resource_name(resource)}_#{association_name}_count"
+      end
+
+      def association_method_name(resource,association_name)
+        "#{singular_resource_name(resource)}_#{association_name.to_s.singularize}"
+      end
+
+      def finder_query(property_name,value)
+        "?#{@url_encoder.escape(property_name)}=#{@url_encoder.escape(value)}"
+      end
+
+      def invalid_stub_error(object_stub)
+        "The object stub is invalid: #{object_stub}"
+      end
+
+      def invalid_method_error(plural_name)
+        "The API doesn't have the method '#{plural_name}'"
+      end
+
+      def no_metadata_error
+        "The API doesn't provide metadata."
+      end
+    end
+  end
+end

data/lib/rod/rest/collection_proxy.rb

@@ -0,0 +1,52 @@
+require 'rod/rest/exception'
+
+module Rod
+  module Rest
+    class CollectionProxy
+      include Enumerable
+      attr_reader :size
+
+      # Initializes a CollectionPorxy.
+      # * +:proxy+ - the object this collection belongs to
+      # * +:association_name+ - the name of proxie's plural association this collection is returned for
+      # * +:size+ - the size of the collection
+      # * +:client+ - the REST API client
+      def initialize(proxy,association_name,size,client)
+        @proxy = proxy
+        @association_name = association_name
+        @size = size
+        @client = client
+      end
+
+      # Returns true if the collection is empty (i.e. its size == 0).
+      def empty?
+        self.size == 0
+      end
+
+      # Returns the index-th element of the collection.
+      def [](index)
+        begin
+          @client.fetch_related_object(@proxy,@association_name,index)
+        rescue MissingResource
+          nil
+        end
+      end
+
+      # Returns the last element of the collection.
+      def last
+        size > 0 ? self[size - 1] : nil
+      end
+
+      # Iterates over the elements of the collection.
+      def each
+        if block_given?
+          @size.times do |index|
+            yield self[index]
+          end
+        else
+          enum_for(:each)
+        end
+      end
+    end
+  end
+end