WO2025093052A1 - Low-code conversion method and apparatus, readable storage medium, and device - Google Patents

Abstract

The present invention provides a low-code conversion method and apparatus, a readable storage medium, and a device. The method comprises: on the basis of a first keyword, a second keyword, and a third keyword in complete component code, extracting a module name, title, and filling code of the component code, and combining a preset readme file template with the module name, title, and filling code of the component code and generating low-code snippets; converting the low-code snippets into first-format code blocks; replacing the first, second, and third keywords with preset first, second, and third escape characters, so as to obtain escaped first-format code blocks; and traversing each escaped first-format code block and performing matching therefor against a preset second-format template, extracting the module name, title, and filling code of the component code from matched escaped first-format code blocks, and filling same into the second-format template and generating readable code. The method achieves automatic generation of fillable formatted code blocks, improving the efficiency of importing code into the system.

Description

Low-code conversion method, device, readable storage medium and equipment Technical Field

The present invention relates to the field of code conversion, and in particular to a low-code conversion method, device, readable storage medium and equipment.

Background Art

In the current software development process, developers will save the source code of the project to the Git repository, and then deliver the Git repository to the code management platform for operation. However, different developers use different development platforms, coding languages, and coding habits, which may lead to different source code formats or coding languages for different components of the project. Therefore, after developing a component, developers need to manually write code snippets for external use and external application interface documents, and users need to spend a lot of time reading and understanding the principles of component implementation.

If the user needs to use the integrated development environment system, they need to switch pages to copy and paste the code into the integrated development environment system, and cannot quickly search and use all components in the component library. The above situation greatly reduces the development efficiency of R&D personnel and is not conducive to the large-scale copying and dissemination of codes.

Summary of the invention

Based on this, the present invention provides a low-code conversion method, device, readable storage medium and equipment, which convert the code snippets of components into data files in a fixed format, and generate code blocks that can be directly used in the IDE system from the data files through scripts, greatly improving the development efficiency of R&D personnel.

In a first aspect, the present invention provides a low-code snippet conversion method, comprising:

Get the complete component code and preset README template;

Extracting a module name, a title, and a filler code of the component code according to the first keyword, the second keyword, and the third keyword in the complete component code, and combining the preset readme file template with the module name, the title, and the filler code of the component code to generate a low-code snippet;

If the low code snippet is updated, convert the low code snippet into a first format code block;

Replacing the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after the escape;

The preset second format template is traversed through each of the escaped first format code blocks for matching, and the module name, title and fill code of the component code are extracted from the matched escaped first format code block and filled into the second format template to generate readable code.

Further, the module name, title and filler code of the component code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically:

Determine the proportion of various coding languages in the code base where the component code is stored, and record the coding language with the highest proportion as the code base language;

According to the rule of the code library language, a first keyword in the component code is identified, and a text corresponding to the first keyword is set as a module name of a code block;

According to the rule of the code library language, a second keyword is identified between the two adjacent first keywords, and a text corresponding to the second keyword is set as a title of the code block;

According to the rule of the code library language, a third keyword is identified between the adjacent second keywords, and the text between the two adjacent third keywords is set as the filling code of the code block.

Furthermore, the first format is Json format.

Furthermore, the second format is an integrated development environment format.

In a second aspect, the present invention further provides a low code fragment conversion device, comprising:

Information acquisition module, used to obtain complete component code and preset README template;

a content extraction module, for extracting a module name, a title and a filler code of a code block according to the first keyword, the second keyword and the third keyword in the complete component code, and combining the readme file template with the module name, the title and the filler code of the component code to generate a low-code snippet;

A format conversion module, configured to convert the low-code snippet into a first format code block if an update of the low-code snippet is monitored;

A parsing and conversion module, used for replacing the first keyword, the second keyword and the third keyword with a preset first escape character, a second escape character and a third escape character respectively, to obtain a first format code block after the escape;

