Andrew French

1601004540

A Declarative static site generator using Deno and TypeScript

Degen

A Declarative static site generator using Deno and TypeScript

Version: Beta 1

Versions increment in whole numbers.
Degen will exit Beta probably around the time I finish my website.

Brief

Degen is a simple static site generator written in TypeScript and uses Deno as the runtime environment. Degen tries to find a good balance between KISS and being flexible/configurable.
The code is open source in case anyone might find it useful.

Motivation

I wanted to use a static site generator for creating my portfolio website. After looking and the available SSGs online, I decided to make my own. I created Degen out of pure curiosity, interest, and for the experience. I also wanted to build a project using the new and fresh Deno runtime.
Any changes to Degen while building my portfolio will be reflected here.

If you happen to find this, I recommend the using other static site generators:

  • Eleventy
  • Hugo
  • Gatsby
  • Jekyll
  • and other SSGs I have failed to mention

Using Degen

Dependencies

Degen has two dependencies:

  1. Deno + standard library
  2. Markdown-it (Likely to change if I find a Native Deno Module)

Execution

  1. Configure the degen.toml file to fit the structure of your project
    • e.g. change source_directory and export_path
  2. Run Degen
    • deno run --allow-read --allow-write --allow-env .\degen.ts

Currently, we need the flags --allow-read --allow-write --allow-env.

--allow-read & --allow-write: Read markdown, template, and other files and write out rendered HTML files.
--allow-env: This is used by Deno’s require() (Node-compatibility interface), which is needed to use markdown-it Node module.

Current Issues

  • Need to clean up Error creation
  • Update my tests
  • Add more tests
  • Resolve all TODOs
  • And many more issues on my Trello board

Download Details:

Author: Jakob-Strobl

Source Code: https://github.com/Jakob-Strobl/Degen

#deno #nodejs #node #javascript #typescript

What is GEEK

Buddha Community

A Declarative static site generator using Deno and TypeScript

Andrew French

1601004540

A Declarative static site generator using Deno and TypeScript

Degen

A Declarative static site generator using Deno and TypeScript

Version: Beta 1

Versions increment in whole numbers.
Degen will exit Beta probably around the time I finish my website.

Brief

Degen is a simple static site generator written in TypeScript and uses Deno as the runtime environment. Degen tries to find a good balance between KISS and being flexible/configurable.
The code is open source in case anyone might find it useful.

Motivation

I wanted to use a static site generator for creating my portfolio website. After looking and the available SSGs online, I decided to make my own. I created Degen out of pure curiosity, interest, and for the experience. I also wanted to build a project using the new and fresh Deno runtime.
Any changes to Degen while building my portfolio will be reflected here.

If you happen to find this, I recommend the using other static site generators:

  • Eleventy
  • Hugo
  • Gatsby
  • Jekyll
  • and other SSGs I have failed to mention

Using Degen

Dependencies

Degen has two dependencies:

  1. Deno + standard library
  2. Markdown-it (Likely to change if I find a Native Deno Module)

Execution

  1. Configure the degen.toml file to fit the structure of your project
    • e.g. change source_directory and export_path
  2. Run Degen
    • deno run --allow-read --allow-write --allow-env .\degen.ts

Currently, we need the flags --allow-read --allow-write --allow-env.

--allow-read & --allow-write: Read markdown, template, and other files and write out rendered HTML files.
--allow-env: This is used by Deno’s require() (Node-compatibility interface), which is needed to use markdown-it Node module.

Current Issues

  • Need to clean up Error creation
  • Update my tests
  • Add more tests
  • Resolve all TODOs
  • And many more issues on my Trello board

Download Details:

Author: Jakob-Strobl

Source Code: https://github.com/Jakob-Strobl/Degen

#deno #nodejs #node #javascript #typescript

Vincent Lab

Vincent Lab

1605177550

Building a Static Website with Hugo

#hugo #static #site #generator #markup #static site generator

Tyrique  Littel

Tyrique Littel

1604008800

Static Code Analysis: What It Is? How to Use It?

Static code analysis refers to the technique of approximating the runtime behavior of a program. In other words, it is the process of predicting the output of a program without actually executing it.

Lately, however, the term “Static Code Analysis” is more commonly used to refer to one of the applications of this technique rather than the technique itself — program comprehension — understanding the program and detecting issues in it (anything from syntax errors to type mismatches, performance hogs likely bugs, security loopholes, etc.). This is the usage we’d be referring to throughout this post.

“The refinement of techniques for the prompt discovery of error serves as well as any other as a hallmark of what we mean by science.”

  • J. Robert Oppenheimer

