infopark_reactor 1.25.0 → 1.27.0.rc4

data/lib/reactor/persistence.rb

@@ -1,6 +1,5 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/attributes/link_list_from_accessor'
-require 'reactor/attributes/link_list_from_attr_values'
+require "reactor/attributes/link_list_from_accessor"
+require "reactor/attributes/link_list_from_attr_values"
 
 module Reactor
   module Persistence
@@ -32,18 +31,18 @@ module Reactor
       # 3. object is invalid
       # 4. other error occoured
       # @param comment [String] comment to leave for the next user
-      def release(comment=nil)
-        return release!(comment)
+      def release(comment = nil)
+        release!(comment)
       rescue Reactor::Cm::XmlRequestError, ActiveRecord::RecordInvalid, Reactor::NotPermitted, Reactor::AlreadyReleased
-        return false
+        false
       end
 
       # Removes the working version of the object,
       # if it exists
       # @param comment [String] comment to leave for the next user
       # @return [true]
-      def revert(comment=nil)
-        return revert!(comment)
+      def revert(comment = nil)
+        revert!(comment)
       end
 
       # Removes the working version of the object,
@@ -51,10 +50,10 @@ module Reactor
       # @param comment [String] comment to leave for the next user
       # @return [true]
       # @note There is no difference between #revert and #revert!
-      def revert!(comment=nil)
+      def revert!(comment = nil)
         crul_obj.revert!(comment)
         reload
-        return true
+        true
       end
 
       # Releases the object. Returns true on succes, can raise exceptions
@@ -62,13 +61,14 @@ module Reactor
       # @raise [Reactor::AlreadyReleased]
       # @raise [ActiveRecord::RecordInvalid] validations failed
       # @raise [Reactor::NotPermitted] current user lacks required permissions
-      def release!(comment=nil)
+      def release!(comment = nil)
         run_callbacks(:release) do
-          raise(Reactor::AlreadyReleased) unless self.really_edited?
+          raise(Reactor::AlreadyReleased) unless really_edited?
+
           crul_obj.release!(comment)
           reload
         end
-        return true
+        true
       end
 
       # Makes the current user the editor of the object. Returns true when
@@ -78,11 +78,11 @@ module Reactor
       # 2. the object has not beed edited
       # 3. other error occured
       # @param comment [String] comment to leave for the next user
-      def take(comment=nil)
+      def take(comment = nil)
         take!(comment)
-        return true
+        true
       rescue Reactor::Cm::XmlRequestError, Reactor::NotPermitted, Reactor::NoWorkingVersion
-        return false
+        false
       end
 
       # Makes the current user the editor of the object. Returns true when
@@ -90,13 +90,14 @@ module Reactor
       # @param comment [String] comment to leave for the next user
       # @raise [Reactor::NoWorkingVersion] there is no working version of the object
       # @raise [Reactor::NotPermitted] current user lacks required permissions
-      def take!(comment=nil)
-        raise(Reactor::NoWorkingVersion) unless self.really_edited?
+      def take!(comment = nil)
+        raise(Reactor::NoWorkingVersion) unless really_edited?
+
         # TODO: refactor the if condition
-        crul_obj.take!(comment) if (crul_obj.editor != Reactor::Configuration::xml_access[:username])
+        crul_obj.take!(comment) if crul_obj.editor != Reactor::Configuration.xml_access[:username]
         # neccessary to recalculate #editor
         reload
-        return true
+        true
       end
 
       # Creates a working version of the object. Returns true on success or when
@@ -104,41 +105,41 @@ module Reactor
       # @param comment [String] comment to leave for the next user
       # 1. user lacks the permissions
       # 2. other error occured
-      def edit(comment=nil)
+      def edit(comment = nil)
         edit!(comment)
-        return true
+        true
       rescue Reactor::Cm::XmlRequestError, Reactor::NotPermitted
-        return false
+        false
       end
 
       # Creates a working version of the object. Returns true on success or when
       # the object already has a working version. Raises exceptions
       # @param comment [String] comment to leave for the next user
       # @raise [Reactor::NotPermitted] current user lacks required permissions
-      def edit!(comment=nil)
-        crul_obj.edit!(comment) unless self.really_edited?
+      def edit!(comment = nil)
+        crul_obj.edit!(comment) unless really_edited?
         reload
-        return true
+        true
       end
 
       # Returns true, if the object has any links pointing to it.
       # @raise [Reactor::Cm::XmlRequestError] generic error occoured
       def has_super_links?
