neo4r 0.0.3

data/lib/neo4r/rest_wrapper.rb

@@ -0,0 +1,10 @@
+module Neo4r
+  # REST API proxy class
+  class RestWrapper
+    @@rest = Neography::Rest.new
+    def method_missing(name, *args, &block)
+      # Create rest object everytyime to avoid exception
+      @@rest.__send__ name, *args, &block
+    end
+  end
+end

data/lib/neo4r/type_converters.rb

@@ -0,0 +1,336 @@
+module Neo4r
+
+  # 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 Neo4r::NodeMixin
+  #     property :thing, type: MyType
+  #  end
+  #
+  #  module Neo4r::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?
+          Array === value ? value.map(&:to_s)  : value.to_s
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value
+        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?
+          Array === value ? value.map(&:to_i) : 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?
+          Array === value ? value.map(&:to_f) : value.to_f
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          value
+        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.
+        # DateTime values are automatically converted to UTC.
+        def to_java(value)
+          return nil if value.nil?
+          value = value.new_offset(0) if value.respond_to?(:new_offset)
+          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.is_a?(Date)
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          elsif value.is_a?(String)
+            Time.parse(value).utc.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
+          Neo4r::TypeConverters.constants.find_all do |c|
+            Neo4r::TypeConverters.const_get(c).respond_to?(:convert?)
+          end.map do  |c|
+            Neo4r::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 Neo4r::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/neo4r/version.rb

@@ -0,0 +1,3 @@
+module Neo4r
+  VERSION = "0.0.3"
+end

data/lib/neo4r/will_paginate.rb

@@ -0,0 +1,20 @@
+require 'will_paginate/collection'
+require 'will_paginate/per_page'
+require 'neo4r/paginated'
+
+module Neo4r
+  # The module provides the common interface for the pagination on any Enumerable class.
+  module WillPaginate
+    include ::WillPaginate::CollectionMethods
+
+    def paginate(options = {})
+      page = options[:page].to_i || 1
+      per_page = options[:per_page].to_i || ::WillPaginate.per_page
+      ::WillPaginate::Collection.create(page, per_page) do |pager|
+        res = ::Neo4r::Paginated.create_from(self, page, per_page)
+        pager.replace res.to_a
+        pager.total_entries = res.total unless pager.total_entries
+      end
+    end
+  end
+end

data/neo4r.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neo4r/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "neo4r"
+  spec.version       = Neo4r::VERSION
+  spec.authors       = ["Hiroyuki Sato"]
+  spec.email         = ["hiroyuki_sato@spiber.jp"]
+  spec.summary       = %q{A graph database for Ruby}
+  spec.description   = %q{A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks heavily inspired by ActiveRecord.}
+  spec.homepage      = "https://github.com/hiroponz/neo4r"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+
+  spec.add_runtime_dependency "activemodel", "~>3.2"
+  spec.add_runtime_dependency "activesupport", "~>3.2"
+  spec.add_runtime_dependency "neography", "~>1.6"
+  spec.add_runtime_dependency "will_paginate", "~>3.0"
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: neo4r
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Hiroyuki Sato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: neography
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks
+  heavily inspired by ActiveRecord.
+email:
+- hiroyuki_sato@spiber.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/neo4r.rb
+- lib/neo4r/attributes.rb
+- lib/neo4r/finder.rb
+- lib/neo4r/index_config_loader.rb
+- lib/neo4r/node.rb
+- lib/neo4r/node_relationship.rb
+- lib/neo4r/node_traverser.rb
+- lib/neo4r/paginated.rb
+- lib/neo4r/property_container.rb
+- lib/neo4r/relation.rb
+- lib/neo4r/relationship.rb
+- lib/neo4r/relationship_traverser.rb
+- lib/neo4r/rest_wrapper.rb
+- lib/neo4r/type_converters.rb
+- lib/neo4r/version.rb
+- lib/neo4r/will_paginate.rb
+- neo4r.gemspec
+homepage: https://github.com/hiroponz/neo4r
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: A graph database for Ruby
+test_files: []