nvim_conf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b19da8fe7f4b4cd45d17e7c3d00866a6dbd2fc5d6c690826e3352b69ff227ec3
+  data.tar.gz: 13f5ce2072b6a61cf586d660cec6624407e3f6193f61b330fcd3b6779a625132
+SHA512:
+  metadata.gz: fdd6c1532042741f60b69f0044d6889b0476c719b471be2c8777f9b20182dc7d7c3c36acdcac33aef109dd433258ed71015f776bac0d9878503b73ceaea0f480
+  data.tar.gz: 48580bebf403d43248b5d757a0b14936c376ee3658572da214a5ef967b78a6c68a9da41db028f7de5d4e801837da422689850b1471129e739bd37552732a70e6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Liberatys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# NvimConf
+
+A configuration manager for neovim that functions as an abstraction between your intentions and your configuration.
+Functions in a way that prevents having to rewrite everything in order to change your plugin manager.
+
+## Usage
+
+```ruby
+NvimConf::Core.define do
+  plugins(:packer) do # add some plugins with any available plugin manager
+    plug("tpope/vim-fugitive")
+    plug("tpope/vim-surround")
+  end
+
+  configuration do # configurate the generation of code and documentation
+    output_folder '$HOME/.config/nvim'
+    code_output :lua # you want lua? you want vim? NO PROBLEM!
+    documented true
+    commented
+  end
+
+  settings do # define all your settings
+    set "tabstop"
+    unset "tabstop"
+  end
+end
+```
+
+### Output
+#### Configuration
+
+```lua
+File: $HOME/.config/nvim/init.lua
+
+return require('packer').startup(function()
+  use "tpope/vim-fugitive"
+  use "tpope/vim-surround"
+end)
+
+vim.o.tabstop = true
+vim.o.tabstop = false
+```
+
+#### Documentation
+
+```markdown
+File: $HOME/.config/nvim/Init.md
+
+# Configuration Documentation Vim - NvimConf
+
+
+## Settings
+- tabstop => true
+- tabstop => false
+```
+## Why use NvimConf?
+
+Neovim is changing fast! Every other week we can use an new package manager.
+
+There is always a better version of your autocomplete plugin.
+
+### **The goals of NvimConf are**
+- Add automatic documentation to your configuration
+- Decouple the configuration from the actual code needed to arrive at the configuration state
+- Don't **version control** the configuration but manage the configuration schema
+- No more file changes due to a change in package manager... just change the one line in your configuration generator
+- Provide reproducible configuration
+- Sharable and copiable configuration that allows everyone to configure their neovim
+- Toolset to embed logic into your compiled configuration.
+
+## Features to come
+
+- Generators
+  - More plugin managers
+  - Auto Completion
+  - Linters
+- Configuraton optimization
+  - Remove duplicate Plugins
+  - Remove overwriting settings
+- Param Checker
+  - Validate the settings parameters
+  - Check generated settings for functionality
+- Custom embeeded Functions
+- Split Configuraton into multiple files
+- Render optimization by reducing the generation set
+- Comment your configuration automatically
+- Extend documentation generation
+  - Add plugin documentation
+  - Options for styling / spacing
+- Meta information for your configuration
+  - Version
+  - Author-Name
+  - Generation Date
+  - Generation Architecture (Macos / Linux)
+
+## Examples
+
+You can find more examples of configurations here: [example folder](./examples)

data/bin/nvim_conf

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'nvim_conf'
+
+if ARGV[0]
+  puts "Running nvim_conf for #{ARGV[0]}"
+
+  load(Pathname.new(ARGV[0]).expand_path)
+else
+  puts 'No file path to run nvim_conf was given'
+end

data/lib/nvim_conf/compiler_configurations/compiler_configuration.rb

@@ -0,0 +1,12 @@
+require "dry-initializer"
+
+module NvimConf
+  module CompilerConfigurations
+    class CompilerConfiguration
+      extend Dry::Initializer
+
+      param :name
+      param :value
+    end
+  end
+end

data/lib/nvim_conf/compiler_configurations/manager.rb

@@ -0,0 +1,74 @@
+require "nvim_conf/compiler_configurations/compiler_configuration"
+
+module NvimConf
+  module CompilerConfigurations
+    class Manager < NvimConf::Manager
+      attr_reader :configurations
+
+      def initialize
+        @configurations = []
+      end
+
+      def store?
+        @configurations.any?
+      end
+
+      def output_folder(path)
+        store_configuration(
+          :output_folder,
+          path
+        )
+      end
+
+      def write(acceptance = true)
+        store_configuration(
+          :write,
+          acceptance
+        )
+      end
+
+      def code_output(language)
+        store_configuration(
+          :code_output,
+          language.to_s
+        )
+      end
+
+      def mono_file(acceptance = true)
+        store_configuration(
+          :mono_file,
+          acceptance
+        )
+      end
+
+      def documented(formats)
+        store_configuration(
+          :documented,
+          formats
+        )
+      end
+
+      def commented(acceptance = true)
+        store_configuration(
+          :commented,
+          acceptance
+        )
+      end
+
+      private
+
+      def store_configuration(name, value)
+        @configurations << build_configuration(
+          name, value
+        )
+      end
+
+      def build_configuration(name, value)
+        CompilerConfiguration.new(
+          name,
+          value
+        )
+      end
+    end
+  end
+end