A readable code generation module is used to traverse the preset second format template through each of the escaped first format code blocks for matching, extract the module name, title and filling code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code.

Furthermore, the content extraction module is used to extract the module name, title and filler code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, including:

A coding language determination unit, used to determine the proportion of various coding languages in the code library where the component code is stored, and record the coding language with the highest proportion as the code library language;

A module name determination unit, configured to identify a first keyword in the component code according to a rule of the code library language, and set a text corresponding to the first keyword as a module name of a code block;

a title determination unit, configured to identify a second keyword between the two adjacent first keywords according to a rule of the code library language, and set a text corresponding to the second keyword as a title of the code block;

The filling code determining unit is used to identify a third keyword between the adjacent second keywords according to the rule of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block.

Furthermore, the first format is Json format.

Furthermore, the second format is an integrated development environment format.

In a third aspect, the present invention further provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of any one of the low-code conversion methods in the first aspect.

In a fourth aspect, the present invention further provides a computer device comprising a memory and a processor, wherein the memory stores a computer program, and when the processor executes the computer program, it executes any one of the low-code conversion methods in the first aspect.

The beneficial effects of adopting the above technical solution are: by converting the low-code snippet format, fillable formatted code blocks are automatically generated according to semantics, reducing the cost of manual writing; and converting the low-code snippets into readable mode, improving the work efficiency of daily development, reducing the workload of importing code into the system, and improving office efficiency.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art are briefly introduced below.

FIG1 is a schematic diagram of a low-code snippet conversion method in one embodiment of the present application;

FIG2 is a schematic diagram of a low-code snippet conversion method in one embodiment of the present application;

FIG3 is a schematic diagram of Json format code generation in one embodiment of the present application;

FIG4 is a schematic diagram of IDE format code generation in one embodiment of the present application;

FIG5 is a schematic diagram of searching for code blocks in an IDE system in one embodiment of the present application;

FIG6 is a schematic diagram of a partial script of a conversion method in a low-code snippet in one embodiment of the present application;

FIG. 7 is a schematic diagram of a conversion device in a low-code fragment in an embodiment of the present application.

DETAILED DESCRIPTION

The following will combine the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention. In order to explain the present invention in more detail, the low-code conversion method, device, readable storage medium and equipment provided by the present invention are specifically described below in combination with the drawings.

Git is an open source distributed version control system developed based on the Linux kernel. It uses a distributed version library to make the release and communication of source code extremely convenient, and can handle various project version management effectively and quickly. Git includes workspace, staging area, warehouse area and remote warehouse. Among them, the workspace is where developers usually store project component codes; the staging area is used to temporarily store changes to project component codes and save the list of files to be submitted; the warehouse area is also called the version library, which is a safe place to store data and saves all versions of submitted data; the remote warehouse is generally a server that hosts the code and is used for remote data exchange.

An integrated development environment system, also known as an IDE system, integrates a variety of development tools and functions, can automatically manage code bases, help developers avoid common programming errors, and perform static code analysis and code refactoring to improve code quality. At the same time, the IDE system also supports multi-person collaborative development, such as multiple developer teams working together to develop projects and complete project components.

In the current software development process, R&D personnel need to copy and paste some commonly used code snippets for use. In addition, when the degree of modularization and componentization is high, developers need to read external application program interface documents when using each component, which reduces the development efficiency of R&D personnel.

In this regard, the present invention provides a low-code conversion method, which converts the complete component code uploaded by the R&D personnel into a low-code fragment that is easy to transmit, and then converts it into a unified first format code so that the code is readable on most platforms, and finally converts it into a second format code so that the component code can be directly applied in the integrated development environment system. The application of this method to a terminal device is used as an example for explanation, combined with the schematic diagram of the low-code conversion method shown in Figure 1 and the schematic diagram of the low-code conversion method flow shown in Figure 2.

