carrierwave-neo4j 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5507ccab191bfca681514fde9d25ad62c56ff8ab
-  data.tar.gz: b849d9e4f6b4b73c7e985454f6f09fc10235e9b5
+SHA256:
+  metadata.gz: ee1ece089b8cbd55532f4c0cba7a7a19054b24edc86f81a077c5497c49f4c801
+  data.tar.gz: a8a1b8fb5355129bfb9fd41839b59bbeee38e5808d59cac0a21fcc7ee6291a55
 SHA512:
-  metadata.gz: 0911192167258d8be9d4ecf37857dc056725627706c30b2d853c0b6d4e10b8c38cd9fe3d0d90e0b143cc2ef5a8656fe1f0220d1ccac7aa9eeaa0ece0a39cd3ac
-  data.tar.gz: 4fd214ca10c2f7a0950156760d3bf7a25b45dc2b618026a27118184dc47a9603632e1ef577f4c78dccfc57256178ae103ee0137d3f16f1471cd1fad391b7878e
+  metadata.gz: f2adb7d1d88b7f225d2d89c4bdcae75ada1f4fa3edfc5679cbd0aa034c80d6738bc2990dc9a2527555ae92837edbf9f447fb0ed811c9da133d2613c88019dd45
+  data.tar.gz: e9168769c2f8e656c3e8e1046e5c7d5fbaaec1d53269525557fe50b3f4a77ba08aa0966529cd5835750b4fe57b7b7a85b5e58aea3ac145b151f93e6c451b9a97

data/.gitignore

