keymaker 0.0.1

data/lib/keymaker.rb

@@ -0,0 +1,43 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'active_model'
+
+require 'keymaker/request'
+require 'keymaker/response'
+require 'keymaker/configuration'
+require 'keymaker/service'
+
+require 'keymaker/add_node_to_index_request'
+require 'keymaker/batch_get_nodes_request'
+require 'keymaker/create_node_request'
+require 'keymaker/create_relationship_request'
+require 'keymaker/delete_relationship_request'
+require 'keymaker/execute_cypher_request'
+require 'keymaker/execute_gremlin_request'
+require 'keymaker/path_traverse_request'
+require 'keymaker/remove_node_from_index_request'
+require 'keymaker/update_node_properties_request'
+
+require 'keymaker/indexing'
+require 'keymaker/serialization'
+require 'keymaker/node'
+
+module Keymaker
+
+  VERSION = "0.0.1"
+
+  def self.service
+    @service ||= Keymaker::Service.new(Keymaker::Configuration.new)
+  end
+
+  def self.configure
+    @configuration = Keymaker::Configuration.new
+    yield @configuration
+    @service = Keymaker::Service.new(@configuration)
+  end
+
+  def self.configuration
+    @configuration
+  end
+
+end

data/lib/keymaker/add_node_to_index_request.rb

@@ -0,0 +1,9 @@
+module Keymaker
+  class AddNodeToIndexRequest < Request
+
+    def submit
+      service.post(node_index_path(opts[:index_name]), {key: opts[:key], value: opts[:value], uri: node_uri(opts[:node_id])})
+    end
+
+  end
+end

data/lib/keymaker/batch_get_nodes_request.rb

@@ -0,0 +1,19 @@
+module Keymaker
+
+  class BatchGetNodesRequest < Request
+
+    def submit
+      service.post(batch_path, batch_get_nodes_properties)
+    end
+
+    def batch_get_nodes_properties
+      [].tap do |batch_request|
+        opts.each_with_index do |node_id, request_id|
+          batch_request << {id: request_id, to: node_uri(node_id), method: "GET"}
+        end
+      end
+    end
+
+  end
+
+end

data/lib/keymaker/configuration.rb

@@ -0,0 +1,90 @@
+require "addressable/uri"
+
+module Keymaker
+  class Configuration
+
+    attr_accessor :protocol, :server, :port,
+      :data_directory, :cypher_path, :gremlin_path,
+      :log_file, :log_enabled, :logger,
+      :authentication, :username, :password
+
+    def initialize(attrs={})
+      self.protocol       = attrs.fetch(:protocol) {'http'}
+      self.server         = attrs.fetch(:server) {'localhost'}
+      self.port           = attrs.fetch(:port) {7474}
+      self.data_directory = attrs.fetch(:data_directory) {'db/data'}
+      self.cypher_path    = attrs.fetch(:cypher_path) {'cypher'}
+      self.gremlin_path   = attrs.fetch(:gremlin_path) {'ext/GremlinPlugin/graphdb/execute_script'}
+      self.authentication = attrs.fetch(:authentication) {{}}
+      self.username       = attrs.fetch(:username) {nil}
+      self.password       = attrs.fetch(:password) {nil}
+    end
+
+    def service_root
+      service_root_url.to_s
+    end
+
+    def service_root_url
+      Addressable::URI.new(url_opts)
+    end
+
+    def url_opts
+      {}.tap do |url_opts|
+        url_opts[:scheme] = protocol
+        url_opts[:host] = server
+        url_opts[:port] = port
+        url_opts[:user] = username if username
+        url_opts[:password] = password if password
+      end
+    end
+
+    def full_cypher_path
+      [service_root, data_directory, cypher_path].join("/")
+    end
+
+    def full_gremlin_path
+      [service_root, data_directory, gremlin_path].join("/")
+    end
+
+    def node_path
+      [data_directory, "node"].join("/")
+    end
+
+    def node_properties_path(node_id)
+      [node_path, node_id.to_s, "properties"].join("/")
+    end
+
+    def path_traverse_node_path(node_id)
+      [node_path, node_id.to_s, "traverse", "path"].join("/")
+    end
+
+    def batch_node_path(node_id)
+      ["/node", node_id.to_s].join("/")
+    end
+
+    def batch_path
+      [data_directory, "batch"].join("/")
+    end
+
+    def relationship_path(relationship_id)
+      [data_directory, "relationship", relationship_id.to_s].join("/")
+    end
+
+    def relationships_path_for_node(node_id)
+      [node_path, node_id.to_s, "relationships"].join("/")
+    end
+
+    def node_full_index_path(index_name, key, value, node_id)
+      [node_index_path(index_name), key, value, node_id].join("/")
+    end
+
+    def node_index_path(index_name)
+      [data_directory, "index", "node", index_name.to_s].join("/")
+    end
+
+    def node_uri(node_id)
+      [service_root, node_path, node_id.to_s].join("/")
+    end
+
+  end
+end