The embodiment of the present application provides an application scenario of the low-code conversion method, which includes a terminal device provided in the embodiment, wherein the terminal device includes but is not limited to a smart phone and a computer device, wherein the computer device can be at least one of a desktop computer, a portable computer, a laptop computer, a mainframe computer, a tablet computer, etc. The user operates the terminal device to obtain a readable code, and the specific process is shown in the embodiment of the low-code conversion method.

Step S101: Obtain complete component code and a preset README file template.

Among them, the component can also be recorded as an object, which is a simple encapsulation of data and methods. The function of the component can be realized through the complete component code. The complete component code is generally the component code written by the developer. The complete component code is stored in the Git repository. Due to the different development platforms and writing formats used by developers, the complete component code stored in the Git repository exists in multiple coding languages and multiple coding formats.

The readme file is used as an auxiliary file provided to the user, which can assist the user in reading and using the component code of the Git repository. The readme file template refers to the description corresponding to each component in the readme file of the Git repository storing the component code.

Step S102: extract the module name, title and fill-in code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, and combine the preset self-reading file template with the module name, title and fill-in code of the component code to generate a low-code snippet.

The low-code snippet is different from the traditional component complete code, which uses visualization and less code to express the component at a faster speed. Through the preset self-reading file template, the complete component code content is screened, and the unnecessary content is discarded, leaving only the valid code block module name, title and filler code to form a low-code snippet.

Step S103: If the low-code snippet is monitored to be updated, convert the low-code snippet into a first format code block.

The first format is the Json format, which is a lightweight data exchange format that is easy to read and write, can exchange data between multiple coding languages, is easy to machine parse and generate, and has higher communication and readability. The specific conversion code can be found in Figure 3.

Step S104: replace the first keyword, the second keyword and the third keyword with a preset first escape character, a second escape character and a third escape character respectively to obtain a first format code block after escape.

Since the first format code block may contain keywords that are likely to cause objections, in order to avoid recognition errors during the conversion of the first format code block, the first keyword, the second keyword and the third keyword in the first format code block are replaced with the first escape character, the second escape character and the third escape character respectively.

Step S105: traverse the preset second format template to match each of the escaped first format code blocks, extract the module name, title and fill code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code.

Among them, the second format is the integrated development environment format, and is also a code format that can be recognized in the system environment where the component needs to run. The Git repository stores multiple escaped first format code blocks, and the preset second format template is matched with each escaped first format code block stored in the Git repository to find the escaped first format code block with corresponding information. The corresponding content is filled into the second format template to generate a readable code, and the readable code can be directly called in the integrated development environment. The complete filled code in the readable code can be called by searching for the corresponding keyword. Among them, the specific conversion code can be seen in Figure 4.

Furthermore, in step S102, the code block module name, code block title and code block filling code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically:

Step S201: determining the proportion of various coding languages in the code base where the component code is stored, and recording the coding language with the highest proportion as the code base language.

According to the proportion of coding languages in the Git repository where the complete component code is located, the coding language with the highest proportion is used as the code base language of the Git repository, and a specific coding language label is added.

Step S202: According to the rules of the code library language, identify the first keyword in the component code, and set the text corresponding to the first keyword as the module name of the code block.

The first keyword may be “###”, the first keyword is identified, and the text corresponding to the first keyword is set as the code block module name.

Step S203: According to the rule of the code library language, a second keyword is identified between the two adjacent first keywords, and a text corresponding to the second keyword is set as a code block title.

For example, the second keyword is “number+‘.”, which is a list number. By determining the second keyword, the text in the same line as the second keyword is matched as a code block title.

Step S204: according to the rule of the code library language, a third keyword is identified between the adjacent second keywords, and the text between the two adjacent third keywords is set as a code block filling code.

Among them, the third keyword is "`" or "(````)", and the text between the two third keywords is the filling code.

By identifying the above keywords, the corresponding code block module name, title and filling code in the complete component code can be obtained.

