keymaker 0.0.9 → 0.1.0

data/Rakefile

@@ -134,7 +134,7 @@ NEO4J_PORT = ENV['NEO4J_PORT'] || '7477' # Don't clobber standard neo4j ports 74
 
 namespace :neo4j do
 
-  desc "Install neo4j on localhost:#{NEO4J_PORT}. e.g. rake neo4j:install[community,1.7.M03]"
+  desc "Install neo4j on localhost:#{NEO4J_PORT}. e.g. rake neo4j:install[community,1.8.RC1]"
   task :install, :edition, :version do |t, args|
     args.with_defaults(:edition => "community", :version => "1.7")
 

data/keymaker.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'keymaker'
-  s.version           = '0.0.9'
-  s.date              = '2012-09-22'
+  s.version           = '0.1.0'
+  s.date              = '2012-10-14'
 
   s.description   = %q{A multi-layer REST API wrapper for neo4j.}
   s.summary       = %q{A multi-layer REST API wrapper for neo4j.}
@@ -48,6 +48,7 @@ Gem::Specification.new do |s|
     lib/keymaker/indexing.rb
     lib/keymaker/match_method.rb
     lib/keymaker/node.rb
+    lib/keymaker/parsers/cypher_response_parser.rb
     lib/keymaker/rails_tasks.rb
     lib/keymaker/railtie.rb
     lib/keymaker/request.rb
@@ -69,42 +70,8 @@ Gem::Specification.new do |s|
     lib/keymaker/response.rb
     lib/keymaker/serialization.rb
     lib/keymaker/service.rb
-    spec/cassettes/Keymaker_AddNodeToIndexRequest/with_valid_options/returns_a_201_status_code.yml
-    spec/cassettes/Keymaker_AddNodeToIndexRequest/with_valid_options/returns_application/json.yml
-    spec/cassettes/Keymaker_AddNodeToIndexRequest/with_valid_options/returns_the_Neo4j_REST_API_starting_point_response_request.yml
-    spec/cassettes/Keymaker_BatchRequest/when_a_resource_is_not_found/raises_BatchRequestError.yml
-    spec/cassettes/Keymaker_BatchRequest/when_to_and_method_are_not_set/raises_BatchRequestError.yml
-    spec/cassettes/Keymaker_BatchRequest/with_valid_options/returns_a_200_status_code.yml
-    spec/cassettes/Keymaker_BatchRequest/with_valid_options/runs_the_commands_and_returns_their_respective_results.yml
-    spec/cassettes/Keymaker_CreateNodeRequest/returns_a_201_status_code.yml
-    spec/cassettes/Keymaker_CreateNodeRequest/returns_application/json.yml
-    spec/cassettes/Keymaker_CreateNodeRequest/with_properties/creates_a_node_with_the_given_properties.yml
-    spec/cassettes/Keymaker_CreateNodeRequest/without_properties/creates_an_empty_node.yml
-    spec/cassettes/Keymaker_CreateRelationshipRequest/with_invalid_options/raises_ClientError.yml
-    spec/cassettes/Keymaker_CreateRelationshipRequest/with_properties/creates_a_node_with_the_given_properties.yml
-    spec/cassettes/Keymaker_CreateRelationshipRequest/with_properties/returns_a_201_status_code.yml
-    spec/cassettes/Keymaker_CreateRelationshipRequest/with_properties/returns_application/json.yml
-    spec/cassettes/Keymaker_CreateRelationshipRequest/without_properties/creates_an_empty_relationship_of_type_birthed_.yml
-    spec/cassettes/Keymaker_DeleteRelationshipRequest/with_a_non-existent_relationship/raises_ResourceNotFound.yml
-    spec/cassettes/Keymaker_DeleteRelationshipRequest/with_an_existing_relationship/deletes_the_relationship.yml
-    spec/cassettes/Keymaker_ExecuteCypherRequest/with_a_valid_Cypher_Query/returns_a_200_status_code.yml
-    spec/cassettes/Keymaker_ExecuteCypherRequest/with_an_invalid_Cypher_Query/raises_ClientError.yml
-    spec/cassettes/Keymaker_ExecuteGremlinRequest/with_a_valid_Gremlin_Script/returns_a_200_status_code.yml
-    spec/cassettes/Keymaker_ExecuteGremlinRequest/with_an_invalid_Gremlin_Script/raises_ClientError.yml
-    spec/cassettes/Keymaker_GetNodeRequest/with_a_non-existent_node_id/raises_ResourceNotFound.yml
-    spec/cassettes/Keymaker_GetNodeRequest/with_an_empty_node_id/raises_ClientError.yml
-    spec/cassettes/Keymaker_GetRelationshipTypesRequest/with_existing_relationships/returns_a_unique_array_of_relationship_types.yml
-    spec/cassettes/Keymaker_ServiceRootRequest/returns_a_200_status_code.yml
-    spec/cassettes/Keymaker_ServiceRootRequest/returns_application/json.yml
-    spec/cassettes/Keymaker_ServiceRootRequest/returns_the_Neo4j_REST_API_starting_point_response_request.yml
-    spec/cassettes/Keymaker_TraversePathRequest/_traverse_path_properties/with_options/builds_the_query_properties_with_defaults.yml
-    spec/cassettes/Keymaker_TraversePathRequest/with_invalid_options/raise_a_ClientError.yml
-    spec/cassettes/Keymaker_TraversePathRequest/with_valid_options/returns_status_code_200.yml
-    spec/cassettes/Keymaker_UpdateNodePropertiesRequest/_node_properties/excludes_the_node_id.yml
-    spec/cassettes/Keymaker_UpdateNodePropertiesRequest/with_invalid_options/raises_a_ClientError.yml
-    spec/cassettes/Keymaker_UpdateNodePropertiesRequest/with_valid_options/returns_a_status_of_204.yml
-    spec/cassettes/Keymaker_UpdateNodePropertiesRequest/with_valid_options/updates_the_properties.yml
     spec/configuration_spec.rb
