infopark_reactor 1.26.1 → 1.27.0.rc10

data/config/routes.rb

@@ -1,3 +1,2 @@
-# -*- encoding : utf-8 -*-
 Rails.application.routes.draw do
 end

data/infopark_reactor.gemspec

@@ -1,29 +1,30 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$:.push File.expand_path("lib", __dir__)
 require "reactor/version"
 
 Gem::Specification.new do |s|
   s.name        = "infopark_reactor"
-  s.version     = "#{Reactor::VERSION}"
+  s.version     = Reactor::VERSION.to_s
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Tomasz Przedmojski"]
-  s.email       = ["tomasz.przedmojski@infopark.de"]
+  s.authors     = ["Tomasz Przedmojski", "Anton Mezin", "Roman Lemekha"]
+  s.email       = ["tomasz.przedmojski@infopark.de", "anton.mezin@infopark.de", "roman.lemekha@infopark.de"]
   s.homepage    = ""
-  s.summary     = %q{Write into CM in familiar, Rails-like way}
-  s.description = %q{Use the ActiveRecord mimicking API to write into CM and enjoy all the benefits of callbacks, validations and permission checking}
-  s.license     = 'LGPL-3'
+  s.summary     = "Write into CM in familiar, Rails-like way"
+  s.description = "Use the ActiveRecord mimicking API to write into CM and enjoy all the benefits of callbacks, validations and permission checking"
+  s.license     = "LGPL-3"
 
-  #s.rubyforge_project = "infopark_reactor"
+  # s.rubyforge_project = "infopark_reactor"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'rails', '>= 3.0.10', '< 4.3.0'
-  #s.add_dependency 'infopark_rails_connector'
-  s.add_dependency 'nokogiri'
+  s.add_dependency "infopark_fiona_connector", "~> 7.0.1.5.2.4.rc1"
+  s.add_dependency "nokogiri", "~> 1"
+  s.add_dependency "rails", "~> 5.0"
 
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'yard'
+  s.add_development_dependency "rspec", "~> 3"
+  s.add_development_dependency "rubocop", "~> 0.87.1"
+  s.add_development_dependency "rubocop-performance", "~> 1"
+  s.add_development_dependency "yard", ">= 0"
 end

data/lib/generators/cm/migration/migration_generator.rb

@@ -1,19 +1,15 @@
-# -*- encoding : utf-8 -*-
 module Cm
   module Generators
     class MigrationGenerator < Rails::Generators::NamedBase
       include Rails::Generators::Migration
-      def self.next_migration_number(dirname)
+      def self.next_migration_number(_dirname)
         Time.now.utc.strftime("%Y%m%d%H%M%S")
       end
 
-      source_root File.expand_path('../templates', __FILE__)
+      source_root File.expand_path("templates", __dir__)
+
       def create_migration_file
-        if Reactor.rails4_x?
-          migration_template "template.rb", "cm/migrate/#{file_name}.rb"
-        else
-          migration_template "template.rb", "cm/migrate/#{file_name}"
-        end
+        migration_template "template.rb", "cm/migrate/#{file_name}.rb"
       end
     end
   end

data/lib/infopark_reactor.rb

@@ -1,86 +1,60 @@
-# -*- encoding : utf-8 -*-
-# Runtime Rails version detection
-module Reactor
-  def self.rails3_0?
-    ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR == 0
-  end
-
-  def self.rails3_1?
-    ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR == 1
-  end
-
-  def self.rails3_2?
-    ::Rails::VERSION::MAJOR == 3 && ::Rails::VERSION::MINOR == 2
-  end
-
-  def self.rails4_0?
-    ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR == 0
-  end
-
-  def self.rails4_1?
-    ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR == 1
-  end
-
-  def self.rails4_2?
-    ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR == 2
-  end
-
-  def self.rails4_x?
-    ::Rails::VERSION::MAJOR == 4 && [0,1,2].include?(::Rails::VERSION::MINOR)
-  end
-
-  def self.rails4_0_ge6?
-    ::Rails::VERSION::MAJOR == 4 && ::Rails::VERSION::MINOR == 0 && ::Rails::VERSION::TINY >= 6
-  end
-end
 # require config
-require 'reactor/configuration'
-
+require "reactor/configuration"
 
 # require components