The above-mentioned low-code conversion method first extracts the module name, title and fill-in code of the necessary code block from the complete component code to form a low-code snippet; then converts the low-code snippet into a more general Json format code block, which is more convenient for the code block to perform data conversion in different coding languages; finally, according to the integrated development environment, the Json format code block is converted into an integrated development environment code block, that is, an IDE code block, so that developers can directly search for the module name in the integrated development environment to obtain the complete fill-in code part of the code block; it improves the development efficiency of R&D personnel, and also facilitates the large-scale copying and dissemination of code.

In order to more specifically illustrate the above-mentioned low-code conversion method, an example is given as follows in combination with the code in FIG. 5 and the effect diagram in FIG. 6:

The running environment of the low-code conversion method is a bastion host that deploys the Gitlab Runner environment. The bastion host includes but is not limited to computers with Windows, Linux, and MacOS systems.

Step S301: The deployment process of the operating environment is as follows:

Build the Docker runtime environment and start the Docker container;

Run the following command in the bastion machine terminal: docker run-itd-restart=always-privileged=true-name espod -p port1-p port2-p port3-p port4-v;

The bastion host maps the project directory to: project directory espod:1.0.0.

Step S302: Build the Gitlab Runner module on the bastion host, monitor the changes in commits in the Git repository project, and use the Gitlab Runner script to generate low-code snippets. The specific process is as follows:

Install the Gitlab Runner module on the bastion host, including the following 5 installation methods:

(1) curl -L - output custom path /gitlab-runner https://gitlab-runner-downloads,s3.amazonaws,com/latest/binaries/gitlab-runner-linux-amd64;

(2) chmod+x custom path/gitlab-runner;

(3)useradd-comment'Coder'-create-home;

(4)gitlab-runner-shell/bin/bash;

(5)gitlab-runner

install-user=gitlab-runner-working-directory=/home/gitlab-runner;

Start Gitlab-runner start;

Use the registration URL and registration token information in the gitlab CI settings to register to the bastion host;

Configure Gitlab Runner on the bastion machine and register the real-time update monitor of the Git repository. You can run the following command on the bastion machine terminal: gitlab-runner register-url register URL-registration-token register token;

After the listener is triggered, the low-code snippets of the custom template README file are converted into Json format code blocks, and the Json format code blocks are uploaded to the Git repository.

Step S303: Write a script, and after the developer pulls the formatted code repository, generate an IDE code block. See the code content in FIG. 3:

Parse the Json format code block and replace the escape characters in the code block;

Generate IDE code block template template.codesnippet, traverse all Json formatted code blocks, and fill the corresponding fields of IDE code block template with the escaped code blocks;

Obtain administrator privileges and copy the generated IDE code blocks to the Xcode Code Snippets directory.

By setting the above steps, you can find the corresponding IDE code block through the search function in the integrated development environment system and directly get its corresponding fill code. In order to further improve the visualization and search features in the low-code snippet calling process, you can also further set:

To create a Source Editor extension, create a new macOS project in Xcode and add a new Xcode Source Editor Extension target to the project.

Find the info file in the added extension directory and add item under XC-Source-Editor-Command-Definitions;

In the Source-Editor-Command file, read the IDE code block and display it in the GUI;

After developing and running the editor extension, search for the corresponding keywords and double-click the code block in the extension to automatically fill it at the cursor.

The above-mentioned low-code conversion method can improve the code writing efficiency of R&D personnel in the daily development process and reduce the workload of searching module codes and importing module codes.

It should be understood that, although the steps in the flowcharts of Figures 1-2 are shown in sequence according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and these steps can be executed in other orders. Moreover, at least a part of the steps in Figures 1-2 may include multiple sub-steps or sub-stages, and these sub-steps or stages are not necessarily executed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least a part of the sub-steps or stages of other steps.