-        crul_obj.get('hasSuperLinks') == '1'
+        crul_obj.get("hasSuperLinks") == "1"
       end
 
       # Return an array of RailsConnector::AbstractObj that contain a link
       # to this file.
       # @raise [Reactor::Cm::XmlRequestError] generic error occoured
       def super_objects
-        RailsConnector::AbstractObj.where(:obj_id => crul_obj.get('superObjects')).to_a
+        RailsConnector::AbstractObj.where(obj_id: crul_obj.get("superObjects")).to_a
       end
 
       # Returns true if this object hasn't been saved yet -- that is, a record
       # for the object doesn't exist in the data store yet; otherwise, returns false.
       def new_record?
-        #!destroyed? && (self.id.nil? || !self.class.exists?(self.id))
-        !destroyed? && (self.id.nil? || self.path.blank?)
+        # !destroyed? && (self.id.nil? || !self.class.exists?(self.id))
+        !destroyed? && (id.nil? || path.blank?)
       end
 
       # Stolen from Rails 3.
@@ -172,7 +173,7 @@ module Reactor
       # Freezes the object.
       def destroy
         run_callbacks(:destroy) do
-          self.delete
+          delete
         end
       end
 
@@ -181,12 +182,12 @@ module Reactor
       # but tries to mimmic their behaviour.
       def reload(options = nil)
         RailsConnector::AbstractObj.uncached do
-          #super # Throws RecordNotFound when changing obj_class
+          # super # Throws RecordNotFound when changing obj_class
           # AR reload
           clear_aggregation_cache
           clear_association_cache
-          fresh_object = RailsConnector::AbstractObj.find(self.id, options)
-          @attributes = fresh_object.instance_variable_get('@attributes')
+          fresh_object = RailsConnector::AbstractObj.find(id, options)
+          @attributes = fresh_object.instance_variable_get("@attributes")
           @attributes_cache = {}
           # RC reload
           @attr_values = nil
@@ -207,9 +208,9 @@ module Reactor
       # 2. generic error occoured
       def resolve_refs
         resolve_refs!
-        return true
+        true
       rescue Reactor::Cm::XmlRequestError, Reactor::NotPermitted
-        return false
+        false
       end
 
       # Resolves references in any of the html fields. Returns true on success,
@@ -217,52 +218,39 @@ module Reactor
       # @raise [Reactor::NotPermitted] current user lacks required permissions
       def resolve_refs!
         crul_obj.resolve_refs!
-        return true
-      end
-
-      if Reactor.rails3_0?
-        # It should excactly match ActiveRecord::Base.new in it's behavior
-        # @see ActiveRecord::Base.new
-        def initialize(attributes = nil, &block)
-          if true ||  !self.class.send(:attribute_methods_overriden?) # FIXME !!!!
-            ignored_attributes = ignore_attributes(attributes)
-            # supress block hijacking!
-            super(attributes) {}
-            load_ignored_attributes(ignored_attributes)
-            yield self if block_given?
-          else
-            super(attributes)
-          end
-        end
-      elsif Reactor.rails3_1? || Reactor.rails3_2? || Reactor.rails4_x?
-        # It should excactly match ActiveRecord::Base.new in it's behavior
-        # @see ActiveRecord::Base.new
-        def initialize(attributes = nil, options={}, &block)
-          if true ||  !self.class.send(:attribute_methods_overriden?) #FIXME !!!
-            ignored_attributes = ignore_attributes(attributes)
-            # supress block hijacking!
-            super(attributes, options) {}
-            load_ignored_attributes(ignored_attributes)
-            yield self if block_given?
-          else
-            super(attributes, options)
-          end
+        true
+      end
+
+      # It should excactly match ActiveRecord::Base.new in it's behavior
+      # @see ActiveRecord::Base.new
+      def initialize(attributes = nil, _options = {})
+        if true || !self.class.send(:attribute_methods_overriden?)
+          ignored_attributes = ignore_attributes(attributes)
+          # supress block hijacking!
+          super(attributes) {}
+          load_ignored_attributes(ignored_attributes)
+          yield self if block_given?
+        else
+          # TODO
+          # here we get 'ActiveRecord::AssociationTypeMismatch'
+          super(attributes)
         end
-      else
-        raise RuntimeError, "Unsupported Rails version!"
       end
 
       # Equivalent to Obj#edited?
       def really_edited?
-        self.edited?
+        # check if really edited with curl request
+        crul_obj.edited?
+        # self.edited?
       end
 
       # Returns an array of errors
       def reasons_for_incomplete_state
-        crul_obj.get('reasonsForIncompleteState') || []
+        crul_obj.get("reasonsForIncompleteState") || []
       end
 
       protected