+    spec/keymaker/node_spec.rb
     spec/keymaker/requests/add_node_to_index_request_spec.rb
     spec/keymaker/requests/batch_get_nodes_request_spec.rb
     spec/keymaker/requests/batch_request_spec.rb
@@ -123,6 +90,7 @@ Gem::Specification.new do |s|
     spec/keymaker_spec.rb
     spec/service_spec.rb
     spec/spec_helper.rb
+    spec/support/active_model_lint.rb
     spec/support/keymaker.rb
     spec/support/vcr.rb
   ]

data/lib/keymaker.rb

@@ -2,11 +2,18 @@ require 'faraday'
 require 'faraday_middleware'
 require 'hashie'
 require 'active_model'
+require 'active_model/validations'
+require 'active_model/callbacks'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/hash_with_indifferent_access'
 
 require 'keymaker/match_method'
 require 'keymaker/errors'
 require 'keymaker/response'
+require 'keymaker/parsers/cypher_response_parser'
 require 'keymaker/configuration'
 require 'keymaker/service'
 
@@ -14,19 +21,15 @@ require 'keymaker/request'
 
 require 'keymaker/requests/batch_request'
 require 'keymaker/requests/batch_get_nodes_request'
-
 require 'keymaker/requests/create_node_request'
 require 'keymaker/requests/delete_node_request'
 require 'keymaker/requests/get_node_request'
-
 require 'keymaker/requests/add_node_to_index_request'
 require 'keymaker/requests/remove_node_from_index_request'
 require 'keymaker/requests/update_node_properties_request'
-
 require 'keymaker/requests/create_relationship_request'
 require 'keymaker/requests/delete_relationship_request'
 require 'keymaker/requests/get_relationship_types_request'
-
 require 'keymaker/requests/execute_cypher_request'
 require 'keymaker/requests/execute_gremlin_request'
 require 'keymaker/requests/traverse_path_request'
@@ -40,7 +43,7 @@ require 'keymaker/railtie' if defined? Rails::Railtie
 
 module Keymaker
 
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 
   def self.service
     @service ||= Keymaker::Service.new(Keymaker::Configuration.new)

data/lib/keymaker/node.rb

@@ -5,16 +5,21 @@ module Keymaker
   module Node
 
     def self.included(base)
-      base.extend ActiveModel::Callbacks
-      base.extend ClassMethods
 
       base.class_eval do
-        attr_writer :new_node
+        extend ActiveModel::Callbacks
+        extend ActiveModel::Naming
         include ActiveModel::MassAssignmentSecurity
+        include ActiveModel::Validations
+        include ActiveModel::Conversion
 
         include Keymaker::Indexing
         include Keymaker::Serialization
 
+        extend Keymaker::Node::ClassMethods
+        include Keymaker::Node::InstanceMethods
+
+        attr_writer :new_node
         attr_protected :created_at, :updated_at
       end
 
@@ -30,10 +35,10 @@ module Keymaker
       base.property :node_id, Integer
       base.property :created_at, DateTime
       base.property :updated_at, DateTime
+
     end
 
     module ClassMethods
-
       extend Forwardable
 
       def_delegator :Keymaker, :service, :neo_service
