luke-lang

luke

luke as an abstract, extendable programming language and platform that allows custom syntax for domain specific solutions.

Important: The luke project is in early stage and under development. It's not yet production ready. If you'd like to contribute to the code or the module ecosystem, feel free to open a PR.

Table of contents

• Resources
• Examples
• Install
• Usage
• Language
• Custom syntax
• License

Resources

Resource	Description
Luke Website	Official website of the luke project
Luke Module Catalog	Complete collection and documentation of luke modules
Luke on npm	Official npm package
Luke on GitHub	Official luke core repo

Examples

Code

print "Starting luke program";

Modules

// 1. Use a module (local or remote)
 
use rest.luke.js;
use https://domain.com/rest.luke.js;
 
// 3. Use module-specific code
 
ns rest; // (set the module namespace)
POST {name "Hello"} to https://api.com/resource

Install

luke runs on JavaScript Engines and can be used on Node, Browsers and via it's CLI.

CLI

$ npm i luke --global

npm module

npm i luke --save

Browser

<script src="luke.js">

Usage

After you have installed luke via npm, you can use it in your terminal as an interactive CLI or run your luke script files

Interactive Shell

$ luke
$ print "Hello World!"
"Hello World"

You can also include existing luke files into your interactive shell:

$ luke include main.luke

Run a File

// hello.luke
print "I am a luke file"

$ luke run hello.luke
"I am a luke file"

Embedded (JavaScript)

luke scripts can also be run inside JavaScript:

// For Node.js
const luke = require('luke-lang');
 
// For browsers:
<script src="luke.js"/>

luke.parse('print "Hello, I am embedded"')

Language

The luke language aims to provide simple language to build solutions that are taylored for different domains and problems.

The main concepts of luke are:

• Simple language design, understandable for developers and non-developers
• Custom syntax creation
• Open and free platform for syntax modules

Check out the Modules

Default module

luke comes with a built-in default module, which is initalized by default. The default module contains some basic functionalities.

Some code examples from the default module:

Code	Description
print "I'm a luke program"	Print something
var color blue	Set a variable
print color	Print variable content
download https://....com	Download a file
list modules	List all used modules
list commands	List all commands from available modules

Full reference

Syntax from the default namespace will automatically be available in any other module-specific namespace.

Custom syntax, modules

The luke language is a platform for different syntax. Each syntax ist delivered using a module. Basically any module syntax can be different, however they are all aimed at simplicity.

Create a syntax

Building your own custom syntax is fairly simple. It's defined using a JavaScript Object with a common structure.

lang = {
  $: {
    mymodule: { // your namespace name
      echo: {
        follow: ["{param}", "$and"],
        method: function(ctx, param){
          console.log(param)
        }
      },
      and: {
        follow: ["{param}", "$and"],
        method: function(ctx, param){
          console.log(param)
        }
      }
    }
  }
}
module.exports = lang;

The required keys and fields in your syntax definition are:

Key	Description	Example
lang.$.NAMESPACE	The name of your moudle/namespace	example
lang.$.NAMESPACE.TOKEN	Custom tokens	echo
lang.$.NAMESPACE.TOKEN.follow	A list of possible tokens that can follow.	["{param}", "$and"]
lang.$.NAMESPACE.TOKEN.method	The function to be executed, when that token ist parsed	function(param){console.log(param)}

Follow tokens can be defined as follows:

Follow token	Description
$and	Corresponds to the exact token without the leading dollar sign.
{param}	A custom input of any type. This will be available as single parameter in your method: method: function(param){}
{param1,param2}	Multiple custom inputs followed by another. These will be available as object parameter: method: function(obj){//obj.param1, obj.param2}

Define your available tokens as keys under the "$" object. Each key has an attached method, which will be executed, when that token is parsed and an array follow, which defines, which tokens can follow the current token.

Following tokens

Following tokens can either be wildcards for user input ({param}) or another token, specified with a leading "$" (e.g. $and).

These instructions let you create token chains and build your own syntax.

 
|-------------- Statement ------------|
 
  echo    "Peter"   and  "Nicole"   ;
 
   ^        ^        ^      ^       ^
command  command  command command delimeter;
 
 $.echo  {param}   $.and  {param}
 

Publish syntax as module

Your custom syntax modules can be contributed to the official luke module repo.

Learn more: Luke Module Repo

License

luke is open source and released under the MIT License.

See the license