neo4j 1.0.0.beta.9 → 1.0.0.beta.10

data/lib/neo4j.old/config.rb

@@ -1,138 +0,0 @@
-
-module Neo4j
-
-
-  # Keeps configuration for neo4j.
-  #
-  # Neo4j::Config[:storage_path]:: is used for locating the neo4j database on the filesystem.
-  # Neo4j::Config[:rest_port]:: used by the REST extension for starting a web server on a port
-  #
-  class Config
-    # This code is copied from merb-core/config.rb.
-    class << self
-      # Returns the hash of default config values for neo4j
-      #
-      # ==== Returns
-      # Hash:: The defaults for the config.
-      def defaults
-        @defaults ||= {
-          :storage_path => 'tmp/neo4j',
-          :rest_port => 9123
-        }
-      end
-
-     
-      # Yields the configuration.
-      #
-      # ==== Block parameters
-      # c<Hash>:: The configuration parameters.
-      #
-      # ==== Examples
-      # Neo4j::Config.use do |config|
-      # config[:storage_path] = '/var/neo4j'
-      # end
-      #
-      # ==== Returns
-      # nil
-      def use
-        @configuration ||= {}
-        yield @configuration
-        nil
-      end
-      
-      
-      # Set the value of a config entry.
-      #
-      # ==== Parameters
-      # key<Object>:: The key to set the parameter for.
-      # val<Object>:: The value of the parameter.
-      #
-      def []=(key, val)
-        (@configuration ||= setup)[key] = val
-      end
-
-
-      # Gets the the value of a config entry
-      #
-      # ==== Parameters
-      # key<Object>:: The key of the config entry value we want
-      #
-      def [](key)
-        (@configuration ||= setup)[key]
-      end
-
-
-      # Remove the value of a config entry.
-      #
-      # ==== Parameters
-      # key<Object>:: The key of the parameter to delete.
-      #
-      # ==== Returns
-      # Object:: The value of the removed entry.
-      #
-      def delete(key)
-        @configuration.delete(key)
-      end
-
-
-      # Remove all configuration. This can be useful for testing purpose.
-      #
-      #
-      # ==== Returns
-      # nil
-      #
-      def delete_all
-        @configuration = nil
-      end
-
-
-      # Retrieve the value of a config entry, returning the provided default if the key is not present
-      #
-      # ==== Parameters
-      # key<Object>:: The key to retrieve the parameter for.
-      # default<Object>::
-      # The default value to return if the parameter is not set.
-      #
-      # ==== Returns
-      # Object:: The value of the configuration parameter or the default.
-      #
-      def fetch(key, default)
-        @configuration.fetch(key, default)
-      end
-
-      # Sets up the configuration
-      #
-      # ==== Returns
-      # The configuration as a hash.
-      #
-      def setup()
-        @configuration = {}
-        @configuration.merge!(defaults)
-        @configuration
-      end
-
-
-      # Returns the configuration as a hash.
-      #
-      # ==== Returns
-      # Hash:: The config as a hash.
-      #
-      # :api: public
-      def to_hash
-        @configuration
-      end
-
-      # Returns the config as YAML.
-      #
-      # ==== Returns
-      # String:: The config as YAML.
-      #
-      # :api: public
-      def to_yaml
-        require "yaml"
-        @configuration.to_yaml
-      end
-    end
-  end
-
-end

data/lib/neo4j.old/event_handler.rb