The low-code fragment conversion method is described in detail in the embodiment disclosed in the above-mentioned invention. The above-mentioned method disclosed in the present invention can be implemented by various forms of equipment. Therefore, the present invention also discloses a low-code fragment conversion device corresponding to the above-mentioned method. Combined with Figure 7, a specific embodiment is given below for detailed description.

The information acquisition module 401 is used to acquire the complete component code and the preset README file template.

The content extraction module 402 is used to extract the module name, title and fill-in code of the code block according to the first keyword, the second keyword and the third keyword in the complete component code, and generate a low-code snippet by combining the self-description file template with the module name, title and fill-in code of the component code.

The format conversion module 403 is used to convert the low-code snippet into a first format code block if it is monitored that the low-code snippet is updated.

The parsing and conversion module 404 is used to replace the first keyword, the second keyword and the third keyword with a preset first escape character, a second escape character and a third escape character respectively to obtain a first format code block after escape.

The readable code generation module 405 is used to traverse the preset second format template to match each of the escaped first format code blocks, extract the module name, title and filling code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code.

Furthermore, the content extraction module 402 is used to extract the module name, title and filler code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, including:

The coding language determining unit 501 is used to determine the proportion of various coding languages in the code base where the component code is stored, and record the coding language with the highest proportion as the code base language.

The module name determination unit 502 is used to identify the first keyword in the component code according to the rule of the code library language, and set the text corresponding to the first keyword as the module name of the code block.

The title determination unit 503 is used to identify a second keyword between the two adjacent first keywords according to the rule of the code library language, and set the text corresponding to the second keyword as the title of the code block.

The filling code determining unit 504 is used to identify a third keyword between the adjacent second keywords according to the rule of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block.

For the low-code conversion device, please refer to the above definition of the method, which will not be repeated here. Each module in the above device can be implemented in whole or in part by software, hardware and a combination thereof. The above modules can be embedded in or independent of the processor of the terminal device in the form of hardware, or stored in the memory of the terminal device in the form of software, so that the processor can call and execute the operations corresponding to the above modules.

In one embodiment, the present invention also provides a computer-readable storage medium having a computer program stored thereon, and when the computer program is executed by a processor, the steps of the above-mentioned low-code conversion method are implemented.

The computer-readable storage medium may be an electronic memory such as a flash memory, an EEPROM (electrically erasable programmable read-only memory), an EPROM (erasable programmable read-only memory), a hard disk or a ROM. Optionally, the computer-readable storage medium includes a non-transitory computer-readable storage medium. The computer-readable storage medium has storage space for program codes for executing any method step in the above method. These program codes may be read from or written into one or more computer program products, and the program codes may be compressed in an appropriate form.

In one embodiment, the present invention provides a computer device including a memory and a processor, wherein the memory stores a computer program, and the processor performs the above-mentioned low-code conversion method when executing the computer program.

The computer device includes a memory, a processor, and one or more computer programs, wherein the one or more computer programs can be stored in the memory and configured to be executed by one or more processors, and the one or more applications are configured to execute the above-mentioned low-code conversion method.

The processor may include one or more processing cores. The processor uses various interfaces and lines to connect various parts of the entire computer device, and executes various functions of the computer device and processes data by running or executing instructions, programs, code sets or instruction sets stored in the memory, and calling data stored in the memory. Optionally, the processor can be implemented in at least one hardware form of digital signal processing (DSP), field programmable gate array (FPGA), and programmable logic array (PLA). The processor can integrate one or a combination of a central processing unit (CPU), a graphics processing unit (GPU), and a modem. Among them, the CPU mainly processes the operating system, user interface, and application programs; the GPU is responsible for rendering and drawing display content; and the modem is used to process wireless communications. It is understandable that the above-mentioned modem may not be integrated into the processor, but may be implemented separately through a communication chip.

The memory may include a random access memory (RAM) or a read-only memory (ROM). The memory may be used to store instructions, programs, codes, code sets or instruction sets. The memory may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for implementing at least one function (such as a touch function, a sound playback function, an image playback function, etc.), instructions for implementing the above-mentioned various method embodiments, etc. The data storage area may also store data created by the terminal device during use, etc.

