rdm 0.2.0 → 0.3.0

data/lib/rdm/cli/dependencies_controller.rb

@@ -0,0 +1,30 @@
+module Rdm
+  module CLI
+    class DependenciesController
+      class << self
+        def run(package_name:, project_path:, stdout: nil)
+          new(package_name, project_path, stdout).run
+        end
+      end
+
+      def initialize(package_name, project_path, stdout)
+        @package_name = package_name
+        @project_path = project_path
+        @stdout = stdout || $stdout
+      end
+
+      def run
+        @stdout.puts Rdm::Handlers::DependenciesHandler.draw(
+          package_name: @package_name,
+          project_path: @project_path
+        )
+      rescue Rdm::Errors::InvalidParams => e
+        @stdout.puts e.message
+      rescue Rdm::Errors::SourceFileDoesNotExist => e
+        @stdout.puts e.message
+      rescue Rdm::Errors::PackageHasNoDependencies => e
+        @stdout.puts "Package `#{e.message}` has no dependencies"
+      end
+    end
+  end
+end

data/lib/rdm/cli/diff_package.rb

@@ -0,0 +1,21 @@
+class Rdm::CLI::DiffPackage
+  class << self
+    def run(opts = {})
+      Rdm::CLI::DiffPackage.new(opts).run
+    end
+  end
+
+  attr_reader :path, :revision
+  def initialize(path:, revision:)
+    @path      = path
+    @revision = revision
+  end
+
+  def run
+    puts Rdm::Handlers::DiffPackageHandler.handle(path: path, revision: revision)
+  rescue Rdm::Errors::GitRepositoryNotInitialized
+    puts "Git repository is not initialized. Use `git init .`"
+  rescue Rdm::Errors::GitCommandError => e
+    puts e.message
+  end
+end

data/lib/rdm/cli/gen_package.rb

@@ -2,46 +2,38 @@ module Rdm
   module CLI
     class GenPackage
       class << self
-        def run(opts = {})
-          Rdm::CLI::GenPackage.new(opts).run
+        def run(package_name:, current_path:, local_path:, locals: {}, stdout: $stdout)
+          Rdm::CLI::GenPackage.new(package_name, current_path, local_path, locals, stdout).run
         end
       end
 
-      attr_accessor :package_name, :current_dir,  :package_relative_path, :skip_tests
-      def initialize(package_name:, current_dir:, path:, skip_tests:)
-        @current_dir           = current_dir
-        @package_name          = package_name
-        @package_relative_path = path
-        @skip_tests            = skip_tests
+      def initialize(package_name, current_path, local_path, locals, stdout)
+        @current_path = current_path
+        @local_path   = local_path
+        @package_name = package_name
+        @locals       = locals
+        @stdout       = stdout
       end
 
       def run
