universe_compiler 0.2.11

data/lib/universe_compiler/entity/validation.rb

@@ -0,0 +1,92 @@
+module UniverseCompiler
+  module Entity
+
+    module Validation
+
+      def invalid_fields
+        invalid = {}
+        self.class.fields_constraints.each do |field_name, constraints|
+          constraints.each do |constraint_name, value|
+            case constraint_name
+            when :not_null
+              invalid_for_constraint invalid, field_name, constraint_name, value if fields[field_name].nil?
+            when :not_empty
+              invalid_for_constraint invalid, field_name, constraint_name, value if fields[field_name].nil? or fields[field_name].empty?
+            when :should_match
+              unless fields[field_name].nil?
+                invalid_for_constraint invalid, field_name, constraint_name, value unless fields[field_name].to_s.match value
+              end
+            when :class_name
+              unless fields[field_name].nil?
+                case value
+                when String
+                  invalid_for_constraint invalid, field_name, constraint_name, value unless fields[field_name].class.name == value
+                else
+                  invalid_for_constraint invalid, field_name, constraint_name, value unless fields[field_name].class == value
+                end
+              end
+            when :is_array
+              if fields[field_name].nil? or not fields[field_name].is_a? Array
+                invalid_for_constraint invalid, field_name, constraint_name, value
+              end
+            when :is_hash
+              if fields[field_name].nil? or not fields[field_name].is_a? Hash
+                invalid_for_constraint invalid, field_name, constraint_name, value
+              end
+            when :has_one
+              unless fields[field_name].nil?
+                if fields[field_name].respond_to? :type
+                  invalid_for_constraint invalid, field_name, constraint_name, value unless fields[field_name].type == value
+                else
+                  invalid_for_constraint invalid, field_name, constraint_name, value
+                end
+              end
+            when :has_many
+              if fields[field_name].nil? or not fields[field_name].is_a? Array
+                invalid_for_constraint invalid, field_name, constraint_name, value
+              else
+                fields[field_name].each do |related_object|
+                  if related_object.respond_to? :type
+                    invalid_for_constraint invalid, field_name, constraint_name, value unless related_object.type == value
+                  else
+                    invalid_for_constraint invalid, field_name, constraint_name, value
+                  end
+                end
+              end
+            else
+              UniverseCompiler.logger.warn "Cannot handle unknown constraint '#{constraint_name}'! Skipping..."
+            end
+          end
+        end
+        invalid
+      end
+
+      def valid_for_fields_constraints?(raise_error: false)
+        return true if invalid_fields.empty?
+        invalid_fields.each do |name,value|
+          UniverseCompiler.logger.error "Invalid field '#{name}' not compliant with '#{value}'"
+        end
+        fields_labels = invalid_fields.keys.join ', '
+        false_or_raise "Invalid entity '#{to_composite_key}' for fields #{fields_labels} !", raise_error: raise_error
+      end
+
+      def valid?(raise_error: false)
+        return false unless valid_for_fields_constraints? raise_error: raise_error
+        return false unless valid_for_inheritance? raise_error: raise_error
+        if respond_to? :specifically_valid?
+          return false unless specifically_valid? raise_error: raise_error
+        end
+        true
+      end
+
+      private
+
+      def invalid_for_constraint(invalid_fields_definition, field_name, constraint_name, value)
+        invalid_fields_definition[field_name] ||= []
+        invalid_fields_definition[field_name] << { constraint_name => value}
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/entity.rb

