neo4apis-activerecord 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 958a75dd44231361bc7386645f422d8041a49b00
-  data.tar.gz: 7805c98e8aaed169ce2f9e438a485fa12519652a
+  metadata.gz: ab9aecb11a9464f24fea4306dd70129fa149ef80
+  data.tar.gz: 3dfa664c481fa064e3b4ecaee0db545849f5a494
 SHA512:
-  metadata.gz: 0a9da16b04590e66e99d5aed580847df688cd39d3ed01e39ac729997bf8954ac76e58d9ff3e03992df09fa46f26682737f5483fb02924f639f4091dfdc4e7b3e
-  data.tar.gz: 96d2c984a9e98bd2133b741737be303a47c7c8ad807afe00a859e76d275dbb7759ad242b4f7e58ed60daeae162db4009be12cc21783721a36402ecf72d80f80e
+  metadata.gz: 9ee71960a9de10387b975fac9cb76948398f73e1599318f4e1ff7f2133be15ed47db5858c57f716cc5b4e2736ff5efed77a16ae3ae65e14256c4cce85e349608
+  data.tar.gz: ea45c3c56cbbd9e114b5d2a5a46b833968d3a6cbabff9839ecc9fbaba1964ba7e555717f3eea962a883a9a181593171e115da2f9404c9729f4786feda51f9cc0

data/README.md

