nvim_conf 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b19da8fe7f4b4cd45d17e7c3d00866a6dbd2fc5d6c690826e3352b69ff227ec3
-  data.tar.gz: 13f5ce2072b6a61cf586d660cec6624407e3f6193f61b330fcd3b6779a625132
+  metadata.gz: a309afbd9486b05dd70d891277a099b3acfa2e9bd28a9cd6c0c77faeb566d74b
+  data.tar.gz: 348b65e86219ea24189b394c91a5add233ab4f6256fcda8c0791f4c92238a352
 SHA512:
-  metadata.gz: fdd6c1532042741f60b69f0044d6889b0476c719b471be2c8777f9b20182dc7d7c3c36acdcac33aef109dd433258ed71015f776bac0d9878503b73ceaea0f480
-  data.tar.gz: 48580bebf403d43248b5d757a0b14936c376ee3658572da214a5ef967b78a6c68a9da41db028f7de5d4e801837da422689850b1471129e739bd37552732a70e6
+  metadata.gz: bec3cd5f112df5020609ac5c278726e4dcd80ec98a1feab0f1877d9f7beef12456c78956172116e77368aa6fb7ee03d74e3900c1000a326dafcbbfa1a25a4e09
+  data.tar.gz: b8d55f413d375fe6931251189ccf2cb9e25335c90edfd1b496ab6460c476939fa205ab16d193bcc7aab1b3854b58ef02950fff2ebe8a9ef18a209b757267373d

data/README.md

