neo4apis-activerecord 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2ed4f89083577a03b71106a03c4dd24872f8736
-  data.tar.gz: b90a58d0a0b9f10b7556bef961f5d87cf530c6bb
+  metadata.gz: ab2aa8e3fdbb40523bfb2bdf22f200c91e0dfc93
+  data.tar.gz: 5b408d16b2b3f86854576265a9dcd7b213ca1eeb
 SHA512:
-  metadata.gz: b8057af9d9498fc9dfac9227041563b2709f85796bba838290deb616ef812f44ea446a459b22bb093f65ffddfa6d93a2c503a53b3c23d9b1236c43bb10dfa4a8
-  data.tar.gz: fb3f26d22fe4da3a6e573ee78266f7bad145fe49df1c8de7d21d20d0a52b0e217f2f1da4a5a31468f8d1b9896174d342c845059482e7cb6cf5f59bde5e52b8a3
+  metadata.gz: 122c016581350b4e990b7767e10f930cf93642db49f96c70f3a78b3a178509ad5fd432177c7fa0ad959f85885ad11246bb126043ab0e88c28371e309c0ae7a0d
+  data.tar.gz: d3502d4d5c0ff5f25885df4dbdbe2f608146f3bd6297187b71c9c0307dfb0aabe8e4e1d49791428b936e0b23995f18380d43e059a2186cb5f4b93e14d3a03e05

data/README.md

@@ -36,14 +36,16 @@ For a list of all options run:
 
     neo4apis activerecord --help
 
+Some options of particular interest:
+
 ### `--identify-model`
 
 The `--identify-model` option looks for tables' names/primay keys/foreign keys automatically.  Potential options are generated and the database is examined to find out which fits.
 
 As an example: for a table of posts the following possibilities would checked:
 
- * Names: `posts`, `post`, `Posts`, or `Post`
- * Primary keys: `id`, `post_id`, `PostId`, or `uuid`
+ * Names: Looks for names like `posts`, `post`, `Posts`, or `Post`
+ * Primary keys: Table schema is examined first.  If no primary key is specified it will look for columns like `id`, `post_id`, `PostId`, or `uuid`
  * Foreign keys: `author_id` or `AuthorId` will be assumed to go to a table of authors (with a name identified as above)
 
 ### `--import-belongs-to`
@@ -53,3 +55,17 @@ As an example: for a table of posts the following possibilities would checked:
 
 Either specify that a certain class of associations be imported from ActiveRecord models or specify all with `--import-all-associations`
 
+## Using `neo4apis-activerecord` from ruby
+
+If you'd like to do custom importing, you can use `neo4apis-activerecord` in the following way:
+
+    Neo4Apis::ActiveRecord.model_importer(SomeModel)
+
+    neo4apis_activerecord = Neo4Apis::ActiveRecord.new(Neo4j::Session.open, import_all_associations: true)
+
+    neo4apis_activerecord.batch do
+      SomeModel.where(condition: 'value').find_each do |object|
+        neo4apis_activerecord.import object
+      end
+    end
+

data/lib/neo4apis/activerecord.rb

@@ -3,8 +3,6 @@ require 'ostruct'
 
 module Neo4Apis
   class ActiveRecord < Base
-    prefix nil
-
     batch_size 1000
 
     def self.model_importer(model_class)
@@ -21,8 +19,8 @@ module Neo4Apis
               referenced_object = object.send(association_reflection.name)
               add_model_relationship association_reflection.name, node, referenced_object if referenced_object
             end
-          when :has_many
-            if options[:import_has_many]
+          when :has_many, :has_and_belongs_to_many
+            if options[:"import_#{association_reflection.macro}"]
               object.send(association_reflection.name).each do |referenced_object|
                 add_model_relationship association_reflection.name, node, referenced_object if referenced_object
               end

data/lib/neo4apis/cli/activerecord.rb

