universe_compiler 0.2.11

data/lib/universe_compiler/entity/conversion.rb

@@ -0,0 +1,66 @@
+require 'digest'
+
+module UniverseCompiler
+  module Entity
+
+    module Conversion
+
+      def as_path
+        to_composite_key.map(&:to_s).join '/'
+      end
+
+      def to_composite_key
+        [type, name]
+      end
+
+      def to_uniq_id
+        Digest::SHA256.hexdigest to_composite_key.join ':'
+      end
+
+      def inspect
+        msg = "#<#{self.class.name}:#{object_id} composite_key=#{to_composite_key.inspect}"
+        msg << ", @universe='#{universe.name}'" unless universe.nil?
+        msg << '>'
+        msg
+      end
+
+      def ==(another_reference)
+        return false unless another_reference.respond_to? :to_composite_key
+        to_composite_key == another_reference.to_composite_key
+      end
+
+      def eql?(another_reference)
+        self == another_reference and universe == another_reference.universe
+      end
+
+      def to_hash
+        {
+            self.class.name => {
+                type: type,
+                fields: dereferenced_fields
+            }
+        }
+      end
+
+      def to_reference
+        UniverseCompiler::Entity::Reference.new_instance self
+      end
+
+      def encode_with(coder)
+        dereferenced_fields.each do |key, value|
+          coder[key] = value
+        end
+      end
+
+      def init_with(coder)
+        initialize
+        self.fully_resolved = false
+        coder.map.each do |key, value|
+          self[key] = value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/field_binder.rb

@@ -0,0 +1,36 @@
+module UniverseCompiler
+  module Entity
+
+    module FieldBinder
+
+      def field_accessor(*field_names)
+        field_names.each do |field_name|
+          field_reader field_name
+          field_writer field_name
+        end
+      end
+
+      def field_reader(*field_names)
+        field_names.each do |field_name|
+          self.class_eval do
+            define_method field_name do
+              self.fields[field_name]
+            end
+          end
+        end
+      end
+
+      def field_writer(*field_names)
+        field_names.each do |field_name|
+          self.class_eval do
+            define_method "#{field_name}=" do |val|
+              self.fields[field_name] = val
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/field_constraint_management.rb

@@ -0,0 +1,95 @@
+module UniverseCompiler
+  module Entity
+
+    module FieldConstraintManagement
+
+      BOOLEAN_CONSTRAINTS = %i(not_null not_empty is_array is_hash).freeze
+      PARAMETRIZED_CONSTRAINTS = %i(should_match class_name).freeze
+
+      INCOMPATIBLE_CONSTRAINTS = {
+          has_one: %i(has_many is_array is_hash),
+          has_many: %i(has_one is_hash),
+          is_array: %i(has_one is_hash),
+          is_hash: %i(has_one has_many is_array)
+      }.freeze
+
+      def fields_constraints
+        @fields_constraints ||= {}
+      end
+
+      # Dynamically created constraint methods
+      BOOLEAN_CONSTRAINTS.each do |constraint_name|
+        self.class_eval do
+          define_method constraint_name do |*field_names|
+            field_names.each do |field_name|
+              define_constraint field_name, constraint_name, true
+            end
+          end
+        end
+      end
+      PARAMETRIZED_CONSTRAINTS.each do |constraint_name|
+        self.class_eval do
+          define_method constraint_name do |field_name, param|
+            define_constraint field_name, constraint_name, param
+          end
+        end
+      end
+
+      def field(field_name, *options)
+        ['', '='].each do |suffix|
+          method_name = '%s%s' % [field_name, suffix]
+          if instance_methods.include? method_name
+            raise UniverseCompiler::Error,
+                  "'#{method_name}' method cannot be defined on '#{self}' as it is already defined  !"
+          end
+        end
+
+        define_constraint field_name if options.empty?
+
+        options.each do |option|
+          case option
+          when Symbol || String
+            if BOOLEAN_CONSTRAINTS.include? option.to_sym
+              send option, field_name
+            else
+              raise UniverseCompiler::Error, "Unknown field option '#{option}' !"
+            end
+          when Hash
+            option.each do |constraint_name, value|
+              if PARAMETRIZED_CONSTRAINTS.include? constraint_name.to_sym
+                send constraint_name, field_name, value
+              else
+                raise UniverseCompiler::Error, "Unknown field option '#{constraint_name}' !"
+              end
+            end
+          else
+            raise UniverseCompiler::Error, "Invalid option for '#{field_name}': #{option.class.name} => #{option.to_s}"
+          end
+        end
+
+      end
+
+      private
+
+      def define_constraint(field_name, constraint_name = nil, value = nil)
+        fields_constraints[field_name] ||= {}
+        check_constraints_incompatibilities(field_name, constraint_name)
+        unless constraint_name.nil? and value.nil?
+          fields_constraints[field_name][constraint_name] = value
+        end
+      end
+
+      def check_constraints_incompatibilities(field_name, constraint_name)
+        unless INCOMPATIBLE_CONSTRAINTS[constraint_name].nil?
+          INCOMPATIBLE_CONSTRAINTS[constraint_name].each do |incompatible_constraint|
+            if fields_constraints[field_name].keys.include? incompatible_constraint
+              raise UniverseCompiler::Error, "Cannot set constraint '#{constraint_name}' on field '#{field_name}', incompatible with existing ones !"
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/field_management.rb