+
       def prevent_resolve_refs
         @prevent_resolve_refs = true
       end
@@ -272,12 +260,10 @@ module Reactor
       end
 
       def sanitize_name
-        return unless self.name.present?
+        return unless name.present?
 
-        sanitized_name = self.class.send(:sanitize_name, self.name)
-        if sanitized_name != self.name
-          self.name = sanitized_name
-        end
+        sanitized_name = self.class.send(:sanitize_name, name)
+        self.name = sanitized_name if sanitized_name != name
       end
 
       def crul_attributes_set?
@@ -289,13 +275,13 @@ module Reactor
       end
 
       def changed_linklists
-        custom_attrs = 
-          self.singleton_class.send(:instance_variable_get, '@_o_allowed_attrs') ||
-          self.class.send(:instance_variable_get, '@_o_allowed_attrs') ||
+        custom_attrs =
+          singleton_class.send(:instance_variable_get, "@_o_allowed_attrs") ||
+          self.class.send(:instance_variable_get, "@_o_allowed_attrs") ||
           []
 
         custom_attrs.select do |attr|
-          self.send(:attribute_type, attr) == :linklist && self.send(:[],attr.to_sym).try(:changed?)
+          send(:attribute_type, attr) == :linklist && send(:[], attr.to_sym).try(:changed?)
         end
       end
 
@@ -312,28 +298,27 @@ module Reactor
       end
 
       def crul_obj_save
-        attrs, _ = crul_attributes.partition do |field, (value, options)|
-          self.send(:attribute_type, field) != :linklist
+        attrs, = crul_attributes.partition do |field, (_value, _options)|
+          send(:attribute_type, field) != :linklist
         end
         linklists = changed_linklists
 
         new_links = {}.tap do |result|
           linklists.map do |field|
             result[field] = Reactor::Attributes::LinkListFromAccessor.new(self, field).call.map do |l|
-              {:link_id => l.id, :title => l.title, :destination_url => (l.internal? ? l.destination_object.path : l.url), :target => l.target}
+              { link_id: l.id, title: l.title, destination_url: (l.internal? ? l.destination_object.path : l.url), target: l.target }
             end
           end
         end
 
         links_modified = !linklists.empty?
 
-        crul_obj.composite_save(attrs, [], [], [], links_modified) do |attrs, links_to_add, links_to_remove, links_to_set|
-
+        crul_obj.composite_save(attrs, [], [], [], links_modified) do |_attrs, links_to_add, links_to_remove, links_to_set|
           links_to_add.clear
           links_to_remove.clear
           links_to_set.clear
 
-          copy = RailsConnector::AbstractObj.uncached { RailsConnector::AbstractObj.find(self.id) }
+          copy = RailsConnector::BasicObj.uncached { RailsConnector::BasicObj.find(id) }
 
           linklists.each do |linklist|
             original_link_ids = Reactor::Attributes::LinkListFromAttrValues.new(copy, linklist).call.map(&:id)
@@ -365,7 +350,6 @@ module Reactor
             end
           end
         end
-
         self.class.connection.clear_query_cache
       end
 
@@ -378,66 +362,55 @@ module Reactor
       # @param [String] new_name gives the object new name
       def copy(new_parent, recursive = false, new_name = nil)
         self.id = crul_obj.copy(RailsConnector::AbstractObj.path_from_anything(new_parent), recursive, new_name)
-        #self.reload
-        resolve_refs #?
-        self.id
+        # self.reload
+        resolve_refs # ?
+        id
       end
 
       def trim_crul_attributes
-        crul_attributes.delete_if {|attr, options| [:name, :objClass].include?(attr) }
+        crul_attributes.delete_if { |attr, _options| %i(name objClass).include?(attr) }
       end
 
       def crul_obj_create(name, parent, klass)
         @crul_obj = Reactor::Cm::Obj.create(name, parent, klass)
       end
 
+      # TODO: depends on rails version
       def create
         run_callbacks(:create) do
-          c_name  = self.name
-          c_parent= self.class.path_from_anything(self.parent_obj_id)
-          c_objcl = self.obj_class
+          c_name = name
+          c_parent = self.class.path_from_anything(parent_obj_id)
+          c_objcl = obj_class
           crul_obj_create(c_name, c_parent, c_objcl)
           self.id = @crul_obj.obj_id
           crul_obj_save if crul_attributes_set? || crul_links_changed?
-          self.reload # ?
-          self.id
+          reload # ?
+          changes_applied
+          id
         end
       end
 