data/lib/keymaker/create_node_request.rb

@@ -0,0 +1,11 @@
+module Keymaker
+
+  class CreateNodeRequest < Request
+
+    def submit
+      service.post(node_path, opts)
+    end
+
+  end
+
+end

data/lib/keymaker/create_relationship_request.rb

@@ -0,0 +1,26 @@
+module Keymaker
+
+  # Example request
+
+  # POST http://localhost:7474/db/data/node/85/relationships
+  # Accept: application/json
+  # Content-Type: application/json
+  # {"to" : "http://localhost:7474/db/data/node/84", "type" : "LOVES", "data" : {"foo" : "bar"}}
+
+  class CreateRelationshipRequest < Request
+
+    def submit
+      service.post(relationships_path_for_node(opts[:node_id]), rel_properties)
+    end
+
+    def rel_properties
+      {}.tap do |properties|
+        properties[:to] = node_uri(opts[:end_node_id])
+        properties[:type] = opts[:rel_type]
+        properties[:data] = opts[:data] if opts[:data]
+      end
+    end
+
+  end
+
+end

data/lib/keymaker/delete_relationship_request.rb

@@ -0,0 +1,17 @@
+module Keymaker
+
+  # Example request
+
+  # DELETE http://localhost:7474/db/data/relationship/85
+  # Accept: application/json
+  # Content-Type: application/json
+
+  class DeleteRelationshipRequest < Request
+
+    def submit
+      service.delete(relationship_path(opts[:relationship_id]))
+    end
+
+  end
+
+end

data/lib/keymaker/execute_cypher_request.rb

@@ -0,0 +1,9 @@
+module Keymaker
+  class ExecuteCypherRequest < Request
+
+    def submit
+      service.post(full_cypher_path, opts).body
+    end
+
+  end
+end

data/lib/keymaker/execute_gremlin_request.rb

@@ -0,0 +1,9 @@
+module Keymaker
+  class ExecuteGremlinRequest < Request
+
+    def submit
+      service.post(full_gremlin_path, opts).body
+    end
+
+  end
+end

data/lib/keymaker/indexing.rb

@@ -0,0 +1,34 @@
+module Keymaker
+
+  module Indexing
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def index_row(index_name)
+        indices_traits[index_name] = indices_traits.fetch(index_name, [])
+      end
+
+      # index :threds, on: :name, with: :sanitized_name
+      # data structure:
+      # { threds: [{ :index_key => :name, :value => :sanitized_name }], users: [{ :index_key => :email, :value => :email }, { :index_key => :username, :value => :username }] }
+      def index(index_name,options)
+        index_row(index_name.to_s) << { :index_key => options[:on].to_s, :value => options.fetch(:with, options[:on]) }
+      end
+    end
+
+    def update_indices
+      self.class.indices_traits.each do |index,traits|
+        traits.each do |trait|
+          neo_service.remove_node_from_index(index, trait[:index_key], send(trait[:value]), node_id)
+          neo_service.add_node_to_index(index, trait[:index_key], send(trait[:value]), node_id)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/keymaker/node.rb

