architect4r 0.4.3 → 0.4.3.1

data/ReleaseNotes.md

@@ -1,5 +1,10 @@
 # Release Notes
 
+## v0.4.3.1
+
+* Update ActiveSupport::Concern usage by removing InstanceMethods modules
+
+
 ## v0.4.3
 
 * Allow retrieving multiple nodes with a single call to ```Node#find(id, id2, id3)```

data/lib/architect4r/core/cypher_methods.rb

@@ -3,106 +3,104 @@ module Architect4r
     module CypherMethods
       extend ActiveSupport::Concern
       
-      module InstanceMethods
         
-        def execute_cypher(query)
-          query = self.interpolate_node_model_root_references(query)
-          
-          Architect4r.logger.debug("[Architect4r][execute_cypher] QUERY: #{query}")
-          
-          url = prepend_base_url("/cypher")
-          response = Typhoeus::Request.post(url, 
-            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
-            :body => { 'query' => query }.to_json)
-          
-          msg = JSON.parse(response.body)
-          
-          Architect4r.logger.debug("[Architect4r][execute_cypher] CODE: #{response.code} => #{msg.inspect}")
-          
-          # Check if there might be an error with the query
-          if response.code == 400
-            if msg['exception'].to_s.match /org.neo4j.graphdb.NotFoundException/
-              nil
-            else
-              raise Architect4r::InvalidCypherQuery.new(query)
-            end
-          elsif response.code == 500
-            raise Architect4r::InvalidCypherQuery.new(query)
-          elsif response.code == 204
+      def execute_cypher(query)
+        query = self.interpolate_node_model_root_references(query)
+        
+        Architect4r.logger.debug("[Architect4r][execute_cypher] QUERY: #{query}")
+        
+        url = prepend_base_url("/cypher")
+        response = Typhoeus::Request.post(url, 
+          :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          :body => { 'query' => query }.to_json)
+        
+        msg = JSON.parse(response.body)
+        
+        Architect4r.logger.debug("[Architect4r][execute_cypher] CODE: #{response.code} => #{msg.inspect}")
+        
+        # Check if there might be an error with the query
+        if response.code == 400
+          if msg['exception'].to_s.match /org.neo4j.graphdb.NotFoundException/
             nil
           else
-            msg
+            raise Architect4r::InvalidCypherQuery.new(query)
           end
+        elsif response.code == 500
+          raise Architect4r::InvalidCypherQuery.new(query)
+        elsif response.code == 204
+          nil
+        else
+          msg
         end
+      end
+      
+      def cypher_query(query, transform=true)
+        # Get data from server
+        data = execute_cypher(query)
         
-        def cypher_query(query, transform=true)
-          # Get data from server
-          data = execute_cypher(query)
-          
-          Architect4r.logger.debug("[Architect4r][cypher_query] #{data.inspect}")
-          
-          # Create native ruby objects
-          data['data'].map! do |set|
-            set.map { |item| convert_if_possible(item) }
-          end
-          
-          # Transform to hash form
-          if transform
-            transform_cypher_result_to_hash(data)
-          else
-            data
-          end
+        Architect4r.logger.debug("[Architect4r][cypher_query] #{data.inspect}")
+        
+        # Create native ruby objects
+        data['data'].map! do |set|
+          set.map { |item| convert_if_possible(item) }
         end
         
-        # Convert the columnized result array to a hashes within an array
-        #
-        # The input would look like:
-        #
-        # { 'data' => [['r1', 'n1'], ['r2', 'n2'], …], 'columns' => ['rel', 'node']}
-        # 
-        # And it would be transformed to:
-        # [ { 'rel' => 'r1', 'node' => 'n1' }, { 'rel' => 'r2', 'node' => 'n2' } ]
-        #
-        def transform_cypher_result_to_hash(input)
-          results = []
-          input['data'].each_with_index do |row, ri|
-            result_row = {}
-            input['columns'].each_with_index do |column, ci|
-              result_row[column] = row[ci]
-            end
-            results << result_row
+        # Transform to hash form
+        if transform
+          transform_cypher_result_to_hash(data)
+        else
+          data
+        end
+      end
+      
+      # Convert the columnized result array to a hashes within an array
+      #
+      # The input would look like:
+      #
+      # { 'data' => [['r1', 'n1'], ['r2', 'n2'], …], 'columns' => ['rel', 'node']}
+      # 
+      # And it would be transformed to:
+      # [ { 'rel' => 'r1', 'node' => 'n1' }, { 'rel' => 'r2', 'node' => 'n2' } ]
+      #
+      def transform_cypher_result_to_hash(input)
+        results = []
+        input['data'].each_with_index do |row, ri|
+          result_row = {}
+          input['columns'].each_with_index do |column, ci|
+            result_row[column] = row[ci]
           end