-      if Reactor.rails4_x?
-        if Reactor.rails4_0_ge6? || Reactor.rails4_1? || Reactor.rails4_2?
-          alias_method :_create_record, :create
-        else
-          alias_method :create_record, :create
-        end
-      end
-
-      def update
-         run_callbacks(:update) do
-           crul_obj_save if crul_attributes_set? || crul_links_changed?
-           self.reload
-           self.id
-         end
-      end
+      alias_method :_create_record, :create
 
-      if Reactor.rails4_x?
-        if Reactor.rails4_0_ge6? || Reactor.rails4_1? || Reactor.rails4_2?
-          alias_method :_update_record, :update
-        else
-          alias_method :update_record, :update
+      def update(_attribute_names = attribute_names)
+        run_callbacks(:update) do
+          crul_obj_save if crul_attributes_set? || crul_links_changed?
+          reload
+          changes_applied
+          id
         end
       end
 
+      alias_method :_update_record, :update
+
       def ignore_attributes(attributes)
         return {} if attributes.nil?
 
         obj_class = attributes.delete(:obj_class)
         parent    = attributes.delete(:parent)
-        {:obj_class => obj_class, :parent => parent}
+        { obj_class: obj_class, parent: parent }
       end
 
-
-
       def load_ignored_attributes(attributes)
         return if attributes.nil?
 
@@ -455,7 +428,6 @@ module Reactor
         self.obj_class = obj_class
       end
 
-
       # disables active record transactions
       def with_transaction_returning_status
         yield
@@ -469,44 +441,17 @@ module Reactor
     module ClassMethods
       def sanitize_name(old_name)
         if Reactor::Configuration.sanitize_obj_name
-          character_map = {'ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'ß' => 'ss', 'Ä' => 'Ae', 'Ö' => 'Oe', 'Ü' => 'Ue'}
-          new_name = old_name.gsub(/[^-$a-zA-Z0-9]/) {|char| character_map[char] || '_'}.
-            gsub(/__+/,'_').
-            gsub(/^_+/,'').
-            gsub(/_+$/,'')
-          new_name
+          character_map = { "ä" => "ae", "ö" => "oe", "ü" => "ue", "ß" => "ss", "Ä" => "Ae", "Ö" => "Oe", "Ü" => "Ue" }
+          old_name.gsub(/[^-$a-zA-Z0-9]/) { |char| character_map[char] || "_" }
+                  .gsub(/__+/, "_")
+                  .gsub(/^_+/, "")
+                  .gsub(/_+$/, "")
+
         else
           old_name
         end
       end
 
-      if Reactor.rails4_x?
-        # Detect the subclass from the inheritance column of attrs. If the inheritance column value
-        # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
-        # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
-        # this will ignore the inheritance column and return nil
-        def subclass_from_attrs(attrs)
-          subclass_name = attrs.with_indifferent_access[inheritance_column]
-
-          if subclass_name.present? && subclass_name != self.name
-            subclass = subclass_name.safe_constantize
-            
-            if subclass # this if has been added
-              unless descendants.include?(subclass)
-                raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
-              end
-
-              subclass
-            end
-          end
-        end
-
-        if Reactor.rails4_0_ge6? || Reactor.rails4_1? || Reactor.rails4_2?
-          alias_method :subclass_from_attributes, :subclass_from_attrs
-          remove_method :subclass_from_attrs
-        end
-      end
-
       # Convenience method: it is equivalent to following call chain:
       #
       #     i = create(attributes)
@@ -518,22 +463,23 @@ module Reactor
       #
       #     image = Image.upload(File.open('image.jpg'), 'ext', :name => 'image', :parent => '/')
       #
-      def upload(data_or_io, extension, attributes={})
+      def upload(data_or_io, extension, attributes = {})
         # Try to guess the object name from filename, if it's missing
-        if (data_or_io.respond_to?(:path) && !attributes.key?(:name))
+        if data_or_io.respond_to?(:path) && !attributes.key?(:name)
           attributes[:name] = sanitize_name(File.basename(data_or_io.path, File.extname(data_or_io.path)))
         end
 
-        instance = self.create!(attributes)# do |instance|
-          instance.upload(data_or_io, extension)
-          instance.save!
-        #end
+        instance = create!(attributes) # do |instance|
+        instance.upload(data_or_io, extension)
+        instance.save!
+        # end
         instance
       end
 
       protected
+
       def attribute_methods_overriden?
-        self.name != 'RailsConnector::AbstractObj'
+        name != "RailsConnector::BasicObj"
       end
     end
   end