keymaker 0.0.1

data/lib/keymaker/response.rb

@@ -0,0 +1,38 @@
+module Keymaker
+
+  class Response
+
+    attr_accessor :request
+    attr_accessor :service
+    attr_accessor :faraday_response
+
+    def initialize(service, faraday_response)
+      self.service = service
+      self.faraday_response = faraday_response
+    end
+
+    def body
+      faraday_response.body || {}
+    end
+
+    def status
+      faraday_response.status
+    end
+
+    def neo4j_id
+      body["self"] && body["self"][/\d+$/].to_i
+    end
+
+    def on_success
+      if success?
+        yield self
+      end
+    end
+
+    def success?
+      (200..207).include?(status)
+    end
+
+  end
+
+end

data/lib/keymaker/serialization.rb

@@ -0,0 +1,46 @@
+module Keymaker::Serialization
+  include ActiveModel::Serialization
+
+  def self.included(base)
+    base.define_model_callbacks :save, :create
+  end
+
+  COERCION_PROCS = Hash.new(->(v){v}).tap do |procs|
+    procs[Integer] = ->(v){ v.to_i }
+    procs[DateTime] = ->(v) do
+      case v
+      when Time
+        Time.at(v)
+      when String
+        DateTime.strptime(v).to_time
+      else
+        Time.now.utc
+      end
+    end
+  end
+
+  def process_attrs(attrs)
+    attrs.symbolize_keys!
+    self.class.properties.delete_if{|p| p == :node_id}.each do |property|
+      if property == :active_record_id
+        process_attr(property, attrs[:id].present? ? attrs[:id] : attrs[:active_record_id])
+      else
+        process_attr(property, attrs[property])
+      end
+    end
+  end
+
+  def process_attr(key, value)
+    send("#{key}=", coerce(value,self.class.property_traits[key]))
+  end
+
+  def coerce(value,type)
+    COERCION_PROCS[type].call(value)
+  end
+
+  def attributes
+    Hash.new{|h,k| h[k] = send(k) }.tap do |hash|
+      self.class.properties.each{|property| hash[property.to_s] }
+    end
+  end
+end

data/lib/keymaker/service.rb

@@ -0,0 +1,147 @@
+require "addressable/uri"
+
+module Keymaker
+
+  class Service
+
+    attr_accessor :config
+
+    def initialize(config)
+      self.config = config
+    end
+
+    def connection=(connection)
+      @connection = connection
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: config.service_root) do |conn|
+        conn.request :json
+        conn.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
+        conn.adapter :net_http
+      end
+    end
+
+    # Create Node
+    def create_node(attrs)
+      create_node_request(attrs)
+    end
+
+    def create_node_request(opts)
+      CreateNodeRequest.new(self, opts).submit
+    end
+
+    # Update Node properties
+    def update_node_properties(node_id, attrs)
+      update_node_properties_request({node_id: node_id}.merge(attrs))
+    end
+
+    def update_node_properties_request(opts)
+      UpdateNodePropertiesRequest.new(self, opts).submit
+    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
+
+    def create_relationship_request(opts)
+      CreateRelationshipRequest.new(self, opts).submit
+    end
+
+    # Delete Relationship
+    def delete_relationship(relationship_id)
+      delete_relationship_request(relationship_id: relationship_id)
+    end
+
+    def delete_relationship_request(opts)
+      DeleteRelationshipRequest.new(self, opts).submit
+    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
+
+    def add_node_to_index_request(opts)
+      AddNodeToIndexRequest.new(self, opts).submit
+    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
+
+    def remove_node_from_index_request(opts)
+      RemoveNodeFromIndexRequest.new(self, opts).submit
+    end
+
+    # Path Traverse
+    def path_traverse(start_node_id, data={})
+      path_traverse_request({node_id: start_node_id}.merge(data))
+    end
+
+    def path_traverse_request(opts)
+      PathTraverseRequest.new(self, opts).submit
+    end
+
+    # Batch
+    ## GET Nodes
+    def batch_get_nodes(node_ids)
+      batch_get_nodes_request(node_ids)
+    end
+
+    def batch_get_nodes_request(opts)
+      BatchGetNodesRequest.new(self, opts).submit
+    end
+
+    # Cypher Query
+    def execute_query(query, params)
+      execute_cypher_request({query: query, params: params})
+    end
+
+    def execute_cypher_request(opts)
+      ExecuteCypherRequest.new(self, opts).submit
+    end
+
+    # Gremlin Script
+    def execute_script(script, params={})
+      execute_gremlin_request({script: script, params: params})
+    end
+
+    def execute_gremlin_request(opts)
+      ExecuteGremlinRequest.new(self, opts).submit
+    end
+
+    # HTTP Verbs
+
+    def get(url, body)
+      faraday_response = connection.get(parse_url(url), body)
+      Keymaker::Response.new(self, faraday_response)
+    end
+
+    def delete(url)
+      faraday_response = connection.delete(parse_url(url))
+      Keymaker::Response.new(self, faraday_response)
+    end
+
+    def post(url, body)
+      faraday_response = connection.post(parse_url(url), body)
+      Keymaker::Response.new(self, faraday_response)
+    end
+
+    def put(url, body)
+      faraday_response = connection.put(parse_url(url), body)
+      Keymaker::Response.new(self, faraday_response)
+    end
+
+    def parse_url(url)
+      connection.build_url(url).tap do |uri|
+        if uri.port != config.port
+          raise RuntimeError, "bad port"
+        end
+      end
+    end
+
+  end
+end

