infopark_fiona7 0.30.0.2 → 0.70.0.1

data/lib/fiona7/type_loader.rb

@@ -0,0 +1,63 @@
+module Fiona7
+  class TypeLoader
+    class AttributeTypeHelper
+      attr_accessor :cms_attribute
+
+      def initialize(cms_attribute)
+        self.cms_attribute = cms_attribute
+      end
+
+      def real_type
+        self.cms_attribute.attribute_type
+      end
+
+      def virtual_type
+        ::JSON.parse(cms_attribute.help_text(:de))['type'].to_sym rescue nil
+      end
+    end
+    
+    attr_reader :obj_class, :rc_obj_class
+
+    def initialize(obj_class)
+      self.obj_class    = obj_class
+      self.name_aliaser = TypeRegister::NameAliaser.new(virtual: obj_class)
+      self.rc_obj_class = RailsConnector::Meta::EagerLoader.instance.obj_class(self.name_aliaser.real_obj_class)
+
+    end
+
+    def load(type_definition)
+      #puts "loading #{obj_class}"
+      if Fiona7.mode == :legacy
+        type_definition.add_attr('title', :string, 'title', :string)
+        if self.rc_obj_class.obj_type == 'publication' || self.rc_obj_class.obj_type == 'document'
+          type_definition.add_attr('body', :html, 'body', :html)
+        elsif self.rc_obj_class.obj_type == 'image' || self.rc_obj_class.obj_type == 'generic'
+          type_definition.add_attr('blob', :binary, 'blob', :binary)
+        end
+      end
+
+      self.rc_obj_class.custom_attributes.each do |real_name, cms_attribute|
+        next if real_name == 'X_widget_pool'
+
+        # TODO: move this to a better place
+        if Fiona7.mode == :standalone
+          virtual_name = real_name.sub("s_#{self.rc_obj_class.name}__", "")
+        else
+          virtual_name = real_name
+        end
+
+        type_helper  = AttributeTypeHelper.new(cms_attribute)
+        real_type    = type_helper.real_type
+        virtual_type = type_helper.virtual_type || real_type
+        values       = cms_attribute.values
+
+        type_definition.add_attr(virtual_name, virtual_type, real_name, real_type, values)
+      end
+    end
+
+    protected
+    attr_accessor :name_aliaser
+    attr_writer :obj_class, :rc_obj_class
+
+  end
+end

data/lib/fiona7/type_register.rb

@@ -1,140 +1,221 @@
 require 'set'
+require 'singleton'
+require 'fiona7/type_loader'
+require 'fiona7/type_synchronizer'
 
 module Fiona7
   class TypeRegister
+    include Singleton
+
     TYPE_MAP = {
       link:           :linklist,
       reference:      :linklist,
       referencelist:  :linklist,
-      widget:         :linklist,
-      binary:         :linklist
-    }
-
-    class << self
-      def instance
-        self.new
+      widgetlist:     :linklist,
+      binary:         :linklist,
+      stringlist:     :text
+    }.freeze
+
+    class NameAliaser
+      attr_accessor :virtual_obj_class, :real_obj_class
+
+      def initialize(input={})
+        if input[:virtual]
+          self.virtual_obj_class = input[:virtual]
+          self.real_obj_class = input[:virtual].gsub('::', '__')
+        elsif input[:real]
+          self.real_obj_class = input[:real]
+          self.virtual_obj_class = input[:real].gsub('__','::')
+        else
+          raise "Invalid input for NameAliaser"
+        end
       end
     end
+    class TypeDefinition
+      class Attribute < Struct.new(:name, :type, :real_name, :real_type, :values)
+        class Core < Struct.new(:name, :type)
+        end
 
-    class ObjClass < Struct.new('ObjClass', :name, :type, :attributes)
-    end
-
-    class Attribute < Struct.new(:real_name, :virtual_name, :real_type, :virtual_type, :values)
-    end
+        def eql?(other)
+          other.kind_of?(self.class) &&
+            self.name.eql?(other.name)
+            #Core.new(self.name, self.type).eql?(Core.new(other.name, other.type))
+        end
 
-    def cached_type(obj_class_name)
-      @@cached_type ||= {}
-      @@cached_type[obj_class_name.to_s] ||= ObjClass.new.tap do |obj_class|
-        cms_class      = RailsConnector::ObjClass.find_by_obj_class_name(obj_class_name)
-        obj_class.name = cms_class.name
-        obj_class.type = cms_class.obj_type
+        def hash
+          return self.name.hash
+          #Core.new(self.name, self.type).hash
+        end
+      end
 
-        attributes = Set.new
-        cms_class.custom_attributes.each do |real_name, cms_attribute|
-          real_name = real_name.to_sym
+      attr_accessor :name
+      attr_accessor :attrs
+      attr_accessor :aliaser
 
-          next if real_name == :X_widget_pool
+      def initialize(name)
+        self.name = name
+        self.attrs = Set.new
+        self.aliaser = NameAliaser.new(virtual: name)
+      end
 