@@ -1,73 +0,0 @@
-module Neo4j
-
-  # Handles events like a new node is created or deleted
-  class EventHandler
-    def initialize
-      @listeners = []
-      @filter_classes = []
-    end
-
-    def add(listener)
-      @listeners << listener unless @listeners.include?(listener)
-      add_filter(listener) # the listener do not want to get events on it self
-    end
-
-    def remove(listener)
-      @listeners.delete(listener)
-    end
-
-    def remove_all
-      @listeners = []
-    end
-
-    def print
-      puts "Listeners #{@listeners.size}"
-      @listeners.each {|li| puts "  Listener '#{li}'"}
-    end
-
-    def add_filter(filter_class)
-      @filter_classes << filter_class  unless @filter_classes.include?(filter_class)
-    end
-
-    def remove_filter(filter_class)
-      @filter_classes.delete filter_class
-    end
-
-    def node_created(node)
-      return if @filter_classes.include?(node.class)
-      @listeners.each {|li| li.on_node_created(node) if li.respond_to?(:on_node_created)}
-    end
-
-    def node_deleted(node)
-      return if @filter_classes.include?(node.class)
-      @listeners.each {|li| li.on_node_deleted(node) if li.respond_to?(:on_node_deleted)}
-    end
-
-    def relationship_created(relationship)
-      return if @filter_classes.include?(relationship.class)
-      @listeners.each {|li| li.on_relationship_created(relationship) if li.respond_to?(:on_relationship_created)}
-    end
-
-    def relationship_deleted(relationship)
-      return if @filter_classes.include?(relationship.class)
-      @listeners.each {|li| li.on_relationship_deleted(relationship) if li.respond_to?(:on_relationship_deleted)}
-    end
-
-    def property_changed(node, key, old_value, new_value)
-      return if @filter_classes.include?(node.class)
-      @listeners.each {|li| li.on_property_changed(node, key, old_value, new_value) if li.respond_to?(:on_property_changed)}
-    end
-
-    def tx_finished(tx)
-      @listeners.each {|li| li.on_tx_finished(tx) if li.respond_to?(:on_tx_finished)}
-    end
-
-    def neo_started(neo_instance)
-      @listeners.each {|li|  li.on_neo_started(neo_instance)  if li.respond_to?(:on_neo_started)}
-    end
-
-    def neo_stopped(neo_instance)
-      @listeners.each {|li| li.on_neo_stopped(neo_instance) if li.respond_to?(:on_neo_stopped)}
-    end
-  end
-end

data/lib/neo4j.old/extensions/activemodel.rb

@@ -1,158 +0,0 @@
-require 'rubygems'
-require 'singleton'
-require 'neo4j'
-require 'active_model'
-
-
-module Neo4j::NodeMixin
-  def to_model
-    Neo4j::ActiveModel::ActiveModelFactory.instance.to_model(self)
-  end
-
-  def attributes
-    attr = props
-    attr.keys.each {|k| attr.delete k if k[0] == ?_}
-    attr
-  end
-
-end
-
-module Neo4j::ActiveModel
-
-  def self.on_property_changed(node, key, old_value, new_value)
-    # make model dirty since it is changed
-    ActiveModelFactory.instance.dirty_node!(node.neo_id)
-  end
-
-  def self.on_tx_finished(tx)
-    # make all models clean again
-    ActiveModelFactory.instance.clean!
-  end
-
-  class ActiveModelFactory
-    private
-    def initialize
-      @classes = {}
-      @node_models = {}
-      Thread.current[:neo4j_active_model_factory] = self
-      Neo4j.event_handler.add(self)
-    end
-
-    public
-    def self.instance
-      # create one Neo4jActiveModelFactory for each thread
-      # since a transaction belongs to a thread and we don't want
-      # side effect of one transaction making model object dirty or clean for a different transaction
-      # in a different thread.
-      Thread.current[:neo4j_active_model_factory] || ActiveModelFactory.new
-    end
-
-    def dirty_node!(neo_id)
-      @node_models[neo_id] && @node_models[neo_id].dirty!
-    end
-
-    def clean!
-      @node_models.clear
-    end
-
-    def to_model(obj)
-      @node_models[obj.neo_id] || create_model_for(obj)
-    end
-
-    def create_model_for(obj)
-      clazz = @classes[obj.class] || create_wrapped_class_for(obj)
-      @node_models[obj.neo_id] = clazz.new(obj)
-    end
-
-    def create_wrapped_class_for(obj)
-      clazz = Class.new do
-        def initialize(wrapped)
-          @dirty = false
-          @wrapped = wrapped
-        end
-
-        def dirty!
-          @dirty = true
-        end
-
-        def persisted?
-          ! @dirty
-        end
-
-        def to_key
-          persisted? ? @wrapped.neo_id : nil
-        end
-
-        def to_param
-          to_key
-        end
-
-        if obj.respond_to?(:errors)
-          def errors;
-            @wrapped.errors;
-          end
-        else
-          def errors
-            object = Object.new
-
-            def object.[](key)
-              []
-            end
-
-            def object.full_messages()
-              []
-            end
-
-            object
-          end
-        end
-
-        if obj.respond_to?(:valid?)
-          def valid?;
-            @wrapped.valid?;
-          end
-        else
-          def valid?
-            true
-          end
-        end
-      end
-
-      singleton = class << clazz;
-        self;
-      end
-      singleton.class_eval do
-        # class methods
-        define_method :model_name do
-          @_model_name ||= ActiveModel::Name.new(obj.class)
-        end
-      end
-
-      @classes[obj.class] = clazz
-      clazz
-    end
-
-  end
-
-  Neo4j.event_handler.add(self)
-end
-
-
-
-#class LintTest < ActiveModel::TestCase
-#  include ActiveModel::Lint::Tests
-#
-#  class MyModel
-#    include Neo4j::NodeMixin
-#  end
-#
-#  def setup
-#    @model = MyModel.new
-#  end
-#
-#end
-#
-#require 'test/unit/ui/console/testrunner'
-#Neo4j::Transaction.run do
-#  Test::Unit::UI::Console::TestRunner.run(LintTest)
-#end