@@ -0,0 +1,57 @@
+module UniverseCompiler
+  module Entity
+
+    module FieldManagement
+
+      attr_accessor :auto_create_fields
+
+      def method_missing(method_name, *args)
+        if auto_create_fields
+          candidate_field_name = method_name
+          method_name.to_s.match (/^(?<field_name>[^=]+)\s*=?$/) do |md|
+            candidate_field_name = md['field_name'].to_sym
+          end
+          define_field_accessor candidate_field_name
+          raise "Invalid method '#{method_name}' in #{self}" unless self.respond_to? method_name
+          self.send method_name, *args
+        else
+          super(method_name, *args)
+        end
+      end
+
+      private
+
+      def define_known_fields_accessors
+        self.class.fields_constraints.each do |field_name, constraints|
+          define_field_accessor field_name
+          if fields[field_name].nil?
+            fields[field_name] = [] if constraints[:has_many] || constraints[:is_array]
+            fields[field_name] = {} if constraints[:is_hash]
+          end
+        end
+      end
+
+      def define_field_accessor(field_name)
+        metaclass = class << self; self ; end
+        UniverseCompiler.logger.debug 'Defining field accessor %s on class %s (%s)' % [field_name, metaclass, self.type]
+        if self.respond_to? field_name or self.respond_to? "#{field_name}="
+          UniverseCompiler.logger.warn "Cannot define '#{field_name}' or '#{field_name}=' which already exist(s) on class '#{metaclass}' !"
+        else
+          metaclass.instance_eval do
+            define_method field_name do
+              fields[field_name]
+            end
+          end
+          metaclass.instance_eval do
+            define_method "#{field_name}=" do |value|
+              fields[field_name] = value
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/universe_compiler/entity/inheritance.rb

@@ -0,0 +1,87 @@
+module UniverseCompiler
+  module Entity
+
+    module Inheritance
+
+      extend UniverseCompiler::Entity::FieldBinder
+
+      field_accessor :extends
+      attr_reader :compiled
+
+      def apply_inheritance
+        return unless compiled.nil?
+        unless extends.nil?
+          valid_for_inheritance? raise_error: true
+          @fields = fields_inheritance_result
+        end
+      ensure
+        @compiled = true
+      end
+
+      def valid_for_inheritance?(raise_error: false)
+        is_valid = true
+        unless extends.nil?
+          is_valid = false
+          if extends.respond_to? :type and extends.respond_to? :name
+            if extends.respond_to? :fields or extends.is_a? UniverseCompiler::Entity::Reference
+              is_valid = self.type == extends.type
+            end
+          end
+        end
+        return true if is_valid
+        false_or_raise "Invalid entity '#{to_composite_key}' ! Inheritance is invalid !", raise_error: raise_error
+      end
+
+      private
+
+      def fields_inheritance_result
+        stack = inheritance_stack(self).reverse
+        return stack.first if stack.size == 1
+        merge_engine = SuperStack::Manager.new
+        merge_engine.merge_policy = SuperStack::MergePolicies::InheritanceMergePolicy
+        stack.each { |entity| merge_engine << entity.fields.dup }
+        merge_engine[]
+      end
+
+      def inheritance_stack(entity, stack=[], visited=[])
+        if visited.include? entity
+          display_as_path = display_path(*visited.map(&:to_composite_key), entity.to_composite_key)
+          raise UniverseCompiler::Error, "Circular reference detected for '#{to_composite_key}' (#{display_as_path}) !"
+        end
+        visited << entity
+        stack << entity
+        return stack unless entity.extends
+        parent = entity.extends
+        if parent.nil?
+          display_as_path = display_path(*visited.map(&:to_composite_key), entity.extends.to_composite_key)
+          err_msg = "Invalid inheritance defined in '#{entity.to_composite_key}' extending '#{entity.to_composite_key}' (#{display_as_path}) !"
+          raise UniverseCompiler::Error, err_msg
+        end
+        stack = inheritance_stack parent, stack, visited
+        stack
+      end
+
+
+      def inherited_fields_stack(entity, stack=[], visited=[])
+        if visited.include? entity
+          raise UniverseCompiler::Error, "Circular reference detected for '#{self.to_composite_key}' (#{display_path(*visited.map(&:to_composite_key), entity.to_composite_key)}) !"
+        end
+        visited << entity
+        stack << entity.fields
+        return stack unless entity.extends
+        parent = entity.extends
+        if parent.nil?
+          raise UniverseCompiler::Error, "Invalid inheritance defined in '#{entity.to_composite_key}' extending '#{entity.to_composite_key}' (#{display_path(*visited.map(&:composite_key), entity.extends.to_composite_key)}) !"
+        end
+        stack = inherited_fields_stack parent, stack, visited
+        stack
+      end
+
+      def display_path(*names)
+        names.join ' -> '
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/inheritance_merge_policy.rb