-          results
+          results << result_row
         end
-        
-        # Parses a cypher query and replaces all placeholders for model roots 
-        # with the neo4j ids. It should make development faster, as you can 
-        # skip manual id retrieval:
-        #
-        # So instead of writing:
-        #
-        #     "start s=node(#{Person.model_root.id}) match s-->d return d"
-        # 
-        # you can write:
-        # 
-        #     "start s=node(:person_root) match s-->d return d"
-        #
-        def interpolate_node_model_root_references(query)
-          query.scan(/node\((:[^)]*_root)\)/i).flatten.uniq.each do |str|
-            model_name = str.match(/^:(.*)_root$/)[1].to_s.classify
-            if model_name.length > 0
-              # As const_defined? and const_get to not support namespaces, we have to use eval :(
-              begin
-                query.gsub!(str, eval("#{model_name}.model_root.id.to_s"))
-              rescue NoMethodError => ex
-                nil
-              end
+        results
+      end
+      
+      # Parses a cypher query and replaces all placeholders for model roots 
+      # with the neo4j ids. It should make development faster, as you can 
+      # skip manual id retrieval:
+      #
+      # So instead of writing:
+      #
+      #     "start s=node(#{Person.model_root.id}) match s-->d return d"
+      # 
+      # you can write:
+      # 
+      #     "start s=node(:person_root) match s-->d return d"
+      #
+      def interpolate_node_model_root_references(query)
+        query.scan(/node\((:[^)]*_root)\)/i).flatten.uniq.each do |str|
+          model_name = str.match(/^:(.*)_root$/)[1].to_s.classify
+          if model_name.length > 0
+            # As const_defined? and const_get to not support namespaces, we have to use eval :(
+            begin
+              query.gsub!(str, eval("#{model_name}.model_root.id.to_s"))
+            rescue NoMethodError => ex
+              nil
             end
           end
-          query
         end
-        
+        query
       end
+      
     end
   end
 end

data/lib/architect4r/core/node_methods.rb

@@ -3,75 +3,73 @@ module Architect4r
     module NodeMethods
       extend ActiveSupport::Concern
       
-      module InstanceMethods
+      def create_node(properties)
+        # Send request
+        response = Typhoeus::Request.post(prepend_base_url('/node'), 
+          :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          :body => properties.to_json)
         
-        def create_node(properties)
-          # Send request
-          response = Typhoeus::Request.post(prepend_base_url('/node'), 
-            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
-            :body => properties.to_json)
-          
-          # Evaluate response
-          response.code == 201 ? JSON.parse(response.body) : nil
-        end
+        # Evaluate response
+        response.code == 201 ? JSON.parse(response.body) : nil
+      end
+      
+      def get_node(id)
+        # Example response for a node
+        # extensions: {}
+        # 
+        # paged_traverse: http://localhost:7475/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}
+        # self: http://localhost:7475/db/data/node/0
+        # property: http://localhost:7475/db/data/node/0/properties/{key}
+        # data: {}
+        # 
+        # incoming_typed_relationships: http://localhost:7475/db/data/node/0/relationships/in/{-list|&|types}
+        # outgoing_typed_relationships: http://localhost:7475/db/data/node/0/relationships/out/{-list|&|types}
+        # incoming_relationships: http://localhost:7475/db/data/node/0/relationships/in
+        # all_relationships: http://localhost:7475/db/data/node/0/relationships/all
+        # create_relationship: http://localhost:7475/db/data/node/0/relationships
+        # traverse: http://localhost:7475/db/data/node/0/traverse/{returnType}
+        # properties: http://localhost:7475/db/data/node/0/properties
+        # all_typed_relationships: http://localhost:7475/db/data/node/0/relationships/all/{-list|&|types}
+        # outgoing_relationships: http://localhost:7475/db/data/node/0/relationships/out
         
