nvim_conf 0.1.0

data/lib/nvim_conf/plugins/manager.rb

@@ -0,0 +1,41 @@
+require "nvim_conf/plugins/plugin"
+
+module NvimConf
+  module Plugins
+    class Manager < NvimConf::Manager
+      attr_reader :plugins, :name, :bootstraped
+
+      def initialize(name, bootstraped: false)
+        @name = name
+        @bootstraped = bootstraped
+        @plugins = []
+      end
+
+      def store?
+        @plugins.any?
+      end
+
+      def plug(name, **params)
+        store_plugin(
+          name,
+          params
+        )
+      end
+
+      private
+
+      def store_plugin(name, params)
+        @plugins << build_plugin(
+          name, params
+        )
+      end
+
+      def build_plugin(name, params)
+        Plugin.new(
+          name,
+          **params
+        )
+      end
+    end
+  end
+end

data/lib/nvim_conf/plugins/plugin.rb

@@ -0,0 +1,19 @@
+require "dry-initializer"
+
+module NvimConf
+  module Plugins
+    class Plugin
+      extend Dry::Initializer
+
+      param :name
+      option :loader, default: -> { :git }
+      option :provider, default: -> { :github }
+      option :branch, optional: true
+      option :as, optional: true
+      option :opt, optional: true
+      option :file_types, optional: true
+      option :cmd, optional: true
+      option :run, optional: true
+    end
+  end
+end

data/lib/nvim_conf/settings/manager.rb

@@ -0,0 +1,43 @@
+require "nvim_conf/settings/setting"
+
+module NvimConf
+  module Settings
+    class Manager < NvimConf::Manager
+      attr_reader :settings
+
+      def initialize
+        @settings = []
+      end
+
+      def store?
+        @settings.any?
+      end
+
+      def set(key, value = nil, **params)
+        store_setting(
+          :set,
+          key: key,
+          value: value,
+          **params
+        )
+      end
+
+      def unset(key)
+        store_setting(
+          :unset,
+          key: key
+        )
+      end
+
+      private
+
+      def store_setting(operation, key:, value: nil, scope: :global)
+        @settings << build_setting(operation, key, value, scope)
+      end
+
+      def build_setting(operation, key, value, scope)
+        Setting.new(operation, key, value, scope)
+      end
+    end
+  end
+end

data/lib/nvim_conf/settings/setting.rb

@@ -0,0 +1,14 @@
+require "dry-initializer"
+
+module NvimConf
+  module Settings
+    class Setting
+      extend Dry::Initializer
+
+      param :operation
+      param :key
+      param :value, optional: true
+      param :scope, default: -> { :global }
+    end
+  end
+end

data/lib/nvim_conf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NvimConf
+  VERSION = "0.1.0"
+end

data/lib/nvim_conf/writer.rb

@@ -0,0 +1,87 @@
+require "fileutils"
+
+module NvimConf
+  class Writer
+    def initialize(managers)
+      @managers = managers
+      @configuration = NvimConf::ConfigurationBuilder.new(managers).build_configuration
+    end
+
+    def write
+      return unless run?
+
+      create_folder
+      write_configuration
+      write_documentation
+    end
+
+    private
+
+    def run?
+      @configuration[:write]
+    end
+
+    def write_documentation
+      create_documentation_init
+
+      File.open(documentation_file_path, "w+") do |file|
+        NvimConf::Writers::Documentation::Orchestrator.new(
+          @managers,
+          file,
+          @configuration
+        ).aggregate_writes
+      end
+    end
+
+    def create_folder
+      FileUtils.mkdir_p(folder_path)
+    end
+
+    def create_documentation_init
+      FileUtils.remove_file(
+        documentation_file_path,
+        force: true
+      )
+      FileUtils.touch(
+        documentation_file_path
+      )
+    end
+
+    def create_init
+      FileUtils.remove_file(
+        init_file_path,
+        force: true
+      )
+      FileUtils.touch(
+        init_file_path
+      )
+    end
+
+    def write_configuration
+      create_init
+      File.open(init_file_path, "w+") do |file|
+        NvimConf::Writers::Code::Orchestrator.new(
+          @managers,
+          file,
+          @configuration
+        ).aggregate_writes
+      end
+    end
+
+    def documentation_file_path
+      folder_path + "Init.md"
+    end
+
+    def init_file_path
+      folder_path + init_file_name
+    end
+
+    def init_file_name
+      @configuration[:schema] == :nvim ? "init.lua" : "init.vim"
+    end
+
+    def folder_path
+      @folder_path = Pathname.new(@configuration[:output_folder]).expand_path
+    end
+  end
+end

data/lib/nvim_conf/writers/code/mappings.rb