@@ -2,13 +2,15 @@ require 'active_record'
 require 'active_support/inflector'
 require 'thor'
 require 'colorize'
-require 'neo4apis/table_resolver'
+require 'neo4apis/model_resolver'
 require 'neo4apis/cli/base'
 
 module Neo4Apis
   module CLI
     class ActiveRecord < CLI::Base
-      include TableResolver
+      include ModelResolver
+
+      class_option :debug, type: :boolean, default: false, desc: 'Output debugging information'
 
       class_option :import_all_associations, type: :boolean, default: false, desc: 'Shortcut for --import-belongs-to --import-has-many --import-has-one'
       class_option :import_belongs_to, type: :boolean, default: nil
@@ -54,6 +56,12 @@ module Neo4Apis
 
       private
 
+      def debug_log(*messages)
+        return unless options[:debug]
+
+        puts(*messages)
+      end
+
       def import_models_or_tables(*models_or_table_names)
         model_classes = models_or_table_names.map(&method(:get_model))
 
@@ -68,10 +76,8 @@ module Neo4Apis
             query = model_class.all
 
             # Eager load association for faster import
-            include_list = model_class.reflect_on_all_associations.map do |association_reflection|
-              association_reflection.name if import_association?(association_reflection.macro)
-            end.compact
-            query = query.includes(*include_list.map(&:to_sym)) if include_list.present?
+            include_list = include_list_for_model(model_class)
+            query = query.includes(*include_list) if include_list.present?
 
             query.find_each do |object|
               neo4apis_client.import model_class.name.to_sym, object
@@ -80,6 +86,14 @@ module Neo4Apis
         end
       end
 
+      def include_list_for_model(model_class)
+        model_class.reflect_on_all_associations.map do |association_reflection|
+          association_reflection.name.to_sym if import_association?(association_reflection.macro)
+        end.compact.tap do |include_list|
+          debug_log 'include_list', include_list.inspect
+        end
+      end
+
       def setup
         if File.exist?(options[:startup_environment])
           require options[:startup_environment]
@@ -102,55 +116,6 @@ module Neo4Apis
       end
 
 
-      def get_model(model_or_table_name)
-        get_model_class(model_or_table_name).tap do |model_class|
-          if options[:identify_model]
-            apply_identified_table_name!(model_class)
-            apply_identified_primary_key!(model_class)
-            apply_identified_model_associations!(model_class)
-          end
-        end
-      end
-
-      def get_model_class(model_or_table_name)
-        return model_or_table_name if model_or_table_name.is_a?(Class) && model_or_table_name.ancestors.include?(::ActiveRecord::Base)
-
-        model_class = model_or_table_name.gsub(/\s+/, '_')
-        model_class = model_or_table_name.classify unless model_or_table_name.match(/^[A-Z]/)
-        model_class.constantize
-      rescue NameError
-        Object.const_set(model_class, Class.new(::ActiveRecord::Base))
-      end
-
-      def apply_identified_model_associations!(model_class)
-        model_class.columns.each do |column|
-          match = column.name.match(/^(.*)(_id|Id)$/)
-          next if not match
-
-          begin
-            base = match[1].gsub(/ +/, '_').tableize
-
-            if identify_table_name(tables, base.classify) && model_class.name != base.classify
-              model_class.belongs_to base.singularize.to_sym, foreign_key: column.name, class_name: base.classify
-            end
-          rescue UnfoundTableError
-            nil
-          end
-        end
-      end
-
-      def apply_identified_table_name!(model_class)
-        identity = identify_table_name(tables, model_class.name)
-        model_class.table_name = identity if identity
-      end
-
-      def apply_identified_primary_key!(model_class)
-        identity = ::ActiveRecord::Base.connection.primary_key(model_class.table_name)
-        identity ||= identify_primary_key(model_class.column_names, model_class.name)
-        model_class.primary_key = identity if identity
-      end
-
-
       def active_record_config
         require 'yaml'
         YAML.load(File.read(options[:active_record_config_path]))[options[:active_record_environment]]