@@ -0,0 +1,64 @@
+module UniverseCompiler
+  module Entity
+
+    class Base
+
+      include UniverseCompiler::Utils::ErrorPropagation
+      include UniverseCompiler::Utils::DeepTraverse
+      include UniverseCompiler::Entity::TypeManagement
+      include UniverseCompiler::Entity::FieldManagement
+      extend UniverseCompiler::Entity::AutoNamed
+      extend UniverseCompiler::Entity::FieldConstraintManagement
+      extend UniverseCompiler::Entity::RelationsManagement
+      extend UniverseCompiler::Entity::FieldBinder
+      include UniverseCompiler::Entity::Validation
+      include UniverseCompiler::Entity::Marshalling
+      include UniverseCompiler::Entity::Inheritance
+      include UniverseCompiler::Entity::Conversion
+      include UniverseCompiler::Entity::Overridden
+      include UniverseCompiler::Entity::Persistence
+
+      attr_reader :fields
+      attr_accessor :universe
+
+      field_accessor :name
+
+      def initialize(fields: {}, universe: nil)
+        @fields = fields
+        define_known_fields_accessors
+        self.universe = universe
+        self.fully_resolved = true
+        self.name = self.class.get_unique_name if self.class.auto_named_entity_type?
+      end
+
+      def [](key)
+        fields[key]
+      end
+
+      def []=(key, value)
+        fields[key] = value
+      end
+
+    end
+
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/universe_compiler/error.rb

@@ -0,0 +1,15 @@
+module UniverseCompiler
+
+  class Error < StandardError
+
+    attr_accessor :original
+
+    def self.from(exception, message = exception.message)
+      wrapper = new message
+      wrapper.original = exception
+      wrapper
+    end
+
+  end
+
+end

data/lib/universe_compiler/override.rb

@@ -0,0 +1,24 @@
+module UniverseCompiler
+  module Entity
+
+    class Override < UniverseCompiler::Entity::Base
+
+      UNMERGEABLE_FIELDS = %i(name type overrides scenario extends)
+
+      entity_type :entity_override
+
+      field :overrides, :is_array
+      field_accessor :scenario
+
+      def apply_overrides
+        overrides.each do |override|
+          fields_to_be_merged = fields.reject { |key, _| UNMERGEABLE_FIELDS.include? key }
+          UniverseCompiler.logger.debug "Overriding '#{override.to_composite_key}' from overrides defined in '#{to_composite_key}'."
+          override.apply_override fields_to_be_merged, self
+        end
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/package/bootstrap.rb

@@ -0,0 +1,46 @@
+module UniverseCompiler
+  module Package
+
+    module Bootstrap
+
+      DEFAULT_BOOTSTRAP_FILE = 'main.rb'.freeze
+
+      attr_reader :path
+
+      def path=(path)
+        @path = path if path_valid? path
+      end
+
+      def path_valid?(path = self.path)
+        return false unless path.is_a?(String) && File.readable?(path)
+        return true if File.file? path
+        File.exist? default_bootstrap_file(path)
+      end
+
+      def bootstrap_file
+        return nil unless path_valid?
+        if File.file? path
+          path
+        else
+          default_bootstrap_file
+        end
+      end
+
+      def load
+        require bootstrap_file
+      rescue ScriptError => e
+        msg = "Invalid package: '#{bootstrap_file}': #{e.message}"
+        UniverseCompiler.logger.error msg
+        raise UniverseCompiler::Error.from(e, msg)
+      end
+
+      private
+
+      def default_bootstrap_file(path = self.path)
+        File.join(path, DEFAULT_BOOTSTRAP_FILE)
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/package.rb

@@ -0,0 +1,17 @@
+module UniverseCompiler
+
+  module Package
+
+    class Base
+
+      include UniverseCompiler::Utils::WithUniqueName
+      include UniverseCompiler::Package::Bootstrap
+
+      def initialize(path = nil)
+        self.path = path
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/persistence/basic_yaml_engine.rb

