infopark_reactor 1.26.0 → 1.27.0.rc9

data/lib/reactor/attributes/date_serializer.rb

@@ -1,33 +1,40 @@
-# -*- encoding : utf-8 -*-
+# return always utc-timestam in iso format 'YYYYMMDDhhmmss'
 module Reactor
   module Attributes
     class DateSerializer
-      def initialize(attr, value)
-        @attr, @value = attr, value
+      def initialize(key, value)
+        @attr = key
+        @value = value
       end
 
       def serialize
-        @serialized ||= serialize_date
+        @serialized ||= serialize_date(@value)
       end
 
       private
-      def serialize_date
-        if @value.is_a?(Time)
-          @value.dup.utc.to_iso
-        elsif @value.is_a?(String)
-          if iso_format?(@value)
-            @value
-          elsif !@value.empty?
-            Time.zone.parse(@value).utc.to_iso
+
+      def serialize_date(value)
+        return nil if value.blank?
+
+        value = value.to_datetime if value.is_a?(Date)
+        if value.is_a?(Time) || value.is_a?(DateTime)
+          value.utc.to_s(:number)
+        elsif value.is_a?(String)
+          if iso_format?(value)
+            value
           else
-            # empty string <=> clear date
-            nil
+            parse_time(value)
           end
-        else
-          @value
         end
       end
 
+      def parse_time(value)
+        parsed_time = Time.zone.parse(value)
+        return nil unless parsed_time.present?
+
+        parsed_time.utc.to_s(:number)
+      end
+
       def iso_format?(val)
         val =~ /^[0-9]{14}$/
       end

data/lib/reactor/attributes/html_serializer.rb

@@ -1,11 +1,11 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/support/link_matcher'
+require "reactor/support/link_matcher"
 
 module Reactor
   module Attributes
     class HTMLSerializer
       def initialize(attr, value)
-        @attr, @value = attr, value.to_str
+        @attr = attr
+        @value = value.to_str
       end
 
       def serialize
@@ -13,13 +13,14 @@ module Reactor
       end
 
       private
+
       def serialize_html
         link_expressions = [/(href|src|usemap)\s*=\s*"([^"]*)"/, /(href|src|usemap)\s*=\s*'([^']*)'/]
         link_expressions.each do |expr|
           @value.gsub!(expr) do |string|
-            link = Reactor::Support::LinkMatcher.new($2)
+            link = Reactor::Support::LinkMatcher.new(Regexp.last_match(2))
             if link.recognized?
-              "#{$1}=\"#{link.rewrite_url}\""
+              "#{Regexp.last_match(1)}=\"#{link.rewrite_url}\""
             else
               string
             end

data/lib/reactor/attributes/link_list_extender.rb

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/link/temporary_link'
+require "reactor/link/temporary_link"
 
 module Reactor
   module Attributes
@@ -23,11 +22,13 @@ module Reactor
             # install #size_changed callback
             Array.instance_methods(false).each do |meth|
               old = instance_method(meth)
+              next unless meth.to_sym != :map
+
               define_method(meth) do |*args, &block|
                 detect_modification do
                   old.bind(self).call(*args, &block)
                 end
-              end if meth.to_sym != :map
+              end
             end
 
             def changed?
@@ -43,23 +44,24 @@ module Reactor
             end
 
             protected
+
             def link_ids
-              self.map(&:id).compact
+              map(&:id).compact
             end
 
             def temporary_links_present?
-              self.any? {|l| l.kind_of? Reactor::Link::TemporaryLink }
+              any? { |l| l.is_a? Reactor::Link::TemporaryLink }
             end
 
-            def detect_modification(&block)
+            def detect_modification
               original_link_ids
               yield.tap do
-                @changed = @changed || original_link_ids != link_ids
+                @changed ||= original_link_ids != link_ids
               end
             end
 
             def transform_into_link(link_data)
-              if (link_data.respond_to?(:external?) && link_data.respond_to?(:internal?))
+              if link_data.respond_to?(:external?) && link_data.respond_to?(:internal?)
                 link_data
               else
                 Reactor::Link::TemporaryLink.new(link_data)

data/lib/reactor/attributes/link_list_from_accessor.rb

@@ -7,10 +7,11 @@ module Reactor
       end
 
       def call
-        self.obj[self.attribute.to_sym] || RailsConnector::LinkList.new([])
+        obj[attribute.to_sym] || RailsConnector::LinkList.new([])
       end
 
       protected
+
       attr_accessor :obj, :attribute
     end
   end

data/lib/reactor/attributes/link_list_from_attr_values.rb

@@ -7,12 +7,13 @@ module Reactor
       end
 
       def call
-        (self.obj.attr_values[self.attribute.to_s] || []).map do |link_data|
+        (obj.attr_values[attribute.to_s] || []).map do |link_data|
           RailsConnector::Link.new(link_data)
         end
       end
 
       protected
+
       attr_accessor :obj, :attribute
     end
   end

data/lib/reactor/attributes/link_list_serializer.rb

@@ -1,13 +1,12 @@
-# -*- encoding : utf-8 -*-
-require 'reactor/link/temporary_link'
-require 'infopark_fiona_connector'
-#require 'infopark_rails_connector'
+require "reactor/link/temporary_link"
+require "infopark_fiona_connector"
 
 module Reactor
   module Attributes
     class LinkListSerializer
       def initialize(attr, value)
-        @attr, @value = attr, value
+        @attr = attr
+        @value = value
       end
 
       def serialize
@@ -20,10 +19,12 @@ module Reactor
       end
 
       private
+
       def enumerate(value)
         return [] if value.nil? || value.blank?
