neo4j-wrapper 0.0.1-java

data/lib/example.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'neo4j-wrapper'
+
+class Company
+  include Neo4j::NodeMixin
+  has_n(:employees)
+end
+
+class Person
+  include Neo4j::NodeMixin
+  property :name
+  property :age, :size, :type => Fixnum, :index => :exact
+  property :description, :index => :fulltext
+
+  has_one(:best_friend)
+  has_n(:employed_by).from(:employees)
+end
+
+Neo4j::Transaction.run do
+  Person.new(:name => 'jimmy', :age => 35)
+end
+
+person = Person.find(:age => (10..42)).first
+
+Neo4j::Transaction.run do
+  person.best_friend = Person.new
+  person.employed_by << Company.new(:name => "Foo ab")
+end
+
+company = person.employed_by.find { |p| p[:name] == 'Foo ab' }
+puts "Person #{person.name} employed by #{company[:name]}"
+
+company.employees.each {|x| puts x.name}
+

data/lib/neo4j/identity_map.rb

@@ -0,0 +1,109 @@
+module Neo4j
+
+  # = Neo4j Identity Map
+  #
+  # Ensures that each object gets loaded only once by keeping every loaded
+  # object in a map. Looks up objects using the map when referring to them.
+  #
+  # More information on Identity Map pattern:
+  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
+  #
+  # == Configuration
+  #
+  # In order to enable IdentityMap, set <tt>config.neo4j.identity_map = true</tt>
+  # in your <tt>config/application.rb</tt> file. If used outside rails, set Neo4j::Config[:identity_map] = true.
+  #
+  # IdentityMap is disabled by default and still in development (i.e. use it with care).
+  #
+  module IdentityMap
+
+    class << self
+      def enabled=(flag)
+        Thread.current[:neo4j_identity_map] = flag
+      end
+
+      def enabled
+         Thread.current[:neo4j_identity_map] == true
+      end
+
+      alias enabled? enabled
+
+      def node_repository
+        Thread.current[:node_identity_map] ||= java.util.HashMap.new
+      end
+
+      def rel_repository
+        Thread.current[:rel_identity_map] ||= java.util.HashMap.new
+      end
+
+      def repository_for(neo_entity)
+        return nil unless enabled?
+        if neo_entity.class == Neo4j::Node
+          node_repository
+        elsif neo_entity.class == Neo4j::Relationship
+          rel_repository
+        else
+          nil
+        end
+      end
+
+      def use
+        old, self.enabled = enabled, true
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def without
+        old, self.enabled = enabled, false
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      def get(neo_entity)
+        r = repository_for(neo_entity)
+        r && r.get(neo_entity.neo_id)
+      end
+
+      def add(neo_entity, wrapped_entity)
+        r = repository_for(neo_entity)
+        r && r.put(neo_entity.neo_id, wrapped_entity)
+      end
+
+      def remove(neo_entity)
+        r = repository_for(neo_entity)
+        r && r.remove(neo_entity.neo_id)
+      end
+
+      def remove_node_by_id(node_id)
+        node_repository.remove(node_id)
+      end
+
+      def remove_rel_by_id(rel_id)
+        rel_repository.remove(rel_id)
+      end
+
+      def clear
+        node_repository.clear
+        rel_repository.clear
+      end
+
+      def on_after_commit(*)
+        clear
+      end
+
+      def on_neo4j_started(db)
+        if !Neo4j::Config[:identity_map] && !enabled
+          db.event_handler.remove(self)
+        end
+      end
+
+    end
+
+  end
+end
+
+Neo4j.unstarted_db.event_handler.add(Neo4j::IdentityMap)
+

data/lib/neo4j/node_mixin.rb