-        def get_node(id)
-          # Example response for a node
-          # extensions: {}
-          # 
-          # paged_traverse: http://localhost:7475/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}
-          # self: http://localhost:7475/db/data/node/0
-          # property: http://localhost:7475/db/data/node/0/properties/{key}
-          # data: {}
-          # 
-          # incoming_typed_relationships: http://localhost:7475/db/data/node/0/relationships/in/{-list|&|types}
-          # outgoing_typed_relationships: http://localhost:7475/db/data/node/0/relationships/out/{-list|&|types}
-          # incoming_relationships: http://localhost:7475/db/data/node/0/relationships/in
-          # all_relationships: http://localhost:7475/db/data/node/0/relationships/all
-          # create_relationship: http://localhost:7475/db/data/node/0/relationships
-          # traverse: http://localhost:7475/db/data/node/0/traverse/{returnType}
-          # properties: http://localhost:7475/db/data/node/0/properties
-          # all_typed_relationships: http://localhost:7475/db/data/node/0/relationships/all/{-list|&|types}
-          # outgoing_relationships: http://localhost:7475/db/data/node/0/relationships/out
-          
-          # Handle cases where id might be a url
-          
-          response = Typhoeus::Request.get(node_url(id), :headers => { 'Accept' => 'application/json' })
-          response.code == 200 ? JSON.parse(response.body) : nil
-        end
+        # Handle cases where id might be a url
+        
+        response = Typhoeus::Request.get(node_url(id), :headers => { 'Accept' => 'application/json' })
+        response.code == 200 ? JSON.parse(response.body) : nil
+      end
 
-        def update_node(id, properties)
-          # Handle urls
-          url = id.to_i == 0 ? id : node_url(id)
+      def update_node(id, properties)
+        # Handle urls
+        url = id.to_i == 0 ? id : node_url(id)
 
-          # Append the properties
-          url += "/properties"
+        # Append the properties
+        url += "/properties"
 
-          response = Typhoeus::Request.put(url, 
-            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
-            :body => properties.to_json)
-          response.code == 204 ? true : false
-        end
-        
-        def delete_node(id)
-          # Delete all relationships
-          get_node_relationships(id, :all).each do |rel|
-            delete_relationship(rel)
-          end
-          
-          # Delete node itself
-          response = Typhoeus::Request.delete(node_url(id), :headers => { 'Accept' => 'application/json' })
-          response.code == 204 ? true : false
-        end
-        
-        def root
-          get_node(get('/')['reference_node'])
+        response = Typhoeus::Request.put(url, 
+          :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          :body => properties.to_json)
+        response.code == 204 ? true : false
+      end
+      
+      def delete_node(id)
+        # Delete all relationships
+        get_node_relationships(id, :all).each do |rel|
+          delete_relationship(rel)
         end
         
-        def node_id(input)
-          node_url(input).match(/node\/(\d+)$/i)[1].to_i
-        end
+        # Delete node itself
+        response = Typhoeus::Request.delete(node_url(id), :headers => { 'Accept' => 'application/json' })
+        response.code == 204 ? true : false
       end
+      
+      def root
+        get_node(get('/')['reference_node'])
+      end
+      
+      def node_id(input)
+        node_url(input).match(/node\/(\d+)$/i)[1].to_i
+      end
+      
     end
   end
 end

data/lib/architect4r/core/relationship_methods.rb

@@ -3,80 +3,77 @@ module Architect4r
     module RelationshipMethods
       extend ActiveSupport::Concern
       
-      module InstanceMethods
+      def create_relationship(start_node, end_node, type, properties={})
+        # POST http://localhost:7474/db/data/node/3/relationships
+        # {"to" : "http://localhost:7474/db/data/node/4", "type" : "LOVES"}
+        # 201: Created
+        # Location: http://localhost:7474/db/data/relationship/2
         
-        def create_relationship(start_node, end_node, type, properties={})
-          # POST http://localhost:7474/db/data/node/3/relationships
-          # {"to" : "http://localhost:7474/db/data/node/4", "type" : "LOVES"}
-          # 201: Created
-          # Location: http://localhost:7474/db/data/relationship/2
-          
-          # Add the destination node and type to the properties
-          properties = { 'to' => node_url(end_node), 'type' => type.to_s, 'data' => properties }
-          
-          # Send request
-          response = Typhoeus::Request.post(node_url(start_node) + "/relationships", 
-            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
-            :body => properties.to_json)
-          
-          # Evaluate response
-          response.code == 201 ? JSON.parse(response.body) : nil
-        end
+        # Add the destination node and type to the properties
+        properties = { 'to' => node_url(end_node), 'type' => type.to_s, 'data' => properties }
         