@@ -1,8 +1,17 @@
+[![Gem Version](https://badge.fury.io/rb/nvim_conf.svg)](https://badge.fury.io/rb/nvim_conf)
+
 # 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.
 
+## Installation
+
+```markdown
+  gem install nvim_conf
+  nvim_conf path_to_configuration_file
+```
+
 ## Usage
 
 ```ruby
@@ -12,6 +21,11 @@ NvimConf::Core.define do
     plug("tpope/vim-surround")
   end
 
+  requires do
+    setup "nvim_lint"
+    setup "tester"
+  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!
@@ -37,6 +51,9 @@ return require('packer').startup(function()
   use "tpope/vim-surround"
 end)
 
+require "nvim_lint".setup{}
+require "tester".setup{}
+
 vim.o.tabstop = true
 vim.o.tabstop = false
 ```
@@ -55,14 +72,54 @@ File: $HOME/.config/nvim/Init.md
 ```
 ## Why use NvimConf?
 
-Neovim is changing fast! Every other week we can use an new package manager.
+### Abstraction
+
+You no longer have to know about the exact syntax that vim and lua are handling calls to the api. One interface to configure them all.
+
+This allows you to change your configuration without having to worry about a future language to configure vim... because we can just add the needed generators for the new langauge and your old configuration is good to go.
+
+### Ruby
+
+Because the abstraction is written in ruby and the configuration is also just a ruby file you are able to execute
+any valid ruby code directly in your configuration. This allows you to introduce complex build tasks.
 
-There is always a better version of your autocomplete plugin.
+An example:
+
+Input: 
+
+```ruby
+[
+  :gzip,
+  :zip,
+  :zipPlugin,
+  :tar,
+  :tarPlugin,
+  :getscript
+].each do | setting|
+  set "loaded_#{setting}", true
+end
+```
+
+Output:
+
+```lua
+vim.g.loaded_gzip = true
+vim.g.loaded_zip = true
+vim.g.loaded_zipPlugin = true
+vim.g.loaded_tar = true
+vim.g.loaded_tarPlugin = true
+vim.g.loaded_getscript = true
+```
+
+Use environment variables, ruby helpers, modules and all the good that ruby has to offer.
+
+Why repeat yourself when you can script it?
 
 ### **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
+
+- Automatic documentation to your configuration
+- Decoupling the configuration from the actual code needed to arrive at the configuration state
+- Version control of generation schema rather than actual configuration
 - 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
@@ -80,18 +137,17 @@ There is always a better version of your autocomplete plugin.
 - 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)
+- Utility to share and donwload configurations
 
 ## Examples
 

data/lib/nvim_conf/commenter.rb

@@ -0,0 +1,23 @@
+module NvimConf
+  class Commenter
+    class << self
+      def comment_block(configuration, section, spacer: false)
+        return if skip?(configuration)
+
+        padded_title = section.center(20)
+        border = "#" * (padded_title.length + 4)
+
+        <<~FORMAT
+          #{spacer ? "\n\n" : ""}
+          -- #{border}
+          -- # #{padded_title} #
+          -- #{border}
+        FORMAT
+      end
+
+      def skip?(configuration)
+        configuration[:format] != :lua || !configuration[:commented]
+      end
+    end
+  end
+end

data/lib/nvim_conf/configuration_builder.rb

@@ -1,8 +1,8 @@
-require "nvim_conf/compiler_configurations/manager"
+require "nvim_conf/managers/compiler_configurations"
 
 module NvimConf
   class ConfigurationBuilder
-    CONFIGURATION_MANAGER = NvimConf::CompilerConfigurations::Manager
+    CONFIGURATION_MANAGER = NvimConf::Managers::CompilerConfigurations
 
     def initialize(managers)
       @managers = managers

data/lib/nvim_conf/core.rb

@@ -8,45 +8,64 @@ module NvimConf
       ).write
     end
 
-    def plugins(name, bootstraped: false, &block)
-      store_manager(
-        evaluate_for_manager(
-          Plugins::Manager.new(name, bootstraped: bootstraped),
-          &block
-        )
+    def plugins(name, title: nil, bootstraped: false, &block)
+      evaluate_for_manager(
+        Managers::Plugins.new(name, title, bootstraped: bootstraped),
+        &block
+      )
+    end
+
+    def commands(&block)
+      evaluate_for_manager(
+        Managers::Commands.new,
+        &block
+      )
+    end
+
+    def requires(&block)
+      evaluate_for_manager(
+        Managers::Requires.new,
+        &block
+      )
+    end
+
+    def globals(&block)
+      evaluate_for_manager(
+        Managers::Globals.new,
+        &block
       )
     end
 
-    def settings(&block)
-      store_manager(evaluate_for_manager(
-        Settings::Manager.new,
+    def settings(title = nil, &block)
+      evaluate_for_manager(
+        Managers::Settings.new(title),
         &block
-      ))
+      )
     end
 
     def mappings(namespace = nil, &block)
-      store_manager(evaluate_for_manager(
-        Mappings::Manager.new(namespace),
+      evaluate_for_manager(
+        Managers::Mappings.new(namespace),
         &block
-      ))
+      )
     end
 
     def configuration(&block)
-      store_manager(evaluate_for_manager(
-        CompilerConfigurations::Manager.new,
+      evaluate_for_manager(
+        Managers::CompilerConfigurations.new,
         &block
-      ))
+      )
     end
 
     private
 
     def evaluate_for_manager(manager, &block)
       manager.instance_eval(&block)
-      manager
+      store_manager(manager)
     end
 
     def store_manager(manager)
-      return unless manager.store?
+      return unless manager.send(:store?)
 
       NvimConf.managers.push(
         manager

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

@@ -0,0 +1,37 @@
+module NvimConf
+  module Generators
+    module Commands
+      module Code
+        class Lua
+          def initialize(command)
+            @command = command
+          end
+
+          def generate
+            send("#{@command.vim_exec ? "vim" : "lua"}_exec")
+          end
+
+          private
+
+          def lua_exec
+            @command.body
+          end
+
+          def vim_exec
+            <<~FORMAT
+              vim.cmd([[
+              #{align_line_start(@command.body)}
+              ]])
+            FORMAT
+          end
+
+          def align_line_start(body)
+            body.split("\n").map do |line|
+              "  #{line}"
+            end.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module NvimConf
+  module Generators
+    module Globals
+      module Code
+        class Lua
+          def initialize(global)
+            @global = global
+          end
+
+          def generate
+            [
+              "vim.g.#{@global.name}",
+              format_value(@global.value)
+            ].join(" = ")
+          end
+
+          private
+
+          def format_value(value)
+            case value
+            when String
+              [
+                '"',
+                value,
+                '"'
+              ].join
+            when Array
+              [
+                "{",
+                value.map { |inner_value| format_value(inner_value) }.join(", "),
+                "}"
+              ].join
+            else
+              fallback_to_truthy_on_nil(value)
+            end
+          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/mappings/lua.rb

@@ -17,35 +17,67 @@ module NvimConf
             "tmap" => "t"
           }
 
-          BASE_METHOD = "vim.api.nvim_set_keymap"
+          BASE_SET_METHOD = "vim.api.nvim_set_keymap"
+          BASE_UNSET_METHOD = "vim.api.nvim_del_keymap"
 
           def initialize(mapping)
             @mapping = mapping
           end
 
           def generate
+            if @mapping.remove
+              generate_unset
+            else
+              generate_set
+            end
+          end
+
+          private
+
+          def generate_set
             [
-              BASE_METHOD,
+              BASE_SET_METHOD,
               "(",
               argument_list,
               ")"
             ].join
           end
 
-          private
+          def generate_unset
+            [
+              BASE_UNSET_METHOD,
+              "(",
+              [
+                MODE_MAPPING[@mapping.operator.to_s],
+                @mapping.binding
+              ].map { |value| escape_value(value) }.join(", "),
+              ")"
+            ].join
+          end
 
           def argument_list
-            [
+            ([
               MODE_MAPPING[@mapping.operator.to_s],
               @mapping.binding,
               @mapping.action
-            ].map do |value|
-              [
-                "\'",
-                value,
-                "\'"
-              ].join
-            end.join(", ")
+            ].map { |value| escape_value(value) } + options).join(", ")
+          end
+
+          def escape_value(value)
+            escape_character = surround_symbol(value)
+            [
+              escape_character,
+              value,
+              escape_character
+            ].join
+          end
+
+          def surround_symbol(value)
+            value.include?("'") ? '"' : "'"
+          end
+
+          def options
+            ["{}"]
           end
         end
       end

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

@@ -36,14 +36,7 @@ module NvimConf
           end
 
           def command_arguments
-            [
-              :as,
-              :opt,
-              :file_types,
-              :branch,
-              :run,
-              :cmd
-            ].map do |argument|
+            @plugin.class.optional_arguments.map do |argument|
               next if @plugin.send(argument).nil?
 
               [
@@ -60,14 +53,9 @@ module NvimConf
           end
 
           def args?
-            [
-              @plugin.as,
-              @plugin.opt,
-              @plugin.branch,
-              @plugin.file_types,
-              @plugin.cmd,
-              @plugin.run
-            ].any? { |argument| !argument.nil? }
+            @plugin.class.optional_arguments.map do |argument|
+              @plugin.send(argument)
+            end.any? { |argument| !argument.nil? }
           end
         end
       end

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

@@ -0,0 +1,57 @@
+module NvimConf
+  module Generators
+    module Plugins
+      module Code
+        class Paq
+          COMMAND_ALIAS = {
+            file_types: :ft
+          }
+
+          def initialize(plugin)
+            @plugin = plugin
+          end
+
+          def generate
+            (args? ? "{#{command_call}}" : command_call) + ";"
+          end
+
+          private
+
+          def command_call
+            [
+              plugin_name,
+              *command_arguments
+            ].compact.join(", ")
+          end
+
+          def plugin_name
+            "'#{@plugin.name}'"
+          end
+
+          def command_arguments
+            @plugin.class.optional_arguments.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.class.optional_arguments.map do |argument|
+              @plugin.send(argument)
+            end.any? { |argument| !argument.nil? }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module NvimConf
+  module Generators
+    module Requires
+      module Code
+        class Lua
+          def initialize(require)
+            @require = require
+          end
+
+          def generate
+            build_statement
+          end
+
+          private
+
+          def build_statement
+            "require '#{@require.file}'.setup{}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,8 @@ module NvimConf
 
           SETTING_NAMESPACES = {
             global: "o",
-            buffer: "bo"
+            buffer: "bo",
+            opt: "opt"
           }
 
           def initialize(setting)
@@ -15,14 +16,26 @@ module NvimConf
           end
 
           def generate
+            if %i[set unset].include?(@setting.operation)
+              generate_set
+            else
+              generate_addition
+            end
+          end
+
+          private
+
+          def generate_addition
+            "#{call_signature}:append(#{format_value(@setting.value)})"
+          end
+
+          def generate_set
             [
               call_signature,
-              escaped_value
+              format_value(@setting.value)
             ].join(" = ")
           end
 
-          private
-
           def call_signature
             [
               VIM_PREFIX,
@@ -31,14 +44,23 @@ module NvimConf
             ].join(".")
           end
 
-          def escaped_value
-            return fallback_to_truthy_on_nil(@setting.value) unless @setting.value.is_a?(String)
-
-            [
-              '"',
-              @setting.value,
-              '"'
-            ].join
+          def format_value(value)
+            case value
+            when String
+              [
+                '"',
+                value,
+                '"'
+              ].join
+            when Array
+              [
+                "{",
+                value.map { |inner_value| format_value(inner_value) }.join(", "),
+                "}"
+              ].join
+            else
+              fallback_to_truthy_on_nil(value)
+            end
           end
 
           def fallback_to_truthy_on_nil(value)

data/lib/nvim_conf/managers/commands.rb

@@ -0,0 +1,38 @@
+require "nvim_conf/models/command"
+
+module NvimConf
+  module Managers
+    class Commands
+      attr_reader :commands
+
+      def initialize
+        @commands = []
+      end
+
+      class << self
+        def section_name
+          "Commands"
+        end
+      end
+
+      def command(name, description: "", body: "", vim_exec: false)
+        store_command(name, description, body, vim_exec)
+      end
+
+      alias_method :new, :command
+      alias_method :c, :command
+
+      private
+
+      def store_command(name, description, body, vim_exec)
+        @commands << Models::Command.new(
+          name, description, body, vim_exec: vim_exec
+        )
+      end
+
+      def store?
+        @commands.any?
+      end
+    end
+  end
+end

data/lib/nvim_conf/{compiler_configurations/manager.rb → managers/compiler_configurations.rb}

@@ -1,8 +1,8 @@
-require "nvim_conf/compiler_configurations/compiler_configuration"
+require "nvim_conf/models/compiler_configuration"
 
 module NvimConf
-  module CompilerConfigurations
-    class Manager < NvimConf::Manager
+  module Managers
+    class CompilerConfigurations
       attr_reader :configurations
 
       def initialize
@@ -64,7 +64,7 @@ module NvimConf
       end
 
       def build_configuration(name, value)
-        CompilerConfiguration.new(
+        Models::CompilerConfiguration.new(
           name,
           value
         )