datamapper4rails 0.3.0

data/generators/datamapper_scaffold/templates/functional_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class <%= controller_class_name %>ControllerTest < ActionController::TestCase
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:<%= table_name %>)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create <%= file_name %>" do
+    assert_difference('<%= class_name %>.all.size') do
+      post :create, :<%= file_name %> => {
+<% attributes.each_with_index do |attribute, attribute_index| -%>
+      :<%= attribute.name %> => <%= attribute.default_value %><%= attribute_index == attributes.length - 1 ? '' : ','%>
+<% end -%>
+ }
+    end
+
+    assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>).key)
+  end
+
+  test "should show <%= file_name %>" do
+    get :show, :id => <%= table_name %>(:one).to_param
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, :id => <%= table_name %>(:one).to_param
+    assert_response :success
+  end
+
+  test "should update <%= file_name %>" do
+    put :update, :id => <%= table_name %>(:one).to_param, :<%= file_name %> => { }
+    assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>).key)
+  end
+
+  test "should destroy <%= file_name %>" do
+    assert_difference('<%= class_name %>.all.size', -1) do
+      delete :destroy, :id => <%= table_name %>(:one).to_param
+    end
+
+    assert_redirected_to <%= table_name %>_path
+  end
+end

data/generators/datamapper_scaffold/templates/view_edit.html.erb

@@ -0,0 +1,18 @@
+<h1>Editing <%= singular_name %></h1>
+
+<%% form_for(:<%= singular_name %>, :url => <%= singular_name %>_path(@<%= singular_name %>.key), :html => {:method => :put}) do |f| %>
+  <%%= f.error_messages %>
+
+<% for attribute in attributes -%>
+  <p>
+    <%%= f.label :<%= attribute.name %> %><br />
+    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
+  </p>
+<% end -%>
+  <p>
+    <%%= f.submit 'Update' %>
+  </p>
+<%% end %>
+
+<%%= link_to 'Show', <%= singular_name %>_path(@<%= singular_name %>.key) %> |
+<%%= link_to 'Back', <%= plural_name %>_path %>

data/generators/datamapper_scaffold/templates/view_index.html.erb

@@ -0,0 +1,24 @@
+<h1>Listing <%= plural_name %></h1>
+
+<table>
+  <tr>
+<% for attribute in attributes -%>
+    <th><%= attribute.column.human_name %></th>
+<% end -%>
+  </tr>
+
+<%% @<%= plural_name %>.each do |<%= singular_name %>| %>
+  <tr>
+<% for attribute in attributes -%>
+    <td><%%=h <%= singular_name %>.<%= attribute.name %> %></td>
+<% end -%>
+    <td><%%= link_to 'Show', <%= singular_name %>_path(<%= singular_name %>.key) %></td>
+    <td><%%= link_to 'Edit', edit_<%= singular_name %>_path(<%= singular_name %>.key) %></td>
+    <td><%%= link_to 'Destroy', <%= singular_name %>_path(<%= singular_name %>.key), :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<%% end %>
+</table>
+
+<br />
+
+<%%= link_to 'New <%= singular_name %>', new_<%= singular_name %>_path %>

data/generators/datamapper_scaffold/templates/view_new.html.erb

@@ -0,0 +1,17 @@
+<h1>New <%= singular_name %></h1>
+
+<%% form_for(@<%= singular_name %>) do |f| %>
+  <%%= f.error_messages %>
+
+<% for attribute in attributes -%>
+  <p>
+    <%%= f.label :<%= attribute.name %> %><br />
+    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
+  </p>
+<% end -%>
+  <p>
+    <%%= f.submit 'Create' %>
+  </p>
+<%% end %>
+
+<%%= link_to 'Back', <%= plural_name %>_path %>

data/generators/datamapper_scaffold/templates/view_show.html.erb