-          if Fiona7.mode == :standalone
-            virtual_name = real_name.to_s.sub(/^s_#{Regexp.escape obj_class_name}__/, '').to_sym
-          elsif Fiona7.mode == :legacy
-            # X_blob simulates blob attribute
-            if real_name == :X_blob
-              virtual_name = :blob
-            else
-              virtual_name = real_name.to_sym
-            end
-          else
-            raise "Invalid Fiona7.mode = #{Fiona7.mode}"
-          end
+      def real_name
+        self.aliaser.real_obj_class
+      end
 
-          real_type      = cms_attribute.attribute_type.to_sym
-          virtual_type   = ::JSON.parse(cms_attribute.help_text(:de))['type'].to_sym rescue nil
-          virtual_type ||= real_type
+      def virtual_name
+        self.aliaser.virtual_obj_class
+      end
 
-          # real_type = virtual_type in this case
-          if [:enum, :multienum].include?(real_type)
-            values = cms_attribute.values
-          else
-            values = nil
-          end
+      def add_attr(name, type, real_name=nil, real_type=nil, values=nil)
+        real_type ||= TYPE_MAP[type.to_sym] || type
+        # TODO: move this to a better place
+        if Fiona7.mode == :standalone
+          real_name ||= "s_#{self.real_name}__#{name}"
+        else
+          real_name ||= name
+        end
+        self.attrs << Attribute.new(name.to_s, type.to_sym, real_name.to_s, real_type.to_sym, values)
+      end
 
-          attributes << Attribute.new(real_name, virtual_name, real_type, virtual_type, values)
+      def find_attribute(name)
+        name = name.to_s
+        self.attrs.find do |attr|
+          attr.name == name
         end
+      end
 
-        if Fiona7.mode == :legacy
-          # include built-in title and body
-          attributes << Attribute.new(:title, :title, :string, :string, nil)
-          if cms_class.obj_type != "image" && cms_class.obj_type != "generic"
-            attributes << Attribute.new(:body, :body, :html, :html, nil)
+      # TODO: conflict handling for type errors
+      def merge(other_definition)
+        other_definition.attrs.each do |other_attr|
+          if !self.attrs.include?(other_attr)
+            self.attrs << other_attr
           end
         end
+        self
+      end
+    end
+    class AdHocTypeDefinition
+      attr_accessor :values, :obj_class
+      def initialize(values, obj_class=nil)
+        self.values = values
+        self.obj_class = obj_class || values.delete(:_obj_class)
+      end
 
-        obj_class.attributes = attributes.to_a
+      def type_definition
+        type_definition = TypeDefinition.new(self.obj_class)
+        pp values
+        values.each do |name, possible_pair|
+          next if name =~ /\A_/ # built-in attribute
+          next unless possible_pair.kind_of?(Array) && possible_pair.length == 2
+
+          type, _ = *possible_pair
+          type_definition.add_attr(name, type)
+        end
+        type_definition
       end
     end
+    attr_accessor :cms_defs
+    attr_accessor :usr_defs
 
-    def invalidate_cached_type(obj_class_name)
-      @@cached_type.delete(obj_class_name.to_s)
-      # clear reactor cache as well
-      RailsConnector::Meta::EagerLoader.instance.forget_obj_class(obj_class_name)
+    def initialize
+      self.cms_defs = {}
+      self.usr_defs = {}
     end
 
-    def annotated_attributes(obj_class_name)
-      obj_class = cached_type(obj_class_name)
-      raise "Unknown obj_class: #{obj_class_name}" unless obj_class
-      obj_class.attributes
+    def read?(obj_class)
+      self.cms_def_present?(obj_class)
     end
 
-    def attributes(obj_class_name)
-      raise "Deprecated"
+    def write?(obj_class)
+      true &&
+        self.usr_def_present?(obj_class) &&
+        self.cms_def_present?(obj_class) &&
+        self.defs_compatible?(self.cms_defs[obj_class], self.usr_defs[obj_class])
     end
 
-    def obj_type(obj_class_name)
-      self.cached_type(obj_class_name).type
+    def read_mangled(obj_class)
+     read(NameAliaser.new(real: obj_class).virtual_obj_class)
     end
 
-    def attribute_type(obj_class_name, attribute_name)
-      attribute = self.cached_type(obj_class_name).attributes.find {|a| a.virtual_name.to_s == attribute_name.to_s }
+    def read(obj_class)
+      if !self.read?(obj_class)
+        self.load(obj_class) 
+      end
+      self.cms_defs[obj_class]
+    end
 
-      if attribute
-        attribute.virtual_type
-      else
-        raise "unknown attribute: #{attribute_name} in #{obj_class_name}"
+    def write(obj_class)
+      if !self.write?(obj_class)
+        self.synchronize(obj_class) 
+        self.load(obj_class)
       end
+      self.cms_defs[obj_class]
     end
 
-    def real_attribute_name(obj_class_name, attribute_name)
-      if Fiona7.mode == :standalone
-        :"s_#{obj_class_name}__#{attribute_name}"
-      elsif Fiona7.mode == :legacy
-        # blob attribute is always mapped to X_blob attribute if present
-        if attribute_name.to_sym == :blob
-          :X_blob
-        else
-          attribute_name.to_sym
-        end
+    def add_usr_attr(obj_class, name, type, values=nil)
+      self.usr_defs[obj_class] ||= TypeDefinition.new(obj_class)
+      self.usr_defs[obj_class].add_attr(name, type, nil, nil, values)
+    end
+
+    def ad_hoc_synchronize(type_definition)
+      puts "Ad hoc synchronize of #{type_definition.name}"
+      obj_class = type_definition.name
+
+      existing_definition = self.usr_defs[obj_class]
+      if existing_definition
+        type_definition = existing_definition.merge(type_definition)
       else
-        raise "Invalid Fiona7.mode = #{Fiona7.mode}"
+        self.usr_defs[obj_class] = type_definition
       end
+
+      return if true &&
+        self.cms_def_present?(obj_class) &&
+        defs_compatible?(self.cms_defs[obj_class], type_definition)
+
+      puts "Ad hoc synchronization required of #{type_definition.name}"
+
+      self.synchronize(obj_class)
+      self.load(obj_class)
+    end
+
+    protected
+    def usr_def_present?(obj_class)
+      self.usr_defs[obj_class].present?
     end
 
-    def virtual_attribute_name(obj_class_name, attribute_name)
-      attribute_name.to_s.sub("s_#{obj_class_name}__", '').to_sym
+    def cms_def_present?(obj_class)
+      self.cms_defs[obj_class].present?
     end
 
-    def attribute_real_type(obj_class_name, attribute_name)
-      attribute = self.cached_type(obj_class_name).attributes.find {|a| a.virtual_name.to_s == attribute_name.to_s }
+    def defs_compatible?(cms_def, usr_def)
+      cms_attr_map = {}
+      cms_def.attrs.each do |attr|
+        cms_attr_map[attr.name] = attr
+      end
 
-      if attribute
-        attribute.real_type
-      else
-        raise "unknown attribute: #{attribute_name} in #{obj_class_name}"
+      usr_def.attrs.each do |attr|
+        return false if !cms_attr_map[attr.name]
+        return false if attr.type != cms_attr_map[attr.name].type
       end
+
+      return true
     end
 
-    def map_virtual_to_real_type(virtual_type)
-      TYPE_MAP[virtual_type.to_sym] || virtual_type.to_sym
+    def load(obj_class)
+      type_loader     = TypeLoader.new(obj_class)
+      type_definition = TypeDefinition.new(obj_class)
+
+      type_loader.load(type_definition)
+      self.cms_defs[obj_class] = type_definition
+    end
+
+    def synchronize(obj_class)
+      type_definition   = self.usr_defs[obj_class]
+      if type_definition.nil?
+        raise "type definition for #{obj_class} missing, unable to synchronize"
+      end
+      type_synchronizer = TypeSynchronizer.new(type_definition)
+      type_synchronizer.synchronize
     end
   end
 end

data/lib/fiona7/type_synchronizer.rb

@@ -0,0 +1,68 @@
+require 'fiona7/builder/obj_class_builder'
+require 'fiona7/builder/obj_class_updater'
+
+module Fiona7
+  class TypeSynchronizer
+    attr_reader :type_definition, :name_aliaser
+
+    def initialize(type_definition)
+      self.type_definition = type_definition
+      self.name_aliaser    = TypeRegister::NameAliaser.new(virtual: type_definition.name)
+    end
+
+    def synchronize
+      return if skip_this_class?
+
+      Reactor::Sudo.su(Fiona7.root) do
+        if RailsConnector::ObjClass.exists?(:obj_class_name => self.name_aliaser.real_obj_class)
+          Fiona7::Builder::ObjClassUpdater.new(self.builder_values).build
+        else
+          Fiona7::Builder::ObjClassBuilder.new(self.builder_values).build
+        end
+
+        RailsConnector::Meta::EagerLoader.instance.forget_obj_class(self.name_aliaser.real_obj_class)
+      end
+    end
+
+    protected
+    attr_writer :type_definition, :name_aliaser
+
+    def skip_this_class?
+      case self.type_definition.name
+      when 'Scrivito::BasicWidget', 'Scrivito::BasicObj', 'Obj', 'Scrivito::Obj'
+        true
+      else
+        false
+      end
+    end
+
+    def builder_values
+      {
+        name: self.name_aliaser.real_obj_class,
+        attributes: self.builder_attributes
+      }
+    end
+
+    def builder_attributes
+      self.type_definition.attrs.map do |attribute_definition|
+        next if ['title', 'body'].include?(attribute_definition.real_name)
+
+        desc = {
+          real_name: attribute_definition.real_name,
+          real_type: attribute_definition.real_type,
+          name: attribute_definition.name,
+          type: attribute_definition.type
+        }
+
+        # this workaround is needed, because attribute_definition.values
+        # always returns a valid value, be it an empty array
+        case attribute_definition.type
+        when :enum, :multienum
+          desc[:values] = attribute_definition.values
+        end
+
+        desc
+      end.compact
+    end
+  end
+end

data/lib/fiona7/version.rb

@@ -1,3 +1,3 @@
 module Fiona7
-  VERSION = "0.30.0.2"
+  VERSION = "0.70.0.1"
 end