Outline

We cover a lot of ground in this post. The aim is to build an understanding of static code analysis and to equip you with the basic theory, and the right tools so that you can write analyzers on your own.

We start our journey with laying down the essential parts of the pipeline which a compiler follows to understand what a piece of code does. We learn where to tap points in this pipeline to plug in our analyzers and extract meaningful information. In the latter half, we get our feet wet, and write four such static analyzers, completely from scratch, in Python.

Note that although the ideas here are discussed in light of Python, static code analyzers across all programming languages are carved out along similar lines. We chose Python because of the availability of an easy to use ast module, and wide adoption of the language itself.

How does it all work?

Before a computer can finally “understand” and execute a piece of code, it goes through a series of complicated transformations:

static analysis workflow

As you can see in the diagram (go ahead, zoom it!), the static analyzers feed on the output of these stages. To be able to better understand the static analysis techniques, let’s look at each of these steps in some more detail:

Scanning

The first thing that a compiler does when trying to understand a piece of code is to break it down into smaller chunks, also known as tokens. Tokens are akin to what words are in a language.

A token might consist of either a single character, like (, or literals (like integers, strings, e.g., 7Bob, etc.), or reserved keywords of that language (e.g, def in Python). Characters which do not contribute towards the semantics of a program, like trailing whitespace, comments, etc. are often discarded by the scanner.

Python provides the tokenize module in its standard library to let you play around with tokens:

Python

1

import io

2

import tokenize

3

4

code = b"color = input('Enter your favourite color: ')"

5

6

for token in tokenize.tokenize(io.BytesIO(code).readline):

7

    print(token)

Python

1

TokenInfo(type=62 (ENCODING),  string='utf-8')

2

TokenInfo(type=1  (NAME),      string='color')

3

TokenInfo(type=54 (OP),        string='=')

4

TokenInfo(type=1  (NAME),      string='input')

5

TokenInfo(type=54 (OP),        string='(')

6

TokenInfo(type=3  (STRING),    string="'Enter your favourite color: '")

7

TokenInfo(type=54 (OP),        string=')')

8

TokenInfo(type=4  (NEWLINE),   string='')

9

TokenInfo(type=0  (ENDMARKER), string='')

(Note that for the sake of readability, I’ve omitted a few columns from the result above — metadata like starting index, ending index, a copy of the line on which a token occurs, etc.)

#code quality #code review #static analysis #static code analysis #code analysis #static analysis tools #code review tips #static code analyzer #static code analysis tool #static analyzer

Welde Tekle

Welde Tekle

1595884920

Static site generator built with TypeScript and Deno

Sitegeist Static site generator built with TypeScript and Deno

The ultimate goal for Sitegeist is for it to become a mature, simple, and customizable static site generator. Inspiration should come from existing generators like Jekyll, Middleman, and Hugo.

Most React-based generators like Gatsby and Next.js are too generic, requiring the developer to create components from scratch, whereas the classic structure of layouts and partials are usually good enough for static sites. Sitegeist should be a generator for people who want to create lightweight sites that don’t rely on Javascript and that can be developed very rapidly.

Templating

For now, the only supported templating engine is EJS. More will eventually follow.

Getting started

First, make sure you have Deno installed.

To build your site, input the following into your terminal:

deno run -A app.ts build

To build and then serve the site locally, use:

deno run -A app.ts develop

The site will be served at localhost:8000.

To clean the build, use:

deno run -A app.ts clean

Download Details:

Author: starboardcoop

GitHub: https://github.com/starboardcoop/sitegeist

#deno #nodejs #javascript #node-js #typescript

Houston  Sipes

Houston Sipes

1613635296

Building A Static Site Generator with Deno, TypeScript and Markdown

Easily Use TypeScript and Markdown with Deno to build a Static Site Generator

Building static web content is an absolute necessity. If you’ve been active in web development any time in the last 10 years, you’ve more than likely come across static-site generators like Jekyll or Gatsby. Even CMS systems like Wordpress perform quite a bit of static content generation.

Thanks to modern JavaScript, you don’t have to be a programming wizard to build fancy static-site generators. In fact, you can accomplish quite a lot with very little code. That’s what we are going to do in this blog post, and we are going to use an amazing new piece of technology called Deno.

Also, we will be using TypeScript, BUT WAIT! no prior TypeScript skills are required for this tutorial. If you’re comfortable with JavaScript you’ll be absolutely fine. In fact, you can use this to dip your feet in some TypeScript if you haven’t already.

#deno #markdown #javascript #typescript #web-development