data/lib/nvim_conf/configuration_builder.rb

@@ -0,0 +1,37 @@
+require "nvim_conf/compiler_configurations/manager"
+
+module NvimConf
+  class ConfigurationBuilder
+    CONFIGURATION_MANAGER = NvimConf::CompilerConfigurations::Manager
+
+    def initialize(managers)
+      @managers = managers
+      @configuration = default_configuration
+    end
+
+    def build_configuration
+      @managers.select { |manager| manager.instance_of?(CONFIGURATION_MANAGER) }.each do |manager|
+        manager.configurations.each do |configuration|
+          @configuration[configuration.name] = configuration.value
+        end
+      end
+
+      @configuration[:format] ||= @configuration[:schema] == :nvim ? :lua : :vim
+      @configuration
+    end
+
+    private
+
+    def default_configuration
+      {
+        output_folder: "$HOME/.config/nvim",
+        code_output: :lua,
+        write: false,
+        mono_file: true,
+        documented: false,
+        commented: true,
+        schema: :nvim
+      }
+    end
+  end
+end

data/lib/nvim_conf/core.rb

@@ -0,0 +1,56 @@
+module NvimConf
+  class Core
+    def self.define(&block)
+      new.instance_eval(&block)
+
+      NvimConf::Writer.new(
+        NvimConf.managers
+      ).write
+    end
+
+    def plugins(name, bootstraped: false, &block)
+      store_manager(
+        evaluate_for_manager(
+          Plugins::Manager.new(name, bootstraped: bootstraped),
+          &block
+        )
+      )
+    end
+
+    def settings(&block)
+      store_manager(evaluate_for_manager(
+        Settings::Manager.new,
+        &block
+      ))
+    end
+
+    def mappings(namespace = nil, &block)
+      store_manager(evaluate_for_manager(
+        Mappings::Manager.new(namespace),
+        &block
+      ))
+    end
+
+    def configuration(&block)
+      store_manager(evaluate_for_manager(
+        CompilerConfigurations::Manager.new,
+        &block
+      ))
+    end
+
+    private
+
+    def evaluate_for_manager(manager, &block)
+      manager.instance_eval(&block)
+      manager
+    end
+
+    def store_manager(manager)
+      return unless manager.store?
+
+      NvimConf.managers.push(
+        manager
+      )
+    end
+  end
+end

data/lib/nvim_conf/generators/code/mappings/lua.rb

@@ -0,0 +1,54 @@
+module NvimConf
+  module Generators
+    module Mappings
+      module Code
+        class Lua
+          MODE_MAPPING = {
+            "map" => "",
+            "nmap" => "n",
+            "vmap" => "v",
+            "smap" => "s",
+            "xmap" => "x",
+            "omap" => "o",
+            "map!" => "!",
+            "imap" => "i",
+            "lmap" => "l",
+            "cmap" => "c",
+            "tmap" => "t"
+          }
+
+          BASE_METHOD = "vim.api.nvim_set_keymap"
+
+          def initialize(mapping)
+            @mapping = mapping
+          end
+
+          def generate
+            [
+              BASE_METHOD,
+              "(",
+              argument_list,
+              ")"
+            ].join
+          end
+
+          private
+
+          def argument_list
+            [
+              MODE_MAPPING[@mapping.operator.to_s],
+              @mapping.binding,
+              @mapping.action
+            ].map do |value|
+              [
+                "\'",
+                value,
+                "\'"
+              ].join
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/generators/code/mappings/vim.rb

@@ -0,0 +1,27 @@
+module NvimConf
+  module Generators
+    module Mappings
+      module Code
+        class Vim
+          def initialize(mapping)
+            @mapping = mapping
+          end
+
+          def generate
+            [
+              vim_method,
+              @mapping.binding,
+              @mapping.action
+            ].join(" ")
+          end
+
+          private
+
+          def vim_method
+            @mapping.operator.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/generators/code/plugins/packer.rb

