dm-rest-adapter 0.9.11 → 0.10.0

data/{History.txt → History.rdoc}

@@ -1,8 +1,10 @@
-=== 0.9.11 / 2009-03-29
+=== 0.10.0 / 2009-10-15
+
+* Updated to work with dm-core 0.10.0
 
-* 1 major enhancement:
+=== 0.9.11 / 2009-03-29
 
-  * Updated and refactored entire adapter
+* No changes this version
 
 === 0.9.10 / 2009-01-19
 

data/Manifest.txt

@@ -1,21 +1,18 @@
-History.txt
+History.rdoc
 LICENSE
 Manifest.txt
-README.markdown
-README.txt
+README.rdoc
 Rakefile
 TODO
-config/database.rb.example
-dm-rest-adapter.gemspec
 lib/rest_adapter.rb
 lib/rest_adapter/adapter.rb
 lib/rest_adapter/connection.rb
 lib/rest_adapter/exceptions.rb
 lib/rest_adapter/formats.rb
 lib/rest_adapter/version.rb
-spec/connection_spec.rb
-spec/crud_spec.rb
-spec/ruby_forker.rb
+spec/fixtures/book.rb
+spec/semipublic/connection_spec.rb
+spec/semipublic/rest_adapter_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
 tasks/install.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rubygems'
 
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
@@ -12,9 +11,9 @@ AUTHOR = 'Scott Burton @ Joyent Inc'
 EMAIL  = 'scott.burton [a] joyent [d] com'
 GEM_NAME = 'dm-rest-adapter'
 GEM_VERSION = DataMapperRest::VERSION
-GEM_DEPENDENCIES = [['dm-core', GEM_VERSION]]
+GEM_DEPENDENCIES = [['dm-core', GEM_VERSION], ['dm-serializer', GEM_VERSION]]
 GEM_CLEAN = %w[ log pkg coverage ]
-GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.rdoc LICENSE TODO History.rdoc ] }
 
 PROJECT_NAME = 'datamapper'
 PROJECT_URL  = "http://github.com/datamapper/dm-more/tree/master/adapters/#{GEM_NAME}"

data/lib/rest_adapter.rb

@@ -1,11 +1,9 @@
-$:.push File.expand_path(File.dirname(__FILE__))
-
-require 'dm-core'
-require 'extlib'
-require 'pathname'
 require 'rexml/document'
-require 'rubygems'
+
+require 'cgi'  # for CGI.escape
+require 'addressable/uri'
 require 'dm-serializer'
+
 require 'rest_adapter/version'
 require 'rest_adapter/adapter'
 require 'rest_adapter/connection'

data/lib/rest_adapter/adapter.rb

@@ -4,288 +4,165 @@ module DataMapperRest
 
   # All http_"verb" (http_post) method calls use method missing in connection class which uses run_verb
   class Adapter < DataMapper::Adapters::AbstractAdapter
-    include Extlib
-
-    def connection
-      @connection ||= Connection.new(@uri, @format)
-    end
-
-    # Creates a new resource in the specified repository.
-    # TODO: map all remote resource attributes to this resource
     def create(resources)
-      created = 0
       resources.each do |resource|
-        response = connection.http_post(resource_name(resource), resource.to_xml)
-        populate_resource_from_xml(response.body, resource)
+        model = resource.model
 
-        created += 1
-      end
-
-      created
-    end
+        response = connection.http_post("#{resource_name(model)}", resource.to_xml)
 
-    # read_set
-    #
-    # Examples of query string:
-    # A. []
-    #    GET /books/
-    #
-    # B. [[:eql, #<Property:Book:id>, 4200]]
-    #    GET /books/4200
-    #
-    # IN PROGRESS
-    # TODO: Need to account for query.conditions (i.e., [[:eql, #<Property:Book:id>, 1]] for books/1)
-    def read_many(query)
-      resource_name = Inflection.underscore(query.model.name)
-      ::DataMapper::Collection.new(query) do |collection|
-        case query.conditions
-        when []
-          resources_meta = read_set_all(repository, query, resource_name)
-        else
-          resources_meta = read_set_for_condition(repository, query, resource_name)
-        end
-        resources_meta.each do |resource_meta|
-          if resource_meta.has_key?(:associations)
-            load_nested_resources_from resource_meta[:associations], query
-          end
-          collection.load(resource_meta[:values])
-        end
+        update_with_response(resource, response)
       end
     end
 