@@ -0,0 +1,74 @@
+module Neo4j
+
+  # This mixin is used to wrap Neo4j Java Nodes in Ruby objects.
+  #
+  # @example Declare and Use a Lucene Index
+  #
+  #   class Contact
+  #      include Neo4j::NodeMixin
+  #      property :phone, :index => :exact
+  #   end
+  #
+  #   # Find an contact with a phone number
+  #   Contact.find('phone: 12345').first #=> a phone object !
+  #
+  #
+  # = Class Method Modules
+  # * {Neo4j::Wrapper::ClassMethods}
+  # * {Neo4j::Wrapper::NodeMixin::ClassMethods}
+  # * {Neo4j::Wrapper::Property::ClassMethods}
+  # * {Neo4j::Wrapper::HasN::ClassMethods}
+  # * {Neo4j::Wrapper::Find}
+  # * {Neo4j::Wrapper::Rule::ClassMethods}
+  # * {http://rdoc.info/github/andreasronge/neo4j-core/master/Neo4j/Core/Index/ClassMethods Neo4j::Core::Index::ClassMethods}
+  #
+  # = Instance Method Modules
+  # * {http://rdoc.info/github/andreasronge/neo4j-core/master/Neo4j/Core/Index Neo4j::Core::Index}
+  module NodeMixin
+    include Neo4j::Wrapper::NodeMixin::Delegates
+    include Neo4j::Wrapper::NodeMixin::Initialize
+    include Neo4j::Wrapper::HasN::InstanceMethods
+    include Neo4j::Wrapper::Rule::InstanceMethods
+    include Neo4j::Core::Index
+
+    # @private
+    def self.included(klass)
+      klass.extend Neo4j::Wrapper::ClassMethods
+      klass.extend Neo4j::Wrapper::NodeMixin::ClassMethods
+      klass.extend Neo4j::Wrapper::Property::ClassMethods
+      klass.extend Neo4j::Wrapper::HasN::ClassMethods
+      klass.extend Neo4j::Core::Index::ClassMethods
+      klass.extend Neo4j::Wrapper::Find
+      klass.extend Neo4j::Wrapper::Rule::ClassMethods
+
+      klass.send(:include, Neo4j::Wrapper::Rule::Functions)
+
+
+      klass.node_indexer do
+        index_names :exact => "#{klass._index_name}_exact", :fulltext => "#{klass._index_name}_fulltext"
+        trigger_on :_classname => klass.to_s
+        prefix_index_name &klass.method(:index_prefix)
+      end
+
+      def klass.inherited(sub_klass)
+        return super if sub_klass.to_s == self.to_s
+        base_class = self
+
+        # make the base class trigger on the sub class nodes
+        base_class._indexer.config.trigger_on :_classname => sub_klass.to_s
+
+        sub_klass.inherit_rules_from self
+
+        sub_klass.node_indexer do
+          inherit_from base_class
+          index_names :exact => "#{sub_klass._index_name}_exact", :fulltext => "#{sub_klass._index_name}_fulltext"
+          trigger_on :_classname => sub_klass.to_s
+          prefix_index_name &sub_klass.method(:index_prefix)
+        end
+        super
+      end
+      super
+    end
+
+  end
+end

data/lib/neo4j/relationship_mixin.rb