@@ -47,63 +52,82 @@ module Keymaker
         attr_accessor attribute
       end
 
-      def execute_cypher(query, params={}, return_type=:results_only)
-        executed_query = neo_service.execute_query(query, params)
-        if executed_query.present?
-          case return_type
-          when :results_only
-            executed_query["data"].flatten
-          # TODO: Make this less specific
-          when :full_user
-            {"user" => executed_query["data"].flatten[0]["data"], "neo_id" => executed_query["data"].flatten[1]}
+      def create(attributes)
+        new(attributes).save
+      end
+
+      def find_by_cypher(query, params={})
+        find_all_by_cypher(query, params).first
+      end
+
+      def find_all_by_cypher(query, params={})
+        neo_service.execute_cypher(query, params)
+      end
+
+      def find(node_id)
+        node = neo_service.get_node(node_id)
+        if node.present?
+          new(node.slice(*properties)).tap do |neo_node|
+            neo_node.node_id = node.neo4j_id
+            neo_node.new_node = false
           end
-        else
-          return []
         end
       end
 
     end
 
-    def initialize(attrs)
-      @new_node = true
-      process_attrs(attrs) if attrs.present?
-    end
+    module InstanceMethods
 
-    def neo_service
-      self.class.neo_service
-    end
+      def initialize(attrs = {})
+        @new_node = true
+        process_attrs(attrs) if attrs.present?
+      end
 
-    def new?
-      @new_node
-    end
+      def neo_service
+        self.class.neo_service
+      end
 
-    def sanitize(attrs)
-      serializable_hash(except: :node_id).merge(attrs.except('node_id')).reject {|k,v| v.blank?}
-    end
+      def new?
+        @new_node
+      end
 
-    def save
-      create_or_update
-    end
+      def sanitize(attrs)
+        serializable_hash(except: :node_id).merge(attrs.except('node_id')).reject {|k,v| v.blank?}
+      end
 
-    def create_or_update
-      run_callbacks :save do
-        new? ? create : update(attributes)
+      def save
+        create_or_update
       end
-    end
 
-    def create
-      run_callbacks :create do
-        neo_service.create_node(sanitize(attributes)).on_success do |response|
-          self.node_id = response.neo4j_id
-          self.new_node = false
+      def create_or_update
+        run_callbacks :save do
+          new? ? create : update(attributes)
         end
-        self
       end
-    end
 
-    def update(attrs)
-      process_attrs(sanitize(attrs.merge(updated_at: Time.now.utc.to_i)))
-      neo_service.update_node_properties(node_id, sanitize(attributes))
+      def create
+        run_callbacks :create do
+          neo_service.create_node(sanitize(attributes)).on_success do |response|
+            self.node_id = response.neo4j_id
+            self.new_node = false
+          end
+          self
+        end
+      end
+
+      def update(attrs)
+        process_attrs(sanitize(attrs.merge(updated_at: Time.now.utc.to_i)))
+        neo_service.update_node_properties(node_id, sanitize(attributes))
+      end
+
+      def persisted?
+        node_id.present?
+      end
+
+      def to_key
+        persisted? ? [node_id] : nil
+      end
+
     end
 
   end

data/lib/keymaker/parsers/cypher_response_parser.rb

@@ -0,0 +1,25 @@
+module Keymaker
+  class CypherResponseParser
+
+    def self.parse(response_body)
+      response_body.data.map do |result|
+        if response_body.columns.one? && result.first.kind_of?(Hashie::Mash)
+          result.first.data
+        else
+          translate_response(response_body, result)
+        end
+      end
+    end
+
+    def self.translate_response(response_body, result)
+      Hashie::Mash.new(Hash[sanitized_column_names(response_body).zip(result)])
+    end
+
+    def self.sanitized_column_names(response_body)
+      response_body.columns.map do |column|
+        column[/[^\.]+$/]
+      end
+    end
+
+  end
+end

data/lib/keymaker/serialization.rb

@@ -12,7 +12,7 @@ module Keymaker::Serialization
       when Time
         Time.at(v)
       when String
-        DateTime.strptime(v).to_time
+        v.to_time
       else
         Time.now.utc
       end
@@ -43,4 +43,5 @@ module Keymaker::Serialization
       self.class.properties.each{|property| hash[property.to_s] }
     end
   end
+
 end

data/lib/keymaker/service.rb

@@ -18,8 +18,8 @@ module Keymaker
 
     def connection
       @connection ||= Faraday.new(url: config.connection_service_root_url) do |conn|
-        conn.use FaradayMiddleware::Mashify
         conn.request :json