@@ -0,0 +1,68 @@
+require 'fileutils'
+
+module UniverseCompiler
+  module Persistence
+
+    class BasicYamlEngine
+
+      attr_accessor :universe, :universe_uri
+
+      def initialize(universe, universe_uri)
+        @universe = universe
+        @universe_uri = universe_uri
+      end
+
+      def export_universe
+        FileUtils.mkdir_p universe_uri
+        universe.get_entities.each do |entity|
+          export_entity entity
+        end
+      end
+
+      def import_universe(recursive: false, stop_on_error: true, &block)
+        sub_search_path = recursive ? '**' : '*'
+        glob_pattern = File.join universe_uri, sub_search_path, '*.yaml'
+        Dir.glob(glob_pattern) do |file|
+          UniverseCompiler.logger.debug "Importing '#{file}' entity file."
+          new_entity = nil
+          begin
+            new_entity = import_entity file
+          rescue => e
+            raise e if stop_on_error
+          end
+          if new_entity.nil?
+            UniverseCompiler.logger.debug "#{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+            UniverseCompiler.logger.warn "Could not load entity from file '#{file}' because '#{e.message}'"
+          else
+            block.call new_entity if block_given?
+          end
+        end
+      end
+
+      def export_entity(entity)
+        dir = File.join(universe_uri, entity.type.to_s)
+        FileUtils.mkdir_p dir
+        entity_file = entity.source_uri || File.join(dir, "#{entity.name}.yaml")
+        entity.save entity_file
+        UniverseCompiler.logger.info 'Exporting entity "%s" to file "%s"' % [entity.name, entity_file]
+        UniverseCompiler.logger.debug "Saved entity:\n%s" % [entity.to_yaml]
+      end
+
+      def import_entity(uri)
+        entity = UniverseCompiler::Entity::Persistence.load uri
+        universe.add entity
+        # Fix references link to universe
+        entity.traverse_fields do |leaf|
+          if leaf.is_a? UniverseCompiler::Entity::Reference
+            leaf.universe = universe
+          end
+        end
+        entity
+      end
+
+
+
+    end
+
+  end
+end

data/lib/universe_compiler/persistence/management.rb

@@ -0,0 +1,30 @@
+module UniverseCompiler
+  module Persistence
+
+    module Management
+
+      DEFAULT_ENGINE_NAME = 'BasicYamlEngine'.freeze
+
+      def persistence_engine
+        if @persistence_engine.nil?
+          self.persistence_engine_name = DEFAULT_ENGINE_NAME
+        end
+        @persistence_engine
+      end
+
+      def persistence_engines
+        UniverseCompiler::Persistence.constants.map(&:to_s).grep(/Engine$/).map do |engine_name|
+          self.persistence_engine_name = engine_name
+          persistence_engine
+        end
+      end
+
+      def persistence_engine_name=(engine_name)
+        @persistence_engine = UniverseCompiler::Persistence.const_get engine_name
+        @persistence_engine_name = engine_name
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/universe/compile.rb

@@ -0,0 +1,45 @@
+module UniverseCompiler
+  module Universe
+
+    module Compile
+
+      include UniverseCompiler::Utils::DeepTraverse
+
+      def compile(scenario: nil)
+        valid? raise_error: true
+        UniverseCompiler.logger.info "Starting compilation of universe '#{name}'"
+        # Pass 1 - Universe duplication
+        target_universe = dup
+
+        # Pass 2 - Applying entities inheritance
+        target_universe.apply_entities_inheritance
+
+        # Apply scenario
+        target_universe.apply_entities_overrides scenario unless scenario.nil?
+
+        UniverseCompiler.logger.info "Completed compilation of universe '#{name}' into '#{target_universe.name}'"
+        target_universe
+      end
+
+      protected
+
+      def apply_entities_overrides(scenario)
+        UniverseCompiler.logger.debug "Starting override process for universe '#{name}'."
+        candidates = by_type.fetch(UniverseCompiler::Entity::Override.entity_type, []).select { |overrider| overrider.scenario == scenario }
+        UniverseCompiler.logger.warn "No override found for scenario '#{scenario}' in universe '#{name}'." if candidates.empty?
+        candidates.each(&:apply_overrides)
+        UniverseCompiler.logger.debug "Completed override process for universe '#{name}'."
+        self
+      end
+
+      def apply_entities_inheritance
+        UniverseCompiler.logger.debug "Starting inheritance process for universe '#{name}'."
+        entities.each(&:apply_inheritance)
+        UniverseCompiler.logger.debug "Completed inheritance process for universe '#{name}'."
+        self
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/universe/duplication.rb