@@ -0,0 +1,19 @@
+module SuperStack
+  module MergePolicies
+
+    module InheritanceMergePolicy
+
+      extend UniverseCompiler::Utils::DeepTraverse
+      extend UniverseCompiler::Entity::Marshalling
+
+      def self.merge(h1, h2)
+        h1_dereferenced = dereferenced_fields h1
+        h2_dereferenced = dereferenced_fields h2
+        merged = h1_dereferenced.deep_merge! h2_dereferenced
+        resolve_fields_references merged
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/marshalling.rb

@@ -0,0 +1,71 @@
+module UniverseCompiler
+  module Entity
+
+    module Marshalling
+
+
+      def fully_resolved?
+        fully_resolved || false
+      end
+
+      def resolve_fields_references!(from_fields = fields)
+        UniverseCompiler.logger.debug "Starting resolution for '#{to_composite_key}'."
+        @fields = resolve_fields_references from_fields
+        UniverseCompiler.logger.debug "Completed resolution for '#{to_composite_key}'."
+        self
+      end
+
+      def resolve_fields_references(from_fields = fields)
+        self.fully_resolved = true
+        deep_map from_fields do |leaf|
+          case leaf
+          when UniverseCompiler::Entity::Reference
+            res = leaf.to_entity raise_error: false
+            if res
+              res
+            else
+              self.fully_resolved = false
+              leaf
+            end
+          else
+            leaf
+          end
+        end
+      end
+
+      def traverse_fields(fields_to_process = fields)
+        deep_traverse(fields_to_process) do |leaf|
+          yield leaf
+        end
+      end
+
+      def dereferenced_fields(fields_to_dereference = fields)
+        deep_map(fields_to_dereference) do |leaf|
+          case leaf
+          when UniverseCompiler::Entity::Base
+            leaf.to_reference
+          when Symbol, Numeric, NilClass, TrueClass, FalseClass
+            leaf
+          else
+            leaf.clone
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :fully_resolved
+
+      def marshal_dump
+        { fields: dereferenced_fields, universe: universe.name }
+      end
+
+      def marshal_load(data)
+        stored_universe = UniverseCompiler::Universe::Base.universes[data[:universe]]
+        initialize fields: data[:fields], universe: stored_universe
+      end
+    end
+
+  end
+end
+

data/lib/universe_compiler/entity/overridden.rb

@@ -0,0 +1,31 @@
+module UniverseCompiler
+  module Entity
+
+    module Overridden
+
+      def overridden_by
+        @overridden_by ||= []
+      end
+
+      def apply_override(override_fields, overrider)
+        merge_engine = SuperStack::Manager.new
+        merge_engine.merge_policy = SuperStack::MergePolicies::InheritanceMergePolicy
+        merge_engine << fields.to_hash
+        merge_engine << override_fields
+        add_overrider overrider
+        @fields = merge_engine[]
+        merge_engine.clear_layers
+        @fields
+      end
+
+      private
+
+      def add_overrider(overrider)
+        raise "This object #{to_composite_key} is already overridden by #{overrider.to_composite_key}" if overridden_by.include? overrider
+        overridden_by << overrider
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/persistence.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module UniverseCompiler
+  module Entity
+
+    module Persistence
+
+      attr_accessor :source_uri
+
+      def self.load(uri)
+        entity = YAML.load_file uri
+        entity.source_uri = uri
+        entity
+      end
+
+      def save(uri = source_uri, raise_error: true)
+        valid? raise_error: raise_error
+        FileUtils.mkpath File.dirname(uri)
+        File.write uri, to_yaml, mode: 'w'
+        self.source_uri = uri
+        self
+      end
+
+      def delete
+        universe.delete self
+        unless self.source_uri.nil?
+          FileUtils.rm self.source_uri
+        end
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/reference.rb