@@ -0,0 +1,10 @@
+<% for attribute in attributes -%>
+<p>
+  <b><%= attribute.column.human_name %>:</b>
+  <%%=h @<%= singular_name %>.<%= attribute.name %> %>
+</p>
+
+<% end -%>
+
+<%%= link_to 'Edit', edit_<%= singular_name %>_path(@<%= singular_name %>.key) %> |
+<%%= link_to 'Back', <%= plural_name %>_path %>

data/lib/datamapper4rails.rb

@@ -0,0 +1,14 @@
+require 'rails_datamapper'
+require 'rack-datamapper'
+require 'datamapper4rails/datamapper_store'
+
+# keep this here until rails_datamapper has it included
+module DataMapper
+  module Validate
+    class ValidationErrors
+      def count
+        size
+      end
+    end
+  end
+end

data/lib/datamapper4rails/adapters/base_adapter.rb

@@ -0,0 +1,198 @@
+require 'dm-core'
+require 'slf4r'
+
+module DataMapper
+  module Adapters
+    class NoopTransaction
+      
+      def close ; end
+      def begin ; end
+      def prepare ; end
+      def commit ; end
+      def rollback ; end
+      def rollback_prepared ; end
+      
+    end
+    class BaseAdapter < AbstractAdapter
+
+      include Slf4r::Logger
+
+      # @see AbstractAdapter
+      def transaction_primitive
+        NoopTransaction.new
+      end
+
+      def initialize(name, uri_or_options)
+        super(name, uri_or_options)
+      end
+
+      protected
+      
+      # checks whether a given resource fullfils the conditions
+      # @param [DataMapper::Resource] resource
+      # @param [Array<Condition>] conditions
+      # @return [Boolean] 
+      #   true if the resource are within the conditions otherwise false
+      def filter_resource(resource, conditions)
+        #puts "condi"
+        #p conditions
+        # no conditation => no filter
+        if conditions.size == 0
+          true
+        else
+          conditions.all? do |tuple|
+            operator, property, bind_value = *tuple
+            
+            value = property.get!(resource)
+            case operator
+            when :eql, :in then equality_comparison(bind_value, value)
+            when :not      then !equality_comparison(bind_value, value)
+            when :like     then Regexp.new(bind_value.gsub(/%/, ".*")) =~ value
+            when :gt       then !value.nil? && value >  bind_value
+            when :gte      then !value.nil? && value >= bind_value
+            when :lt       then !value.nil? && value <  bind_value
+            when :lte      then !value.nil? && value <= bind_value
+            else raise "Invalid query operator: #{operator.inspect}"
+            end
+          end
+        end
+      end
+
+      # helper method to dispatch the equality test for different
+      # classes
+      def equality_comparison(bind_value, value)
+        case bind_value
+          when Array, Range then bind_value.include?(value)
+          when NilClass     then value.nil?
+          else                   bind_value == value
+        end
+      end
+
+      public
+
+      # @see AbstractAdapter
+      # @param [Array<DataMapper::Resources>] resources
+      #   aaaa
+      # @return [Fixnum] 
+      #    number of the newly created resources
+      def create(resources)
+        resources.select do |resource|
+
+          create_resource(resource)
+
+        end.size # just return the number of create resources
+      end
+
+      # @see AbstractAdapter
+      # @param [Hash] attributes
+      #   collection of attribute, i.e. the name/value pairs which 
+      #   needs to be updated
+      # @param [Query] 
+      #   on all resources which are selected by that query the 
+      #   update will be applied
+      # @return [Fixnum] 
+      #   number of the updated resources
+      def update(attributes, query)
+        read_many(query).select do |resource|
+          
+          update_resource(resource, attributes)
+
+        end.size
+      end
+
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #    which selects the resource
+      # @return [DataMapper::Resource] 
+      #    the found Resource or nil
+      def read_one(query)
+        result = read_resource(query)
+        if result.is_a? Resource
+          result
+        elsif result # assume result to be Array with the values
+          #puts "------------------"
+          #p result
+          query.model.load(result, query)
+        end
+      end
+      
+      # @see AbstractAdapter
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [DataMapper::Collection] 
+      #   collection of Resources
+      def read_many(query)
+        Collection.new(query) do |set|
+          result = read_resources(query)
+#puts "read_many"
+#p result
+          if result.size > 0 and result.first.is_a? Resource
+            set.replace(result)
+          else
+            result.each do |values|
+              set.load(values)
+            end
+          end
+        end
+      end
+
+      # @see AbstractAdapter
+      # @param [Query] query
+      #   which selects the resources to be deleted
+      # @return [Fixnum]
+      #   number of the deleted resources
+      def delete(query)
+        read_many(query).each do |resource|
+
+          delete_resource(resource)
+
+        end.size
+      end
+      
+      private
+
+      # @param [DataMapper::Resource] resource
+      #   which will be created
+      # @return [DataMapper::Resource] 
+      #   either the resource itself if the creation was successful or nil 
+      def create_resource(resource)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resource
+      # @return [DataMapper::Resource,Array<String>] 
+      #   the resource or a set of values ordered in the same manner as query.fields attributes
+      def read_resource(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Query] query
+      #   which selects the resources
+      # @return [Array<DataMapper::Resource>,Array<String>]
+      #   resources or ordered values 
+      # @see #read_resource
+      def read_resources(query)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be updated with the given attributes.
+      # @param [Hash] attributes 
+      #    the keys are the property names and the values are the new values of that property. 
+      # @return [DataMapper::Resource] 
+      #   resource on success otherwise nil
+      def update_resource(resource, attributes)
+        raise NotImplementedError.new
+      end
+
+      # @param [DataMapper::Resource] resource
+      #   which will be deleted
+      # @return [DataMapper::Resource]
+      #   either the resource if the deletion was successful or nil 
+      def delete_resource(resource)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/datamapper4rails/adapters/restful_adapter.rb

