tfs_graph 0.1.1 → 0.1.2

data/lib/tfs_graph/project/project_store.rb

@@ -1,30 +1,21 @@
-require 'tfs_graph/tfs_client'
+require 'tfs_graph/abstract_store'
+
 require 'tfs_graph/project/project_normalizer'
+require 'tfs_graph/abstract_store'
 
 module TFSGraph
-  class ProjectStore
-    extend TFSClient
-
-    class << self
-      def cache
-        projects = tfs.projects.run
-        normalized = ProjectNormalizer.normalize_many projects
-
-        normalized.map do |project_attrs|
-          project = Project.create project_attrs
-          Related::Relationship.create(:projects, Related.root, project)
-
-          project
-        end
-      end
+  class ProjectStore < AbstractStore
+    def cache(project)
+      RepositoryRegistry.project_repository.create project
+    end
 
-      def all_cached
-        Related.root.outgoing(:projects).options(model: Project).nodes.to_a
-      end
+    private
+    def root_query
+      tfs.projects
+    end
 
-      def find_cached(name)
-        all_cached.detect {|p| p.name == name }
-      end
+    def normalize(projects)
+      ProjectNormalizer.normalize_many projects
     end
   end
 end

data/lib/tfs_graph/repository.rb

@@ -0,0 +1,78 @@
+require 'active_support/hash_with_indifferent_access'
+require 'tfs_graph/extensions'
+
+require 'tfs_graph/project'
+require 'tfs_graph/branch'
+require 'tfs_graph/changeset'
+
+require 'tfs_graph/behaviors'
+
+module TFSGraph
+  class Repository
+    include Extensions
+    attr_reader :type
+
+    NotFound = Class.new(RuntimeError)
+
+    def initialize(type)
+      @type = type
+
+      add_behavior self, constantize("TFSGraph::Behaviors::#{self.base_class_name}::#{type.base_class_name}")
+
+      # register self as the server type
+      ServerRegistry.server(self)
+    end
+
+    def find(id)
+      rebuild find_native(id)
+    end
+
+    def exists?(id)
+      begin
+        find_native(id)
+        true
+      rescue NotFound
+        false
+      end
+    end
+
+    def related?(node1, node2, type)
+      node1.rels(dir: :outgoing, between: node2, type: type).any?
+    end
+
+    def save(object)
+      db_object = object.persisted? ? update(object) : persist(object)
+      object.persist get_id(db_object), db_object
+    end
+
+    def delete(obj)
+      obj.db_object = nil
+      obj.id = nil
+    end
+
+    def build(args={})
+      @type.new self, args
+    end
+
+    def rebuild(db_object)
+      attributes = HashWithIndifferentAccess.new db_object.attributes
+
+      obj = build attributes
+      obj.persist get_id(db_object), db_object
+    end
+
+    def create(args)
+      object = build(args)
+      save(object)
+    end
+
+    def inspect
+      type
+    end
+
+    private
+    def normalize(attrs)
+      HashWithIndifferentAccess.new attrs
+    end
+  end
+end

data/lib/tfs_graph/repository/neo4j_repository.rb