@@ -0,0 +1,62 @@
+module Neo4j
+  # Use this mixin to wrap Neo4j Relationship Java object.
+  # This mixin is similar to Neo4j::NodeMixin which wraps Neo4j::Node Java objects.
+  #
+  # @example
+  #   class Friend
+  #      include Neo4j::RelationshipMixin
+  #      property :since, :type => Fixnum, :index => :exact
+  #      property :strength, :type => Float
+  #      property :location
+  #    end
+  #
+  #  Friend.new(:knows, node_a, node_b, :strength => 3.14)
+  #  Friend.find(:strength => (2..5)).first
+  #
+  # = Class Method Modules
+  # * {Neo4j::Wrapper::RelationshipMixin::ClassMethods}
+  # * {Neo4j::Wrapper::Property::ClassMethods}
+  # * {Neo4j::Core::Index::ClassMethods}
+  # * {Neo4j::Wrapper::Find}
+  module RelationshipMixin
+
+    include Neo4j::Wrapper::RelationshipMixin::Initialize
+    include Neo4j::Wrapper::RelationshipMixin::Delegates
+
+    # @private
+    def self.included(klass)
+      klass.extend Neo4j::Wrapper::ClassMethods
+      klass.extend Neo4j::Wrapper::RelationshipMixin::ClassMethods
+      klass.extend Neo4j::Wrapper::Property::ClassMethods
+      klass.extend Neo4j::Core::Index::ClassMethods
+      klass.extend Neo4j::Wrapper::Find
+
+      index_name = klass.to_s.gsub("::", '_')
+
+      klass.rel_indexer do
+        index_names :exact => "#{index_name}_exact", :fulltext => "#{index_name}_fulltext"
+        trigger_on :_classname => klass.to_s
+      end
+
+      def klass.inherited(sub_klass)
+        return super if sub_klass.to_s == self.to_s
+        index_name = sub_klass.to_s.gsub("::", '_')
+        base_class = self
+
+        # make the base class trigger on the sub class nodes
+        base_class._indexer.config.trigger_on :_classname => sub_klass.to_s
+
+        sub_klass.rel_indexer do
+          inherit_from base_class
+          index_names :exact => "#{index_name}_exact", :fulltext => "#{index_name}_fulltext"
+          trigger_on :_classname => sub_klass.to_s
+        end
+        super
+      end
+
+      super
+
+    end
+
+  end
+end

data/lib/neo4j/type_converters/type_converters.rb