@@ -0,0 +1,77 @@
+require 'digest'
+
+module UniverseCompiler
+  module Entity
+
+    class Reference
+
+      class << self
+
+        def references
+          @references ||= {}
+        end
+
+        def new_instance(entity = nil)
+          k = entity_to_cache_key entity
+          return references[k] if references[k]
+          e = new entity
+          references[k] = e
+          e
+        end
+
+        def entity_to_cache_key(entity_or_reference)
+          universe_name = entity_or_reference.universe.nil? ? '' : entity_or_reference.universe.name
+          universe_name ||= ''
+          [entity_or_reference.type, entity_or_reference.name, universe_name]
+        end
+
+        private :new
+
+      end
+
+      yaml_tag '!psref'
+
+      include UniverseCompiler::Utils::ErrorPropagation
+      include UniverseCompiler::Entity::Conversion
+
+      attr_reader :type, :name, :universe
+
+      def initialize(entity = nil)
+        self.entity = entity unless entity.nil?
+      end
+
+      def entity=(entity)
+        @type = entity.type
+        @name = entity.name
+        self.universe = entity.universe
+      end
+
+      def universe=(another_universe)
+        k = self.class.entity_to_cache_key self
+        self.class.references.delete k
+        @universe = another_universe
+        self.class.entity_to_cache_key self
+      end
+
+      def to_entity(raise_error: true)
+        false_or_raise "Cannot get entity '#{to_composite_key.inspect}' if its universe is not defined!", raise_error: raise_error if universe.nil?
+        entity = universe.get_entity *to_composite_key
+        false_or_raise "Cannot find entity '#{to_composite_key.inspect}' in the universe '#{universe}'", raise_error: raise_error if entity.nil?
+        entity
+      end
+
+      def encode_with(coder)
+        coder['type'] = type
+        coder['name'] = name
+      end
+
+      def init_with(coder)
+        initialize
+        @type = coder['type']
+        @name = coder['name']
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity/relations_management.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/string/inflections'
+
+module UniverseCompiler
+  module Entity
+
+    module RelationsManagement
+
+      def has_one(entity_type, name: nil)
+        case entity_type
+        when Class
+          name = name.nil? ? entity_type.entity_type : name.to_sym
+          define_constraint name, :has_one, entity_type.entity_type
+        when Symbol, String
+          name = name.nil? ? entity_type.to_sym : name.to_sym
+          define_constraint name, :has_one, entity_type.to_sym
+        end
+      end
+
+      def has_many(entity_type, name: nil)
+        name = case entity_type
+               when Class
+                 name.nil? ? entity_type.entity_type : name.to_sym
+               when Symbol, String
+                 name.nil? ? entity_type.to_sym : name.to_sym
+               end
+        field_name = name.to_s.pluralize.to_sym
+
+        case entity_type
+        when Class
+          define_constraint field_name, :has_many, entity_type.entity_type
+        when Symbol, String
+          define_constraint field_name, :has_many, entity_type.to_sym
+        end
+      end
+
+      def entity_type_relations
+        fields_constraints.select do |_, constraints|
+          constraints.keys.include? :has_one or constraints.keys.include? :has_many
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/universe_compiler/entity/type_management.rb

@@ -0,0 +1,43 @@
+module UniverseCompiler
+  module Entity
+
+    module TypeManagement
+
+      module ClassMethods
+
+        def entity_type(value = nil)
+          if value.nil?
+            @entity_type || name.underscore
+          else
+            self.entity_type = value
+          end
+        end
+
+        def entity_type=(value)
+          raise UniverseCompiler::Error, "You cannot change an entity type for class '#{self.name}'" unless @entity_type.nil?
+          raise UniverseCompiler::Error, 'Only Symbol is supported for entity_type !' unless value.is_a? Symbol
+          @entity_type = value
+        end
+
+      end
+
+      def self.valid_for_type?(entity)
+        entity.respond_to? :type and entity.class.respond_to? :entity_type
+      end
+
+      def type
+        self.class.entity_type
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def self.extended(base)
+        included base.class
+      end
+
+    end
+
+  end
+end