@@ -0,0 +1,97 @@
+require 'neo4j-core'
+require 'tfs_graph/repository'
+
+module TFSGraph
+  class Repository
+    class Neo4jRepository < Repository
+      def find_native(id)
+        node = Neo4j::Label.query(type.base_class_name.downcase.to_sym, conditions: {id: id}).to_a.first
+        node ||= find_by_neo_id(id)
+
+        raise NotFound, id unless node
+        node
+      end
+
+      def find_by_neo_id(id)
+        Neo4j::Node.load(id)
+      end
+
+      def session
+        Neo4j::Session.current
+      end
+
+      def flush
+        @root = nil
+      end
+
+      def delete(obj)
+        obj.db_object.del
+        super
+      end
+
+      def drop_all
+        flush
+        session.query("MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
+      end
+
+      def root
+        @root ||= begin
+          node = Neo4j::Label.find_all_nodes(:root).first
+          node = Neo4j::Node.create({name: "Root node"}, :root) if node.nil?
+          node
+        end
+      end
+
+      def relate(relationship, parent, child)
+        Neo4j::Relationship.create relationship, parent, child unless related?(parent, child, relationship)
+      end
+
+      def get_nodes(entity, direction, relation, type)
+        begin
+          entity.nodes(dir: direction.to_sym, type: relation.to_sym).map do |node|
+            type.repository.rebuild node
+          end
+        rescue Neo4j::Server::CypherResponse::ResponseError => e
+          []
+        end
+      end
+
+      def rebuild(db_object)
+        attributes = normalize db_object.props
+
+        obj = build attributes
+        obj.persist get_id(db_object), db_object
+      end
+
+      def rebuild_from_query(attrs, id)
+        obj = build normalize(attrs)
+        obj.persist id, nil
+      end
+
+      private
+      # persist and update both expose the DB object from Neo4j
+      # make methods private so we have to use save to persist
+
+      # create the DB object
+      def persist(object)
+        begin
+          Neo4j::Node.create(object.to_hash, object.base_class_name.downcase)
+        rescue Neo4j::Server::CypherResponse::ResponseError => e
+          # assume all errors come from constraint errors... probably a bad idea
+          fetch_existing_record(object)
+        end
+      end
+
+      # update the DB object
+      def update(object)
+        object.db_object.update_props object.attributes
+        object.db_object
+      end
+
+      def get_id(object)
+        return 0 if object.nil?
+        object.neo_id
+      end
+    end
+  end
+end

data/lib/tfs_graph/repository/related_repository.rb

@@ -0,0 +1,89 @@
+require 'related'
+require 'tfs_graph/repository'
+
+module TFSGraph
+  class Repository
+    class RelatedRepository < Repository
+      def initialize(type)
+        super
+        Related.redis = ServerRegistry.redis
+      end
+
+      def find_native(id)
+        begin
+          Related::Node.find(id)
+        rescue Related::NotFound => e
+          raise TFSGraph::Repository::NotFound, e.message
+        end
+      end
+
+      def root
+        Related.root
+      end
+
+      def session
+        ServerRegistry.redis
+      end
+
+      def flush
+        # noop
+      end
+
+      def drop_all
+        flush
+        session.keys("*").each do |k|
+          session.del k
+        end
+      end
+
+      def delete(obj)
+        obj.db_object.destroy
+        super
+      end
+
+      def relate(relationship, parent, child)
+        Related::Relationship.create relationship, parent, child
+      end
+
+      def get_nodes(entity, direction, relation, type)
+        get_nodes_for(get_relation(entity, direction, relation), type)
+      end
+
+      def get_nodes_for(relation, type)
+        relation.nodes.map do |node|
+          type.repository.rebuild node
+        end
+      end
+
+      def get_relation(entity, direction, relation)
+        entity.send(direction.to_sym, relation.to_sym)
+      end
+
+      private
+      # persist and update both expose the DB object from Redis/Related
+      # make methods private so we have to use save to persist
+
+      # create the DB object
+      def persist(object)
+        Related::Node.create(object.to_hash)
+      end
+
+      # update the DB object
+      def update(object)
+        db_object = object.db_object
+
+        object.attributes.each do |key, value|
+          db_object.write_attribute key, value
+        end
+
+        db_object.save
+        db_object
+      end
+
+      def get_id(object)
+        return 0 if object.nil?
+        object.id
+      end
+    end
+  end
+end

data/lib/tfs_graph/repository_registry.rb

@@ -0,0 +1,60 @@
+require 'singleton'
+require 'tfs_graph/extensions'
+
+module TFSGraph
+  class RepositoryRegistry
+    include Extensions
+    include Singleton
+
+    TYPES = %w(branch changeset project)
+
+    def self.register
+      # assume re-registering means we want to clear existing repos
+      instance.reset!
+      yield instance if block_given?
+
+      instance
+    end
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @base_repo = nil
+
+      TYPES.each do |type|
+        instance_variable_set repo_memo(type), nil
+      end
+    end
+
+    def identifier
+      (@base_repo.name =~ /Neo4j/i) ? "neo4j" : "redis"
+    end
+
+    def type(type)
+      @base_repo = type
+    end
+
+    TYPES.each do |type|
+      define_method "#{type}_repository" do
+        existing = instance_variable_get repo_memo(type)
+        return existing unless existing.nil?
+
+        repo = @base_repo.new constantize("TFSGraph::#{type.capitalize}")
+
+        instance_variable_set(repo_memo(type), repo)
+        repo
+      end
+
+      define_singleton_method "#{type}_repository" do
+        instance.send "#{type}_repository"
+      end
+    end
+
+    private
+    def repo_memo(type)
+      "@#{type}_repo"
+    end
+  end
+end

data/lib/tfs_graph/server_registry.rb

@@ -0,0 +1,45 @@
+require 'redis-namespace'
+
+module TFSGraph
+  class ServerRegistry
+    include Singleton
+
+    DEFAULT_REDIS = {url: "redis://localhost:6379", namespace: "tfs_graph" }
+
+    def reset!
+      @redis = nil
+    end
+
+    def self.register
+      instance.reset!
+
+      yield instance if block_given?
+      instance
+    end
+
+    def initialize
+      reset!
+    end
+
+    def server(server_obj=nil)
+      return @server if @server && server_obj.nil?
+      raise ArgumentError, "Need to register a server first" unless server_obj
+
+      @server = server_obj
+    end
+
+    def redis(url: DEFAULT_REDIS[:url], namespace: DEFAULT_REDIS[:namespace])
+      return @redis unless @redis.nil?
+
+      @redis = Redis::Namespace.new(namespace, redis: Redis.connect(url: url))
+    end
+
+    define_singleton_method :redis do |url: DEFAULT_REDIS[:url], namespace: DEFAULT_REDIS[:namespace]|
+      instance.redis url: url, namespace: namespace
+    end
+
+    define_singleton_method :server do |server_obj=nil|
+      instance.server server_obj
+    end
+  end
+end

data/lib/tfs_graph/store_helpers.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'tfs_graph/server_registry'
 
 module TFSGraph
   module StoreHelpers
@@ -6,9 +7,7 @@ module TFSGraph
 
     # flush by key so that we only disturbe our namespace
     def flush_all
-      redis.keys("*").each do |k|
-        redis.del k
-      end
+      RepositoryRegistry.project_repository.drop_all
     end
 
     def mark_as_updated(time=nil)
@@ -18,14 +17,14 @@ module TFSGraph
 
     def last_updated_on
       date = redis.get(UPDATED_KEY)
-      return Time.now unless date
+      return Time.at(0).localtime unless date
 
       Time.parse(date).localtime
     end
 
     private
     def redis
-      Related.redis
+      ServerRegistry.redis
     end
   end
 end