rdm 0.2.0 → 0.3.0

data/lib/rdm/git/diff_command.rb

@@ -0,0 +1,13 @@
+require 'open3'
+
+class Rdm::Git::DiffCommand
+  class << self
+    def get_only_diff_filenames(revision:, path:)
+      command = `cd #{path} && git diff --name-only #{revision}`
+
+      raise Rdm::Errors::GitCommandError, command unless $?.success?
+    
+      command.split("\n")
+    end
+  end
+end

data/lib/rdm/git/diff_manager.rb

@@ -0,0 +1,30 @@
+require 'fileutils'
+
+module Rdm
+  module Git
+    class DiffManager
+      GIT_ERROR_MESSAGE = "fatal: Not a git repository (or any of the parent directories): .git"
+      DEFAULT_REVISION  = 'HEAD'
+
+      class << self
+        def run(path:, revision: nil)
+          abs_path = Rdm::Git::RepositoryLocator.locate(path)
+
+          check_repository_initialized!(abs_path)
+
+          return Rdm::Git::DiffCommand
+            .get_only_diff_filenames(revision: revision, path: path)
+            .map { |filename| File.expand_path(File.join(abs_path, filename)) }
+        end
+
+        private
+
+          def check_repository_initialized!(folder)
+            unless %x( cd #{folder} && git status 2>&1 >/dev/null ).empty?
+              raise Rdm::Errors::GitRepositoryNotInitialized 
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rdm/git/repository_locator.rb

@@ -0,0 +1,23 @@
+class Rdm::Git::RepositoryLocator
+  GIT_FOLDER = '.git'
+
+  class << self 
+    def locate(path)
+      raise Rdm::Errors::GitRepositoryNotInitialized, path if root_reached?(path)
+      
+      return path if git_present?(path)
+      
+      locate(File.dirname(path))
+    end
+
+    def root_reached?(path)
+      File.expand_path(path) == '/'
+    end
+
+    def git_present?(path)
+      expected_source_file = File.join(path, GIT_FOLDER)
+      
+      File.exist?(expected_source_file)
+    end
+  end
+end

data/lib/rdm/handlers/dependencies_handler.rb

@@ -0,0 +1,110 @@
+module Rdm
+  module Handlers
+    class DependenciesHandler
+      ALREADY_MENTIONED_DEPS = '...'
+      
+      class << self
+        def show_names(package_name:, project_path:)
+          new(package_name, project_path).show_names
+        end
+
+        def show_packages(package_name:, project_path:)
+          new(package_name, project_path).show_packages
+        end
+        
+        def draw(package_name:, project_path:)
+          new(package_name, project_path).draw
+        end
+      end
+      
+      def initialize(package_name, project_path)
+        @package_name = package_name
+        @project_path = project_path
+      end
+
+      def show_names
+        if @package_name.nil? || @package_name.empty?
+          raise Rdm::Errors::InvalidParams, "Package name should be specified" 
+        end
+        
+        if @project_path.nil? || @project_path.empty?
+          raise Rdm::Errors::InvalidParams, "Project directory should be specified" 
+        end
+        
+        recursive_find_dependencies([@package_name])
+      end
+
+      def show_packages
+        names = show_names
+
+        source.packages.values.select do |p| 
+          names.include?(p.name)
+        end
+      end
+
+      def draw(pkg_name = @package_name, uniq_packages = [], self_predicate = '', child_predicate = '')
+        raise Rdm::Errors::InvalidParams, "Type package name, ex: rdm gen.deps repository" if pkg_name.to_s.empty?
+        raise Rdm::Errors::PackageHasNoDependencies, @package_name if source.packages[@package_name].local_dependencies.empty?
+
+        node = [format(pkg_name, self_predicate)]
+        
+        return node if pkg_name == ALREADY_MENTIONED_DEPS
+
+        local_dependencies = source.packages[pkg_name].local_dependencies.dup
+
+        if uniq_packages.include?(pkg_name)
+          local_dependencies = local_dependencies.count == 0 ? [] : [ALREADY_MENTIONED_DEPS]
+        else
+          uniq_packages.push(pkg_name)
+        end
+
+        local_dependencies.count.times do
+          dependency = local_dependencies.pop
+
+          if local_dependencies.empty?
+            tmp_self_predicate = child_predicate + '2'
+            tmp_child_predicate = child_predicate + '0'
+          else
+            tmp_self_predicate = child_predicate + '1'
+            tmp_child_predicate = child_predicate + '3'
+          end
+          
+          node.push(*draw(dependency, uniq_packages, tmp_self_predicate, tmp_child_predicate))
+        end
+
+        node
+      end
+
+      private
+
+      def source
+        @source ||= Rdm::SourceParser.read_and_init_source(Rdm::SourceLocator.locate(@project_path))
+      end
+
+      def format(pkg_name, predicate)
+        predicate
+          .concat(pkg_name)
+          .gsub(/0/, '    ')
+          .gsub(/1/, '├── ')
+          .gsub(/2/, '└── ')
+          .gsub(/3/, '|   ')
+      end
+
+      def recursive_find_dependencies(package_names)
+        all_packages = source.packages.values
+
+        deps_package_names = all_packages
+          .select {|pkg| package_names.include?(pkg.name)}
+          .map(&:local_dependencies)
+          .flatten
+          .uniq
+
+        extended_package_names = deps_package_names | package_names
+        
+        return package_names if package_names == extended_package_names
+        
+        recursive_find_dependencies(extended_package_names)
+      end
+    end
+  end
+end

data/lib/rdm/handlers/diff_package_handler.rb

@@ -0,0 +1,48 @@
+module Rdm
+  module Handlers
+    class DiffPackageHandler
+      class << self
+        def handle(path:, revision: 'HEAD')
+          return Rdm::Handlers::DiffPackageHandler.new(path: path, revision: revision).handle
+        end
+      end
+
+      attr_reader :path, :revision, :all_packages
+      def initialize(path:, revision:)
+        @path     = path
+        @revision = revision
+
+        source_path   = Rdm::SourceLocator.locate(path)
+        @all_packages = Rdm::SourceParser.read_and_init_source(source_path).packages.values
+      end
+
+      def handle
+        @revision = 'HEAD' if @revision.nil? || @revision.empty?
+
+        modified_packages = Rdm::Git::DiffManager
+          .run(path: path, revision: revision)
+          .map { |file| Rdm::Packages::Locator.locate(file) rescue nil }
+          .map { |path_to_package| Rdm::PackageParser.parse_file(path_to_package).name rescue nil }
+          .reject(&:blank?)
+          .uniq
+        
+        return get_dependencies(modified_packages) || []
+      end
+
+      private
+        def get_dependencies(base_packages)
+          base_packages.sort!
+
+          new_packages = all_packages
+            .select {|p| (p.local_dependencies & base_packages).any?}
+            .map(&:name)
+          
+          extended_dependencies = (base_packages | new_packages).sort
+          
+          return extended_dependencies if extended_dependencies == base_packages
+
+          get_dependencies(extended_dependencies) || []
+        end
+    end
+  end
+end

data/lib/rdm/handlers/template_handler.rb

@@ -0,0 +1,118 @@
+require 'pathname'
+require 'fileutils'
+
+module Rdm
+  module Handlers
+    class TemplateHandler
+      class << self
+        def generate(template_name:, local_path:, current_path:, locals: {}, 
+                     ignore_source_file: false, stdout: STDOUT, stdin: STDIN)
+
+          Rdm::Handlers::TemplateHandler.new(
+            template_name:      template_name.to_s, 
+            local_path:         local_path, 
+            current_path:       current_path, 
+            ignore_source_file: ignore_source_file,
+            locals:             locals,
+            stdout:             stdout,
+            stdin:              stdin
+          ).generate
+        end
+      end
+
+      def initialize(template_name:, local_path:, current_path:,  
+                     locals:, ignore_source_file:, stdout:, stdin:)
+
+        @template_name      = template_name
+        @local_path         = local_path
+        @current_path       = current_path
+        @ignore_source_file = ignore_source_file
+        @missing_variables  = []
+        @stdout             = stdout
+        @stdin              = stdin
+        
+        @locals            = default_locals.merge(locals)
+      end
+
+      def generate
+        project_path      = @ignore_source_file ? @current_path : File.dirname(Rdm::SourceLocator.locate(@current_path))
+        template_detector = Rdm::Templates::TemplateDetector.new(project_path)
+
+        @template_directory    = template_detector.detect_template_folder(@template_name)
+        @destination_directory = File.join(project_path, @local_path)
+
+        template_files_list = Dir[ 
+          File.join(@template_directory, '**', '.?*'), 
+          File.join(@template_directory, '**', '*') 
+        ]
+        .select { |p| File.file?(p) }
+        .reject { |p| File.basename(p) == '.DS_Store' }
+
+        template_dir_list   = Dir[ File.join(@template_directory, '**', '*') ].select { |p| File.directory? p }
+
+        template_files_list.each do |file|
+          missings = Rdm::Templates::TemplateRenderer.get_undefined_variables(get_destination_path(file), @locals)
+          
+          if File.extname(file) != '.erb'
+            missings.push(
+              *Rdm::Templates::TemplateRenderer.get_undefined_variables(File.read(file), @locals)
+            ) 
+          end
+          
+          @missing_variables.push(*missings)
+        end
+
+        template_dir_list.each do |dir|
+          @missing_variables.push(
+            *Rdm::Templates::TemplateRenderer.get_undefined_variables(get_destination_path(dir), @locals)
+          )
+        end
+
+        @missing_variables.uniq!
+        if @missing_variables.any?
+          @stdout.puts "Undefined variables were found:"
+          @missing_variables.size.times {|t| @stdout.puts "  #{t+1}. #{@missing_variables[t]}"}
+
+          @missing_variables.each do |var|
+            @stdout.print "Type value for '#{var}': "
+            @locals[var] = @stdin.gets.chomp
+          end
+        end
+
+        template_dir_list.each do |dir|
+          rendered_abs_path = Rdm::Templates::TemplateRenderer.handle(get_destination_path(dir), @locals)
+          FileUtils.mkdir_p rendered_abs_path
+        end
+
+        template_files_list.map do |file|
+          rendered_abs_path = Rdm::Templates::TemplateRenderer.handle(get_destination_path(file), @locals)
+          raise Rdm::Errors::TemplateFileExists.new(rendered_abs_path) if File.exists?(rendered_abs_path)
+
+          rendered_file_content = File.extname(file) == '.erb' ?
+            File.read(file) :
+            Rdm::Templates::TemplateRenderer.handle(File.read(file), @locals)
+            
+          FileUtils.mkdir_p(File.dirname(rendered_abs_path))
+          File.open(rendered_abs_path, 'w') { |f| f.write rendered_file_content }
+
+          Pathname.new(rendered_abs_path).relative_path_from Pathname.new(project_path)
+        end
+      end
+
+      private
+
+      def get_destination_path(file)
+        return nil unless defined? @template_directory && defined? @destination_directory
+
+        template_rel_path = Pathname.new(file).relative_path_from Pathname.new(@template_directory)
+        File.join(@destination_directory, template_rel_path)
+      end   
+
+      def default_locals
+        {
+          package_subdir_name: Rdm.settings.send(:package_subdir_name)
+        }
+      end
+    end
+  end
+end

data/lib/rdm/helpers/path_helper.rb

@@ -0,0 +1,15 @@
+module Rdm
+  module Helpers
+    module PathHelper
+      def package_path(package_name, current_file: nil)
+        current_file ||= caller[0].split(':').first
+
+        source = Rdm::SourceParser.read_and_init_source(Rdm::SourceLocator.locate(current_file))
+
+        raise Rdm::Errors::PackageDoesNotExist unless source.packages.keys.include?(package_name.to_s)
+
+        return source.packages.fetch(package_name.to_s).path
+      end
+    end
+  end
+end

data/lib/rdm/package.rb

@@ -69,6 +69,12 @@ class Rdm::Package
     exec_metadata :version, value
   end
 
+  def ==(other_package)
+    return false if other_package.class != self.class
+
+    other_package.name == name
+  end
+
   private
 
   def current_group

data/lib/rdm/package_importer.rb

@@ -69,7 +69,7 @@ class Rdm::PackageImporter
     package.config_dependencies(group).each do |dependency|
       import_config(dependency, source: source)
     end
-
+    
     # only after importing dependencies - require package itself
     begin
       require package_name

data/lib/rdm/packages/compiler_service.rb

@@ -0,0 +1,78 @@
+require 'fileutils'
+
+module Rdm
+  module Packages
+    class CompilerService
+      class << self
+        def compile(compile_path:, project_path:, package_name:)
+          Rdm::Packages::CompilerService.new(
+            compile_path: compile_path,
+            project_path: project_path,
+            package_name: package_name
+          ).compile
+        end
+      end
+
+      def initialize(compile_path:, project_path:, package_name:)
+        @compile_path = compile_path
+        @project_path = project_path
+        @package_name = package_name
+      end
+
+      def compile
+        render_helper_path = "#{@project_path}/.rdm/helpers/render_helper.rb"
+        require_relative render_helper_path if File.exist?(render_helper_path)
+
+        FileUtils.rm_rf(@compile_path) if Dir.exists?(@compile_path)
+        FileUtils.mkdir_p(@compile_path)
+
+        dependent_packages = Rdm::Handlers::DependenciesHandler.show_packages(
+          package_name: @package_name, 
+          project_path: @project_path
+        )
+
+        dependent_packages.each do |pkg|
+          rel_path = Pathname.new(pkg.path).relative_path_from(Pathname.new(@project_path))
+          new_path = File.dirname(File.join(@compile_path, rel_path))
+          
+          FileUtils.mkdir_p(new_path)
+          FileUtils.cp_r(pkg.path, new_path)
+        end
+
+        
+        source_rdm_path = File.join(@project_path, Rdm::SOURCE_FILENAME)
+        dest_rdm_path   = File.join(@compile_path, Rdm::SOURCE_FILENAME)
+        package_definition_regex = /package\s+['"]([\w\/]+)['"]/i
+
+        File.open(dest_rdm_path, "w") do |out_file|
+          File.foreach(source_rdm_path) do |line|
+            package_line = package_definition_regex.match(line)
+            if package_line.nil?
+              out_file.puts line
+            else
+              dependent_package_definition = dependent_packages.detect do |pkg|
+                package_line[1] == Pathname.new(pkg.path).relative_path_from(Pathname.new(@project_path)).to_s
+              end
+
+              out_file.puts line if dependent_package_definition.present?
+            end
+          end
+        end
+
+        FileUtils.cp_r(File.join(@project_path, 'configs'), File.join(@compile_path, 'configs'))
+
+        Rdm.settings.compile_ignore_files.each do |file|
+          Dir["#{@compile_path}/**/#{file}"].each do |file_to_remove|
+            FileUtils.rm_rf(file_to_remove)
+          end
+        end
+
+        Rdm.settings.compile_add_files.each do |file|
+          FileUtils.cp(File.join(@project_path, file), File.join(@compile_path, file))
+        end
+
+        return dependent_packages.map(&:name)
+      end
+    end
+  end
+end