@@ -6,3 +6,6 @@ db/*
 .idea
 
 .ruby-version
+spec/public/uploads/*
+bin/
+

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/) 
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [3.0.0] - 2020-07-15
+
+### Fixed
+
+- Updated and fixed all tests to work with neo4j.rb 9.x and CarrierWave 2.x
+- Updated the overall format of the plugin to mirror CarrierWave::Orm::ActiveRecord as much as possible
+- Files are now deleted correctly on `#destroy`
+- File information is now correctly reloaded on `#find`
+- Thanks @deobald for all the fixes.
+
+## [2.0.4] - 2018-04-03
+
+### Fixed
+
+- Fix the fix from 2.0.3 (`@_mounters` is sometimes `nil`) (thanks @janbiedermann / see #15)
+
+## [2.0.3] - 2018-04-01
+
+### Fixed
+
+- Make it work with recent Neo4j (thanks @janbiedermann / see #14)
+
+## [2.0.2]
+
+### Fixed
+- Fixed `gemspec` to allow newer version of `carrierwave` gem (thanks @edenvicary, see #12)
+- Fixed `uninitialized constant CarrierWave::Mount::Mounter` (thanks @thanksoni7uka, see #11 and #12)
+
+<!-- CHANGELOG started after version 2.0.1 -->

data/Gemfile

@@ -2,5 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in carrierwave_neo4j.gemspec
 gemspec
-
-gem 'database_cleaner', github: 'dpisarewski/database_cleaner', branch: 'neo4j'

data/README.md

@@ -1,21 +1,81 @@
 ## CarrierWave for Neo4j
 
-This gem adds support for Neo4j 3.0+ to CarrierWave, see the CarrierWave documentation for more detailed usage instructions.
+This gem adds support for Neo4j 3.0+ (neo4j.rb 9.6.0+) to CarrierWave 2.1.0+, see the CarrierWave documentation for more detailed usage instructions.
 
 ### Installation Instructions
 
 Add to your Gemfile:
 
 ```ruby
-gem 'carrierwave-neo4j', require: 'carrierwave/neo4j', github: 'dpisarewski/carrierwave-neo4j'
+gem 'carrierwave-neo4j', '~> 3.0', require: 'carrierwave/neo4j'
 ```
-Use it like this:
+
+You can see example usage in `spec/neo4j_realistic_spec.rb` but in brief, you can use it like this:
 
 ```ruby
+class AttachmentUploader < CarrierWave::Uploader::Base
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+end
+
 class Asset
   include Neo4j::ActiveNode
 
   property :attachment, type: String
   mount_uploader :attachment, AttachmentUploader
 end
-```
+```
+
+If you want image manipulation, you will need to install ImageMagick
+
+On Ubuntu:
+
+```sh
+sudo apt-get install imagemagick --fix-missing
+```
+
+On macOS:
+
+```sh
+brew install imagemagick
+```
+
+### Development
+
+```sh
+bundle install
+rake neo4j:install[community-latest,test]
+rake neo4j:start[test]
+rake spec
+```
+
+### Troubleshooting
+
+#### Files are nil
+
+If you aren't getting your files back after querying a record from Neo4j, be aware that this will only happen automatically for the `Model#find` method. For all other finders (`#all`, `#first`, `#find_by`, `#find_by_*`, `#find_by_*!`, `#last`) you will need to force a reload so the model sees the file. For example:
+
+```ruby
+users = User.all
+users.each(&:reload_from_database!)
+```
+
+Sorry, this sucks. But this is a limitation of Neo4j.rb as these other finders don't fire any callbacks.
+
+#### binstubs (particularly `bin/rspec`) seem broken
+
+If you're getting some infinite recursion when you run the specs that ultimately results in an error like:
+
+```
+`ensure in require': CRITICAL: RUBYGEMS_ACTIVATION_MONITOR.owned?: before false -> after true (RuntimeError)
+```
+
+You may want to try:
+
+```sh
+rm .bundle/config
+bundle install
+```

data/Rakefile

@@ -1 +1,12 @@
 require 'bundler/gem_tasks'
+require 'neo4j/rake_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  puts "RSpec not installed...?"
+end

data/carrierwave-neo4j.gemspec

@@ -7,19 +7,21 @@ Gem::Specification.new do |s|
   s.version     = CarrierWave::Neo4j::VERSION
   s.authors     = ["Rodrigo Navarro"]
   s.email       = ["navarro@manapot.com.br"]
-  s.homepage    = "https://github.com/reu/carrierwave-neo4j"
+  s.homepage    = "https://github.com/neo4jrb/carrierwave-neo4j"
   s.summary     = %q{Neo4j support for Carrierwave}
   s.description = %q{Neo4j support for Carrierwave}
 
-  s.rubyforge_project = "carrierwave_neo4j"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("activesupport", ">= 3.0" )
-  s.add_dependency("neo4j", ">= 1.1")
-  s.add_dependency("carrierwave", "~> 0.5")
-  s.add_development_dependency("rspec", "~> 2.0")
+  s.add_dependency("activesupport", ">= 6.0" )
+  s.add_dependency("neo4j", "~> 9.6.0")
+  s.add_dependency("carrierwave", ">= 2.1")
+  s.add_development_dependency("rspec", "~> 3.0")
+  s.add_development_dependency("rspec-its")
+  s.add_development_dependency("webmock")
+  s.add_development_dependency("neo4j-rake_tasks")
+  s.add_development_dependency("rake")
 end

data/lib/carrierwave/neo4j.rb

@@ -5,71 +5,207 @@ require "carrierwave/validations/active_model"
 require "carrierwave/neo4j/uploader_converter"
 require "active_support/concern"
 
+######
+# This file attempts to maintain symmetry with:
+# https://github.com/carrierwaveuploader/carrierwave/blob/master/lib/carrierwave/orm/activerecord.rb
+# 
+# Behaviours linked to callbacks (ex. `after_save :"store_#{column}!"`) belong to:
+# https://github.com/carrierwaveuploader/carrierwave/blob/master/lib/carrierwave/mount.rb
+# ...which is mixed into Model classes.
+######
 module CarrierWave
   module Neo4j
-    extend ActiveSupport::Concern
 
+    # this class methods junk is necessary because ActiveNode is implemented as
+    # a model instead of a class for god-knows-what-reason.
+    extend ActiveSupport::Concern
     module ClassMethods
+
       include CarrierWave::Mount
+
       ##
       # See +CarrierWave::Mount#mount_uploader+ for documentation
       #
-      def mount_uploader(column, uploader = nil, options = {}, &block)
+      def mount_uploader(column, uploader=nil, options={}, &block)
         super
 
+        mod = Module.new
+        prepend mod
+        mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+          def remote_#{column}_url=(url)
+            column = _mounter(:#{column}).serialization_column
+            __send__(:"\#{column}_will_change!")
+            super
+          end
+        RUBY
+      end
+
+      ##
+      # See +CarrierWave::Mount#mount_uploaders+ for documentation
+      #
+      def mount_uploaders(column, uploader=nil, options={}, &block)
+        super
+
+        mod = Module.new
+        prepend mod
+        mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+          def remote_#{column}_urls=(url)
+            column = _mounter(:#{column}).serialization_column
+            __send__(:"\#{column}_will_change!")
+            super
+          end
+        RUBY
+      end
+
+      def add_reload_callback(method)
+        @_reload_callbacks = [] unless @_reload_callbacks
+        @_reload_callbacks << method unless @_reload_callbacks.include?(method)
+      end
+
+      def reload_callbacks
+        @_reload_callbacks
+      end
+
+    private
+
+      def mount_base(column, uploader=nil, options={}, &block)
+        super
+
+        # this seems necessary to prevent the _identifier from including
+        # the entire path ('img.jpg' vs. '/uploads/user/image/img.jpg')
         serialize column, ::CarrierWave::Uploader::Base
 
         include CarrierWave::Validations::ActiveModel
 
-        validates_integrity_of  column if uploader_option(column.to_sym, :validate_integrity)
+        validates_integrity_of column if uploader_option(column.to_sym, :validate_integrity)
         validates_processing_of column if uploader_option(column.to_sym, :validate_processing)
+        validates_download_of column if uploader_option(column.to_sym, :validate_download)
+
+        # carrierwave keeps a instance variable of @uploaders, cached at init time
+        # but at init time, the value of the column is not yet available
+        # so after init, the empty @uploaders cache must be invalidated
+        # it will reinitialized with the processed column value on first access
+        after_initialize :_set_uploaders_nil
 
-        after_save :"store_#{column}!"
         before_save :"write_#{column}_identifier"
+        after_save :"store_#{column}!"
+        # this 'after_update' hook doesn't seem necessary, but please 
+        # don't remove it just in case it ever becomes necessary:
+        after_update :"mark_remove_#{column}_false"
         after_destroy :"remove_#{column}!"
+        after_find :"force_retrieve_#{column}"
+
+        add_reload_callback :"force_retrieve_#{column}"
+
+        # TRYING THIS OUT FROM MONGOID:
+        # TODO: copy the other mongoid adapter code over
+        # https://github.com/carrierwaveuploader/carrierwave-mongoid/blob/master/lib/carrierwave/mongoid.rb
+        before_update :"store_previous_changes_for_#{column}"
+        after_save :"remove_previously_stored_#{column}"
 
         class_eval <<-RUBY, __FILE__, __LINE__+1
-        def #{column}=(new_file)
-          column = _mounter(:#{column}).serialization_column
-          send(:attribute_will_change!, :#{column})
-          super
-        end
-
-        def remote_#{column}_url=(url)
-          column = _mounter(:#{column}).serialization_column
-          send(:attribute_will_change!, :#{column})
-          super
-        end
-
-        def remove_#{column}!
-          super
-          write_uploader(_mounter(:#{column}).serialization_column, nil)
-        end
-
-        def _mounter(column)
-          @_mounters ||= {}
-          @_mounters[column] ||= CarrierWave::Mount::Mounter.new(self, column)
-        end
-
-        def read_uploader(name)
-          send(:attribute, name.to_s)
-        end
-
-        def write_uploader(name, value)
-          send(:attribute=, name.to_s, value)
-        end
-
-        def reload_from_database
-          if reloaded = self.class.load_entity(neo_id)
-            send(:attributes=, reloaded.attributes.reject{ |k,v| v.is_a?(::CarrierWave::Uploader::Base) })
+
+          # def remote_#{column}_url=(url) is defined in 'mount_uploader'
+
+          def #{column}=(new_file)
+            column = _mounter(:#{column}).serialization_column
+            if !(new_file.blank? && __send__(:#{column}).blank?)
+              __send__(:"\#{column}_will_change!")
+            end
+            super
+          end
+
+          def remove_#{column}=(value)
+            column = _mounter(:#{column}).serialization_column
+            result = super
+            __send__(:"\#{column}_will_change!") if _mounter(:#{column}).remove?
+            result
+          end
+
+          def remove_#{column}!
+            self.remove_#{column} = true
+            write_#{column}_identifier
+            self.remove_#{column} = false
+            super
+          end
+
+          # Reset cached mounter on record reload
+          def reload(*)
+            _set_uploaders_nil
+            @_mounters = nil
+            super
+          end
+
+          # Reset cached mounter on record dup
+          def initialize_dup(other)
+            _set_uploaders_nil
+            @_mounters = nil
+            super
+          end
+
+          def _set_uploaders_nil
+            if @_mounters
+              @_mounters.each do |_, mounter|
+                mounter.instance_variable_set(:@uploaders, nil)
+              end
+            end
+          end
+
+          def _force_uploaders_reload
+            @_mounters.each do |_, mounter|
+              mounter.send(:uploaders)
+            end
+          end
+
+          # okay, this actually works:
+          def force_retrieve_#{column}
+            send(:#{column}).send(:retrieve_from_store!, #{column}_identifier)
           end
-          reloaded
-        end
+
+          # these produce an infinite loop, so... don't reintroduce them:
+          # alias_method :read_uploader, :read_attribute
+          # alias_method :write_uploader, :write_attribute
+          # public :read_uploader
+          # public :write_uploader
+          
+          def read_uploader(name)
+            send(:attribute, name.to_s)
+          end
+
+          def write_uploader(name, value)
+            send(:attribute=, name.to_s, value)
+          end
+
+          def reload_from_database
+            if reloaded = self.class.load_entity(neo_id)
+              self.class.reload_callbacks.each { |m| reloaded.send(m) }
+            end
+            reloaded
+          end
+
+          def reload_from_database!
+            if reloaded = self.class.load_entity(neo_id)
+              send(:attributes=, reloaded.attributes)
+              self.class.reload_callbacks.each { |m| send(m) }
+            end
+            self
+          end
+
+          # MONGOID:
+          # CarrierWave 1.1 references ::ActiveRecord constant directly which
+          # will fail in projects without ActiveRecord. We need to overwrite this
+          # method to avoid it.
+          # See https://github.com/carrierwaveuploader/carrierwave/blob/07dc4d7bd7806ab4b963cf8acbad73d97cdfe74e/lib/carrierwave/mount.rb#L189
+          def store_previous_changes_for_#{column}
+            @_previous_changes_for_#{column} = changes[_mounter(:#{column}).serialization_column]
+          end
+
         RUBY
       end
-    end
 
+
+    end
   end
 end
 
-Neo4j::ActiveNode.send :include, CarrierWave::Neo4j
+Neo4j::ActiveNode.include CarrierWave::Neo4j

data/lib/carrierwave/neo4j/uploader_converter.rb

@@ -7,7 +7,11 @@ module CarrierWave::Neo4j
         end
 
         def to_db(value)
-          value.identifier
+          if value.is_a?(Array)
+            value.map(&:identifier)
+          else
+            value.identifier
+          end
         end
 
         def to_ruby(value)
@@ -18,9 +22,15 @@ module CarrierWave::Neo4j
   end
 end
 
-mod = case Neo4j::VERSION.split('.').first.to_i
-        when 3 then Neo4j
-        when 4 then Neo4j::Shared
-      end
+def register_converter(mod)
+  mod::TypeConverters.send :include, CarrierWave::Neo4j::TypeConverters
+end
 
-mod::TypeConverters.send :include, CarrierWave::Neo4j::TypeConverters
+major = Neo4j::VERSION.split('.').first.to_i
+
+case major
+  when 1..2 then fail('Unsupported version of Neo4j gem. Please update it.')
+  when 3    then register_converter(Neo4j)
+  when 4    then register_converter(Neo4j::Shared)
+  when 5..Float::INFINITY then Neo4j::Shared::TypeConverters.register_converter(CarrierWave::Neo4j::TypeConverters::UploaderConverter)
+end