+        conn.response :mashify
         conn.response :json, :content_type => /\bjson$/
         conn.adapter :net_http
       end
@@ -36,8 +36,6 @@ module Keymaker
       super
     end
 
-    ## Nodes
-    # Create Node
     def create_node(attrs)
       # TODO: parse response into manageable Ruby objects
       create_node_request(attrs)
@@ -49,58 +47,47 @@ module Keymaker
       data.merge!("neo4j_id" => response.neo4j_id, "__raw_response__" => response)
     end
 
-    # Update Node properties
     def update_node_properties(node_id, attrs)
       update_node_properties_request({node_id: node_id}.merge(attrs))
     end
 
-    # Delete Node
     def delete_node(node_id)
       delete_node_request(node_id: node_id)
     end
 
-    # Create Relationship
     def create_relationship(rel_type, start_node_id, end_node_id, data={})
       create_relationship_request({node_id: start_node_id, rel_type: rel_type, end_node_id: end_node_id, data: data})
     end
 
-    # Delete Relationship
     def delete_relationship(relationship_id)
       delete_relationship_request(relationship_id: relationship_id)
     end
 
-    # Add Node to Index
     def add_node_to_index(index_name, key, value, node_id)
       add_node_to_index_request(index_name: index_name, key: key, value: value, node_id: node_id)
     end
 
-    # Remove Node from Index
     def remove_node_from_index(index_name, key, value, node_id)
       remove_node_from_index_request(index_name: index_name, key: key, value: value, node_id: node_id)
     end
 
-    # Path Traverse
     def path_traverse(start_node_id, data={})
       traverse_path_request({node_id: start_node_id}.merge(data))
     end
 
-    # Batch
-    ## GET Nodes
     def batch_get_nodes(node_ids)
       batch_get_nodes_request(node_ids)
     end
 
-    # Cypher Query
-    def execute_query(query, params)
-      execute_cypher_request({query: query, params: params}).body
+    def execute_cypher(query, params)
+      response = execute_cypher_request({query: query, params: params})
+      Keymaker::CypherResponseParser.parse(response.body)
     end
 
-    # Gremlin Script
     def execute_script(script, params={})
       execute_gremlin_request({script: script, params: params})
     end
 
-    # HTTP Verbs
     def get(url, body)
       faraday_response = connection.get(parse_url(url), body)
       Keymaker::Response.new(self, faraday_response)

data/spec/keymaker/node_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+class Terminator
+  include Keymaker::Node
+  property :name
+end
+
+describe Keymaker::Node do
+
+  let(:terminator) { Terminator.create(name: 'T1000') }
+
+  subject { terminator }
+
+  it_behaves_like "ActiveModel"
+
+  describe ".create" do
+    subject { terminator }
+    its(:node_id) { should be_present }
+    its(:name) { should == 'T1000' }
+    it { should_not be_new }
+    it { should be_a(Terminator) }
+  end
+
+  describe ".find(node_id)" do
+
+    subject { Terminator.find(node_id) }
+
+    context "when terminator is present" do
+      let(:node_id) { terminator.node_id }
+
+      its(:node_id) { should be_present }
+      its(:name) { should == 'T1000' }
+      it { should be_present }
+      it { should_not be_new }
+      it { should be_a(Terminator) }
+    end
+
+    context "when terminator is not present" do
+      let(:node_id) { 9001 }
+      it "raises an Keymaker::ResourceNotFound error" do
+        expect { subject }.to raise_error(Keymaker::ResourceNotFound)
+      end
+    end
+
+  end
+
+  describe "#persisted?" do
+    let(:new_node) { Terminator.new(name: "T1000") }
+    subject { node.persisted? }
+
+    context "when persisted" do
+      let(:node) { new_node.save }
+      it { subject.should be_true }
+    end
+
+    context "when not persisted" do
+      let(:node) { new_node }
+      it { subject.should be_false }
+    end
+
+  end
+
+  describe "#to_key" do
+
+    context "when persisted" do
+      subject { terminator.to_key }
+      it { subject.first.should be_a(Integer)  }
+      it { subject.should include(terminator.node_id)  }
+    end
+
+    context "when not persisted" do
+      subject { Terminator.new(name: "T1000").to_key }
+      it { subject.should be_blank  }
+    end
+
+  end
+
+  describe "#to_param" do
+
+    context "when persisted" do
+      subject { terminator.to_param }
+      it { subject.should == terminator.node_id.to_s }
+    end
+
+    context "when not persisted" do
+      subject { Terminator.new(name: "T1000").to_param }
+      it { subject.should be_nil }
+    end
+
+  end
+
+end