-        return [value] unless value.kind_of?(Array)
-        return value
+        return [value] unless value.is_a?(Array)
+
+        value
       end
     end
   end

data/lib/reactor/attributes_handlers.rb

@@ -0,0 +1,164 @@
+require "reactor/attributes/date_serializer"
+require "reactor/attributes/html_serializer"
+require "reactor/attributes/link_list_serializer"
+
+require "reactor/attributes/link_list_extender"
+
+require "singleton"
+
+module Reactor
+  class AttributeHandlers
+    include Singleton
+
+    def initialize
+      # t1 = Time.now
+      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)
+      klass.send(:include, handler_module(obj_class)) if obj_class_known?(obj_class)
+    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 /^[A-Z]/.match?(obj_class.try(:name))
+      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?(**options)
+          attribute_changed?(:#{attribute}, options)
+        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
+end

data/lib/reactor/cache/permission.rb

@@ -1,32 +1,29 @@
-# -*- encoding : utf-8 -*-
-
 module Reactor
   module Cache
     class Permission
       BACKING_CACHE_EXPIRATION = 5
 
       def self.instance
-        self.new
+        new
       end
 
       def initialize
         @@backing_storage ||= ActiveSupport::Cache::MemoryStore.new({ size: 1.megabyte })
       end
 
-      def lookup(user, key, &block)
-        cache_entry = @@backing_storage.fetch(user.to_s, :expires_in => BACKING_CACHE_EXPIRATION.minutes) do
-          {key => block.call}
+      def lookup(user, key)
+        cache_entry = @@backing_storage.fetch(user.to_s, expires_in: BACKING_CACHE_EXPIRATION.minutes) do
+          { key => yield }
         end
         if cache_entry.key?(key)
           cache_entry[key]
         else
-          result = block.call
-          @@backing_storage.write(user.to_s, cache_entry.merge({key => result}), :expires_in => BACKING_CACHE_EXPIRATION.minutes)
+          result = yield
+          @@backing_storage.write(user.to_s, cache_entry.merge({ key => result }), expires_in: BACKING_CACHE_EXPIRATION.minutes)
           result
         end
       end
 
-
       def invalidate(user)
         @@backing_storage.delete(user.to_s)
       end

data/lib/reactor/cache/user.rb

@@ -1,12 +1,10 @@
-# -*- encoding : utf-8 -*-
-
 module Reactor
   module Cache
     class User
       BACKING_CACHE_EXPIRATION = 5
 
       def self.instance
-        self.new
+        new
       end
 
       def initialize
@@ -18,19 +16,18 @@ module Reactor
         # Rails.logger.debug "User:Cache hit: #{hit?(user_name.to_s)} [#{@cache[user_name.to_s].inspect}]"
 
         key = user_name.to_s
-        @@backing_storage.fetch(key, :expires_in => BACKING_CACHE_EXPIRATION.minutes) do
+        @@backing_storage.fetch(key, expires_in: BACKING_CACHE_EXPIRATION.minutes) do
           Reactor::Session::User.new(key)
         end
       end
 
       def set(user_name, user)
-        @@backing_storage.write(user_name.to_s, user, :expires_in => BACKING_CACHE_EXPIRATION.minutes)
+        @@backing_storage.write(user_name.to_s, user, expires_in: BACKING_CACHE_EXPIRATION.minutes)
       end
 
       def invalidate(user_name)
         @@backing_storage.delete(user_name.to_s)
       end
-
     end
   end
 end

data/lib/reactor/cm/attribute.rb

@@ -1,30 +1,29 @@
-# -*- encoding : utf-8 -*-
 module Reactor
   module Cm
     class Attribute
       def self.exists?(name)
         begin
-          return Attribute.new.send(:get,name).ok?
-        rescue
-          return false
+          Attribute.new.send(:get, name).ok?
+        rescue StandardError
+          false
         end
       end
 
       def self.instance(name)
         attr = Attribute.new
-        attr.instance_variable_set('@name', name)
+        attr.instance_variable_set("@name", name)
         attr
       end
 
       def self.get(name)
         attr = Attribute.new
-        attr.send(:get,name)
+        attr.send(:get, name)
         attr
       end
 
       def self.create(name, type)
         attr = Attribute.new
-        attr.send(:create,name,type)
+        attr.send(:create, name, type)
         attr
       end
 
@@ -34,27 +33,28 @@ module Reactor
 
       def save!
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.set_tag!(base_name) do
             @params.each do |key, value|
               xml.value_tag!(key.to_s, value)
             end
           end
         end
-        response = request.execute!
+        request.execute!
       end
 
       def delete!
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', @name)
+          xml.where_key_tag!(base_name, "name", @name)
           xml.tag!("#{base_name}-delete")
         end
-        response = request.execute!
+        request.execute!
       end
 
       protected
+
       def base_name
-        'attribute'
+        "attribute"
       end
 
       def initialize
@@ -63,8 +63,8 @@ module Reactor
 
       def get(name)
         request = XmlRequest.prepare do |xml|
-          xml.where_key_tag!(base_name, 'name', name)
-          xml.get_key_tag!(base_name, 'name')
+          xml.where_key_tag!(base_name, "name", name)
+          xml.get_key_tag!(base_name, "name")
         end
         response = request.execute!
         @name = name
@@ -74,10 +74,10 @@ module Reactor
       def create(name, type)
         request = XmlRequest.prepare do |xml|
           xml.create_tag!(base_name) do
-            xml.tag!('name') do
+            xml.tag!("name") do
               xml.text!(name)
             end
-            xml.tag!('type') do
+            xml.tag!("type") do
               xml.text!(type)
             end
           end