@@ -0,0 +1,76 @@
+module NvimConf
+  module Generators
+    module Plugins
+      module Code
+        class Packer
+          COMMAND_PREFIX = :use
+
+          COMMAND_ALIAS = {
+            file_types: :ft
+          }
+
+          def initialize(plugin)
+            @plugin = plugin
+          end
+
+          def generate
+            generated_call = [
+              COMMAND_PREFIX,
+              command_call
+            ].join(" ")
+
+            args? ? "{#{generated_call}}" : generated_call
+          end
+
+          private
+
+          def command_call
+            [
+              plugin_name,
+              *command_arguments
+            ].compact.join(", ")
+          end
+
+          def plugin_name
+            "'#{@plugin.name}'"
+          end
+
+          def command_arguments
+            [
+              :as,
+              :opt,
+              :file_types,
+              :branch,
+              :run,
+              :cmd
+            ].map do |argument|
+              next if @plugin.send(argument).nil?
+
+              [
+                COMMAND_ALIAS[argument] || argument,
+                escape_value(@plugin.send(argument))
+              ].join(" = ")
+            end.compact
+          end
+
+          def escape_value(value)
+            return value unless value.is_a?(String)
+
+            "'#{value}'"
+          end
+
+          def args?
+            [
+              @plugin.as,
+              @plugin.opt,
+              @plugin.branch,
+              @plugin.file_types,
+              @plugin.cmd,
+              @plugin.run
+            ].any? { |argument| !argument.nil? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/generators/code/settings/lua.rb

@@ -0,0 +1,53 @@
+module NvimConf
+  module Generators
+    module Settings
+      module Code
+        class Lua
+          VIM_PREFIX = :vim
+
+          SETTING_NAMESPACES = {
+            global: "o",
+            buffer: "bo"
+          }
+
+          def initialize(setting)
+            @setting = setting
+          end
+
+          def generate
+            [
+              call_signature,
+              escaped_value
+            ].join(" = ")
+          end
+
+          private
+
+          def call_signature
+            [
+              VIM_PREFIX,
+              SETTING_NAMESPACES[@setting.scope] || SETTING_NAMESPACES[:global],
+              @setting.key
+            ].join(".")
+          end
+
+          def escaped_value
+            return fallback_to_truthy_on_nil(@setting.value) unless @setting.value.is_a?(String)
+
+            [
+              '"',
+              @setting.value,
+              '"'
+            ].join
+          end
+
+          def fallback_to_truthy_on_nil(value)
+            return value unless value.nil?
+
+            @setting.operation == :set
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/generators/code/settings/vim.rb

@@ -0,0 +1,47 @@
+module NvimConf
+  module Generators
+    module Settings
+      module Code
+        class Vim
+          SET_OPERATION = :set
+
+          def initialize(setting)
+            @setting = setting
+          end
+
+          def generate
+            [
+              call_identifier,
+              escaped_value
+            ].compact.join(" = ")
+          end
+
+          private
+
+          def call_identifier
+            [
+              SET_OPERATION,
+              negated_operator!
+            ].join(" ")
+          end
+
+          def negated_operator!
+            return @setting.key if @setting.operation == :set
+
+            "#{@setting.key}!"
+          end
+
+          def escaped_value
+            return @setting.value unless @setting.value.is_a?(String)
+
+            [
+              '"',
+              @setting.value,
+              '"'
+            ].join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nvim_conf/generators/generator.rb

@@ -0,0 +1,6 @@
+module NvimConf
+  module Generators
+    class Generator
+    end
+  end
+end

data/lib/nvim_conf/manager.rb

@@ -0,0 +1,6 @@
+module NvimConf
+  class Manager
+    def store?
+    end
+  end
+end

data/lib/nvim_conf/mappings/manager.rb

@@ -0,0 +1,58 @@
+require "nvim_conf/mappings/mapping"
+# TODO: Refactor error messages
+module NvimConf
+  module Mappings
+    class Manager < NvimConf::Manager
+      AVAILABLE_METHODS = %w[map map! nmap vmap imap cmap smap xmap omap lmap]
+      attr_reader :mappings
+
+      def initialize(namespace)
+        @mappings = []
+        @namespace = namespace&.to_s
+
+        validate!
+      end
+
+      def validate!
+        return if @namespace.nil? || @namespace.empty?
+
+        raise "Invalid namespace given for <mappings>: #{@namespace}" unless AVAILABLE_METHODS.include?(@namespace)
+      end
+
+      def store?
+        @mappings.any?
+      end
+
+      AVAILABLE_METHODS.each do |operator|
+        define_method(operator) do |binding, action|
+          store_mapping(
+            operator, binding, action
+          )
+        end
+      end
+
+      def new(binding, action)
+        raise "No namespace was given for <mappings>" unless @namespace
+        raise "No namespace was given for <mappings>" if @namespace.empty?
+
+        store_mapping(
+          @namespace, binding, action
+        )
+      end
+
+      alias_method :m, :new
+
+      private
+
+      def store_mapping(operator, binding, action)
+        @mappings << build_mapping(
+          operator, binding, action
+        )
+      end
+
+      def build_mapping(operator, binding, action)
+        Mapping.new(operator, binding, action)
+      end
+    end
+  end
+end

data/lib/nvim_conf/mappings/mapping.rb

@@ -0,0 +1,13 @@
+require "dry-initializer"
+
+module NvimConf
+  module Mappings
+    class Mapping
+      extend Dry::Initializer
+
+      param :operator
+      param :binding
+      param :action
+    end
+  end
+end