data/lib/neo4j.old/extensions/aggregate/aggregate_enum.rb

@@ -1,40 +0,0 @@
-module Neo4j::Aggregate
-  # Used for an enumerable result of aggregates
-  # See Neo4j::NodeMixin#aggregates
-  #
-  # :api: private
-  class AggregateEnum #:nodoc:
-    include Enumerable
-
-    def initialize(node)
-      @node = node
-    end
-
-    def empty?
-      each {true}.nil?
-    end
-
-    def each
-      # if node is an aggregate group then we should look for parent aggregates
-      if (@node.property?(:aggregate_group))
-        @node.rels.incoming.nodes.each do |parent_group|
-          next unless parent_group.property?(:aggregate_size)
-          # if it has the property aggregate_group then it is a group node
-          if (parent_group.property?(:aggregate_group))
-            AggregateEnum.new(parent_group).each {|agg| yield agg}
-          else
-            # aggregate found
-            yield parent_group
-          end
-        end
-      else
-        # the given node (@node) is not a group, we guess it is an leaf in an aggregate
-        # get all the groups that this leaf belongs to and then those groups aggregate nodes
-        @node.rels.incoming(:aggregate).nodes.each do |group|
-          AggregateEnum.new(group ).each {|agg| yield agg}
-        end
-      end
-    end
-  end
-
-end

data/lib/neo4j.old/extensions/aggregate/ext/node_mixin.rb

@@ -1,69 +0,0 @@
-org.neo4j.kernel.impl.core.NodeProxy.class_eval do
-
-  # Returns an enumeration of aggregates that this nodes belongs to.
-  #
-  # Is used in combination with the Neo4j::AggregateNodeMixin
-  #
-  # ==== Example
-  #
-  #   class MyNode
-  #      include Neo4j::NodeMixin
-  #      include Neo4j::NodeAggregateMixin
-  #   end
-  #
-  #   agg1 = MyNode
-  #   agg1.aggregate([node1,node2]).group_by(:colour)
-  #
-  #   agg2 = MyNode
-  #   agg2.aggregate([node1,node2]).group_by(:age)
-  #
-  #   [*node1.aggregates] # => [agg1, agg2]
-  #
-  def aggregates
-    Neo4j::Aggregate::AggregateEnum.new(self)
-  end
-
-  # Returns an enumeration of groups that this nodes belongs to.
-  #
-  # Is used in combination with the Neo4j::AggregateNodeMixin
-  #
-  # ==== Parameters
-  #
-  # * group which aggregate group we want, default is :all - an enumeration of all groups will be return
-  #
-  #
-  # ==== Returns
-  # an enumeration of all groups that this node belongs to, or if the group parameter was used
-  # only the given group or nil if not found.
-  #
-  # ==== Example
-  #
-  #   class MyNode
-  #      include Neo4j::NodeMixin
-  #      include Neo4j::AggregateNodeMixin
-  #   end
-  #
-  #   agg1 = MyNode
-  #   agg1.aggregate(:colours).group_by(:colour)
-  #
-  #   agg2 = MyNode
-  #   agg2.aggregate(:age).group_by(:age)
-  #
-  #   agg1 << node1
-  #   agg2 << node1
-  #
-  #   [*node1.aggregate_groups] # => [agg1[some_group], agg2[some_other_group]]
-  #
-  def aggregate_groups(group = :all)
-    return rels.incoming(:aggregate).nodes if group == :all
-    [*rels.incoming(:aggregate).filter{self[:aggregate_group] == group.to_s}.nodes][0]
-  end
-
-end
-
-
-module Neo4j
-  module NodeMixin
-   def_delegators :@_java_node, :aggregate_groups, :aggregates
-  end
-end

data/lib/neo4j.old/extensions/aggregate/node_aggregate.rb

@@ -1,8 +0,0 @@
-module Neo4j::Aggregate
-
-  class NodeAggregate
-    include Neo4j::NodeMixin
-    include Neo4j::Aggregate::NodeAggregateMixin
-  end
-
-end