@@ -0,0 +1,320 @@
+require 'datamapper4rails/adapters/base_adapter'
+require 'net/http'
+require 'extlib/inflection'
+require 'extlib/module'
+require 'dm-serializer'
+
+module DataMapper
+  module Adapters
+    class RestfulAdapter < BaseAdapter
+
+      include ::Slf4r::Logger
+
+      def resource_name_from_model(model)
+        ::Extlib::Inflection.underscore(model.name)
+      end
+
+      def resource_name_from_query(query)
+        resource_name_from_model(query.model)
+      end
+
+      def keys_from_query(query)
+        keys = query.model.key
+        # work around strange missing of properties in model
+        # but the query has still the fields :P
+        if keys.size == 0
+          query.fields.select do |f|
+            f.key?
+          end
+        else
+          keys
+        end
+      end
+
+      def key_value_from_query(query)
+        keys = keys_from_query(query)
+        logger.debug { "keys=#{keys.inspect}" }
+        if keys.size == 1
+          key = keys[0]
+          # return the third element of the condition array
+          # which belongs to the key
+          query.conditions.detect do |c|
+            c[1] == key
+          end[2]
+        else
+          raise "compound keys are not supported"
+        end
+      end
+      
+      def single_entity_query?(query)
+        query.conditions.count {|c| c[1].key? and c[0] == :eql} == query.model.key.size
+      end
+
+      def attributes_to_xml(name, attributes)
+        xml = "<#{name}>"
+        attributes.each do |attr, val|
+          xml += "<#{attr.name}>#{val}</#{attr.name}>"
+        end
+        xml += "</#{name}>"
+      end
+
+      def http_get(uri)
+        send_request do |http|
+          request = Net::HTTP::Get.new(uri)
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request)
+        end
+      end
+
+      def http_post(uri, data = nil)
+        send_request do |http|
+          request = Net::HTTP::Post.new(uri, {
+                                          'content-type' => 'application/xml',
+                                          'content-length' => data.length.to_s
+                                        })
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request, data)
+        end
+      end
+
+      def http_put(uri, data = nil)
+        send_request do |http|
+          request = Net::HTTP::Put.new(uri, {
+                                          'content-type' => 'application/xml',
+                                          'content-length' => data.length.to_s
+                                        })
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+#          request.set_form_data(data)
+          http.request(request, data)
+        end
+      end
+
+      def http_delete(uri)
+        send_request do |http|
+          request = Net::HTTP::Delete.new(uri)
+          request.basic_auth(@uri[:login], 
+                             @uri[:password]) unless @uri[:login].blank?
+          http.request(request)
+        end
+      end
+
+      def send_request(&block)
+        res = nil
+        Net::HTTP.start(@uri[:host], @uri[:port].to_i) do |http|
+          res = yield(http)
+        end
+        logger.debug { "response=" + res.code }
+        res
+      end
+
+      def parse_resource(xml, model, query = nil)
+        elements = {}
+        associations = {}
+        many_to_many = {}
+        xml.elements.collect do |element|
+          if element.text.nil? 
+            if element.attributes['type'] == 'array'
+              many_to_many[element.name.gsub('-','_').to_sym] = element
+            else
+              associations[element.name.gsub('-','_').to_sym] = element
+            end
+          else
+            elements[element.name.gsub('-','_').to_sym] = element.text
+          end
+        end
+#puts
+#puts "elements"
+#p elements
+#p query
+#p model.properties
+        props = model.properties.length == 0 ? query.fields : model.properties
+#p props
+        resource = model.load(props.collect do |f| #model.properties.collect do |f|
+                                  elements[f.name]
+                                end, query)
+#p resource
+#p query
+        resource.send("#{keys_from_query(query)[0].name}=".to_sym, elements[keys_from_query(query)[0].name] )
+#p resource
+#p associations
+        associations.each do |name, association| 
+#          puts "asso"
+#          p model
+#          p name
+#          p association
+#p model.relationships
+          is_one_to_one = false
+          asso_model = 
+            if rel = model.relationships[name]
+#puts "rel"
+#p rel
+              if rel.child_model == model
+                rel.parent_model
+              else
+                rel.child_model
+              end
+              #                  else
+#::Extlib::Inflection.constantize(::Extlib::Inflection.classify(name))
+#                    model.find_const(::Extlib::Inflection.classify(name))
+            end
+  #        p asso_model
+          if resource.respond_to? "#{name}=".to_sym
+           #  puts
+#             puts "association"
+#             puts name
+#             p model
+#             p asso_model
+            resource.send("#{name}=".to_sym, 
+                          parse_resource(association, asso_model,
+                                         ::DataMapper::Query.new(query.repository, asso_model ))) unless asso_model.nil?
+          else
+            resource.send("#{name.to_s.pluralize}".to_sym).send(:<<, 
+                          parse_resource(association, asso_model,
+                                         ::DataMapper::Query.new(query.repository, asso_model ))) unless asso_model.nil?
+          end
+        end
+
+#puts "many 2 many"
+#p many_to_many
+        many_to_many.each do |name, many|
+          if model.relationships[name]
+            # TODO
+            puts "TODO"
+          else
+ #           p ::Extlib::Inflection.classify(name.to_s.singularize)
+            many_model = Object.const_get(::Extlib::Inflection.classify(name.to_s.singularize))
+#p resource
+#p many_model
+#puts "many"
+#p(parse_resource(many, many_model,
+#                                      ::DataMapper::Query.new(query.repository, many_model ))) unless many_model.nil?
+            set = resource.send(name)
+ #           p set
+            many.elements.each do |element|
+              set << parse_resource(element, many_model,
+                                    ::DataMapper::Query.new(query.repository, many_model ))
+            end unless many_model.nil?
+  #          p set
+          end
+        end
+        resource.instance_variable_set(:@new_record, false)
+#p resource
+        resource
+      end
+
+      # @see BaseAdapter
+      def create_resource(resource)
+        name = resource.model.name
+        uri = "/#{name.pluralize}.xml"
+        logger.debug { "post #{uri}" }
+        response = http_post(uri, resource.to_xml )
+        logger.debug { response.body.to_s }
+        resource_new = parse_resource(REXML::Document::new(response.body).root, 
+                                  resource.model,
+                                  ::DataMapper::Query.new(resource.repository, 
+                                                          resource.model ))
+
+        # copy all attributes/associations from the downloaded resource
+        # to the given resource
+        # TODO better pass the given resource into parse_resource
+        resource_new.attributes.each do |key, value|
+          resource.send(:properties)[key].set!(resource, value)
+        end
+        resource_new.send(:relationships).each do |key, value|
+          resource.send("#{key}=".to_sym, resource_new.send(key))
+        end
+        resource_new
+      end
+
+      # @see BaseAdapter
+      def read_resource(query)
+        key = key_value_from_query(query)
+        uri = "/#{resource_name_from_query(query).pluralize}/#{key}.xml"
+        logger.debug { "get #{uri}" }
+        response = http_get(uri)
+        if response.kind_of?(Net::HTTPSuccess)
+          logger.debug { response.body.to_s }
+          parse_resource(REXML::Document::new(response.body).root, 
+                         query.model, 
+                         query)
+        else
+            #TODO may act on different response codes differently
+        end
+      end
+
+      # @see BaseAdapter
+      def read_resources(query)
+        if single_entity_query?(query)
+          [read_resource(query)]
+        else
+          uri = "/#{resource_name_from_query(query).pluralize}.xml"
+          logger.debug { "get #{uri}" }
+          response = http_get(uri)
+          if response.kind_of?(Net::HTTPSuccess)
+            result = []
+            logger.debug { response.body.to_s }
+            REXML::Document::new(response.body).root.each do |element|
+              result << parse_resource(element, 
+                                       query.model, 
+                                       query)
+            end
+            result
+          else
+            #TODO may act on different response codes differently
+          end
+        end
+      end
+
+      # @overwrite BaseAdapter
+      def update(attributes, query)
+        if query.limit == 1 or single_entity_query?(query)
+          xml = attributes_to_xml(resource_name_from_query(query), attributes)
+          key = key_value_from_query(query)
+          uri = "/#{resource_name_from_query(query).pluralize}/#{key}.xml"
+          logger.debug { "put #{uri}" }
+          response = http_put(uri, xml)
+          response.kind_of?(Net::HTTPSuccess)
+        else
+          super
+        end
+      end
+
+      # @see BaseAdapter
+      def update_resource(resource, attributes)
+        query = resource.to_query
+        xml = attributes_to_xml(resource.name, attributes)
+        key = key_value_from_query(query)
+        logger.debug {resource.to_xml}
+        response = http_put("/#{resource_name_from_query(query).pluralize}/#{key}.xml", xml)
+        response.kind_of?(Net::HTTPSuccess)
+      end
+      
+      # @overwrite BaseAdapter
+      def delete(query)
+        if query.limit == 1 or single_entity_query?(query)
+          name = resource_name_from_query(query)
+          key = key_value_from_query(query)
+          uri = "/#{name.pluralize}/#{key}.xml"
+          logger.debug { "delete #{uri}" }
+          response = http_delete(uri)
+          response.kind_of?(Net::HTTPSuccess) 
+        else
+          super
+        end
+      end
+
+      # @see BaseAdapter
+      def delete_resource(resource)
+        name = resource.name
+        key = key_value_from_query(resource.to_query)
+        uri = "/#{name.pluralize}/#{key}.xml"
+        logger.debug { "delete #{uri}" }
+        response = http_delete(uri)
+        response.kind_of?(Net::HTTPSuccess) 
+      end
+    end
+  end
+end