-require 'reactor/cm/bridge'
-require 'reactor/cm/language'
-require 'reactor/cm/object_base'
-require 'reactor/cm/user'
-require 'reactor/cm/attribute'
-require 'reactor/cm/obj'
-require 'reactor/cm/obj_class'
-require 'reactor/cm/attribute_group'
-require 'reactor/cm/link'
-require 'reactor/cm/group'
-require 'reactor/cm/editorial_group'
-require 'reactor/cm/live_group'
-require 'reactor/cm/workflow'
-require 'reactor/cm/log_entry'
-require 'reactor/cm/channel'
+require "reactor/cm/bridge"
+require "reactor/cm/language"
+require "reactor/cm/object_base"
+require "reactor/cm/user"
+require "reactor/cm/attribute"
+require "reactor/cm/obj"
+require "reactor/cm/obj_class"
+require "reactor/cm/attribute_group"
+require "reactor/cm/link"
+require "reactor/cm/group"
+require "reactor/cm/editorial_group"
+require "reactor/cm/live_group"
+require "reactor/cm/workflow"
+require "reactor/cm/log_entry"
+require "reactor/cm/channel"
 
 # require main class
-require 'reactor/migration'
+require "reactor/migration"
 
 # require misc
-require 'reactor/cm/xml_request_error'
-require 'reactor/cm/blob_too_small_error'
-require 'reactor/cm/missing_credentials'
+require "reactor/cm/xml_request_error"
+require "reactor/cm/blob_too_small_error"
+require "reactor/cm/missing_credentials"
 
 # require public tools
-require 'reactor/tools/uploader'
+require "reactor/tools/uploader"
 
 # require exceptions
-require 'reactor/already_released'
-require 'reactor/no_working_version'
-require 'reactor/not_permitted'
-
-# require eager loader
-require 'rails_connector/meta/eager_loader'
+require "reactor/already_released"
+require "reactor/no_working_version"
+require "reactor/not_permitted"
 
 # require components
-require 'reactor/main'
-require 'reactor/rc_independent'
-require 'reactor/sudo'
+require "reactor/legacy"
+require "reactor/validations"
+require "reactor/permission"
+require "reactor/workflow"
+require "reactor/streaming_upload"
+require "reactor/rc_independent"
+require "reactor/sudo"
+require "reactor/main"
+require "reactor/attributes"
+require "reactor/attributes_handlers"
+require "reactor/persistence"
 
 # require rails integration
-require 'reactor/session'
-require 'reactor/session/user'
+# session handling
+require "reactor/session"
+require "reactor/session/user"
+require "reactor/session_helper/auth_helper"
+require "reactor/session_helper/auth_filter"
+require "reactor/session_helper/rsession_helper"
+require "reactor/session_helper/session_state"
 
 # require engine
-require File.expand_path('../reactor/engine', __FILE__) if defined?(Rails)
+require File.expand_path("reactor/engine", __dir__) if defined?(Rails)

data/lib/reactor/already_released.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 module Reactor
-class AlreadyReleased < StandardError ; end
+  class AlreadyReleased < StandardError; end
 end

data/lib/reactor/attributes.rb

@@ -1,171 +1,12 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/attributes/date_serializer'
-require 'reactor/attributes/html_serializer'
-require 'reactor/attributes/link_list_serializer'
+require "reactor/attributes/date_serializer"
+require "reactor/attributes/html_serializer"
+require "reactor/attributes/link_list_serializer"
 
-require 'reactor/attributes/link_list_extender'
+require "reactor/attributes/link_list_extender"
 
-require 'singleton'
+require "singleton"
 
 module Reactor