data/lib/neo4apis/model_resolver.rb

@@ -0,0 +1,58 @@
+require 'neo4apis/table_resolver'
+
+module Neo4Apis
+  module ModelResolver
+    def self.included(included_class)
+      included_class.include TableResolver
+    end
+
+    def get_model(model_or_table_name)
+      get_model_class(model_or_table_name).tap do |model_class|
+        if options[:identify_model]
+          apply_identified_table_name!(model_class)
+          apply_identified_primary_key!(model_class)
+          apply_identified_model_associations!(model_class)
+        end
+      end
+    end
+
+    def get_model_class(model_or_table_name)
+      return model_or_table_name if model_or_table_name.is_a?(Class) && model_or_table_name.ancestors.include?(::ActiveRecord::Base)
+
+      model_class = model_or_table_name.gsub(/\s+/, '_')
+      model_class = model_or_table_name.classify unless model_or_table_name.match(/^[A-Z]/)
+      model_class.constantize
+    rescue NameError
+      Object.const_set(model_class, Class.new(::ActiveRecord::Base))
+    end
+
+    def apply_identified_model_associations!(model_class)
+      model_class.columns.each do |column|
+        match = column.match(/^(.+)_id$/i) || column.match(/^(.+)id$/i)
+        next if not match
+
+        begin
+          base = match[1].gsub(/ +/, '_').tableize
+
+          if identify_table_name(tables, base.classify) && model_class.name != base.classify
+            debug_log "Defining: belongs_to #{base.singularize.to_sym.inspect}, foreign_key: #{column.name.inspect}, class_name: #{base.classify.inspect}"
+            model_class.belongs_to base.singularize.to_sym, foreign_key: column.name, class_name: base.classify
+          end
+        rescue UnfoundTableError
+          nil
+        end
+      end
+    end
+
+    def apply_identified_table_name!(model_class)
+      identity = identify_table_name(tables, model_class.name)
+      model_class.table_name = identity if identity
+    end
+
+    def apply_identified_primary_key!(model_class)
+      identity = ::ActiveRecord::Base.connection.primary_key(model_class.table_name)
+      identity ||= identify_primary_key(model_class.column_names, model_class.name)
+      model_class.primary_key = identity if identity
+    end
+  end
+end

data/lib/neo4apis/table_resolver.rb

@@ -22,7 +22,7 @@ module Neo4Apis
         case standardize(column)
         when 'id', 'uuid', /#{standardize(class_name.singularize)}id/, /#{standardize(class_name.pluralize)}id/
           true
-        when  
+        when
           true
         end
       end.tap do |found_key| # rubocop:disable Style/MultilineBlockChain

data/neo4apis-activerecord.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name     = 'neo4apis-activerecord'
-  s.version  = '0.6.1'
+  s.version  = '0.7.0'
   s.required_ruby_version = '>= 1.9.1'
 
   s.authors  = 'Brian Underwood'
@@ -18,6 +18,6 @@ A ruby gem using neo4apis to make importing SQL data to neo4j easy
   s.require_path = 'lib'
   s.files = Dir.glob('{bin,lib,config}/**/*') + %w(README.md Gemfile neo4apis-activerecord.gemspec)
 
-  s.add_dependency('neo4apis', '~> 0.5.0')
+  s.add_dependency('neo4apis', '~> 0.6.0')
   s.add_dependency('activerecord', '~> 4.0')
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4apis-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Brian Underwood
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: neo4apis
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -50,6 +50,7 @@ files:
 - lib/neo4apis-activerecord.rb
 - lib/neo4apis/activerecord.rb
 - lib/neo4apis/cli/activerecord.rb
+- lib/neo4apis/model_resolver.rb
 - lib/neo4apis/table_resolver.rb
 - neo4apis-activerecord.gemspec
 homepage: https://github.com/neo4jrb/neo4apis-activerecord/