power_stencil 0.3.0

data/lib/power_stencil/engine/directory_processor.rb

@@ -0,0 +1,111 @@
+require 'fileutils'
+require 'erb'
+
+module PowerStencil
+  module Engine
+
+    module DirectoryProcessor
+
+      include PowerStencil::Utils::DirectoryProcessor
+
+      def render_source(source_dir, destination_dir, overwrite_files: false, main_entry_point: nil)
+        compiled_universe = root_universe.compile scenario: config[:scenario]
+        puts_and_logs 'Entities analysis completed.'
+
+        logger.info 'Generating target...'
+        setup_files_not_to_render source_dir
+        setup_files_not_to_rename source_dir
+        process_directory source: source_dir,
+                          destination: destination_dir,
+                          ignore_files_pattern: config[:ignore_filename_for_files_to_skip] do |src_file, dest_file|
+          dest_file = detemplatized_file_name(dest_file, main_entry_point) unless main_entry_point.nil?
+          if File.directory? src_file
+            check_or_build_target_directory dest_file
+            next
+          else
+            process_file src_file, dest_file,
+                         compiled_universe,
+                         overwrite_files: overwrite_files,
+                         main_entry_point: main_entry_point
+          end
+        end
+      ensure
+        @rendering_context = nil
+        @files_not_to_render = nil
+      end
+
+      private
+
+      def detemplatized_file_name(filename, replacement_text)
+        replacement_text = replacement_text.tr '- /', '___'
+        filename.gsub '{entity}', replacement_text
+      end
+
+      attr_reader :files_not_to_render, :files_not_to_rename
+
+      def setup_files_not_to_render(source_dir)
+        @files_not_to_render = DirGlobIgnore::IgnoreFileLists.new source_dir
+        files_not_to_render.ignore_file_name = config[:ignore_filename_for_files_to_copy]
+        files_not_to_render.load_ignore_files
+      end
+
+      def setup_files_not_to_rename(source_dir)
+        @files_not_to_rename = DirGlobIgnore::IgnoreFileLists.new source_dir
+        files_not_to_rename.ignore_file_name = config[:ignore_filename_for_files_to_rename]
+        files_not_to_rename.load_ignore_files
+      end
+
+      def process_file(src_file, dest_file, universe, overwrite_files: false, main_entry_point: nil)
+        unless files_not_to_rename.ignore_file? src_file
+          config[:file_renaming_patterns].each do |regexp_str, replacement|
+            regexp = Regexp.new regexp_str
+            next if (dest_file =~ regexp).nil?
+            dest_file = dest_file.gsub regexp, replacement
+            break
+          end
+        end
+        if File.exist? dest_file
+          unless overwrite_files
+            logger.info "Skipping file '#{dest_file}'..."
+            return
+          end
+        end
+        check_or_build_target_directory File.dirname dest_file
+        source_mode = File.stat(src_file).mode
+        File.open(dest_file, 'w') do |f|
+          if files_not_to_render.ignore_file? src_file
+            logger.debug "Copying file '#{src_file}' to '#{dest_file}' (ignored for substitutions)."
+            f.write File.read src_file
+          else
+            logger.debug "Rendering file '#{src_file}' to '#{dest_file}'."
+            f.write render_template(src_file, universe, main_entry_point: main_entry_point)
+          end
+        end
+        File.chmod source_mode, dest_file
+      end
+
+
+      def check_or_build_target_directory(dir)
+        FileUtils.mkpath dir
+      end
+
+      def render_template(source, universe, main_entry_point: nil)
+        config[:templating_engines_map].each do |engine_name, file_pattern|
+          unless (source =~ /#{file_pattern}/).nil?
+            templating_engine_method_name = "render_#{engine_name}_template".to_sym
+            unless private_methods.include? templating_engine_method_name
+              raise PowerStencil::Error, "File '#{source}' is supposed to be rendered using '#{engine_name}', but seems not to be supported !"
+            end
+            context = running_context universe, main_entry_point: main_entry_point
+            return send templating_engine_method_name, source, context
+          end
+        end
+        logger.warn "File '#{source}' was supposed to be processed but there is no template engine defined ! Applying simple copy."
+        File.read source
+      end
+
+
+    end
+
+  end
+end

data/lib/power_stencil/engine/entities_definitions.rb

@@ -0,0 +1,42 @@
+module PowerStencil
+  module Engine
+
+    module EntitiesDefinition
+
+      SYSTEM_ENTITY_DEFINITION_ENTRY_POINT = 'power_stencil/system_entity_definitions/all'.freeze
+
+      include PowerStencil::Utils::SecureRequire
+
+      def require_definition_files(files_or_dirs)
+        required_files = []
+        files_or_dirs.each do |file_or_dir|
+          if File.directory? file_or_dir and File.readable? file_or_dir
+            Dir.entries(file_or_dir).grep(/\.rb$/).each do |file|
+              required_files << File.join(file_or_dir, file)
+            end
+            next
+          end
+          if File.file? file_or_dir and File.readable? file_or_dir
+            required_files << file_or_dir
+            next
+          end
+          # This is a ruby library or there is something wrong
+          securely_require file_or_dir
+          # unless securely_require file_or_dir
+          #   logger.warn "While trying to load definition files, found that '#{file_or_dir}' has a problem. Ignored..."
+          # end
+        end
+        required_files.sort!.each {|file| securely_require file, fail_on_error: true}
+        required_files
+      end
+
+      private
+
+      def load_system_entities_definition
+        require_definition_files [SYSTEM_ENTITY_DEFINITION_ENTRY_POINT]
+      end
+
+    end
+
+  end
+end

data/lib/power_stencil/engine/entities_handling.rb

@@ -0,0 +1,76 @@
+module PowerStencil
+  module Engine
+
+    module EntitiesHandling
+
+      include Climatic::Utils::Input
+
+      def self.all_types
+        entities_base_type = UniverseCompiler::Entity::Base
+
+        klasses = ObjectSpace.each_object(Class).select do |klass|
+          klass < entities_base_type and not klass.singleton_class?
+        end
+        types = klasses.map &:entity_type
+
+        types.zip(klasses).to_h.reject do |t, k|
+          t.to_s.include? '/'
+        end
+      end
+
+      def available_entities_hash(force_rescan: false)
+        if force_rescan
+          available_entity_types force_rescan: true
+        end
+        @available_entities_hash
+      end
+
+      def available_entity_types(force_rescan: false)
+        if force_rescan
+          @available_entities_hash = PowerStencil::Engine::EntitiesHandling.all_types
+        else
+          @available_entities_hash ||= PowerStencil::Engine::EntitiesHandling.all_types
+        end
+        @available_entities_hash.keys
+      end
+
+      def entity(type, name, universe)
+        universe.get_entity type, name
+      end
+
+      def entities(universe, criterion: nil, value: nil, &filter_block)
+        universe.get_entities criterion: criterion, value: value, &filter_block
+      end
+
+      def delete_entity(work_universe, type, name, delete_files: false)
+        entity_to_delete = work_universe.get_entity type, name
+        get_user_confirmation prompt: "Are you sure you want delete '#{[type, name].join '/'}' ?" do
+          entity_to_delete.delete force_files_deletion: delete_files
+          entity_to_delete.universe = nil
+          entity_to_delete
+        end
+      end
+
+      def new_entity(work_universe, type, fields: {}, user: false)
+        logger.debug "Trying to create a new entity in '#{work_universe.name}'"
+        unless available_entity_types.include? type.to_sym
+          raise PowerStencil::Error, "Unknown entity type: '#{type}'"
+        end
+        fields[:name] = fields[:name].to_s
+        res = @available_entities_hash[type.to_sym].new fields: fields, universe: work_universe
+        logger.debug "Created new '#{type}': \n#{fields.to_yaml}"
+        work_universe.add res
+        if work_universe == PowerStencil.project.engine.root_universe
+          res.source_uri = user ? PowerStencil.project.user_entity_path(res) : PowerStencil.project.project_entity_path(res)
+        else
+          PowerStencil.logger.warn "Creating entity, but you won't be able to save it in compiled mode !"
+        end
+        res
+      end
+
+
+
+    end
+
+  end
+end

data/lib/power_stencil/engine/entity_engine.rb

@@ -0,0 +1,20 @@
+require 'power_stencil/engine/project_engine'
+
+module PowerStencil
+  module Engine
+
+    class EntityEngine < PowerStencil::Engine::Base
+
+      UNIVERSE_BASENAME = 'Entities directory creation'.freeze
+
+      def initialize(universe = UniverseCompiler::Universe::Base.new(unique_name))
+        super
+        load_system_entities
+      end
+
+
+    end
+
+
+  end
+end

data/lib/power_stencil/engine/init_engine.rb

@@ -0,0 +1,18 @@
+require 'power_stencil/engine/base'
+
+module PowerStencil
+  module Engine
+
+    class InitEngine < PowerStencil::Engine::Base
+
+      def initialize
+        super
+        root_universe.name = 'Project initialization universe'
+        load_system_entities_definition
+        load_system_entities
+      end
+
+    end
+
+  end
+end

data/lib/power_stencil/engine/project_engine.rb

@@ -0,0 +1,75 @@
+require 'power_stencil/engine/base'
+require 'power_stencil/engine/entities_handling'
+require 'power_stencil/engine/build_handling'
+
+module PowerStencil
+  module Engine
+
+    class ProjectEngine < PowerStencil::Engine::Base
+
+      include PowerStencil::Engine::EntitiesHandling
+      include PowerStencil::Engine::BuildHandling
+
+      attr_reader :project
+
+      def initialize(project)
+        super()
+        @project = project
+        load_system_entities_definition
+        load_plugins_entities_definition
+        load_project_entities_definition
+        load_entities
+      end
+
+      protected
+
+      def load_project_entities_definition
+        dir = project.project_entity_definitions_path
+        if Dir.exist? dir and File.readable? dir
+          logger.info 'Loading project specific entity definitions.'
+          $LOAD_PATH << dir
+          require_definition_files [dir]
+        end
+      end
+
+      def load_plugins_entities_definition
+        project.plugins.each do |plugin_name, plugin|
+          if plugin.capabilities[:entity_definitions]
+            logger.info "Loading entity definitions for plugin '#{plugin_name}'."
+            plugin.plugin_module.send PowerStencil::Plugins::Require::SETUP_ENTITY_DEFINITIONS_CALLBACK
+          end
+        end
+      end
+
+      def load_entities
+        root_universe.clear
+        load_system_entities
+        load_project_entities
+        load_user_entities
+      end
+
+      private
+
+      def load_project_entities
+        logger.debug 'Loading project entities - NOT IMPLEMENTED'
+        root_universe.import project.project_entities_path, stop_on_error: false do |new_entity|
+          process_entity new_entity
+        end
+      end
+
+      def load_user_entities
+        logger.debug 'Loading user entities - NOT IMPLEMENTED'
+        root_universe.import project.user_entities_path, stop_on_error: false do |new_entity|
+          process_entity new_entity
+        end
+      end
+
+      def process_entity(entity)
+        logger.debug "New entity: '#{entity.name}' (#{entity.type})"
+      end
+
+
+    end
+
+  end
+end

data/lib/power_stencil/engine/renderers/erb.rb

@@ -0,0 +1,21 @@
+module PowerStencil
+  module Engine
+    module Renderers
+
+      module Erb
+
+        private
+
+        def render_erb_template(source, context)
+          logger.debug "Using ERB to render file '#{source}'"
+          ERB.new(File.read(source), nil, '-').result(context)
+        rescue => e
+          logger.debug PowerStencil::Error.report_error(e)
+          raise PowerStencil::Error, "Error rendering '#{source}': '#{e.message}'"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/power_stencil/error.rb

@@ -0,0 +1,20 @@
+module PowerStencil
+  class Error < StandardError
+
+    DEFAULT_EXIT_CODE = 127
+
+    def exit_code=(val)
+      raise PowerStencil::Error, 'Invalid exit code !' unless val.is_a? Fixnum
+      @exit_code = val
+    end
+
+    def exit_code
+      @exit_code ||= DEFAULT_EXIT_CODE
+    end
+
+    def self.report_error(e)
+      "#{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+    end
+
+  end
+end

data/lib/power_stencil/initializer.rb

@@ -0,0 +1,87 @@
+require 'yaml'
+
+module PowerStencil
+
+  module Initializer
+
+    BASE_COMMANDS_DEFINITION_FILE = 'base_commands_definition.yml'.freeze
+
+    include Climatic::Proxy
+
+    def bootstrap(cmd_line_args = ARGV.dup)
+      setup_climatic cmd_line_args
+      logger.debug 'Starting PowerStencil initialization...'
+      setup_system_processors
+      setup_universe_compiler_logger
+      # @project = try_to_load_project fail_on_error: false
+      begin
+        project.setup_templates_for_entities # unless project.nil?
+      rescue => e
+        logger.debug PowerStencil::Error.report_error e
+      end
+      logger.debug 'PowerStencil initialization complete'
+    end
+
+    def project
+      @project ||= try_to_load_project
+    end
+
+    private
+
+    include PowerStencil::Utils::FileHelper
+
+    def try_to_load_project(fail_on_error: true)
+      PowerStencil::Project::Base.instantiate_from_config config
+
+    end
+
+    def setup_system_processors
+      logger.debug 'Registering system processors'
+      {
+          '' => PowerStencil::CommandProcessors::Root,
+          init: PowerStencil::CommandProcessors::Init,
+          info: PowerStencil::CommandProcessors::Info,
+          get: PowerStencil::CommandProcessors::Get,
+          check: PowerStencil::CommandProcessors::Check,
+          create: PowerStencil::CommandProcessors::Create,
+          edit: PowerStencil::CommandProcessors::Edit,
+          delete: PowerStencil::CommandProcessors::Delete,
+          shell: PowerStencil::CommandProcessors::Shell,
+          :'new-plugin' => PowerStencil::CommandProcessors::NewPlugin,
+          build: PowerStencil::CommandProcessors::Build
+      }.each do |command_name, processor|
+        command_line_manager.register_processor command_line_manager.command_by_alias(command_name),
+                                                processor.new
+      end
+    end
+
+    def setup_climatic(cmd_line_args)
+      mngr = Climatic::ConfigLayers::CommandLineLayer.build_command_line_manager base_commands_definition_file
+      Climatic.bootstrap cmd_line_args: cmd_line_args, command_manager: mngr
+      begin
+        # Fix command line layer priority to allow a bigger number of plugins
+        config.command_line_layer.priority = 999
+        config.command_line_layer.reload
+        config.include_gem_layer_for :power_stencil
+      rescue Slop::UnknownOption => e
+        # Forget those errors. Will be caught later.
+      end
+
+    end
+
+    def setup_universe_compiler_logger
+      UniverseCompiler.logger = Climatic.logger
+    end
+
+    def base_commands_definition_file
+      File.join gempath, 'etc', BASE_COMMANDS_DEFINITION_FILE
+    end
+
+    def gempath
+      Climatic::ConfigLayers::ExecutableGemLayer.executable_gem_config_root
+    end
+
+
+  end
+
+end