neo4j 3.0.0.alpha.2 → 3.0.0.alpha.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3106c4da4e5d9b64e6532db51a5c8f9952ac5021
-  data.tar.gz: 90d7e176d183c6a4cbcb0599af69da46b828610c
+  metadata.gz: 7f3c1c35ef38235d2f240757530f1fec08473cc8
+  data.tar.gz: a0e24982bc743984f10a702d8933be694c9c2adf
 SHA512:
-  metadata.gz: 1dcb5b39e8e3d4298224c6cb2a7915724bf3844e52dba70796429394525abdffde42fcf0331ebadddb27154293640ee570cc3c85e8adef0b9f6cd20f11dda28c
-  data.tar.gz: ff3c1edf2057a71eadcfa0ada92dd38de54a07c7d66d6bfa62453cb25afae551da6faec8c52a6c24d4c3923a821013dd6d28afb323a6ac159a6650c8e888c785
+  metadata.gz: ee0818fd0db7f265ab529f0bf8792c862cec09daa137aa340f3b0f009d419e664c53c21541775be7c883dc66e29b016a360949a45eadffefce7966d54a9153d0
+  data.tar.gz: f37ed9996c2d068663e574887bf29828a29d9b9250144006701d14e4bc17b64259be36bf96c0ec4ca6046a52ed81d577b2300bdfc7f46629e73825bfec28af1b

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 3.0.0.alpha.3
+* Support for rails scaffolds
+* Support for created_at and updated_at (#305)
+* Support for ability to select a session to use per model (#299)
+* BugFix: updating a model should not clear out old properties (#296)
+
 == 3.0.0.alpha.2
 * Support for both embedded (only JRuby) and server API (runs on MRI Ruby !)
 * Simple Rails app now work

data/Gemfile

@@ -4,6 +4,8 @@ gemspec
 
 # gem 'neo4j-core', :path => '../neo4j-core'
 
+gem 'coveralls', require: false
+
 group 'development' do
   gem 'os' # for neo4j-server rake task
   gem 'rake'
@@ -12,4 +14,5 @@ end
 
 group 'test' do
   gem "rspec"
+  gem "its"
 end

data/README.md

@@ -1,12 +1,17 @@
-# Welcome to Neo4j.rb [![Build Status](https://secure.travis-ci.org/andreasronge/neo4j.png?branch=master)](http://travis-ci.org/andreasronge/neo4j) [![Dependency Status](https://gemnasium.com/andreasronge/neo4j.png)](https://gemnasium.com/andreasronge/neo4j)
-/Users/andreasronge/projects/neo4j-core/lib/neo4j-wrapper/delegates.rb
+# Welcome to Neo4j.rb [![Build Status](https://secure.travis-ci.org/andreasronge/neo4j.png?branch=master)](http://travis-ci.org/andreasronge/neo4j) [![Coverage Status](https://coveralls.io/repos/andreasronge/neo4j/badge.png)](https://coveralls.io/r/andreasronge/neo4j) [![Code Climate](https://codeclimate.com/github/andreasronge/neo4j.png)](https://codeclimate.com/github/andreasronge/neo4j)
+
 Neo4j.rb is a graph database for Ruby (and JRuby)
 
 ## Version 3.0
 
+Unstable !
+
 * Wiki: https://github.com/andreasronge/neo4j/wiki/Neo4j-v3
 * Example: https://github.com/andreasronge/neo4j/tree/3.0/example/blog
 
+## Version 2.x
+
+This is the stable version, see https://github.com/andreasronge/neo4j/tree/2.x
 
 ## Contributing
 

data/lib/neo4j.rb

@@ -16,6 +16,7 @@ require 'active_support/core_ext/class/attribute.rb'
 
 require 'active_attr'
 require 'neo4j/wrapper'
+require 'neo4j/type_converters'
 require "neo4j/active_node/labels"
 require 'neo4j/active_node/identity'
 require 'neo4j/active_node/callbacks'
@@ -28,3 +29,10 @@ require 'neo4j/active_node/has_n'
 require 'neo4j/active_node/has_n/decl_rel'
 require 'neo4j/active_node/has_n/nodes'
 require 'neo4j/active_node'
+
+if defined? Rails::Generators
+  # TODO, not sure this is the correct way of adding rails generators
+  # See https://github.com/andreasronge/neo4j/blob/gh-pages/neo4j.rb
+  # It is required from the rails config/application file
+  require 'rails/generators/neo4j_generator'
+end

data/lib/neo4j/active_node.rb

@@ -46,6 +46,19 @@ module Neo4j
       _persisted_node || raise("Tried to access native neo4j object on a none persisted object")
     end
 
+    module ClassMethods
+      def neo4j_session_name (name)
+        @neo4j_session_name = name
+      end
+
+      def neo4j_session
+        if @neo4j_session_name
+          Neo4j::Session.named(@neo4j_session_name) || raise("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
+        else
+          Neo4j::Session.current
+        end
+      end
+    end
 
     included do
       def self.inherited(other)
@@ -57,4 +70,4 @@ module Neo4j
       end
     end
   end
-end
+end

data/lib/neo4j/active_node/has_n/decl_rel.rb

@@ -201,8 +201,7 @@ module Neo4j
         end
 
         def all_relationships(node)
-          # TODO fix ruby warning - warning: Enumerator.new without a block is deprecated; use Object#to_enum
-          Enumerator.new(self, :each_rel, node)
+          to_enum(:each_rel, node)
         end
 
         def each_rel(node, &block) #:nodoc:
@@ -218,16 +217,9 @@ module Neo4j
         end
 
         # @private
-        def _each_node(node, &block) #:nodoc:
-          node._rels(dir: dir, type: rel_type).each do |rel|
-            block.call rel._other_node(node)
-          end
-        end
-
-        # @private
-        def create_relationship_to(node, other) # :nodoc:
+        def create_relationship_to(node, other, relationship_props={}) # :nodoc:
           from, to = incoming? ? [other, node] : [node, other]
-          from.create_rel(@rel_type, to)
+          from.create_rel(@rel_type, to, relationship_props)
         end
 
       end

data/lib/neo4j/active_node/has_n/nodes.rb

@@ -55,8 +55,8 @@ module Neo4j
 
         # Creates a relationship instance between this and the other node.
         # Returns the relationship object
-        def create(other)
-          @decl_rel.create_relationship_to(@node, other)
+        def create(other, relationship_props)
+          @decl_rel.create_relationship_to(@node, other, relationship_props)
         end
 
 

data/lib/neo4j/active_node/initialize.rb

@@ -1,15 +1,17 @@
 module Neo4j::ActiveNode::Initialize
   extend ActiveSupport::Concern
+  include Neo4j::TypeConverters
 
   attr_reader :_persisted_node
 
   # called when loading the node from the database
   # @param [Neo4j::Node] persisted_node the node this class wraps
-  # @param [Hash] properties properties of the persisted node.
+  # @param [Hash] properties of the persisted node.
   def init_on_load(persisted_node, properties)
     @_persisted_node = persisted_node
     @changed_attributes && @changed_attributes.clear
     @attributes = attributes.merge(properties.stringify_keys)
+    @attributes = convert_properties_to :ruby, @attributes
   end
 
   # Implements the Neo4j::Node#wrapper and Neo4j::Relationship#wrapper method

data/lib/neo4j/active_node/labels.rb

@@ -46,8 +46,8 @@ module Neo4j
 
         # Find all nodes/objects of this class, with given search criteria
         # @param [Hash, nil] args the search critera or nil if finding all
-        # @param [Neo4j::Session] session defaults to the current
-        def all(args = nil, session = Neo4j::Session.current)
+        # @param [Neo4j::Session] session defaults to the model's session
+        def all(args = nil, session = self.neo4j_session)
           if (args)
             find_by_hash(args, session)
           else
@@ -56,7 +56,7 @@ module Neo4j
         end
 
         # @return [Fixnum] number of nodes of this class
-        def count(session = Neo4j::Session.current)
+        def count(session = self.neo4j_session)
           q = session.query("MATCH (n:`#{mapped_label_name}`) RETURN count(n) AS count")
           q.to_a[0][:count]
         end
@@ -64,7 +64,7 @@ module Neo4j
         # Same as #all but return only one object
         # If given a String or Fixnum it will return the object with that neo4j id.
         # @param [Hash,String,Fixnum] args search criteria
-        def find(args, session = Neo4j::Session.current)
+        def find(args, session = self.neo4j_session)
           case args
             when Hash
               find_by_hash(args, session).first
@@ -78,14 +78,14 @@ module Neo4j
 
         # Destroy all nodes an connected relationships
         def destroy_all
-          Neo4j::Session.current._query("MATCH (n:`#{mapped_label_name}`)-[r]-() DELETE n,r")
-          Neo4j::Session.current._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
+          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`)-[r]-() DELETE n,r")
+          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
         end
 
         # Creates a Neo4j index on given property
         # @param [Symbol] property the property we want a Neo4j index on
         def index(property)
-          if Neo4j::Session.current
+          if self.neo4j_session
             _index(property)
           else
             Neo4j::Session.add_listener do |event, _|
@@ -134,9 +134,10 @@ module Neo4j
         def set_mapped_label_name(name)
           @_label_name = name.to_sym
         end
+
       end
 
     end
 
   end
-end
+end

data/lib/neo4j/active_node/persistence.rb

@@ -10,6 +10,7 @@ module Neo4j::ActiveNode
     end
 
     extend ActiveSupport::Concern
+    include Neo4j::TypeConverters
 
     # Saves the model.
     #
@@ -18,14 +19,22 @@ module Neo4j::ActiveNode
     # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
     # There’s a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
     def save(*)
+      # Update magic properties
+      update_magic_properties
       create_or_update
     end
 
+    def update_magic_properties
+      self.updated_at = DateTime.now if respond_to?(:updated_at=)
+    end
+
     # Creates a model with values matching those of the instance attributes and returns its id.
     # @private
     # @return true
     def create_model(*)
-      node = _create_node(props)
+      self.created_at = DateTime.now if respond_to?(:created_at=)
+      properties = convert_properties_to :db, props
+      node = _create_node(properties)
       init_on_load(node, node.props)
       # Neo4j::IdentityMap.add(node, self)
       # write_changed_relationships
@@ -94,13 +103,14 @@ module Neo4j::ActiveNode
     def update_model
       if @changed_attributes && !@changed_attributes.empty?
         changed_props = attributes.select{|k,v| @changed_attributes.include?(k)}
-        _persisted_node.props = changed_props
+        changed_props = convert_properties_to :db, changed_props
+        _persisted_node.update_props(changed_props)
         @changed_attributes.clear
       end
     end
 
     def _create_node(*args)
-      session = Neo4j::Session.current
+      session = self.class.neo4j_session
       props = args[0] if args[0].is_a?(Hash)
       labels = self.class.mapped_label_names
       session.create_node(props, labels)
@@ -190,4 +200,4 @@ module Neo4j::ActiveNode
 
   end
 
-end
+end

data/lib/neo4j/active_node/property.rb

@@ -23,6 +23,8 @@ module Neo4j::ActiveNode
     module ClassMethods
 
       def property(name, options={})
+        # Magic properties
+        options[:type] = DateTime if name.to_sym == :created_at || name.to_sym == :updated_at
         attribute(name, options)
       end
 

data/lib/neo4j/railtie.rb

@@ -15,22 +15,34 @@ module Neo4j
 
       cfg.session_type ||= :server_db
       cfg.session_path ||= "http://localhost:7474"
+      cfg.sessions ||= []
 
-      if !(RUBY_PLATFORM =~ /java/) && cfg.session_type == :embedded_db
-        raise "Tried to start embedded Neo4j db without using JRuby (got #{RUBY_PLATFORM}), please run `rvm jruby`"
+      if cfg.sessions.empty?
+        cfg.sessions << {type: cfg.session_type, path: cfg.session_path}
       end
 
-      puts "Create Neo4j Session #{cfg.session_type}, path: #{cfg.session_path}"
-      session = Neo4j::Session.open(cfg.session_type, cfg.session_path)
-      if cfg.session_type == :embedded_db
+      cfg.sessions.each do |session_opts|
+        if !(RUBY_PLATFORM =~ /java/) && session_opts[:type] == :embedded_db
+          raise "Tried to start embedded Neo4j db without using JRuby (got #{RUBY_PLATFORM}), please run `rvm jruby`"
+        end
 
-        # See https://github.com/jruby/jruby/wiki/UnlimitedStrengthCrypto
-        security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
-        restricted_field = security_class.get_declared_field('isRestricted')
-        restricted_field.accessible = true
-        restricted_field.set nil, false
+        puts "Create Neo4j Session #{session_opts[:type]}, path: #{session_opts[:path]}"
+        if (session_opts.key? :name)
+          session = Neo4j::Session.open_named(session_opts[:type], session_opts[:name], session_opts[:default], session_opts[:path])
+        else
+          session = Neo4j::Session.open(session_opts[:type], session_opts[:path])
+        end
 
-        session.start
+        if session_opts[:type] == :embedded_db
+
+          # See https://github.com/jruby/jruby/wiki/UnlimitedStrengthCrypto
+          security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
+          restricted_field = security_class.get_declared_field('isRestricted')
+          restricted_field.accessible = true
+          restricted_field.set nil, false
+
+          session.start
+        end
       end
 
       #cfg.storage_path = "#{app.config.root}/db/neo4j-#{::Rails.env}" unless cfg.storage_path

data/lib/neo4j/type_converters.rb

@@ -0,0 +1,124 @@
+module Neo4j
+
+  module TypeConverters
+
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+
+        def convert_type
+          Date
+        end
+
+        def to_db(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
+
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+
+        def convert_type
+          DateTime
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # DateTime values are automatically converted to UTC.
+        def to_db(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
+
+      end
+    end
+
+    class TimeConverter
+      class << self
+
+        def convert_type
+          Time
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_db(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
+
+      end
+    end
+
+    def convert_properties_to(medium, properties)
+      # Perform type conversion
+      properties = properties.inject({}) do |new_attributes, key_value_pair|
+        attr, value = key_value_pair
+        type = self.class._attribute_type(attr)
+        new_attributes[attr] = if TypeConverters.converters[type].nil?
+                                   value
+                                else
+                                  TypeConverters.send "to_#{medium}", value, type
+                                end
+        new_attributes
+      end
+    end
+
+    class << self
+
+      # Converts the value to ruby from a Neo4j database value if there is a converter for given type
+      def to_ruby(value, type = nil)
+        found_converter = converters[type]
+        found_converter ? found_converter.to_ruby(value) : value
+      end
+
+      # Converts the value to a Neo4j database value from ruby if there is a converter for given type
+      def to_db(value, type = nil)
+        found_converter = converters[type]
+        found_converter ? found_converter.to_db(value) : value
+      end
+
+      def converters
+        @converters ||= begin
+          Neo4j::TypeConverters.constants.find_all do |c|
+            Neo4j::TypeConverters.const_get(c).respond_to?(:convert_type)
+          end.map do  |c|
+            Neo4j::TypeConverters.const_get(c)
+          end.inject({}) do |ack, t|
+            ack[t.convert_type] = t
+            ack
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "3.0.0.alpha.2"
+  VERSION = "3.0.0.alpha.3"
 end

data/lib/rails/generators/neo4j/model/model_generator.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..','neo4j.rb')
+
+class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
+  argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+  check_class_collision
+
+  class_option :timestamps, :type => :boolean
+  class_option :parent,     :type => :string, :desc => "The parent class for the generated model"
+  class_option :indices,    :type => :array,  :desc => "The properties which should be indexed"
+  class_option :has_one,    :type => :array,  :desc => "A list of has_one relationships"
+  class_option :has_n,      :type => :array,  :desc => "A list of has_n relationships"
+
+  def create_model_file
+    template "model.erb", File.join('app/models', "#{singular_name}.rb")
+  end
+
+  protected
+  def migration?
+    false
+  end
+
+  def timestamps?
+    options[:timestamps]
+  end
+
+  def has_n?
+    options[:has_n]
+  end
+
+  def has_n_statements
+    txt = ""
+    options[:has_n].each do |key|
+      to, from = key.split(':')
+      txt << (from ? "\n  has_n(:#{to}).from(:#{from})\n" : "\n  has_n :#{to}")
+    end
+    txt
+  end
+
+  def has_one?
+    options[:has_one]
+  end
+
+  def has_one_statements
+    txt = ""
+    options[:has_one].each do |key|
+      to, from = key.split(':')
+      txt << (from ? "\n  has_one(:#{to}).from(:#{from})\n" : "\n  has_one :#{to}")
+    end
+    txt
+  end
+
+  def indices?
+    options[:indices]
+  end
+
+
+  def index_fragment(property)
+    if options[:indices] && options[:indices].include?(property)
+      "index :#{property}"
+    end
+  end
+
+  def parent?
+    options[:parent]
+  end
+
+  def timestamp_statements
+    %q{
+  property :created_at, :type => DateTime
+  # property :created_on, :type => Date
+
+  property :updated_at, :type => DateTime
+  # property :updated_on, :type => Date
+}
+  end
+
+  hook_for :test_framework
+end

data/lib/rails/generators/neo4j/model/templates/model.erb

@@ -0,0 +1,11 @@
+class <%= class_name %> <%= parent? ? "#{options[:parent].classify}" : "" %>
+    include Neo4j::ActiveNode
+<% attributes.each do |attribute| -%>
+    property :<%= attribute.name %><%= ", :type => #{attribute.type_class}" unless attribute.type_class == 'any' %>
+    <%= index_fragment(attribute.name) %>
+<% end -%>
+<%= has_n_statements if has_n? -%>
+<%= has_one_statements if has_one? -%>
+
+<%= timestamp_statements if timestamps? -%>
+end

data/lib/rails/generators/neo4j_generator.rb

@@ -0,0 +1,74 @@
+require 'rails/generators/named_base'
+require 'rails/generators/active_model'
+
+
+module Neo4j
+  module Generators #:nodoc:
+  end
+end
+
+class Neo4j::Generators::Base < ::Rails::Generators::NamedBase #:nodoc:
+  def self.source_root
+    @_neo4j_source_root ||= File.expand_path(File.join(File.dirname(__FILE__),
+                                                       'neo4j', generator_name, 'templates'))
+  end
+end
+
+class Neo4j::Generators::ActiveModel < Rails::Generators::ActiveModel #:nodoc:
+  def self.all(klass)
+    "#{klass}.all"
+  end
+
+  def self.find(klass, params=nil)
+    "#{klass}.find(#{params})"
+  end
+
+  def self.build(klass, params=nil)
+    if params
+      "#{klass}.new(#{params})"
+    else
+      "#{klass}.new"
+    end
+  end
+
+  def save
+    "#{name}.save"
+  end
+
+  def update_attributes(params=nil)
+    "#{name}.update_attributes(#{params})"
+  end
+
+  def errors
+    "#{name}.errors"
+  end
+
+  def destroy
+    "#{name}.destroy"
+  end
+end
+
+module Rails
+  module Generators
+    class GeneratedAttribute #:nodoc:
+      def type_class
+        case type.to_s.downcase
+          when 'any' then
+            'any'
+          when 'datetime' then
+            'DateTime'
+          when 'date' then
+            'Date'
+          when 'text' then
+            'String'
+          when 'integer', 'number', 'fixnum' then
+            'Fixnum'
+          when 'float' then
+            'Float'
+          else
+            'String'
+        end
+      end
+    end
+  end
+end

data/lib/test.rb

@@ -0,0 +1,16 @@
+require 'neo4j'
+
+class Person
+  include Neo4j::ActiveNode
+  property :born, type: Date
+  property :since
+
+end
+
+#Neo4j::Session.open(:server_db, 'http://localhost:7474')
+
+puts "Type #{Person._attribute_type(:born)}, class #{Person._attribute_type(:born).class}"
+puts "Type since #{Person._attribute_type(:since)}"
+p = Person.new(born: Date.today)
+#p.save
+puts "BORN #{p.born} type: #{p.born.class}"

data/neo4j.gemspec

@@ -32,7 +32,7 @@ It comes included with the Apache Lucene document database.
   s.add_dependency("activemodel", "~> 4.0.0")
   s.add_dependency("railties", "~> 4.0.0")
   s.add_dependency('active_attr', "~> 0.8")
-  s.add_dependency("neo4j-core", "= 3.0.0.alpha.6")
+  s.add_dependency("neo4j-core", "= 3.0.0.alpha.8")
 
   if RUBY_PLATFORM =~ /java/
     s.add_dependency("neo4j-community", '~> 2.0.0')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha.2
+  version: 3.0.0.alpha.3
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-09 00:00:00.000000000 Z
+date: 2014-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.0.alpha.6
+        version: 3.0.0.alpha.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.0.alpha.6
+        version: 3.0.0.alpha.8
 description: "You can think of Neo4j as a high-performance graph engine with all the
   features of a mature and robust database.\nThe programmer works with an object-oriented,
   flexible network structure rather than with strict and static tables \nyet enjoys
@@ -106,9 +106,14 @@ files:
 - lib/neo4j/active_node/validations.rb
 - lib/neo4j/active_node.rb
 - lib/neo4j/railtie.rb
+- lib/neo4j/type_converters.rb
 - lib/neo4j/version.rb
 - lib/neo4j/wrapper.rb
 - lib/neo4j.rb
+- lib/rails/generators/neo4j/model/model_generator.rb
+- lib/rails/generators/neo4j/model/templates/model.erb
+- lib/rails/generators/neo4j_generator.rb
+- lib/test.rb
 - config/locales/en.yml
 - config/neo4j/config.yml
 - README.md