SCR #0 - add generating all docblock

README.md

@@ -1,12 +1,14 @@
 # PHPHelper
 Plugin for neovim, which will help in creating dock blocks, generating getters and setters for the PHP programming language
 
-Create dockblock at cursor
+Create docblock at cursor
 ![PHPHelper gif](https://github.com/curkan/phphelper/blob/master/phphelper.gif)
 
+Generate all docblock for this class (While it only works with methods)
+![PHPHelpergenerate gif](https://github.com/curkan/phphelper/blob/master/phphelper_generate_all_docblock.gif)
 
 Generate getter and setter for class
-![PHPHelpergenerate gif](https://github.com/curkan/phphelper/blob/master/phphelper_generate.gif)
+![PHPHelpergenerate gif](https://github.com/curkan/phphelper/blob/master/phphelper_generate_getter_and_setter.gif)
 
 ## Setup
 
@@ -25,18 +27,19 @@ require "phphelper"
 
 ## Usage
 
-There are two key bindings provided by default (create php dockblock):
+There are two key bindings provided by default (create php docblock):
 
     <leader>p
 
 you can override:
 
-    vim.api.nvim_set_keymap('n', '<leader>p', '<cmd>:AddPhpDockBlock()<cr>', default_opts)
+    vim.api.nvim_set_keymap('n', '<leader>p', '<cmd>:PHPAddDocblock()<cr>', default_opts)
 
 Commands: 
 
-    :PHPAddDockBlock
-    :PHPGenerateAll
+    :PHPAddDocblock
+    :PHPGenerateAllDocblock
+    :PHPGenerateGetterAndSetter
     :PHPGenerateGetter
     :PHPGenerateSetter
 

lua/.gitignore

@@ -1,2 +1 @@
-test.php
-getterSetter.php
+phpTest

lua/docblock/docblock.lua

@@ -0,0 +1,69 @@
+local M = {}
+
+    -- Основная функция для генерации докблоков
+    function M.generateAllDocblock()
+        local ts_utils = require 'nvim-treesitter.ts_utils'
+        local bufnr = vim.api.nvim_get_current_buf()
+        -- local getMethodNode = require('lua.docblock.lib.getMethodNode')
+        -- local cursor_node = ts_utils.get_node_at_cursor()
+        local parser = vim.treesitter.get_parser(bufnr, 'php')
+        local root = parser:parse()[1]
+
+        local function findClassDeclaration(node)
+            if node == nil then
+                return nil
+            end
+
+            if node:type() == 'class_declaration' then
+                return node
+            else 
+                findClassDeclaration(node:child())
+            end
+        end
+
+        local class = nil
+
+        for node in root:root():iter_children() do
+            class = findClassDeclaration(node)
+
+            if class ~= nil then
+                break
+            end
+        end
+
+        if class ~= nil then
+            local getMethodNode = require('docblock.lib.getMethodNode')
+            local methodNodesTable = getMethodNode.getMethodNode(class)
+            local iterableCountDocblock = 0
+
+            local tableNodeWithParamsAndReturnTypes = {}
+
+            -- Получили все методы
+            for _, node in ipairs(methodNodesTable) do
+                local formal_module = require('docblock.lib.getFormalParametrsForMethod')
+                local formalParametrs = formal_module.getFormalParametrsForMethod(node)[1]
+                local methodParametrs = {}
+                local methodReturnTypes = {}
+
+                methodParametrs = formalParametrs
+
+                local return_module = require('docblock.lib.getReturnTypesForMethod')
+                local returnTypes = return_module.getReturnTypesForMethod(node)
+
+                for _, returns in ipairs(returnTypes) do
+                    methodReturnTypes = returns
+                end
+
+                table.insert(tableNodeWithParamsAndReturnTypes, {node = node, parametrs = methodParametrs, returnTypes = methodReturnTypes})
+            end
+
+            for _, node in ipairs(tableNodeWithParamsAndReturnTypes) do
+                local printer = require('docblock.lib.printDocblock')
+                iterableCountDocblock = printer.print(bufnr, node.node, node.parametrs, node.returnTypes, iterableCountDocblock)
+            end
+        end
+
+    end
+
+
+return M

lua/docblock/lib/getFormalParametrsForMethod.lua

@@ -0,0 +1,39 @@
+local M = {}
+    local function iterableFormalParametrs(node)
+        local tableParamets = {}
+        for child in node:iter_children() do
+            if child:type() == 'simple_parameter' then
+                local type = child:field('type')[1]
+                local name = child:field('name')[1]
+
+                if type ~= nil then
+                    type = vim.treesitter.get_node_text(type, 0)
+                end
+
+                if name ~= nil then
+                    name = vim.treesitter.get_node_text(name, 0)
+                end
+
+                table.insert(tableParamets, {type = type, name = name})
+            end
+        end
+
+        return tableParamets
+    end
+
+    function M.getFormalParametrsForMethod(node)
+        local parametrs = {}
+
+        local allParametrs = node:field('parameters')
+
+        -- print(#allParametrs)
+        for _, nodeParametrs in pairs(allParametrs) do
+            -- formal_parametrs
+            local params = iterableFormalParametrs(nodeParametrs)
+            table.insert(parametrs, params)
+        end
+
+        return parametrs
+    end
+
+return M

lua/docblock/lib/getMethodNode.lua

@@ -0,0 +1,30 @@
+local M = {}
+
+    function M.getMethodNode(node)
+        local tableNodesMethod = {}
+
+        local function getMethod(my_node)
+            for child in my_node:iter_children() do
+                if child:type() == 'method_declaration' then
+                    local prevNode = child:prev_sibling()
+                    if prevNode ~= nil then
+                        if prevNode:type() == 'comment' then
+                            goto continue
+                        end
+                    end
+
+                    table.insert(tableNodesMethod, child)
+                else
+                    getMethod(child)
+                end
+                ::continue::
+            end
+
+            return tableNodesMethod
+        end
+
+        tableNodesMethod = getMethod(node)
+        return tableNodesMethod
+    end
+
+return M

lua/docblock/lib/getReturnTypesForMethod.lua

@@ -0,0 +1,30 @@
+local M = {}
+    local function iterableReturnTypes(node)
+        local tableReturns = {}
+
+        for child in node:iter_children() do
+            if child:type() == 'primitive_type' then
+                local returnType = vim.treesitter.get_node_text(child, 0)
+
+                table.insert(tableReturns, returnType)
+            end
+        end
+
+        return tableReturns
+    end
+
+    function M.getReturnTypesForMethod(node)
+        local returnsTable = {}
+
+        local allReturnTypes = node:field('return_type')
+
+        for _, returnType in pairs(allReturnTypes) do
+            local returns = iterableReturnTypes(returnType)
+            table.insert(returnsTable, returns)
+        end
+
+        return returnsTable
+    end
+
+return M
+

lua/docblock/lib/printDocblock.lua

@@ -0,0 +1,55 @@
+local M = {}
+
+    local function generateDocblock(method, parameters, returnTypes)
+        local docblock = {
+            '    /**',
+        }
+
+        for _, parametr in pairs(parameters) do
+            table.insert(
+                docblock, '     * param '
+                .. (parametr.type ~= nil and parametr.type .. ' ' or '')
+                .. (parametr.name ~= nil and parametr.name or '')
+            )
+        end
+
+        if returnTypes == nil then
+            return
+        end
+
+        if next(returnTypes) ~= nil then
+            local countReturnTypes = #returnTypes
+            local returnString = ''
+
+            if countReturnTypes > 1 then
+                returnString = table.concat(returnTypes, '|')
+            else
+                returnString = returnTypes[1]
+            end
+
+            table.insert(
+                docblock, '     * return ' .. returnString
+            )
+        end
+
+        table.insert(docblock, '     */')
+
+        return docblock
+    end
+
+    function M.print(bufnr, method, parameters, returnTypes, iterableCountDocblock)
+        local docblock = generateDocblock(method, parameters, returnTypes)
+
+        if docblock == nil then
+            return 0
+        end
+
+        vim.api.nvim_buf_set_lines(bufnr, method:start() + iterableCountDocblock, method:start() + iterableCountDocblock, false, docblock)
+
+        iterableCountDocblock = iterableCountDocblock + #docblock
+
+        return iterableCountDocblock
+    end
+
+return M
+

lua/phphelper.lua

@@ -4,7 +4,7 @@ local variable = require("lib.variable")
 local map = vim.api.nvim_set_keymap
 local default_opts = {noremap = true, silent = true}
 
-function add_dockblock()
+function add_docblock()
     local lnum = vim.fn.line('.')
     local indent = vim.fn.indent(lnum)
     local line = vim.fn.getline(lnum)
@@ -20,14 +20,20 @@ function add_dockblock()
     end
 end
 
-function generate(method)
+function generateGetterAndSetter(method)
     local ts = require('utils.generate')
     ts.generate_getters_setters(method)
 end
 
+function generateAllDocblock()
+    local docblock = require('docblock.docblock')
+    docblock.generateAllDocblock()
+end
+
 
-vim.cmd("command! PHPAddDockBlock lua add_dockblock()")
-vim.cmd("command! PHPGenerateAll lua generate()")
-vim.cmd("command! PHPGenerateGetter lua generate('getter')")
-vim.cmd("command! PHPGenerateSetter lua generate('setter')")
-map('n', '<leader>p', '<cmd>lua add_dockblock()<cr>', default_opts)
+vim.cmd("command! PHPAddDocblock lua add_docblock()")
+vim.cmd("command! PHPGenerateAllDocblock lua generateAllDocblock()")
+vim.cmd("command! PHPGenerateGetterAndSetter lua generateGetterAndSetter()")
+vim.cmd("command! PHPGenerateGetter lua generateGetterAndSetter('getter')")
+vim.cmd("command! PHPGenerateSetter lua generateGetterAndSetter('setter')")
+map('n', '<leader>p', '<cmd>lua add_docblock()<cr>', default_opts)

lua/utils/generate.lua

@@ -39,9 +39,9 @@ end
 local function writeGetter(bufnr, property, existing_getters, last_brace_index, method)
 
     -- Генерируем DocBlock
-    local dockblock_module = require('utils.generate_dockblock')
-    local dockblock = {}
-    dockblock = dockblock_module.makeDockBlock(property, method)
+    local docblock_module = require('utils.generate_docblock')
+    local docblock = {}
+    docblock = docblock_module.makeDocblock(property, method)
 
     local getter_name = 'get' .. capitalizeFirstLetter(property.name)
     local getter_type = property.type
@@ -58,18 +58,18 @@ local function writeGetter(bufnr, property, existing_getters, last_brace_index,
 
         local getter_index = last_brace_index
         local tableGetter = {}
-        table.move(dockblock, 1, #dockblock, 1, tableGetter)
-        table.move(getter_code, 1, #getter_code, #dockblock + 1, tableGetter)
+        table.move(docblock, 1, #docblock, 1, tableGetter)
+        table.move(getter_code, 1, #getter_code, #docblock + 1, tableGetter)
 
         vim.api.nvim_buf_set_lines(bufnr, getter_index, getter_index, false, tableGetter)
     end
 end
 
 local function writeSetter(bufnr, property, existing_setters, last_brace_index, method)
     -- Генерируем DocBlock
-    local dockblock_module = require('utils.generate_dockblock')
-    local dockblock = {}
-    dockblock = dockblock_module.makeDockBlock(property, method)
+    local docblock_module = require('utils.generate_docblock')
+    local docblock = {}
+    docblock = docblock_module.makeDocblock(property, method)
 
 
     local setter_name = 'set' .. capitalizeFirstLetter(property.name)
@@ -88,8 +88,8 @@ local function writeSetter(bufnr, property, existing_setters, last_brace_index,
         local setter_index = last_brace_index
 
         local tableSetter = {}
-        table.move(dockblock, 1, #dockblock, 1, tableSetter)
-        table.move(setter_code, 1, #setter_code, #dockblock + 1, tableSetter)
+        table.move(docblock, 1, #docblock, 1, tableSetter)
+        table.move(setter_code, 1, #setter_code, #docblock + 1, tableSetter)
 
         vim.api.nvim_buf_set_lines(bufnr, setter_index, setter_index, false, tableSetter)
     end

lua/utils/generate_docblock.lua

@@ -0,0 +1,31 @@
+local M = {}
+
+    function M.makeDocblock(property, method)
+        local docblock = {
+            '    /**',
+        }
+
+        if method == 'getter' then
+            if property.type ~= '' then
+                table.insert(docblock, '     * @return ' .. property.type)
+            else
+                table.insert(docblock, '     * @return mixed')
+            end
+        end
+
+        if method == 'setter' then
+            if property.type ~= '' then
+                table.insert(docblock, '     * @param ' .. property.type .. ' $value')
+                table.insert(docblock, '     * @return void')
+            else
+                table.insert(docblock, '     * @param mixed $value')
+                table.insert(docblock, '     * @return void')
+            end
+        end
+
+        table.insert(docblock, '     */')
+
+        return docblock
+    end
+
+return M