-        check_preconditions!
-        begin
-          generate
-        rescue Errno::ENOENT => e
-          puts "Error occurred. Possible reasons:\n #{Rdm::SOURCE_FILENAME} not found. Please run on directory containing #{Rdm::SOURCE_FILENAME} \n#{e.inspect}"
-        rescue Rdm::Errors::PackageExists
-          puts 'Error. Package already exist. Package was not generated'
-        rescue Rdm::Errors::PackageDirExists
-          puts "Error. Directory #{package_relative_path} exists. Package was not generated"
-        end
-      end
-
-      def generate
-        Rdm::Gen::Package.generate(
-          current_dir: current_dir,
-          package_name: package_name,
-          package_relative_path: package_relative_path,
-          skip_tests: skip_tests
+        generated_files_list = Rdm::Gen::Package.generate(
+          current_path: @current_path,
+          local_path:   @local_path,
+          package_name: @package_name,
+          locals:       @locals
         )
-      end
-
-      def check_preconditions!
-        return unless package_name.empty?
 
-        puts 'Package name was not specified!'
-        exit 1
+        generated_files_list.each { |file| @stdout.puts "Generated: #{file}" }
+      rescue Errno::ENOENT => e
+        @stdout.puts "Error occurred. Possible reasons:\n #{Rdm::SOURCE_FILENAME} not found. Please run on directory containing #{Rdm::SOURCE_FILENAME} \n#{e.inspect}"
+      rescue Rdm::Errors::PackageExists
+        @stdout.puts 'Error. Package already exist. Package was not generated'
+      rescue Rdm::Errors::PackageNameNotSpecified
+        @stdout.puts "Package name was not specified!"
+      rescue Rdm::Errors::SourceFileDoesNotExist => e
+        @stdout.puts "Rdm.packages was not found. Run 'rdm init' to create it"
+      rescue Rdm::Errors::PackageDirExists => e
+        @stdout.puts "Error. Directory #{e.message} exists. Package was not generated"
       end
     end
   end

data/lib/rdm/cli/init.rb

@@ -2,41 +2,34 @@ module Rdm
   module CLI
     class Init
       class << self
-        def run(opts = {})
-          Rdm::CLI::Init.new(opts).run
+        def run(current_path:, test:, console:, stdout: $stdout)
+          Rdm::CLI::Init.new(current_path, test, console, stdout).run
         end
       end
 
-      attr_accessor :current_dir, :test, :console
-      def initialize(current_dir:, test:, console:)
-        @current_dir = current_dir
-        @test        = test
-        @console     = console
+      def initialize(current_path, test, console, stdout)
+        @current_path = current_path
+        @test         = test
+        @console      = console
+        @stdout       = stdout
       end
 
       def run
-        check_preconditions!
-        begin
-          generate
-        rescue Errno::ENOENT => e
-          puts "Error occurred. Possible reasons:\n #{current_dir} not found. Please run on empty directory \n#{e.inspect}"
-        rescue Rdm::Errors::ProjectAlreadyInitialized
-          puts 'Error. Project was already initialized.'
-        end
-      end
-
-      def generate
-        Rdm::Gen::Init.generate(
-          current_dir: current_dir,
-          test:        test,
-          console:     console
+        generated_files_list = Rdm::Gen::Init.generate(
+          current_path: @current_path,
+          test:         @test,
+          console:      @console
         )
-      end
 
-      def check_preconditions!
-        return unless current_dir.empty?
-        puts 'Current directory was not specified!'
-        exit 1
+        generated_files_list.each { |file| @stdout.puts "Generated: #{file}" }
+      rescue Errno::ENOENT => e
+        @stdout.puts "Error occurred. Possible reasons:\n #{@current_path} not found. Please run on empty directory \n#{e.inspect}"
+      rescue Rdm::Errors::ProjectAlreadyInitialized
+        @stdout.puts 'Error. Project was already initialized'
+      rescue Rdm::Errors::InvalidParams => e
+        @stdout.puts e.message
+      rescue Rdm::Errors::InvalidProjectDir => e
+        @stdout.puts "#{e.message} doesn't exist. Initialize new rdm project with existing directory"
       end
     end
   end

data/lib/rdm/cli/template_generator.rb

@@ -0,0 +1,38 @@
+module Rdm
+  module CLI
+    class TemplateGenerator
+      class << self
+        def run(template_name:, current_path:, local_path:, locals:)
+          TemplateGenerator.new(
+            template_name: template_name,
+            current_path:  current_path,
+            local_path:    local_path,
+            locals:        locals
+          ).run
+        end
+      end
+
+      def initialize(template_name:, current_path:, local_path:, locals:)
+        @template_name = template_name
+        @current_path  = current_path
+        @local_path    = local_path
+        @locals        = locals
+      end
+
+      def run
+        Rdm::Handlers::TemplateHandler.generate(
+          template_name: @template_name,
+          current_path:  @current_path,
+          local_path:    @local_path,
+          locals:        @locals
+        )
+      rescue Rdm::Errors::TemplateDoesNotExist
+        puts "Template '#{@template_name}' does not exist. Create new at #{File.join(@current_path, '.rdm/templates/', @template_name)} folder"
+      rescue Rdm::Errors::SourceFileDoesNotExist => e
+        puts e.message
+      rescue Rdm::Errors::TemplateFileExists => e
+        puts "File #{e.message} already exists. Try to user another variable name"
+      end
+    end
+  end
+end

data/lib/rdm/errors.rb

@@ -9,6 +9,43 @@ module Rdm
     end
 
     class SourceFileDoesNotExist < StandardError
+      attr_reader :message
+      def initialize(message = nil)
+        @message = message || "Rdm.packages was not found. Run 'rdm init' to create it"
+      end
+    end
+    
+    class GitRepositoryNotInitialized < StandardError
+    end
+
+    class PackageFileDoesNotFound < StandardError
+    end
+
+    class GitCommandError < StandardError
+    end
+
+    class PackageDoesNotExist < StandardError
+    end
+
+    class TemplateVariableNotDefined < StandardError
+    end
+
+    class TemplateDoesNotExist < StandardError
+    end
+
+    class TemplateFileExists < StandardError
+    end
+
+    class PackageNameNotSpecified < StandardError
+    end
+
+    class InvalidParams < StandardError
+    end
+
+    class InvalidProjectDir < StandardError
+    end
+
+    class PackageHasNoDependencies < StandardError
     end
   end
 end

data/lib/rdm/gen/init.rb

@@ -1,68 +1,53 @@
 require 'fileutils'
 require 'pathname'
-require 'active_support/inflector'
 
 module Rdm
   module Gen
     class Init
+      TEMPLATE_NAME        = 'init'
+      INIT_PATH            = './'
+      LOCAL_TEMPLATES_PATH = '.rdm/templates'
+
       class << self
-        def generate(current_dir:, test: 'rspec', console: 'irb')
-          Rdm::Gen::Init.new(current_dir: current_dir, test: test, console: console).generate
+        def generate(current_path:, test: 'rspec', console: 'irb')
+          Rdm::Gen::Init.new(current_path, test, console).generate
         end
       end
 
-      include Rdm::Gen::Concerns::TemplateHandling
-
-      attr_accessor :current_dir, :test, :console
-      def initialize(current_dir:, test:, console:)
-        @current_dir = File.expand_path(current_dir)
-        @test        = test
-        @console     = console
+      def initialize(current_path, test, console)
+        @current_path      = current_path
+        @test              = test
+        @console           = console
+        @template_detector = Rdm::Templates::TemplateDetector.new(current_path)
       end
 
       def generate
-        check_preconditions!
-
-        Dir.chdir(current_dir) do
-          ensure_file(['.gitignore'])
-          ensure_file(
-            ['Rdm.packages'],
-            template_content('Rdm.packages.erb')
-          )
-
-          ensure_file(
-            ['Gemfile'],
-            template_content('Gemfile.erb')
-          )
-
-          ensure_file(
-            ['Readme.md'],
-            template_content('Readme.md.erb')
-          )
-          move_templates
+        if @current_path.nil? || @current_path.empty?
+          raise Rdm::Errors::InvalidParams, "Error. Project folder not specified. Type path to rdm project, ex: 'rdm init .'" 
         end
-      end
+        raise Rdm::Errors::InvalidProjectDir, @current_path unless Dir.exist?(@current_path)
 
-      def check_preconditions!
-        if File.exist?(File.join(current_dir, Rdm::SOURCE_FILENAME))
-          raise Rdm::Errors::ProjectAlreadyInitialized, "#{current_dir} has already #{Rdm::SOURCE_FILENAME}"
+        if File.exist?(File.join(@current_path, Rdm::SOURCE_FILENAME))
+          raise Rdm::Errors::ProjectAlreadyInitialized, "#{@current_path} has already #{Rdm::SOURCE_FILENAME}"
         end
-      end
 
-      def move_templates
-        Dir.chdir(templates_path) do
-          copy_template('tests/run')
-        end
+        FileUtils.mkdir_p(local_templates_path)
+        FileUtils.cp_r(
+          @template_detector.detect_template_folder('package'),
+          local_templates_path
+        )
+        Rdm::Handlers::TemplateHandler.generate(
+          template_name:      TEMPLATE_NAME,
+          current_path:       @current_path,
+          local_path:         INIT_PATH,
+          ignore_source_file: true
+        )
       end
 
       private
 
-      def templates_path
-        Pathname.new(File.join(File.dirname(__FILE__), '..', 'templates/init'))
-      end
-
-      def target_path
-        current_dir
+      def local_templates_path
+        File.join(@current_path, LOCAL_TEMPLATES_PATH)
       end
     end
   end

data/lib/rdm/gen/package.rb

@@ -1,98 +1,44 @@
 require 'fileutils'
 require 'pathname'
-require 'active_support/inflector'
 
 module Rdm
   module Gen
     class Package
+      TEMPLATE_NAME = 'package'
+
       class << self
-        def generate(current_dir:, package_name:, package_relative_path:, skip_tests: false)
-          Rdm::Gen::Package.new(
-            current_dir, package_name, package_relative_path, skip_tests
-          ).create
+        def generate(package_name:, current_path:, local_path:, locals: {})
+          Rdm::Gen::Package.new(package_name, current_path, local_path, locals).create
         end
       end
 
-      include Rdm::Gen::Concerns::TemplateHandling
-
-      attr_accessor :current_dir, :package_name, :package_relative_path, :skip_tests
-      def initialize(current_dir, package_name, package_relative_path, skip_tests = false)
-        @current_dir           = File.expand_path(current_dir)
-        @package_name          = package_name
-        @package_relative_path = package_relative_path
-        @skip_tests            = skip_tests
-      end
-
-      def rdm_source
-        @rdm_source ||= Rdm::SourceParser.new(source_path).parse_source_content
-      end
-
-      def source_path
-        File.join(current_dir, Rdm::SOURCE_FILENAME)
-      end
-
-      def source_content
-        File.open(source_path).read
+      def initialize(package_name, current_path, local_path, locals = {})
+        @current_path = current_path
+        @package_name = package_name
+        @local_path   = local_path
+        @locals       = locals
       end
 
       def create
-        check_preconditions!
-        package_subdir_name = Rdm.settings.send(:package_subdir_name)
-
-        Dir.chdir(current_dir) do
-          ensure_file([package_relative_path, '.gitignore'])
-          ensure_file([package_relative_path, package_subdir_name, package_name, '.gitignore'])
-          ensure_file(
-            [package_relative_path, package_subdir_name, "#{package_name}.rb"],
-            template_content('main_module_file.rb.erb', package_name_camelized: package_name.camelize)
-          )
-          ensure_file(
-            [package_relative_path, 'Package.rb'],
-            template_content('package.rb.erb', package_name: package_name)
-          )
-          init_rspec unless skip_tests
-
-          move_templates
-          append_package_to_rdm_packages
-        end
-      end
-
-      def check_preconditions!
-        if Dir.exist?(File.join(current_dir, package_relative_path))
-          raise Rdm::Errors::PackageDirExists, 'package dir exists'
-        end
-
-        if rdm_source.package_paths.include?(package_relative_path)
-          raise Rdm::Errors::PackageExists, 'package exists'
-        end
-      end
-
-      def append_package_to_rdm_packages
-        new_source_content = source_content.strip + "\npackage '#{package_relative_path}'"
-        File.write(source_path, new_source_content)
-      end
-
-      def init_rspec
-        Dir.chdir(templates_path) do
-          copy_template('.rspec')
-          copy_template('spec/spec_helper.rb')
-        end
-      end
-
-      def move_templates
-        Dir.chdir(templates_path) do
-          copy_template('bin/console_irb', 'bin/console')
-        end
-      end
+        raise Rdm::Errors::PackageDirExists.new(@local_path) if Dir.exist?(File.join(source.root_path, @local_path))
+        raise Rdm::Errors::PackageNameNotSpecified           if @package_name.nil? || @package_name.empty?
+        raise Rdm::Errors::PackageExists                     if source.packages.keys.include?(@package_name)
 
-      private
+        File.open(File.join(source.root_path, Rdm::SOURCE_FILENAME), 'a+') {|f| f.write("package '#{@local_path}'")}
 
-      def templates_path
-        Pathname.new(File.join(File.dirname(__FILE__), '..', 'templates/package'))
+        Rdm::Handlers::TemplateHandler.generate(
+          template_name: TEMPLATE_NAME,
+          current_path:  @current_path,
+          local_path:    @local_path,
+          locals: {
+            package_name:           @package_name,
+            package_name_camelized: Rdm::Utils::StringUtils.camelize(@package_name)
+          }.merge(@locals)
+        )
       end
 
-      def target_path
-        File.join(current_dir, package_relative_path)
+      def source
+        @source ||= Rdm::SourceParser.read_and_init_source(Rdm::SourceLocator.locate(@current_path))
       end
     end
   end