-        def get_relationship(relationship)
-          response = Typhoeus::Request.get(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
-          response.code == 200 ? JSON.parse(response.body) : nil
-        end
+        # Send request
+        response = Typhoeus::Request.post(node_url(start_node) + "/relationships", 
+          :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          :body => properties.to_json)
         
-        def delete_relationship(relationship)
-          response = Typhoeus::Request.delete(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
-          response.code == 204 ? true : false
-        end
-        
-        def get_node_relationships(node, direction = :all, *types)
-          # GET http://localhost:7474/db/data/node/6/relationships/all
-          # GET http://localhost:7474/db/data/node/11/relationships/in
-          # GET http://localhost:7474/db/data/node/16/relationships/out
-          # GET http://localhost:7474/db/data/node/21/relationships/all/LIKES&HATES
-          # 200: OK
-          
-          # Set direction
-          direction = case direction.to_s
-            when 'incoming'
-              'in'
-            when 'outgoing'
-              'out'
-            else
-              'all'
-          end
-          
-          # Create typ filter
-          types = types.map { |e| URI.escape(e) }.join('&')
-          
-          # Send request
-          url = node_url(node) + "/relationships/#{direction}/#{types}"
-          response = Typhoeus::Request.get(url, :headers => { 'Accept' => 'application/json' })
-          response.code == 200 ? JSON.parse(response.body) : []
-        end
+        # Evaluate response
+        response.code == 201 ? JSON.parse(response.body) : nil
+      end
+      
+      def get_relationship(relationship)
+        response = Typhoeus::Request.get(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
+        response.code == 200 ? JSON.parse(response.body) : nil
+      end
+      
+      def delete_relationship(relationship)
+        response = Typhoeus::Request.delete(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
+        response.code == 204 ? true : false
+      end
+      
+      def get_node_relationships(node, direction = :all, *types)
+        # GET http://localhost:7474/db/data/node/6/relationships/all
+        # GET http://localhost:7474/db/data/node/11/relationships/in
+        # GET http://localhost:7474/db/data/node/16/relationships/out
+        # GET http://localhost:7474/db/data/node/21/relationships/all/LIKES&HATES
+        # 200: OK
         
-        def update_relationship(id, properties)
-          # PUT http://localhost:7474/db/data/relationship/0/properties
-          # 204: No Content
-          url = relationship_url(id) + '/properties'
-          response = Typhoeus::Request.put(url, 
-            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
-            :body => properties.to_json)
-          response.code == 204 ? true : false
+        # Set direction
+        direction = case direction.to_s
+          when 'incoming'
+            'in'
+          when 'outgoing'
+            'out'
+          else
+            'all'
         end
         
-        def get_relationship_types
-          # GET http://localhost:7474/db/data/relationship/types
-          # 200: OK
-          response = Typhoeus::Request.get(prepend_base_url('/relationship/types'), :headers => { 'Accept' => 'application/json' })
-          response.code == 200 ? JSON.parse(response.body) : []
-        end
+        # Create typ filter
+        types = types.map { |e| URI.escape(e) }.join('&')
         
+        # Send request
+        url = node_url(node) + "/relationships/#{direction}/#{types}"
+        response = Typhoeus::Request.get(url, :headers => { 'Accept' => 'application/json' })
+        response.code == 200 ? JSON.parse(response.body) : []
+      end
+      
+      def update_relationship(id, properties)
+        # PUT http://localhost:7474/db/data/relationship/0/properties
+        # 204: No Content
+        url = relationship_url(id) + '/properties'
+        response = Typhoeus::Request.put(url, 
+          :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+          :body => properties.to_json)
+        response.code == 204 ? true : false
+      end
+      
+      def get_relationship_types
+        # GET http://localhost:7474/db/data/relationship/types
+        # 200: OK
+        response = Typhoeus::Request.get(prepend_base_url('/relationship/types'), :headers => { 'Accept' => 'application/json' })
+        response.code == 200 ? JSON.parse(response.body) : []
       end
+      
     end
   end
 end

data/lib/architect4r/model/connection.rb

@@ -3,12 +3,8 @@ module Architect4r
     module Connection
       extend ActiveSupport::Concern
       
-      module InstanceMethods
-      
-        def connection
-          self.class.connection
-        end
-        
+      def connection
+        self.class.connection
       end
       
       module ClassMethods

data/lib/architect4r/model/persistency.rb

@@ -3,65 +3,57 @@ module Architect4r
     module Persistency
       extend ActiveSupport::Concern
       
-      included do
-        
+      # Creates the document in the db. Raises an exception
+      # if the document is not created properly.
+      def create!(options = {})
+        self.fail_validate!(self) unless self.create(options)
       end
       
-      module InstanceMethods
-        
-        # Creates the document in the db. Raises an exception
-        # if the document is not created properly.
-        def create!(options = {})
-          self.fail_validate!(self) unless self.create(options)
-        end
-        
-        def save(options = {})
-          self.new? ? create(options) : update(options)
-        end
+      def save(options = {})
+        self.new? ? create(options) : update(options)
+      end
 
-        def save!
-          self.class.fail_validate!(self) unless self.save
-          true
-        end
-        
-        def id
-          @id ||= if raw_data && raw_data['self'].present?
-            raw_data['self'].split('/').last.to_i
-          else
-            nil
-          end
+      def save!
+        self.class.fail_validate!(self) unless self.save
+        true
+      end
+      
+      def id
+        @id ||= if raw_data && raw_data['self'].present?
+          raw_data['self'].split('/').last.to_i
+        else
+          nil
         end
-        alias :to_key :id
-        alias :to_param :id
+      end
+      alias :to_key :id
+      alias :to_param :id
 
-        def new?
-          # Persisted objects always have an id.
-          id.nil?
-        end
-        alias :new_record? :new?
+      def new?
+        # Persisted objects always have an id.
+        id.nil?
+      end
+      alias :new_record? :new?
 
-        def destroyed?
-          !!@_destroyed
-        end
+      def destroyed?
+        !!@_destroyed
+      end
 
-        def persisted?
-          !new? && !destroyed?
-        end
+      def persisted?
+        !new? && !destroyed?
+      end
 
-        # Update the document's attributes and save. For example:
-        def update_attributes(hash)
-          update_attributes_without_saving hash
-          save
-        end
+      # Update the document's attributes and save. For example:
+      def update_attributes(hash)
+        update_attributes_without_saving hash
+        save
+      end
 
-        protected
+      protected
 
-        def perform_validations(options = {})
-          (options[:validate].presence || true) ? valid? : true
-        end
-        
+      def perform_validations(options = {})
+        (options[:validate].presence || true) ? valid? : true
       end
-      
+    
       module ClassMethods
         
         def create(*args, &block)

data/lib/architect4r/model/properties.rb

@@ -1,7 +1,5 @@
 module Architect4r
-  
   module Model
-    
     module Properties
       extend ActiveSupport::Concern
       
@@ -10,78 +8,74 @@ module Architect4r
         self.properties ||= {}
       end
       
-      module InstanceMethods
-        def parse_properties(properties = {})
-          @properties_data = {}
-          update_attributes_without_saving(properties)
-        end
-        
-        # Return a hash of all properties which can be transformed into json
-        # Remove all nil values, as those cannot be stored in the graph
-        def _to_database_hash
-          @properties_data.merge('architect4r_type' => self.class.name).
-                           reject { |key, value| value.nil? }
-        end
+      def parse_properties(properties = {})
+        @properties_data = {}
+        update_attributes_without_saving(properties)
+      end
+      
+      # Return a hash of all properties which can be transformed into json
+      # Remove all nil values, as those cannot be stored in the graph
+      def _to_database_hash
+        @properties_data.merge('architect4r_type' => self.class.name).
+                         reject { |key, value| value.nil? }
+      end
 
-        # Read the casted value of an attribute defined with a property.
-        #
-        # ==== Returns
-        # Object:: the casted attibutes value.
-        def read_attribute(property, locale = nil)
-          property = "#{property}_#{locale}" if locale
-          @properties_data[property.to_s]
-        end
+      # Read the casted value of an attribute defined with a property.
+      #
+      # ==== Returns
+      # Object:: the casted attibutes value.
+      def read_attribute(property, locale = nil)
+        property = "#{property}_#{locale}" if locale
+        @properties_data[property.to_s]
+      end
 
-        # Store a casted value in the current instance of an attribute defined
-        # with a property and update dirty status
-        def write_attribute(property, value, locale = nil)
-          # retrieve options for the attribute
-          opts = self.class.properties[property.to_s]
-          
-          # Check if we should store a localized version of the data
-          property = "#{property}_#{locale}" if locale
-          
-          # TODO: Mark dirty attribute tracking
-          
-          # Cast the value before storing it
-          cast_to = opts && opts[:cast_to] || Object
-          
-          @properties_data[property.to_s] = if value.nil?
-            nil
-          elsif cast_to == String
-            value.to_s
-          elsif cast_to == Integer
-            value.to_i
-          elsif cast_to == Float
-            value.to_f
-          elsif cast_to == DateTime
-            value.to_datetime
-          elsif cast_to == TrueClass or cast_to == FalseClass
-            if value.kind_of?(Integer)
-              value == 1
-            else
-              %w[ true 1 t ].include?(value.to_s.downcase)
-            end
+      # Store a casted value in the current instance of an attribute defined
+      # with a property and update dirty status
+      def write_attribute(property, value, locale = nil)
+        # retrieve options for the attribute
+        opts = self.class.properties[property.to_s]
+        
+        # Check if we should store a localized version of the data
+        property = "#{property}_#{locale}" if locale
+        
+        # TODO: Mark dirty attribute tracking
+        
+        # Cast the value before storing it
+        cast_to = opts && opts[:cast_to] || Object
+        
+        @properties_data[property.to_s] = if value.nil?
+          nil
+        elsif cast_to == String
+          value.to_s
+        elsif cast_to == Integer
+          value.to_i
+        elsif cast_to == Float
+          value.to_f
+        elsif cast_to == DateTime
+          value.to_datetime
+        elsif cast_to == TrueClass or cast_to == FalseClass
+          if value.kind_of?(Integer)
+            value == 1
           else
-            value
+            %w[ true 1 t ].include?(value.to_s.downcase)
           end
+        else
+          value
         end
-        
-        def update_attributes_without_saving(hash)
-          return if hash.nil?
-          hash.each do |key, value|
-            if self.respond_to?("#{key}=")
-              self.send("#{key}=", value)
-            else
-              @properties_data[key] = value
-            end
+      end
+      
+      def update_attributes_without_saving(hash)
+        return if hash.nil?
+        hash.each do |key, value|
+          if self.respond_to?("#{key}=")
+            self.send("#{key}=", value)
+          else
+            @properties_data[key] = value
           end
         end
-        alias :attributes= :update_attributes_without_saving
-        
-        
       end
-      
+      alias :attributes= :update_attributes_without_saving
+    
       module ClassMethods
         
         # Allow setting properties
@@ -163,9 +157,6 @@ module Architect4r
         end
         
       end
-      
     end
-    
   end
-  
 end

data/lib/architect4r/model/queries.rb

@@ -3,10 +3,6 @@ module Architect4r
     module Queries
       extend ActiveSupport::Concern
       
-      module InstanceMethods
-        
-      end
-      
       module ClassMethods
         
         def count(opts = {}, &block)

data/lib/architect4r/model/relationships.rb

@@ -3,12 +3,8 @@ module Architect4r
     module Relationships
       extend ActiveSupport::Concern
       
-      module InstanceMethods
-        
-        def links
-          @links_query_interface = LinksQueryInterface.new(self)
-        end
-        
+      def links
+        @links_query_interface = LinksQueryInterface.new(self)
       end
       
     end

data/lib/architect4r/version.rb

@@ -1,3 +1,3 @@
 module Architect4r
-  VERSION = "0.4.3"
+  VERSION = "0.4.3.1"
 end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: architect4r
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 97
   prerelease: 
   segments: 
   - 0
   - 4
   - 3
-  version: 0.4.3
+  - 1
+  version: 0.4.3.1
 platform: ruby
 authors: 
 - Maximilian Schulz
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-01 00:00:00 Z
+date: 2012-03-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activemodel