data/lib/keymaker/update_node_properties_request.rb

@@ -0,0 +1,15 @@
+module Keymaker
+
+  class UpdateNodePropertiesRequest < Request
+
+    def submit
+      service.put(node_properties_path(opts[:node_id]), node_properties)
+    end
+
+    def node_properties
+      opts.except(:node_id)
+    end
+
+  end
+
+end

data/spec/lib/keymaker_integration_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+require "addressable/uri"
+require 'keymaker'
+
+describe Keymaker do
+
+  include_context "John and Sarah nodes"
+
+  context "indices" do
+    include_context "John and Sarah indexed nodes"
+
+    context "given a bad port number" do
+
+      let(:url) { john_node_url.dup.gsub("7475", "49152") }
+
+      after { service.connection = connection }
+
+      def do_it
+        connection.get(url) do |req|
+          req.options[:timeout] = 0
+          req.options[:open_timeout] = 0
+        end
+      end
+
+      it "raises an error" do
+        expect { do_it }.to raise_error
+      end
+
+    end
+
+    context "given an explicit connection" do
+
+      let(:url) { john_node_url }
+
+      before { service.connection = test_connection }
+      after { service.connection = connection }
+
+      def do_it
+        service.connection.get(url)
+      end
+
+      it "uses the connection for requests" do
+        faraday_stubs.get(Addressable::URI.parse(url).path) do
+          [200, {}, "{}"]
+        end
+        do_it
+        faraday_stubs.verify_stubbed_calls
+      end
+
+    end
+
+    describe "#add_node_to_index(index_name, key, value, node_id)" do
+
+      def do_it
+        service.add_node_to_index(:users, :email, email, node_id)
+      end
+
+      context "given existing values" do
+
+        let(:email) { john_email }
+        let(:node_id) { john_node_id }
+        let(:index_result) { connection.get(index_query_for_john_url).body[0]["self"] }
+
+        it "adds the node to the index" do
+          do_it
+          index_result.should == john_node_url
+        end
+
+        it "returns a status of 201" do
+          do_it.status.should == 201
+        end
+
+      end
+
+      context "given an invalid node id" do
+
+        let(:email) { john_email }
+        let(:node_id) { -22 }
+
+        it "returns a 500 status" do
+          do_it.status.should == 500
+        end
+
+      end
+
+    end
+
+    describe "#remove_node_from_index(index_name, key, value, node_id)" do
+
+      def do_it
+        service.remove_node_from_index(:users, :email, email, node_id)
+      end
+
+      context "given existing values" do
+
+        let(:email) { john_email }
+        let(:node_id) { john_node_id }
+
+        it "removes the node from the index" do
+          do_it
+          connection.get(index_query_for_john_url).body.should be_empty
+        end
+
+        it "returns a status of 204" do
+          do_it.status.should == 204
+        end
+
+        it "keeps the other node indices" do
+          do_it
+          connection.get(index_query_for_sarah_url).body.should_not be_empty
+        end
+
+      end
+
+      context "given unmatched values" do
+
+        let(:email) { "unknown@example.com" }
+        let(:node_id) { -22 }
+
+        it "returns a 404 status" do
+          do_it.status.should == 404
+        end
+
+      end
+
+    end
+  end
+
+  describe "#execute_query" do
+
+    def do_it
+      service.execute_query("START user=node:users(email={email}) RETURN user", email: john_email)
+    end
+
+    context "given existing values" do
+
+      before { service.add_node_to_index(:users, :email, john_email, john_node_id) }
+      let(:query_result) { do_it["data"][0][0]["self"] }
+
+      it "performs the cypher query and responds" do
+        query_result.should == john_node_url
+      end
+
+    end
+
+  end
+
+  context "nodes" do
+
+    include_context "Keymaker connections"
+
+    describe "#create_node" do
+
+      let(:properties) { { first_name: "john", last_name: "connor", email: "john@resistance.net" } }
+
+      def do_it
+        new_node_id = service.create_node(properties).neo4j_id
+        connection.get("/db/data/node/#{new_node_id}/properties").body
+      end
+
+      it "creates a node with properties" do
+        do_it.should == {"first_name"=>"john", "email"=>"john@resistance.net", "last_name"=>"connor"}
+      end
+
+    end
+
+  end
+
+  context "relationships" do
+
+    include_context "Keymaker connections"
+
+    describe "#create_relationship" do
+
+      def do_it
+        service.create_relationship(:loves, john_node_id, sarah_node_id).neo4j_id
+        connection.get("/db/data/node/#{john_node_id}/relationships/all/loves").body.first
+      end
+
+      it "creates the relationship between the two nodes" do
+        do_it["start"].should == john_node_url
+        do_it["end"].should == sarah_node_url
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+ROOT = File.expand_path('../..', __FILE__)
+Dir[File.join(ROOT, 'spec/support/**/*.rb')].each {|f| require f}
+$LOAD_PATH.unshift(File.expand_path('lib', ROOT))
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end