@@ -0,0 +1,39 @@
+require "nvim_conf/generators/code/mappings/lua"
+require "nvim_conf/generators/code/mappings/vim"
+
+module NvimConf
+  module Writers
+    module Code
+      class MappingsWriter
+        MAPPING_GENERATOR_MAPPING = {
+          lua: Generators::Mappings::Code::Lua,
+          vim: Generators::Mappings::Code::Vim
+        }
+
+        def initialize(manager, io, format: :lua, commented: false)
+          @manager = manager
+          @io = io
+          @format = format
+          @commented = commented
+        end
+
+        def write
+          @manager.mappings.each do |mapping|
+            @io.write(
+              [
+                generator_class.new(mapping).generate,
+                "\n"
+              ].join
+            )
+          end
+        end
+
+        private
+
+        def generator_class
+          MAPPING_GENERATOR_MAPPING[@format]
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/code/orchestrator.rb

@@ -0,0 +1,55 @@
+require "nvim_conf/writers/code/settings"
+require "nvim_conf/writers/code/mappings"
+require "nvim_conf/writers/code/plugins"
+
+module NvimConf
+  module Writers
+    module Code
+      class Orchestrator
+        NON_WRITABLE_MANAGER = NvimConf::CompilerConfigurations::Manager
+
+        WRITER_CONFIGURATION = {
+          NvimConf::Settings::Manager => SettingsWriter,
+          NvimConf::Mappings::Manager => MappingsWriter,
+          NvimConf::Plugins::Manager => PluginsWriter
+        }
+
+        def initialize(managers, io, configuration = nil)
+          @managers = managers
+          @io = io
+          @configuration = configuration || default_configuration
+        end
+
+        def aggregate_writes
+          @managers.select { |manager| manager.class != NON_WRITABLE_MANAGER }.each_with_index do |manager, index|
+            if index.positive?
+              @io.write(
+                separator
+              )
+            end
+            aggregate_writes_for_manager(manager)
+          end
+        end
+
+        private
+
+        def separator
+          "\n\n"
+        end
+
+        def aggregate_writes_for_manager(manager)
+          WRITER_CONFIGURATION[manager.class]&.new(
+            manager, @io, **@configuration.slice(:format, :commented)
+          )&.write
+        end
+
+        def default_configuration
+          {
+            format: :lua,
+            commented: false
+          }
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/code/plugins.rb