-  class AttributeHandlers
-    include Singleton
-
-    def initialize
-      # t1 = Time.now
-      self.generate_attribute_handlers
-      # Rails.logger.debug "Reactor::AttributeHandlers: generate_attribute_handlers took #{Time.now - t1}"
-    end
-
-    # Use this method to install attributes into class
-    def self.install_attributes(klass)
-      Reactor::AttributeHandlers.instance.install(klass, obj_class(klass))
-    end
-
-    # Use this method if attributes changed and you wish to reinstall them
-    def self.reinstall_attributes(klass, obj_class)
-      Reactor::AttributeHandlers.instance.tap do |handler|
-        handler.regenerate_attribute_handler(obj_class)
-        handler.install(klass, obj_class)
-      end
-    end
-
-    def self.obj_class(klass)
-      klass.name.split('::').last
-    end
-
-    def install(klass, obj_class)
-      if obj_class_known?(obj_class)
-        klass.send(:include, handler_module(obj_class))
-      end
-    end
-
-    def regenerate_attribute_handler(obj_class_name)
-      generate_attribute_handler(RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class_name))
-    end
-
-    protected
-
-    def handler_module(obj_class)
-      Reactor::AttributeHandlers.const_get('Handler__' + obj_class.to_s)
-    end
-
-    def obj_class_known?(obj_class)
-      Reactor::AttributeHandlers.const_defined?('Handler__' + obj_class.to_s)
-    end
-
-    def generate_attribute_handlers
-      RailsConnector::Meta::EagerLoader.instance.obj_classes.each do |_, obj_class|
-        # Rails.logger.debug "Reactor::AttributeHandlers: preparing obj class #{obj_class.name}"
-        generate_attribute_handler(obj_class) if obj_class.name =~ /^[A-Z]/
-      end
-    end
-
-    def generate_attribute_handler(obj_class)
-      # Rails.logger.debug "Reactor::AttributeHandlers: generating handler for #{obj_class.name}"
-      attribute_methods = []
-      writers = []
-
-      obj_class.custom_attributes.each do |attribute, attribute_data|
-        writers << attribute.to_sym
-        writers << attribute.to_s.underscore.to_sym
-
-        # Custom attribute readers: prevent unwanted nils
-        case attribute_data.attribute_type.to_sym
-        when :html
-          attribute_methods << <<-EOC
-            def #{attribute}
-              self[:#{attribute}] || ''.html_safe
-            end
-          EOC
-        when :date, :enum
-          attribute_methods << <<-EOC
-            def #{attribute}
-              self[:#{attribute}]
-            end
-          EOC
-        when :linklist
-          attribute_methods << <<-EOC
-            def #{attribute}
-              self[:#{attribute}] || RailsConnector::LinkList.new([])
-            end
-          EOC
-        when :multienum
-          attribute_methods << <<-EOC
-            def #{attribute}
-              self[:#{attribute}] || []
-            end
-          EOC
-        else
-          attribute_methods << <<-EOC
-            def #{attribute}
-              self[:#{attribute}] || ''
-            end
-          EOC
-        end
-
-        # active model dirty tracking
-        attribute_methods << <<-EOC
-        def #{attribute}_changed?
-          attribute_changed?(:#{attribute})
-        end
-        EOC
-      end
-
-
-
-      [:contentType].each do |attribute|
-        writers << attribute.to_sym
-        writers << attribute.to_s.underscore.to_sym
-      end
-
-      Reactor::Cm::Obj::OBJ_ATTRS.each do |attribute|
-        writers << attribute.to_sym
-        writers << attribute.to_s.underscore.to_sym
-      end
-
-      writers.uniq!
-
-      writers.each do |attribute|
-        attribute_methods << <<-EOC
-          def #{attribute}=(value)
-            set(:#{attribute},value)
-          end
-        EOC
-      end
-
-      # if a handler for this obj class has been defined previously, purge its methods
-      if Reactor::AttributeHandlers.const_defined?("Handler__#{obj_class.name}")
-        mod = Reactor::AttributeHandlers.const_get("Handler__#{obj_class.name}")
-        mod.instance_methods.each do |method|
-          mod.send(:remove_method, method)
-        end
-      end
-
-      Reactor.class_eval <<-EOC
-        class AttributeHandlers
-          module Handler__#{obj_class.name}
-            def self.included(base)
-              # store allowed attributes
-              allowed_attrs = %w|#{writers * ' '}|.map(&:to_sym)
-              base.send(:instance_variable_set, '@_o_allowed_attrs', allowed_attrs)
-            end
-
-            # attribute readers and writers
-            #{attribute_methods.join("\n")}
-
-            # parent-setting handling
-            def parent=(parent_something)
-              set_parent(parent_something)
-            end
-          end
-        end
-      EOC
-
-      handler_module(obj_class.name)
-      # "Reactor::AttributeHandlers::Handler__#{obj_class.name}"
-    end
-  end
   # This module provides support for ActiveRecord like attribute setting, plus additional
   # #set method, which is equivalent to the setters.
   #
@@ -207,11 +48,7 @@ module Reactor
       end
 
       def blob
-        if attr_dict.respond_to?(:blob)
-          attr_dict.send :blob
-        else
-          nil
-        end
+        attr_dict.send :blob if attr_dict.respond_to?(:blob)
       end
 
       def blob=(value)
@@ -226,49 +63,46 @@ module Reactor
         set(:channels, value)
       end
 
-      def suppress_export=(value)
-        set(:suppress_export, value)
-      end
-
       def channels
         self[:channels] || []
       end
 
-      def body_changed?
-        attribute_changed?(:body)
-      end
-
-      def title_changed?
-        attribute_changed?(:title)
+      def suppress_export=(value)
+        set(:suppress_export, value)
       end
 
-      def channels_changed?
-        attribute_changed?(:channels)
+      def _read_attribute(key)
+        if active_record_attr?(key)
+          super
+        else
+          __send__(key)
+        end
       end
 
       # Sets given attribute, to given value. Converts values if neccessary
       # @see [Reactor::Attributes]
       # @note options are passed to underlying xml interface, but as of now have no effect
-      def set(key, value, options={})
+      def set(key, value, options = {})
         key = key.to_sym
         raise TypeError, "can't modify frozen object" if frozen?
-        key = resolve_attribute_alias(key)
-        raise ArgumentError, "Unknown attribute #{key.to_s} for #{self.class.to_s} #{self.path}" unless allowed_attr?(key)
-        attr = key_to_attr(key)
+        raise ArgumentError, "Unknown attribute #{key} for #{self.class} #{path}" unless allowed_attr?(key)
 
-        not_formated_value = value
-        formated_value = serialize_value(key, value)
-        crul_set(attr, formated_value, options)
+        attribute_will_change!(key.to_s)
 
-        __track_dirty_attribute(key)
-        active_record_set(key, formated_value) if active_record_attr?(key)
-        rails_connector_set(key, formated_value, not_formated_value)
+        attribute = key_to_attr(key)
 
-        # return new value
+        formated_value = serialize_value(key, value)
+        crul_set(attribute, formated_value, options)
+
+        if active_record_attr?(key)
+          formated_value = to_time_in_zone(formated_value) if attribute_type(key) == :date
+        else
+          rails_connector_set(key, formated_value)
+        end
+        @attributes.write_from_user(key.to_s, formated_value)
         __send__(key)
       end
 
-
       # Uploads a file/string into a CM. Requires call to save afterwards(!)
       # @param [String, IO] data_or_io
       # @param [String] extension file extension
@@ -279,16 +113,16 @@ module Reactor
       end
 
       def uploaded?
-        self.uploaded == true
+        uploaded == true
       end
 
       # @deprecated
       def set_link(key, id_or_path_or_cms_obj)
         target_path = case id_or_path_or_cms_obj
-        when Integer then Obj.find(id_or_path_or_cms_obj).path
-        when String then id_or_path_or_cms_obj
-        when Obj then id_or_path_or_cms_obj.path
-        else raise ArgumentError.new("Link target must Integer, String or Obj, but was #{id_or_path_or_cms_obj.class}.")
+                      when Integer then Obj.find(id_or_path_or_cms_obj).path
+                      when String then id_or_path_or_cms_obj
+                      when Obj then id_or_path_or_cms_obj.path
+                      else raise ArgumentError, "Link target must Integer, String or Obj, but was #{id_or_path_or_cms_obj.class}."
         end
 
         edit!
@@ -296,45 +130,53 @@ module Reactor
         crul_obj.set_link(key, target_path.to_s)
       end
 
-      def reload_attributes(new_obj_class=nil)
-        new_obj_class = new_obj_class || self.obj_class
+      def reload_attributes(new_obj_class = nil)
+        new_obj_class ||= obj_class
         RailsConnector::Meta::EagerLoader.instance.forget_obj_class(new_obj_class)
-        Reactor::AttributeHandlers.reinstall_attributes(self.singleton_class, new_obj_class)
+        Reactor::AttributeHandlers.reinstall_attributes(singleton_class, new_obj_class)
+        self.class.reinitialize_attributes
       end
 
       protected
+
       attr_accessor :uploaded
+
+      def builtin_attributes
+        @builtin_attrs ||= (active_record_attributes + Reactor::Cm::Obj::PREDEFINED_ATTRS).map { |item| item.to_s.underscore.to_sym }
+      end
+
       def builtin_attr?(attr)
-        [:channels, :parent, :valid_from, :valid_until, :name, :obj_class, :content_type, :body, :blob, :suppress_export, :permalink, :title].include?(attr)
+        builtin_attributes.include?(attr)
+      end
+
+      def active_record_attributes
+        @active_record_attrs ||= self.class.columns.map(&:name)
       end
 
       def active_record_attr?(attr)
-        [:valid_from, :valid_until, :name, :obj_class, :suppress_export, :permalink].include?(attr)
+        active_record_attributes.include?(attr.to_s)
       end
 
       def allowed_attr?(attr)
+        # TODO: rebuild with current attribute_names method
         return true if builtin_attr?(attr)
 
         custom_attrs =
-          self.singleton_class.send(:instance_variable_get, '@_o_allowed_attrs') ||
-          self.class.send(:instance_variable_get, '@_o_allowed_attrs') ||
+          singleton_class.send(:instance_variable_get, "@_o_allowed_attrs") ||
+          self.class.send(:instance_variable_get, "@_o_allowed_attrs") ||
           []
 
         custom_attrs.include?(key_to_attr(attr))
       end
 
-      def resolve_attribute_alias(key)
-        key
-      end
-
       def key_to_attr(key)
         @__attribute_map ||= {
-          :body             => :blob,
-          :valid_until      => :validUntil,
-          :valid_from       => :validFrom,
-          :content_type     => :contentType,
-          :suppress_export  => :suppressExport,
-          :obj_class        => :objClass
+          body: :blob,
+          valid_until: :validUntil,
+          valid_from: :validFrom,
+          content_type: :contentType,
+          suppress_export: :suppressExport,
+          obj_class: :objClass
         }
 
         key = key.to_sym
@@ -342,67 +184,43 @@ module Reactor
         key
       end
 
-      def serialize_value(attr, value)
-        case attribute_type(attr)
+      def serialize_value(key, value)
+        case attribute_type(key)
         when :html
-          HTMLSerializer.new(attr, value).serialize
+          HTMLSerializer.new(key, value).serialize
         when :date
-          DateSerializer.new(attr, value).serialize
+          DateSerializer.new(key, value).serialize
         when :linklist
-          LinkListSerializer.new(attr, value).serialize
+          LinkListSerializer.new(key, value).serialize
         else
           value
         end
       end
 
-      def rails_connector_set(field, value, supplied_value)
-        field = :blob if field.to_sym == :body
+      def rails_connector_set(field, value)
         field = field.to_sym
-
+        field = :blob if field == :body
         case attribute_type(field)
         when :linklist
-          send(:attr_dict).instance_variable_get('@attr_cache')[field] = value
+          send(:attr_dict).instance_variable_get("@attr_cache")[field] = value
           send(:attr_dict).send(:blob_dict)[field] = :special_linklist_handling_is_broken
         when :date
-          if supplied_value.nil? || supplied_value.kind_of?(String)
-            parsed_value = Time.from_iso(value).in_time_zone rescue nil
-          else
-            parsed_value = supplied_value
-          end
-          send(:attr_dict).instance_variable_get('@attr_cache')[field] = parsed_value
+          send(:attr_dict).instance_variable_get("@attr_cache")[field] = to_time_in_zone(value)
           send(:attr_dict).send(:blob_dict)[field] = value
         else
-          send(:attr_dict).instance_variable_get('@attr_cache')[field] = nil
+          send(:attr_dict).instance_variable_get("@attr_cache")[field] = nil
           send(:attr_dict).send(:blob_dict)[field] = value
         end
       end
 
-      def cached_value?(attr, value)
-        attribute_type(attr) == :linklist
-      end
+      def to_time_in_zone(value)
+        return nil if value.blank?
 
-      if Reactor.rails4_2?
-        def active_record_set(field, value)
-          @attributes.write_from_user(field.to_s, value)
-        end
-      else
-        def active_record_set(field, value)
-          @attributes_cache.delete(field.to_s)
-          @attributes[field.to_s] = value
-        end
+        ActiveSupport::TimeZone["UTC"].parse(value).in_time_zone
       end
 
-      if Reactor.rails4_2? || Reactor.rails4_1?
-        def __track_dirty_attribute(key)
-          __send__(:attribute_will_change!, key.to_s)
-        end
-      else
-        def __track_dirty_attribute(key)
-          # in rails versions <= Rails 4.0 sometimes the first option
-          # and sometimes the second option is used
-          __send__(:attribute_will_change!, key.to_s)
-          __send__(:attribute_will_change!, key.to_sym)
-        end
+      def cached_value?(attr, _value)
+        attribute_type(attr) == :linklist
       end
 
       # Lazily sets values for crul interface. May be removed in later versions
@@ -412,21 +230,24 @@ module Reactor
       end
 
       private
-      def path=(*args) ; super ; end
+
+      def path=(*args)
+        super
+      end
 
       def attribute_type(attr)
-        return :html if [:body, :blob].include?(attr.to_sym)
-        return :date if [:valid_from, :valid_until, :last_changed].include?(attr.to_sym)
-        return :string if [:name, :title, :obj_class, :permalink, :suppress_export].include?(attr.to_sym)
+        return :html if %i(body blob).include?(attr.to_sym)
+        return :date if %i(valid_from valid_until last_changed).include?(attr.to_sym)
+        return :string if %i(name title obj_class permalink suppress_export).include?(attr.to_sym)
         return :multienum if [:channels].include?(attr.to_sym)
 
-        custom_attr = self.obj_class_def.try(:custom_attributes).try(:[],attr.to_s)
-        raise TypeError, "obj_class_def is nil for: #{obj_class}" if self.obj_class_def.nil?
+        custom_attr = obj_class_def.try(:custom_attributes).try(:[], attr.to_s)
+        raise TypeError, "obj_class_def is nil for: #{obj_class}" if obj_class_def.nil?
 
         # FIXME: this should blow up on error
         # raise TypeError, "Unable to determine type of attribute: #{attr}" if custom_attr.nil?
-        custom_attr ||= {"attribute_type"=>:string}
-        return custom_attr["attribute_type"].to_sym
+        custom_attr ||= { "attribute_type" => :string }
+        custom_attr["attribute_type"].to_sym
       end
     end
     module ClassMethods
@@ -440,21 +261,24 @@ module Reactor
       end
 
       def __cms_attributes(obj_class)
-        obj_class_def = RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class) #RailsConnector::ObjClass.where(:obj_class_name => obj_class).first
+        obj_class_def = RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class) # RailsConnector::ObjClass.where(:obj_class_name => obj_class).first
         obj_class_def ? obj_class_def.custom_attributes : {}
       end
 
       def __mandatory_cms_attributes(obj_class)
-        obj_class_def = RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class) #RailsConnector::ObjClass.where(:obj_class_name => obj_class).first
-        obj_class_def ? obj_class_def.mandatory_attribute_names(:only_custom_attributes => true) : []
+        obj_class_def = RailsConnector::Meta::EagerLoader.instance.obj_class(obj_class) # RailsConnector::ObjClass.where(:obj_class_name => obj_class).first
+        obj_class_def ? obj_class_def.mandatory_attribute_names(only_custom_attributes: true) : []
       end
 
-      def reload_attributes(new_obj_class=nil)
-        new_obj_class ||= self.name
-        raise ArgumentError, "Cannot reload attributes because obj_class is unknown, provide one as a parameter" if new_obj_class.nil?
+      def reload_attributes(new_obj_class = nil)
+        new_obj_class ||= name
+        if new_obj_class.nil?
+          raise ArgumentError, "Cannot reload attributes because obj_class is unknown, provide one as a parameter"
+        end
 
         RailsConnector::Meta::EagerLoader.instance.forget_obj_class(new_obj_class)
         Reactor::AttributeHandlers.reinstall_attributes(self, new_obj_class)
+        reinitialize_attributes
       end
     end
   end