@@ -0,0 +1,62 @@
+module UniverseCompiler
+  module Universe
+
+    module Duplication
+
+      def dup
+        UniverseCompiler.logger.debug "Starting '#{name}' universe duplication"
+        duplicated_universe = build_duplicated_universe_with_references
+        duplicated_universe.resolve_entities_reference
+        raise UniverseCompiler::Error, "Compilation error: Generated universe '#{duplicated_universe.name}' is invalid!" unless duplicated_universe.valid?
+        UniverseCompiler.logger.debug "Completed '#{name}' universe duplication"
+        duplicated_universe
+      end
+
+
+      protected
+
+      def resolve_entities_reference
+        entities.map!(&:resolve_fields_references!)
+        self
+      end
+
+      private
+
+      def duplicate_entities(target_universe = nil)
+        entities.map do |entity|
+          debug_msg = "Duplicating '#{entity.to_composite_key}' from universe '#{self.name}'"
+          debug_msg += " to universe '#{target_universe.name}'" unless target_universe.nil?
+          UniverseCompiler.logger.debug debug_msg
+          fields = Marshal::load(Marshal.dump entity).fields
+          entity_copy = entity.class.new fields: fields
+          entity_copy.universe = target_universe
+          deep_map entity_copy.fields do |leaf|
+            case leaf
+            when UniverseCompiler::Entity::Base
+              # All entities are supposed to be now references instead after the Marshall dump/load process
+              raise UniverseCompiler::Error, 'Should never happen!!'
+            when UniverseCompiler::Entity::Reference
+              leaf.universe = target_universe
+            else
+              raise UniverseCompiler::Error, 'Should never happen too!!' if leaf.respond_to? :universe
+              leaf
+            end
+          end
+          target_universe.add entity_copy unless target_universe.nil?
+        end
+      end
+
+      def build_duplicated_universe_with_references
+        target_name = '%s - COMPILED #%s' % [name, '%s']
+        duplicated_universe = self.class.new target_name
+        duplicated_universe.name = duplicated_universe.name % [duplicated_universe.object_id]
+        UniverseCompiler.logger.debug "Generating new universe '#{duplicated_universe.name}'."
+        duplicate_entities duplicated_universe
+        duplicated_universe
+      end
+
+    end
+
+  end
+end
+

data/lib/universe_compiler/universe/entities.rb

@@ -0,0 +1,52 @@
+module UniverseCompiler
+  module Universe
+
+    module Entities
+
+      def empty?
+        entities.empty?
+      end
+
+      def add(entity)
+        raise UniverseCompiler::Error, 'An entity cannot be null !' if entity.nil?
+        raise UniverseCompiler::Error, 'An entity must have a name !' unless entity.respond_to? :name
+        raise UniverseCompiler::Error, 'An entity must have a name !' if entity.name.nil? or entity.name.empty?
+        unless UniverseCompiler::Entity::TypeManagement.valid_for_type? entity
+          entity.extend UniverseCompiler::Entity::TypeManagement
+        end
+        raise UniverseCompiler::Error, "An entity named '#{entity.name}' already exists with the type '#{entity.type}' !" if by_uniq_key.keys.include? [entity.type, entity.name]
+        raise UniverseCompiler::Error, 'Invalid type specified' if entity.type.nil?
+        raise UniverseCompiler::Error, 'Type cannot contain spaces' if entity.type =~ /\s/
+        # Normally here the entity is valid
+        # We add it to the universe and index it
+        entities << entity
+        if entity.respond_to? :'universe='
+          entity.universe = self
+        end
+        index entity
+        entity
+      end
+
+      def <<(entity)
+        add entity
+        self
+      end
+
+      def delete(entity)
+        entities.delete entity
+        reindex_all entities
+      end
+
+      def clear
+        entities.clear
+        clear_indices
+      end
+
+      private
+
+      attr_reader :entities
+
+    end
+
+  end
+end