The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit the same. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that the technical solutions described in the aforementioned embodiments may still be modified, or some of the technical features may be replaced by equivalents. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims (10)

A low code snippet conversion method, characterized by comprising: Get the complete component code and preset README template; Extracting a module name, a title, and a filler code of the component code according to the first keyword, the second keyword, and the third keyword in the complete component code, and combining the preset readme file template with the module name, the title, and the filler code of the component code to generate a low-code snippet; If the low code snippet is updated, convert the low code snippet into a first format code block; Replacing the first keyword, the second keyword, and the third keyword with a preset first escape character, a second escape character, and a third escape character, respectively, to obtain a first format code block after the escape; The preset second format template is traversed through each of the escaped first format code blocks for matching, and the module name, title and fill code of the component code are extracted from the matched escaped first format code block and filled into the second format template to generate readable code. The low-code conversion method according to claim 1 is characterized in that the module name, title and filler code of the component code are extracted according to the first keyword, the second keyword and the third keyword in the complete component code, specifically: Determine the proportion of various coding languages in the code base where the component code is stored, and record the coding language with the highest proportion as the code base language; According to the rule of the code library language, a first keyword in the component code is identified, and a text corresponding to the first keyword is set as a module name of a code block; According to the rule of the code library language, a second keyword is identified between the two adjacent first keywords, and a text corresponding to the second keyword is set as a title of the code block; According to the rule of the code library language, a third keyword is identified between the adjacent second keywords, and the text between the two adjacent third keywords is set as the filling code of the code block. The low-code conversion method as described in claim 1 is characterized in that the first format is Json format. The low-code conversion method as described in claim 1 is characterized in that the second format is an integrated development environment format. A low code snippet conversion device, characterized by comprising: Information acquisition module, used to obtain complete component code and preset README template; a content extraction module, for extracting a module name, a title and a filler code of a code block according to the first keyword, the second keyword and the third keyword in the complete component code, and combining the readme file template with the module name, the title and the filler code of the component code to generate a low-code snippet; A format conversion module, configured to convert the low-code snippet into a first format code block if an update of the low-code snippet is monitored; A parsing and conversion module, used for replacing the first keyword, the second keyword and the third keyword with a preset first escape character, a second escape character and a third escape character respectively, to obtain a first format code block after the escape; A readable code generation module is used to traverse the preset second format template through each of the escaped first format code blocks for matching, extract the module name, title and filling code of the component code from the matched escaped first format code block and fill them into the second format template to generate readable code. The low-code conversion module according to claim 5, characterized in that the content extraction module is used to extract the module name, title and filler code of the component code according to the first keyword, the second keyword and the third keyword in the complete component code, including: A coding language determination unit, used to determine the proportion of various coding languages in the code library where the component code is stored, and record the coding language with the highest proportion as the code library language; A module name determination unit, configured to identify a first keyword in the component code according to a rule of the code library language, and set a text corresponding to the first keyword as a module name of a code block; a title determination unit, configured to identify a second keyword between the two adjacent first keywords according to a rule of the code library language, and set a text corresponding to the second keyword as a title of the code block; The filling code determining unit is used to identify a third keyword between the adjacent second keywords according to the rule of the code library language, and set the text between the two adjacent third keywords as the filling code of the code block. The low-code conversion device as described in claim 5 is characterized in that the first format is Json format. The low-code conversion device as described in claim 5 is characterized in that the second format is an integrated development environment format. A computer-readable storage medium having a computer program stored thereon, characterized in that when the computer program is executed by a processor, the steps of any one of the low-code conversion methods of claims 1-4 are implemented. A computer device comprises a memory and a processor, wherein the memory stores a computer program, and wherein when the processor executes the computer program, it executes any one of the low-code conversion methods of claims 1-4.