@@ -0,0 +1,111 @@
+require 'forwardable'
+
+module Keymaker
+
+  module Node
+
+    def self.included(base)
+      base.extend ActiveModel::Callbacks
+      base.extend ClassMethods
+
+      base.class_eval do
+        attr_writer :new_node
+        include ActiveModel::MassAssignmentSecurity
+
+        include Keymaker::Indexing
+        include Keymaker::Serialization
+
+        attr_protected :created_at, :updated_at
+      end
+
+      base.after_save :update_indices
+
+      base.class_attribute :property_traits
+      base.class_attribute :indices_traits
+
+      base.property_traits = {}
+      base.indices_traits = {}
+
+      base.property :active_record_id, Integer
+      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
+
+      def properties
+        property_traits.keys
+      end
+
+      def property(attribute,type=String)
+        property_traits[attribute] = type
+        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]}
+          end
+        else
+          return []
+        end
+      end
+
+    end
+
+    def initialize(attrs)
+      @new_node = true
+      process_attrs(attrs) if attrs.present?
+    end
+
+    def neo_service
+      self.class.neo_service
+    end
+
+    def new?
+      @new_node
+    end
+
+    def sanitize(attrs)
+      serializable_hash(except: :node_id).merge(attrs.except('node_id')).reject {|k,v| v.blank?}
+    end
+
+    def save
+      create_or_update
+    end
+
+    def create_or_update
+      run_callbacks :save do
+        new? ? create : update(attributes)
+      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
+          self
+        end
+      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
+
+  end
+
+end

data/lib/keymaker/path_traverse_request.rb

@@ -0,0 +1,34 @@
+module Keymaker
+  class PathTraverseRequest < Request
+
+    # Example request
+
+    # POST http://localhost:7474/db/data/node/9/traverse/path
+    # Accept: application/json
+    # Content-Type: application/json
+    # {"order":"breadth_first","uniqueness":"none","return_filter":{"language":"builtin","name":"all"}}
+
+    def submit
+      service.post(path_traverse_node_path(opts[:node_id]), path_traverse_properties)
+    end
+
+    def path_traverse_properties
+      # :order - breadth_first or depth_first
+      # :relationships - all, in, or out
+      # :uniqueness - node_global, none, relationship_global, node_path, or relationship_path
+      # :prune_evaluator
+      # :return_filter
+      # :max_depth
+
+      {}.tap do |properties|
+        properties[:order] = opts.fetch(:order, "breadth_first")
+        properties[:relationships] = opts.fetch(:relationships, "all")
+        properties[:uniqueness] = opts.fetch(:uniqueness, "relationship_global")
+        properties[:prune_evaluator] = opts[:prune_evaluator] if opts[:prune_evaluator]
+        properties[:return_filter] = opts[:return_filter] if opts[:return_filter]
+        properties[:max_depth] = opts[:max_depth] if opts[:max_depth]
+      end
+    end
+
+  end
+end

data/lib/keymaker/remove_node_from_index_request.rb

@@ -0,0 +1,9 @@
+module Keymaker
+  class RemoveNodeFromIndexRequest < Request
+
+    def submit
+      service.delete(node_full_index_path(opts[:index_name], opts[:key], opts[:value], opts[:node_id]))
+    end
+
+  end
+end

data/lib/keymaker/request.rb

@@ -0,0 +1,34 @@
+module Keymaker
+  class Request
+
+    extend Forwardable
+
+
+    def_delegator :config, :batch_node_path
+    def_delegator :config, :batch_path
+    def_delegator :config, :full_cypher_path
+    def_delegator :config, :full_gremlin_path
+    def_delegator :config, :node_full_index_path
+    def_delegator :config, :node_index_path
+    def_delegator :config, :node_path
+    def_delegator :config, :node_properties_path
+    def_delegator :config, :node_uri
+    def_delegator :config, :path_traverse_node_path
+    def_delegator :config, :relationship_path
+    def_delegator :config, :relationships_path_for_node
+
+    def_delegator :response, :body
+    def_delegator :response, :status
+    def_delegator :response, :faraday_response
+    def_delegator :response, :faraday_response=
+
+    attr_accessor :service, :config, :opts
+
+    def initialize(service, options)
+      self.config = service.config
+      self.opts = options
+      self.service = service
+    end
+
+  end
+end