-    def read_one(query)
-      resource = nil
-      resource_name = resource_name_from_query(query)
-      resources_meta = nil
-      if query.conditions.empty? && query.limit == 1
-        results = read_set_all(repository, query, resource_name)
-        resource_meta = results.first unless results.empty?
-      else
-        id = query.conditions.first[2]
-        # KLUGE: Again, we're assuming below that we're dealing with a pluralized resource mapping
-
-        response = connection.http_get("#{resource_name.pluralize}/#{id}")
+    def read(query)
+      model = query.model
 
-        data = response.body
-        resource_meta = parse_resource(data, query.model, query)
-      end
-      if resource_meta
-        if resource_meta.has_key?(:associations)
-          load_nested_resources_from resource_meta[:associations], query
+      records = if id = extract_id_from_query(query)
+        response = connection.http_get("#{resource_name(model)}/#{id}")
+        [ parse_resource(response.body, model) ]
+      else
+        query_string = if (params = extract_params_from_query(query)).any?
+          params.map { |k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
         end
-        resource = query.model.load(resource_meta[:values], query)
-      end
-      resource
-    end
 
-    def update(attributes, query)
-      # TODO What if we have a compound key?
-      raise NotImplementedError.new unless is_single_resource_query? query
-      id = query.conditions.first[2]
-      resource = nil
-      query.repository.scope do
-        resource = query.model.get(id)
-      end
-      attributes.each do |attr, val|
-        resource.send("#{attr.name}=", val)
+        response = connection.http_get("#{resource_name(model)}#{'?' << query_string if query_string}")
+        parse_resources(response.body, model)
       end
-      # KLUGE: Again, we're assuming below that we're dealing with a pluralized resource mapping
-      res = connection.http_put("#{resource_name_from_query(query).pluralize}/#{id}", resource.to_xml)
-      # TODO: Raise error if cannot reach server
-      res.kind_of?(Net::HTTPSuccess) ? 1 : 0
-    end
 
-    def delete(query)
-      raise NotImplementedError.new unless is_single_resource_query? query
-      id = query.conditions.first[2]
-      res = connection.http_delete("#{resource_name_from_query(query).pluralize}/#{id}")
-      res.kind_of?(Net::HTTPSuccess) ? 1 : 0
+      query.filter_records(records)
     end
 
-  protected
+    def update(dirty_attributes, collection)
+      collection.select do |resource|
+        model = resource.model
+        key   = model.key
+        id    = key.get(resource).join
 
-    def normalize_uri(uri_or_options)
-      @format = uri_or_options[:format].nil? ? "xml" : uri_or_options[:format]
+        dirty_attributes.each { |p, v| p.set!(resource, v) }
 
-      if uri_or_options.kind_of?(String) || uri_or_options.kind_of?(Addressable::URI)
-        uri_or_options = DataObjects::URI.parse(uri_or_options)
-      end
+        response = connection.http_put("#{resource_name(model)}/#{id}", resource.to_xml)
 
-      if uri_or_options.kind_of?(DataObjects::URI)
-        return uri_or_options
-      end
-
-      query = uri_or_options.except(:adapter, :username, :password, :host, :port, :format, :login).map { |pair| pair.join('=') }.join('&')
-      query = nil if query.blank? # not sure if the query is usable
-
-      return DataObjects::URI.parse(Addressable::URI.new(
-        :scheme       => "http",
-        :adapter      => uri_or_options[:adapter].to_s,
-        :user         => uri_or_options[:login],
-        :password     => uri_or_options[:password],
-        :host         => uri_or_options[:host],
-        :port         => uri_or_options[:port]
-      ))
+        update_with_response(resource, response)
+      end.size
     end
 
-    def load_nested_resources_from(nested_resources, query)
-      nested_resources.each do |resource_meta|
-        # TODO: Houston, we have a problem.  Model#load expects a Query.  When we're nested, we don't have a query yet...
-        #resource_meta[:model].load(resource_meta[:values])
-        #if resource_meta.has_key? :associations
-        #  load_nested_resources_from resource_meta, query
-        #end
-      end
-    end
+    def delete(collection)
+      collection.select do |resource|
+        model = resource.model
+        key   = model.key
+        id    = key.get(resource).join
 
-    def read_set_all(repository, query, resource_name)
-      # TODO: how do we know whether the resource we're talking to is singular or plural?
-      res = connection.http_get("#{resource_name.pluralize}")
-      data = res.body
-      parse_resources(data, query.model, query)
-      # TODO: Raise error if cannot reach server
+        response = connection.http_delete("#{resource_name(model)}/#{id}")
+        response.kind_of?(Net::HTTPSuccess)
+      end.size
     end
 
-    #    GET /books/4200
-    def read_set_for_condition(repository, query, resource_name)
-      # More complex conditions
-      raise NotImplementedError.new
-    end
+    private
 
-    # query.conditions like [[:eql, #<Property:Book:id>, 4200]]
-    def is_single_resource_query?(query)
-      query.conditions.length == 1 && query.conditions.first.first == :eql && query.conditions.first[1].name == :id
+    def initialize(*)
+      super
+      @format = @options.fetch(:format, 'xml')
     end
 
-    def values_from_rexml(entity_element, dm_model_class)
-      resource = {}
-      resource[:values] = []
-      entity_element.elements.each do |field_element|
-        attribute = dm_model_class.properties(repository.name).find do |property|
-          property.name.to_s == field_element.name.to_s.tr('-', '_')
-        end
-        if attribute
-          resource[:values] << field_element.text
-          next
-        end
-        association = dm_model_class.relationships.find do |name, dm_relationship|
-          field_element.name.to_s == Inflection.pluralize(Inflection.underscore(dm_relationship.child_model.to_s))
-        end
-        if association
-          field_element.each_element do |associated_element|
-            model = association[1].child_model
-            (resource[:associations] ||= []) << {
-              :model => model,
-              :value => values_from_rexml(associated_element, association[1].child_model)
-            }
-          end
+    def connection
+      @connection ||= Connection.new(normalized_uri, @format)
+    end
+
+    def normalized_uri
+      @normalized_uri ||=
+        begin
+          query = @options.except(:adapter, :user, :password, :host, :port, :path, :fragment)
+          query = nil if query.empty?
+
+          Addressable::URI.new(
+            :scheme       => 'http',
+            :user         => @options[:user],
+            :password     => @options[:password],
+            :host         => @options[:host],
+            :port         => @options[:port],
+            :path         => @options[:path],
+            :query_values => query,
+            :fragment     => @options[:fragment]
+          ).freeze
         end
-      end
-      resource
     end
 
-    def parse_resource(xml, dm_model_class, query = nil)
-      doc = REXML::Document::new(xml)
-      # TODO: handle singular resource case as well....
-      entity_element = REXML::XPath.first(doc, "/#{resource_name_from_model(dm_model_class)}")
-      return nil unless entity_element
-      values_from_rexml(entity_element, dm_model_class)
-    end
+    def extract_id_from_query(query)
+      return nil unless query.limit == 1
 
-    def parse_resources(xml, dm_model_class, query = nil)
-      doc = REXML::Document::new(xml)
-      # # TODO: handle singular resource case as well....
-      # array = XPath(doc, "/*[@type='array']")
-      # if array
-      #   parse_resources()
-      # else
-      resource_name = resource_name_from_model dm_model_class
-      doc.elements.collect("#{resource_name.pluralize}/#{resource_name}") do |entity_element|
-        values_from_rexml(entity_element, dm_model_class)
-      end
-    end
+      conditions = query.conditions
 
-    def resource_name_from_model(model)
-      Inflection.underscore(model.name)
-    end
+      return nil unless conditions.kind_of?(DataMapper::Query::Conditions::AndOperation)
+      return nil unless (key_condition = conditions.select { |o| o.subject.key? }).size == 1
 
-    def resource_name(resource)
-      Inflection.underscore(resource.class.name).pluralize
+      key_condition.first.value
     end
 
-    def resource_name_from_query(query)
-      resource_name_from_model(query.model)
+    def extract_params_from_query(query)
+      conditions = query.conditions
+
+      return {} unless conditions.kind_of?(DataMapper::Query::Conditions::AndOperation)
+      return {} if conditions.any? { |o| o.subject.key? }
+
+      query.options
     end
 
-    def populate_resource_from_xml(xml, resource)
-      doc = REXML::Document::new(xml)
-      entity_element = REXML::XPath.first(doc, "/#{resource_name_from_model(resource.class)}")
-      raise "No root element matching #{resource_name_from_model(resource.class)} in xml" unless entity_element
+    def record_from_rexml(entity_element, field_to_property)
+      record = {}
 
-      entity_element.elements.each do |field_element|
-        attribute = resource.class.properties(repository.name).find { |property| property.name.to_s == field_element.name.to_s.tr('-', '_') }
-        resource.send("#{attribute.name.to_s}=", field_element.text) if attribute && !field_element.text.nil?
-        # TODO: add association saving
+      entity_element.elements.map do |element|
+        # TODO: push this to the per-property mix-in for this adapter
+        field = element.name.to_s.tr('-', '_')
+        next unless property = field_to_property[field]
+        record[field] = property.typecast(element.text)
       end
-      resource
+
+      record
     end
 
-    # TODO: this is a temporary hack to allow applications using models with dm-rest-adapter
-    # together with models using other adapters
-    module Migration
-      #
-      # Returns whether the storage_name exists.
-      #
-      # @param storage_name<String> a String defining the name of a storage,
-      #   for example a table name.
-      #
-      # @return <Boolean> true if the storage exists
-      #
-      def storage_exists?(storage_name)
-        true
-      end
+    def parse_resource(xml, model)
+      doc = REXML::Document::new(xml)
 
-      #
-      # Returns whether the field exists.
-      #
-      # @param storage_name<String> a String defining the name of a storage, for example a table name.
-      # @param field_name<String> a String defining the name of a field, for example a column name.
-      #
-      # @return <Boolean> true if the field exists.
-      #
-      def field_exists?(storage_name, field_name)
-        true
-      end
+      element_name = element_name(model)
 
-      def upgrade_model_storage(repository, model)
-        true
+      unless entity_element = REXML::XPath.first(doc, "/#{element_name}")
+        raise "No root element matching #{element_name} in xml"
       end
 
-      def create_model_storage(repository, model)
-        true
-      end
+      field_to_property = model.properties(name).map { |p| [ p.field, p ] }.to_hash
+      record_from_rexml(entity_element, field_to_property)
+    end
 
-      def destroy_model_storage(repository, model)
-        true
-      end
+    def parse_resources(xml, model)
+      doc = REXML::Document::new(xml)
 
-      def alter_model_storage(repository, *args)
-        true
-      end
+      field_to_property = model.properties(name).map { |p| [ p.field, p ] }.to_hash
+      element_name      = element_name(model)
 
-      def create_property_storage(repository, property)
-        true
+      doc.elements.collect("/#{element_name.pluralize}/#{element_name}") do |entity_element|
+        record_from_rexml(entity_element, field_to_property)
       end
+    end
 
-      def destroy_property_storage(repository, property)
-        true
-      end
+    def element_name(model)
+      Extlib::Inflection.underscore(model.name)
+    end
 
-      def alter_property_storage(repository, *args)
-        true
-      end
+    def resource_name(model)
+      Extlib::Inflection.underscore(model.name).pluralize
+    end
+
+    def update_with_response(resource, response)
+      return unless response.kind_of?(Net::HTTPSuccess) && !response.body.blank?
 
+      model      = resource.model
+      properties = model.properties(name)
+
+      parse_resource(response.body, model).each do |key, value|
+        if property = properties[key.to_sym]
+          property.set!(resource, value)
+        end
+      end
     end
-    include Migration
   end
 end