@@ -0,0 +1,86 @@
+# TODO: This code needs to be refactored.... Bad CODE :D will be done during the addition of the second plugin manager!
+module NvimConf
+  module Writers
+    module Code
+      class PluginsWriter
+        PLUGIN_MAP = {
+          packer: NvimConf::Generators::Plugins::Code::Packer
+        }
+
+        INDENT_MAP = {
+          packer: 2
+        }
+
+        def initialize(manager, io, _params)
+          @manager = manager
+          @io = io
+        end
+
+        def write
+          send("surround_#{@manager.name}") do |plugin|
+            @io.write(
+              [
+                plugin_indent(PLUGIN_MAP[@manager.name.to_sym].new(
+                  plugin
+                ).generate),
+                "\n"
+              ].join
+            )
+          end
+        end
+
+        private
+
+        def surround_packer(&block)
+          if bootstrap?
+            @io.write(
+              <<~BOOTSTRAP
+                local fn = vim.fn
+                local install_path = fn.stdpath('data')..'/site/pack/packer/start/packer.nvim'
+                if fn.empty(fn.glob(install_path)) > 0 then
+                  packer_bootstrap = fn.system({'git', 'clone', '--depth', '1', 'https://github.com/wbthomason/packer.nvim', install_path})
+                end\n
+              BOOTSTRAP
+            )
+          end
+
+          @io.write(
+            "return require('packer').startup(function()\n"
+          )
+
+          @manager.plugins.each(&block)
+
+          if bootstrap?
+            @io.write("\n")
+            @io.write(plugin_indent(
+              <<~BOOTSTRAP
+                if packer_bootstrap then
+                    require('packer').sync()
+                  end\n
+              BOOTSTRAP
+            ))
+          end
+
+          @io.write(
+            "end)\n"
+          )
+        end
+
+        def bootstrap?
+          @manager.bootstraped
+        end
+
+        def plugin_indent(content)
+          [
+            " " * INDENT_MAP[@manager.name.to_sym],
+            content
+          ].join
+        end
+
+        def generator_class
+          PLUGIN_MAP[@manager.name.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/code/settings.rb

@@ -0,0 +1,38 @@
+require "nvim_conf/generators/code/settings/lua"
+require "nvim_conf/generators/code/settings/vim"
+
+module NvimConf
+  module Writers
+    module Code
+      class SettingsWriter
+        SETTING_GENERATOR_MAPPING = {
+          lua: Generators::Settings::Code::Lua,
+          vim: Generators::Settings::Code::Vim
+        }
+
+        def initialize(manager, io, format:, commented:)
+          @manager = manager
+          @io = io
+          @format = format
+        end
+
+        def write
+          @manager.settings.each do |setting|
+            @io.write(
+              [
+                generator_class.new(setting).generate,
+                "\n"
+              ].join
+            )
+          end
+        end
+
+        private
+
+        def generator_class
+          SETTING_GENERATOR_MAPPING[@format]
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/documentation/mappings.rb

@@ -0,0 +1,66 @@
+module NvimConf
+  module Writers
+    module Documentation
+      class Mappings
+        MAIN_HEADER_PREFIX = "##"
+        MAPPING_HEADER_PREFIX = "###"
+
+        def initialize(managers, io)
+          @managers = managers
+          @io = io
+        end
+
+        def aggregate_writes
+          return if @managers.empty?
+
+          @io.write(
+            title(
+              "Mappings",
+              MAIN_HEADER_PREFIX
+            )
+          )
+
+          write_mappings(all_mappings.group_by(&:operator))
+        end
+
+        private
+
+        def write_mappings(grouped_mappings)
+          grouped_mappings.each do |operator, mappings|
+            write_separator
+
+            @io.write(
+              title(
+                operator,
+                MAPPING_HEADER_PREFIX
+              )
+            )
+
+            mappings.each do |mapping|
+              @io.write(
+                [
+                  "- #{mapping.binding}",
+                  mapping.action
+                ].join(" => ") + "\n"
+              )
+            end
+          end
+        end
+
+        def all_mappings
+          @managers.map(&:mappings).flatten
+        end
+
+        def write_separator
+          @io.write(
+            "\n\n"
+          )
+        end
+
+        def title(text, prefix)
+          "#{prefix} #{text}\n"
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/documentation/orchestrator.rb

@@ -0,0 +1,44 @@
+require "nvim_conf/writers/documentation/mappings"
+require "nvim_conf/writers/documentation/settings"
+
+module NvimConf
+  module Writers
+    module Documentation
+      class Orchestrator
+        NON_WRITABLE_MANAGER = NvimConf::CompilerConfigurations::Manager
+
+        def initialize(managers, io, configuration = nil)
+          @managers = managers
+          @io = io
+          @configuration = configuration || default_configuration
+        end
+
+        def aggregate_writes
+          return unless @configuration[:documented]
+
+          write_main_header
+
+          {
+            NvimConf::Writers::Documentation::Settings => NvimConf::Settings::Manager,
+            NvimConf::Writers::Documentation::Mappings => NvimConf::Mappings::Manager
+          }.each do |writer_class, manager_class|
+            writer_class.new(
+              @managers.select { |manager| manager.instance_of?(manager_class) },
+              @io
+            ).aggregate_writes
+
+            @io.write("\n\n")
+          end
+        end
+
+        private
+
+        def write_main_header
+          @io.write(
+            "# Configuration Documentation Vim - NvimConf\n\n"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/writers/documentation/settings.rb

@@ -0,0 +1,71 @@
+module NvimConf
+  module Writers
+    module Documentation
+      class Settings
+        MAIN_HEADER_PREFIX = "##"
+
+        def initialize(managers, io)
+          @managers = managers
+          @io = io
+        end
+
+        def aggregate_writes
+          return if @managers.empty?
+
+          @io.write(
+            title(
+              "Settings",
+              MAIN_HEADER_PREFIX
+            )
+          )
+
+          write_settings_groups(all_settings.group_by(&:operation))
+        end
+
+        private
+
+        def write_settings_groups(groups)
+          groups.each do |operation, settings|
+            write_separator
+
+            @io.write(
+              title(
+                operation.capitalize,
+                "###"
+              )
+            )
+
+            settings.each do |setting|
+              @io.write(
+                [
+                  "- #{setting.key}",
+                  transformed_value(setting, setting.value)
+                ].join(" => ") + "\n"
+              )
+            end
+          end
+        end
+
+        def transformed_value(setting, value)
+          return value unless value.nil?
+
+          setting.operation == :set
+        end
+
+        def all_settings
+          @managers.map(&:settings).flatten
+        end
+
+        def write_separator
+          @io.write(
+            "\n\n"
+          )
+        end
+
+        def title(text, prefix)
+          "#{prefix} #{text}\n"
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "nvim_conf/version"
+require "set"
+require "nvim_conf/core"
+require "nvim_conf/writer"
+require "nvim_conf/manager"
+require "nvim_conf/configuration_builder"
+require "nvim_conf/plugins/manager"
+require "nvim_conf/settings/manager"
+require "nvim_conf/mappings/manager"
+require "nvim_conf/compiler_configurations/manager"
+require "nvim_conf/generators/code/settings/lua"
+require "nvim_conf/generators/code/plugins/packer"
+require "nvim_conf/generators/code/settings/vim"
+require "nvim_conf/generators/code/mappings/lua"
+require "nvim_conf/generators/code/mappings/vim"
+require "nvim_conf/writers/code/orchestrator"
+require "nvim_conf/writers/documentation/orchestrator"
+
+module NvimConf
+  @managers = []
+
+  def self.managers
+    @managers
+  end
+
+  def self.clear_managers
+    @managers = []
+  end
+
+  class Error < StandardError; end
+end