@@ -0,0 +1,55 @@
+# neo4apis-activerecord
+
+**The easiest and quickest way to copy data from PostgreSQL / mySQL / sqlite to Neo4j**
+
+## How to run:
+
+Without existing ActiveRecord application:
+
+    neo4apis activerecord all_tables --import-all-associations --identify-model
+
+or
+
+    neo4apis activerecord tables posts comments --import-all-associations --identify-model
+
+With existing ActiveRecord application:
+
+    neo4apis activerecord all_models --import-all-associations
+
+or
+
+    neo4apis activerecord models Post Comment --import-all-associations
+
+## Installation
+
+Using rubygems:
+
+    gem install neo4apis-activerecord
+
+## How it works
+
+[ActiveRecord](http://guides.rubyonrails.org/active_record_basics.html) is a [ORM](http://en.wikipedia.org/wiki/Object-relational_mapping) for ruby.  `neo4apis-activerecord` uses ActiveRecord models which are either found in an existing ruby app or generated from table structures.  The models are then introspected to create nodes (from tables) and relationships (from associations) in neo4j.  The neo4apis library is used to load data efficiently in batches.
+
+## Options
+
+For a list of all options run:
+
+    neo4apis activerecord --help
+
+### `--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`
+ * 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`
+### `--import-has-many`
+### `--import-has-one`
+### `--import-all-associations`
+
+Either specify that a certain class of associations be imported from ActiveRecord models or specify all with `--import-all-associations`
+

data/lib/neo4apis/cli/activerecord.rb

@@ -8,23 +8,25 @@ module Neo4Apis
     class ActiveRecord < Thor
       class_option :config_path, type: :string,  default: 'config/database.yml'
 
-      class_option :import_associations, type: :boolean, default: false
+      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
       class_option :import_has_one, type: :boolean, default: nil
       class_option :import_has_many, type: :boolean, default: nil
 
-      class_option :guess_model, type: :boolean, default: false
+      class_option :identify_model, type: :boolean, default: false, desc: 'Identify table name, primary key, and foreign keys automatically'
+
+      class_option :startup_environment, type: :string, default: './config/environment.rb', desc: 'Script that will be run before import.  Needs to establish an ActiveRecord connection'
 
       class_option :active_record_config_path, type: :string, default: './config/database.yml'
       class_option :active_record_environment, type: :string, default: 'development'
 
-      desc 'tables MODELS_OR_TABLE_NAMES', 'Import SQL specified tables'
+      desc 'tables MODELS_OR_TABLE_NAMES', 'Import specified SQL tables'
       def tables(*models_or_table_names)
         setup
 
         model_classes = models_or_table_names.map(&method(:get_model))
 
-        puts "Importing tables: " + model_classes.map(&:table_name).join(', ')
+        puts 'Importing tables: ' + model_classes.map(&:table_name).join(', ')
 
         model_classes.each do |model_class|
           ::Neo4Apis::ActiveRecord.model_importer(model_class)
@@ -39,19 +41,28 @@ module Neo4Apis
         end
       end
 
+      desc 'models MODELS_OR_TABLE_NAMES', 'Import specified ActiveRecord models'
+      def models(*models_or_table_names)
+        tables(*models_or_table_names)
+      end
+
       desc 'all_tables', 'Import all SQL tables'
       def all_tables
-        setup
+        tables(*::ActiveRecord::Base.connection.tables)
+      end
+
+      desc 'all_models', 'Import SQL tables using defined '
+      def all_models
+        Rails.application.eager_load!
 
-        models(*::ActiveRecord::Base.connection.tables)
+        tables(ActiveRecord::Base.descendants)
       end
 
       private
 
       def setup
-        if File.exist?('config/environment.rb')
-          # Rails
-          require './config/environment'
+        if File.exist?(options[:startup_environment])
+          require options[:startup_environment]
         else
           ::ActiveRecord::Base.establish_connection(active_record_config)
         end
@@ -67,16 +78,18 @@ module Neo4Apis
       end
 
       def import_association?(type)
-        options[:"import_#{type}"].nil? ? options[:import_associations] : options[:"import_#{type}"]
+        options[:"import_#{type}"].nil? ? options[:import_all_associations] : options[:"import_#{type}"]
       end
 
 
       def get_model(model_or_table_name)
+        return model_or_table_name if model_or_table_name.is_a?(ActiveRecord::Base)
+
         get_model_class(model_or_table_name).tap do |model_class|
-          if options[:guess_model]
-            apply_guessed_table_name!(model_class)
-            apply_guessed_primary_key!(model_class)
-            apply_guessed_model_associations!(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
@@ -89,7 +102,7 @@ module Neo4Apis
         Object.const_set(model_class, Class.new(::ActiveRecord::Base))
       end
 
-      def apply_guessed_model_associations!(model_class)
+      def apply_identified_model_associations!(model_class)
         model_class.columns.each do |column|
           match = column.name.match(/^(.*)(_id|Id)$/)
           next if not match
@@ -97,21 +110,23 @@ module Neo4Apis
           begin
             base = match[1].tableize
 
-            model_class.belongs_to base.singularize.to_sym, foreign_key: column.name, class_name: base.classify if guessed_table_name(base.classify)
+            if identified_table_name(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 NameError
           end
         end
       end
 
-      def apply_guessed_table_name!(model_class)
-        guess = guessed_table_name(model_class.name)
-        model_class.table_name = guess if guess
+      def apply_identified_table_name!(model_class)
+        identity = identified_table_name(model_class.name)
+        model_class.table_name = identity if identity
       end
 
-      def apply_guessed_primary_key!(model_class)
+      def apply_identified_primary_key!(model_class)
         name = model_class.name
-        guess = (model_class.column_names & ['id', name.foreign_key, name.foreign_key.classify, 'uuid']).first
-        model_class.primary_key = guess if guess
+        identity = (model_class.column_names & ['id', name.foreign_key, name.foreign_key.classify, 'uuid']).first
+        model_class.primary_key = identity if identity
       end
 
 
@@ -122,7 +137,7 @@ module Neo4Apis
 
       private
 
-      def guessed_table_name(model_name)
+      def identified_table_name(model_name)
         (::ActiveRecord::Base.connection.tables & [model_name.tableize, model_name.classify, model_name.tableize.singularize, model_name.classify.pluralize]).first
       end
     end

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.3.0'
+  s.version  = '0.4.0'
   s.required_ruby_version = '>= 1.9.1'
 
   s.authors  = 'Brian Underwood'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neo4apis-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Brian Underwood