@@ -0,0 +1,333 @@
+module Neo4j
+
+  # Responsible for converting values from and to Java Neo4j and Lucene.
+  # You can implement your own converter by implementing the method <tt>convert?</tt>, <tt>index_as</tt>
+  # <tt>to_java</tt> and <tt>to_ruby</tt> in this module.
+  #
+  # There are currently three default converters that are triggered when a Time, Date or a DateTime is read or written
+  # if there is a type declared for the property.
+  #
+  # @example  writing your own marshalling converter:
+  #
+  #  class Foo
+  #     include Neo4j::NodeMixin
+  #     property :thing, :type => MyType
+  #  end
+  #
+  #  module Neo4j::TypeConverters
+  #    class MyTypeConverter
+  #      class << self
+  #        def convert?(type)
+  #          type == MyType
+  #        end
+  #
+  #        def to_java(val)
+  #          "silly:#{val}"
+  #        end
+  #
+  #        def to_ruby(val)
+  #          val.sub(/silly:/, '')
+  #        end
+  #
+  #        def index_as
+  #          String
+  #        end
+  #      end
+  #    end
+  #  end
+  #
+  module TypeConverters
+
+    # The default converter to use if there isn't a specific converter for the type
+    class DefaultConverter
+      class << self
+
+        def to_java(value)
+          value
+        end
+
+        def to_ruby(value)
+          value
+        end
+
+        def index_as
+          String
+        end
+      end
+    end
+
+
+    class BooleanConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          :boolean == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          !!value && value != '0'
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          !!value && value != '0'
+        end
+
+        def index_as
+          String
+        end
+      end
+
+    end
+
+    class SymbolConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          :symbol == class_or_symbol || Symbol == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_sym
+        end
+
+        def index_as
+          String
+        end
+
+      end
+    end
+
+
+    class StringConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          [String, :string, :text].include? class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_s
+        end
+
+        def index_as
+          String
+        end
+
+      end
+    end
+
+
+
+    class FixnumConverter
+      class << self
+
+        def convert?(class_or_symbol)
+          Fixnum == class_or_symbol || :fixnum == class_or_symbol || :numeric == class_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_i
+        end
+
+        def index_as
+          Fixnum
+        end
+
+      end
+    end
+
+    class FloatConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Float == clazz_or_symbol || :float == clazz_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          value.to_f
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value.to_f
+        end
+
+        def index_as
+          Float
+        end
+
+      end
+    end
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Date == clazz_or_symbol || :date == clazz_or_symbol
+        end
+
+        def to_java(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc.to_date
+        end
+
+        def index_as
+          Fixnum
+        end
+
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          DateTime == clazz_or_symbol || :datetime == clazz_or_symbol
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          t = Time.at(value).utc
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+
+        def index_as
+          Fixnum
+        end
+
+      end
+    end
+
+    class TimeConverter
+      class << self
+
+        def convert?(clazz_or_symbol)
+          Time == clazz_or_symbol || :time == clazz_or_symbol
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            value.utc.to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+
+        def index_as
+          Fixnum
+        end
+
+      end
+    end
+
+    class << self
+
+      # Mostly for testing purpose, You can use this method in order to
+      # add a converter while the neo4j has already started.
+      def converters=(converters)
+        @converters = converters
+      end
+      
+      # Always returns a converter that handles to_ruby or to_java
+      # if +enforce_type+ is set to false then it will raise in case of unknown type
+      # otherwise it will return the DefaultConverter.
+      def converter(type = nil, enforce_type = true)
+        return DefaultConverter unless type
+        @converters ||= begin
+          Neo4j::TypeConverters.constants.find_all do |c|
+            Neo4j::TypeConverters.const_get(c).respond_to?(:convert?)
+          end.map do  |c|
+            Neo4j::TypeConverters.const_get(c)
+          end
+        end
+        found = @converters.find {|c| c.convert?(type) }
+        raise "The type #{type.inspect} is unknown. Use one of #{@converters.map{|c| c.name }.join(", ")} or create a custom type converter." if !found && enforce_type
+        found or DefaultConverter
+      end
+
+      # Converts the given value to a Java type by using the registered converters.
+      # It just looks at the class of the given value unless an attribute name is given.
+      def convert(value, attribute = nil, klass = nil, enforce_type = true)
+        converter(attribute_type(value, attribute, klass), enforce_type).to_java(value)
+      end
+
+      # Converts the given property (key, value) to Java if there is a type converter for given type.
+      # The type must also be declared using Neo4j::NodeMixin#property property_name, :type => clazz
+      # If no Converter is defined for this value then it simply returns the given value.
+      def to_java(clazz, key, value)
+        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
+        converter(type).to_java(value)
+      end
+
+      # Converts the given property (key, value) to Ruby if there is a type converter for given type.
+      # If no Converter is defined for this value then it simply returns the given value.
+      def to_ruby(clazz, key, value)
+        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
+        converter(type).to_ruby(value)
+      end
+
+      private
+      def attribute_type(value, attribute = nil, klass = nil)
+        type = (attribute && klass) ? attribute_type_from_attribute_and_klass(value, attribute, klass) : nil
+        type || attribute_type_from_value(value)
+      end
+
+      def attribute_type_from_attribute_and_klass(value, attribute, klass)
+        if klass.respond_to?(:_decl_props)
+          (klass._decl_props.has_key?(attribute) && klass._decl_props[attribute][:type]) ? klass._decl_props[attribute][:type] : nil
+        end
+      end
+
+      def attribute_type_from_value(value)
+        value.class
+      end
+    end
+  end
+end

data/lib/neo4j-wrapper/class_methods.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  # Responsible for loading the correct Ruby wrapper class for the Neo4j Entity
+  module Wrapper
+    module ClassMethods
+      # Loads the wrapper by using the original new method and initialize it
+      # @private
+      def _load_wrapper(node)
+        wrapped_node = self.orig_new
+        wrapped_node.init_on_load(node)
+        wrapped_node
+      end
+
+      # Creates an alias to the original new method:  <tt>orig_new</t>
+      # @private
+      def self.extended(klass)
+        klass.instance_eval do
+          class << self
+            alias_method :orig_new, :new
+          end
+        end unless klass.respond_to?(:orig_new)
+        super
+      end
+    end
+  end
+end
+
+