neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j/to_java.rb

@@ -1,31 +0,0 @@
-module Neo4j
-  module ToJava
-
-    def type_to_java(type)
-      org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
-    end
-
-    def dir_to_java(dir)
-      case dir
-        when :outgoing then org.neo4j.graphdb.Direction::OUTGOING
-        when :both     then org.neo4j.graphdb.Direction::BOTH
-        when :incoming then org.neo4j.graphdb.Direction::INCOMING
-        else raise "unknown direction '#{dir}', expects :outgoing, :incoming or :both"
-      end
-    end
-  end
-end
-
-
-org.neo4j.kernel.impl.core.IntArrayIterator.class_eval do
-  def each_wrapped
-    while(hasNext())
-      yield self.next().wrapper
-    end
-  end
-
-  def wrapped
-    Enumerator.new(self, :each_wrapped)
-  end
-
-end

data/lib/neo4j/transaction.rb

@@ -1,68 +0,0 @@
-module Neo4j
-  #
-  # All modifying operations that work with the node space must be wrapped in a transaction. Transactions are thread confined.
-  # Neo4j does not implement true nested transaction, instead it uses flat nested transactions
-  # see http://wiki.neo4j.org/content/Flat_nested_transactions
-  #
-  class Transaction
-
-    # Starts a new Neo4j Transaction
-    # Returns a Java Neo4j Transaction object
-    # See http://api.neo4j.org/current/org/neo4j/graphdb/Transaction.html
-    #
-    # Example:
-    #  tx = Neo4j::Transaction.new
-    #  # modify something
-    #  tx.success
-    #  tx.finish
-    def self.new(instance = Neo4j.started_db)
-      instance.begin_tx
-    end
-
-    # Runs a block in a Neo4j transaction
-    #
-    # Many operations on neo requires an transaction. You will get much better performance if
-    # one transaction is wrapped around several neo operation instead of running one transaction per
-    # neo operation.
-    # If one transaction is already running then a 'placebo' transaction will be created.
-    # Performing a finish on a placebo transaction will not finish the 'real' transaction.
-    #
-    # ==== Params
-    # ::yield:: the block to be performed in one transaction
-    #
-    # ==== Examples
-    #  include 'neo4j'
-    #
-    #  Neo4j::Transaction.run {
-    #    node = PersonNode.new
-    #  }
-    #
-    # You have also access to transaction object
-    #
-    #   Neo4j::Transaction.run { |t|
-    #     # something failed
-    #     t.failure # will cause a rollback
-    #   }
-
-    # If an exception occurs inside the block the transaction will rollback automatically
-    #
-    # ==== Returns
-    # The value of the evaluated provided block
-    #
-    def self.run # :yield: block that will be executed in a transaction
-      raise ArgumentError.new("Expected a block to run in Transaction.run") unless block_given?
-
-      begin
-        tx = Neo4j::Transaction.new
-        ret = yield tx
-        tx.success
-      rescue Exception
-        tx.failure unless tx.nil?
-        raise
-      ensure
-        tx.finish unless tx.nil?
-      end
-      ret
-    end
-  end
-end

data/lib/neo4j/type_converters.rb

@@ -1,98 +0,0 @@
-module Neo4j
-
-  # Responsible for converting values from and to Java Neo4j and Lucene.
-  # You can implement your own converter by implementing the method <tt>to_java</tt> and <tt>to_ruby</tt>
-  # and add it to the Neo4j::Config with the key <tt>:converters</tt>
-  #
-  # There are currently two default converters that are triggered when a Date or a DateTime is read or written.
-  #
-  module TypeConverters
-
-    # Converts Date objects to Java long types. Must be timezone UTC.
-    class DateConverter
-      class << self
-        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
-        end
-      end
-    end
-
-    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
-    class DateTimeConverter
-      class << self
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
-        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
-      end
-    end
-    
-    class TimeConverter
-    	class << self
-    		# Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          value.utc.to_i
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc
-        end
-    	end
-    end
-
-    # Converts the given value to a Java type by using the registered converters.
-    # It just looks at the class of the given value and will convert it if there is a converter
-    # registered (in Neo4j::Config) for this value.
-    def self.convert(value)
-      type      = value.class
-      converter = Neo4j.converters[type]
-      return value unless converter
-      converter.to_java(value)
-    end
-
-    # Converts the given property (key, value) to Java by using configuration from the given class.
-    # If no Converter is defined for this value then it simply returns the given value.
-    def self.to_java(clazz, key, value)
-      type = clazz._decl_props[key] && clazz._decl_props[key][:type]
-      if type
-        converter = Neo4j.converters[type]
-        converter ? converter.to_java(value) : value
-      elsif clazz.superclass != Object
-        to_java(clazz.superclass, key, value)
-      else
-        value
-      end
-    end
-
-    # Converts the given property (key, value) to Ruby by using configuration from the given class.
-    # If no Converter is defined for this value then it simply returns the given value.
-    def self.to_ruby(clazz, key, value)
-      type = clazz._decl_props[key] && clazz._decl_props[key][:type]
-      if type
-        converter = Neo4j.converters[type]
-        converter ? converter.to_ruby(value) : value
-      elsif clazz.superclass != Object
-        to_ruby(clazz.superclass, key, value)
-      else
-        value
-      end
-    end
-  end
-end