data/lib/universe_compiler/universe/index.rb

@@ -0,0 +1,40 @@
+module UniverseCompiler
+  module Universe
+
+    module Index
+
+      private
+
+      attr_reader :by_name, :by_type, :by_uniq_key
+
+      def setup_indices
+        @by_name = {}
+        @by_type = {}
+        @by_uniq_key = {}
+      end
+      alias_method :clear_indices, :setup_indices
+
+
+      def index(entity)
+        # Non unique indices
+        by_name[entity.name] ||= []
+        by_type[entity.type] ||= []
+        by_name[entity.name] << entity
+        by_type[entity.type] << entity
+        # Unique index
+        ref = entity.respond_to?(:to_composite_key) ? entity.to_composite_key : [entity.type, entity.name]
+        by_uniq_key[ref] = entity
+      end
+
+      def reindex_all(entities)
+        clear_indices
+        entities.each do |entity|
+          index entity
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/universe_compiler/universe/multiverse.rb

@@ -0,0 +1,44 @@
+module UniverseCompiler
+  module Universe
+
+    module Multiverse
+
+      DEFAULT_UNIVERSE_NAME = 'Unnamed Universe'.freeze
+
+      def universes
+        @universes ||= {}
+      end
+
+      def register(universe)
+        raise UniverseCompiler::Error, "Universe '#{universe.name}' already exists in this continuum !" if universes.keys.include? universe.name
+        universes[universe.name] = universe
+      end
+
+      def get_unique_name(seed = DEFAULT_UNIVERSE_NAME)
+        max_index = 1
+        universes.keys.each do |universe_name|
+          universe_name.match /^#{seed}(?:(?: - #)(?<index>\d+))?$/ do |md|
+            index = md['index'] || '1'
+            index = index.to_i
+            max_index = index > max_index ? index : max_index
+          end
+        end
+        if max_index == 1
+          seed
+        else
+          UniverseCompiler.logger.debug "Universe #{seed} reached its #{max_index} iteration."
+          format_name(seed, max_index)
+        end
+      end
+
+      private
+
+      def format_name(name, index)
+        '%s - #%d' % [name, index]
+      end
+
+    end
+
+  end
+end
+

data/lib/universe_compiler/universe/persistence.rb

@@ -0,0 +1,23 @@
+module UniverseCompiler
+  module Universe
+
+    module Persistence
+
+      include UniverseCompiler::Persistence::Management
+
+      def export(uri)
+        engine = persistence_engine.new self, uri
+        engine.export_universe
+      end
+
+      def import(uri, force: false, stop_on_error: true, &block)
+        engine = persistence_engine.new self, uri
+        clear if force
+        engine.import_universe recursive: true, stop_on_error: stop_on_error, &block
+        resolve_entities_reference
+      end
+
+    end
+
+  end
+end

data/lib/universe_compiler/universe/query.rb

@@ -0,0 +1,45 @@
+module UniverseCompiler
+  module Universe
+
+    module Query
+
+      def basic_criteria
+        self.private_methods.grep /^by_/
+      end
+
+      def get_entity(type, name)
+        res = get_entities criterion: :by_uniq_key, value: [type, name]
+        res.empty? ? nil : res.first
+      end
+
+      def get_entities(criterion: nil, value: nil, &filter_block)
+        res = if criterion.nil? then
+                entities.clone
+              else
+                raise "Invalid criterion '#{criterion}' !" unless basic_criteria.include? criterion
+                if value.nil?
+                  self.send(criterion).clone
+                else
+                  self.send(criterion).clone[value]
+                end
+              end
+        res = case res
+                when NilClass
+                  []
+                when Array
+                  res
+                else
+                  [res]
+              end
+        if block_given?
+          res.select! do |entity|
+            filter_block.call entity
+          end
+        end
+        res
+      end
+
+    end
+
+  end
+end