finish build steps

Author: ZeroIntensity

.gitignore

@@ -26,3 +26,4 @@ a.md
 new_app/
 vgcore.*
 .vscode/
+*.test

README.md

@@ -3,25 +3,26 @@
 <div align="center"><h2>The Batteries-Detachable Web Framework</h2></div>
 
 > [!Warning]
-> view.py is in very early stages and not yet considered to be ready for production.
-> If you would like to follow development progress, join [the discord](https://discord.gg/tZAfuWAbm2).
-> For contributing to view.py, please see our [CONTRIBUTING.md](https://github.com/ZeroIntensity/view.py/blob/master/CONTRIBUTING.md)
+> view.py is currently in alpha, and may be lacking some features.
+> If you would like to follow development progress, be sure to join [the discord](https://discord.gg/tZAfuWAbm2).
 
 <div align="center">
     <a href="https://clientarea.space-hosting.net/aff.php?aff=303"><img width=150 height=auto src="https://cdn-dennd.nitrocdn.com/fygsTSpFNuiCdXWNTtgOTVMRlPWNnIZx/assets/images/optimized/rev-758b0f8/www.space-hosting.net/wp-content/uploads/2023/02/cropped-Icon.png"></a>
     <h3>view.py is affiliated with <a href="https://clientarea.space-hosting.net/aff.php?aff=303">Space Hosting</a></h3>
 </div>
 
-- [Docs](https://view.zintensity.dev)
-- [Source](https://github.com/ZeroIntensity/view.py)
-- [PyPI](https://pypi.org/project/view.py)
-- [Discord](https://discord.gg/tZAfuWAbm2)
+-   [Docs](https://view.zintensity.dev)
+-   [Source](https://github.com/ZeroIntensity/view.py)
+-   [PyPI](https://pypi.org/project/view.py)
+-   [Discord](https://discord.gg/tZAfuWAbm2)
 
 ## Features
 
-- Batteries Detachable: Don't like our approach to something? No problem! We aim to provide native support for all your favorite libraries, as well as provide APIs to let you reinvent the wheel as you wish.
-- Lightning Fast: Powered by [pyawaitable](https://github.com/ZeroIntensity/pyawaitable), view.py is the first web framework to implement ASGI in pure C, without the use of external transpilers.
-- Developer Oriented: view.py is developed with ease of use in mind, providing a rich documentation, docstrings, and type hints. 
+-   Batteries Detachable: Don't like our approach to something? No problem! We aim to provide native support for all your favorite libraries, as well as provide APIs to let you reinvent the wheel as you wish.
+-   Lightning Fast: Powered by [pyawaitable](https://github.com/ZeroIntensity/pyawaitable), view.py is the first web framework to implement ASGI in pure C, without the use of external transpilers.
+-   Developer Oriented: view.py is developed with ease of use in mind, providing a rich documentation, docstrings, and type hints.
+
+See [why I wrote it](https://view.zintensity.dev/#why-did-i-build-it) on the docs.
 
 ## Examples
 
@@ -62,20 +63,20 @@ def create(name: str, books: dict[str, str]):
 
 **Python 3.8+ is required.**
 
-### Development 
+### Development
 
-```
+```console
 $ pip install git+https://github.com/ZeroIntensity/view.py
 ```
 
-### Linux/macOS
+### PyPI
 
-```
-$ python3 -m pip install -U view.py
+```console
+$ pip install view.py
 ```
 
-### Windows
+### Pipx
 
-```
-> py -3 -m pip install -U view.py
+```console
+$ pipx install view.py
 ```

docs/building-projects/build_steps.md

@@ -120,6 +120,53 @@ requires = ["php"]
 command = "php -f payment.php"
 ```
 
+## Platform-Dependent Steps
+
+Many commands are different based on the platform used. For example, to read from a file on the Windows shell would be `type`, while on Linux and Mac it would be `cat`. If you add multiple step entries (in the form of an [array of tables](https://toml.io/en/v1.0.0-rc.2#array-of-tables)) with `platform` values, view.py will run the entry based on the platform the app was run on.
+
+For example, using the file reading example from above:
+
+Notice the double brackets next to `[[build.steps.read_from_file]]`, specifying an array of tables.
+
+```toml
+# view.toml
+
+[[build.steps.read_from_file]]
+platform = ["mac", "linux"]
+command = "cat whatever.txt"
+
+[[build.steps.read_from_file]]
+platform = "windows"
+command = "type whatever.txt"
+```
+
+The `platform` value can be one of three things per entry:
+
+-   A list of platforms.
+-   A string containing a single platform.
+-   `None`, meaning to use this entry if no other platforms match.
+
+For example, with a `None` platform set (on multiple entries), the above could be rewritten as:
+
+```toml
+# view.toml
+
+[[build.steps.read_from_file]]
+# Windows ONLY runs this step
+platform = "windows"
+command = "type whatever.txt"
+
+[[build.steps.read_from_file]]
+# All other platforms run this!
+command = "cat whatever.txt"
+```
+
+Note that only one step entry can have a `None` platform value, otherwise view.py will throw an error.
+
+!!! note
+
+    The only recognized operating systems for `platform` are the big three: Windows, Mac, and any Linux based system. If you want more fine-grained control (for example, using `pacman` or `apt` depending on the Linux distro), use a custom build script that knows how to read the Linux distribution.
+
 ## Build Requirements
 
 As you've seen above, build requirements are specified via the `requires` value. Out of the box, view.py supports a number of different build tools, compilers, and interpreters. To specify a requirement for one, simply add the name of their executable (_i.e._, how you access their CLI). For example, since `pip` is accessed via using the `pip` command in your terminal, `pip` is the name of the requirement.
@@ -165,7 +212,7 @@ async def __view_requirement__() -> bool:
 
 The above could actually be used via both `script+check_310.py` and `mod+check_310`.
 
-!!! tip
+!!! note
 
     Don't use the view.py build system to check the Python version or if a Python package is installed. Instead, use the `dependencies` section of a `pyproject.toml` file, or [PEP 723](https://peps.python.org/pep-0723/) script metadata.
 

docs/building-projects/request_data.md

@@ -6,18 +6,17 @@ If you've used a framework like [Django](https://djangoproject.com) or [FastAPI]
 
 The `Context` instance contains information about the incoming request, including:
 
-- The headers.
-- The cookies.
-- The HTTP version.
-- The request method.
-- The URL path.
-- The client and server address.
+-   The headers.
+-   The cookies.
+-   The HTTP version.
+-   The request method.
+-   The URL path.
+-   The client and server address.
 
 !!! info
 
     `Context` is an [extension type](https://docs.python.org/3/extending/newtypes_tutorial.html), and is defined in the `_view` module. It's Python signatures are defined in the `_view` type stub.
 
-
 ## Context Input
 
 The context can be added to a route via a route input, which is done through the `context` decorator. Note that `context` has a standard and direct variation (`App.context` is available to prevent imports).
@@ -76,7 +75,7 @@ app.run()
 
 !!! info
 
-    `App.test` is a more internal detail, but is available to use publically. It looks like this:
+    `App.test` is a more internal detail, but is available for public use. It looks like this:
 
     ```py
     from view import new_app
@@ -175,11 +174,11 @@ app.run()
 
 `Context` contains eight attributes:
 
-- `headers`, of type `dict[str, str]`.
-- `cookies`, of type `dict[str, str]`.
-- `client`, of type `ipaddress.IPv4Address`, `ipaddress.IPv6Address`, or `None`.
-- `server`, of type `ipaddress.IPv4Address`, `ipaddress.IPv6Address`, or `None`.
-- `method`, of type `StrMethodASGI` (uppercase string containing the method, such as `"GET"`).
-- `path`, of type `str`.
-- `scheme`, which can be the string `"http"`, `"https"`.
-- `http_version`, which can be the string `"1.0"`, `"1.1"`, `"2.0"`, `"view_test"`.
+-   `headers`, of type `dict[str, str]`.
+-   `cookies`, of type `dict[str, str]`.
+-   `client`, of type `ipaddress.IPv4Address`, `ipaddress.IPv6Address`, or `None`.
+-   `server`, of type `ipaddress.IPv4Address`, `ipaddress.IPv6Address`, or `None`.
+-   `method`, of type `StrMethodASGI` (uppercase string containing the method, such as `"GET"`).
+-   `path`, of type `str`.
+-   `scheme`, which can be the string `"http"`, `"https"`.
+-   `http_version`, which can be the string `"1.0"`, `"1.1"`, `"2.0"`, `"view_test"`.

docs/contributing.md

@@ -0,0 +1,6 @@
+---
+hide:
+    - navigation
+---
+
+--8<-- "CONTRIBUTING.md"

docs/index.md

@@ -11,54 +11,119 @@ Here, you can learn how to use view.py and its various features.
 -   [PyPI](https://pypi.org/project/view.py)
 -   [Discord](https://discord.gg/tZAfuWAbm2)
 
-!!! warning
+## Showcase
 
-    view.py is in very early stages and not yet considered to be ready for production.
-    If you would like to follow development progress, join [the discord](https://discord.gg/tZAfuWAbm2).
-    For contributing to view.py, please see our [contributors file](https://github.com/ZeroIntensity/view.py/blob/master/CONTRIBUTING.md)
+```py
+from view import new_app
 
-## Quickstart
+app = new_app()
 
-Install view.py:
+@app.get("/")
+async def index():
+    return await app.template("index.html", engine="jinja")
 
-```
-$ pip install -U view.py
+app.run()
 ```
 
-Initialize your project:
+```py
+# routes/index.py
+from view import get, HTML
 
+# Build TypeScript Frontend
+@get(steps=["typescript"], cache_rate=1000)
+async def index():
+    return await HTML.from_file("dist/index.html")
 ```
-$ view init
+
+```py
+from dataclasses import dataclass
+from view import body, post
+
+@dataclass
+class User:
+    name: str
+    password: str
+
+@post("/signup")
+@body("data", User)
+def create(data: User):
+    # Use database of your choice...
+    return JSON({"message": "Successfully created your account."}), 201
 ```
 
-**Note:** If this yields unexpected results, you may need to use `py -m view init` instead.
+```py
+from view import new_app, Context, Error, JSON
+
+app = new_app()
+
+@app.get("/")
+@app.context
+async def index(ctx: Context):
+    auth = ctx.headers.get("Authorization")
+    if not auth:
+        raise Error(400)
+
+    return JSON({"data": "..."})
 
-Write your first app:
+app.run()
+```
 
 ```py
 from view import new_app
 
 app = new_app()
 
-@app.query("greeting", str, default="hello")
-@app.query("name", str, default="world")
-@app.get("/")
-async def index(greeting: str, name: str):
-    return f"{greeting}, {name}!"
+@app.post("/login")
+@app.query("username", doc="Username for your account.")
+@app.query("password", doc="Password for your account.")
+async def index():
+    """Log in to your account."""
+    ...
 
 app.run()
 ```
 
-## Why View?
+```html
+<view if="user.type == 'admin'">
+    <view template="admin_panel" />
+</view>
+<view elif="user.type == 'moderator'">
+    <view template="mod_panel" />
+</view>
+<view else>
+    <p>You must be logged in.</p>
+</view>
+```
+
+```toml
+# view.toml
+[build]
+default_steps = ["nextjs"]
+# Only NextJS will be built on startup
+
+[build.steps.nextjs]
+requires = ["npm"]
+command = "npm run build"
+
+[build.steps.php]
+requires = ["php"]
+command = "php -f payment.php"
+```
+
+## Why did I build it?
+
+!!! warning
+
+    This section may seem boring to some. If you don't like reading, skip to the next page.
 
-As of now, view.py is still in alpha. Lot's of development progress is being made, but a production-ready stable release is still a bit far off. With that being said, anything mentioned in this documentation has been deemed already stable. In that case, why choose view.py over other frameworks?
+This is a question I get a lot when it comes to view.py. I originally got the idea for view.py back in 2021, but it was planned to be a library for _only_ designing UI's in Python (hence the name "view"), since the only way you could do it at the time was pretty much just merging HTML and Python using [Jinja](https://jinja.palletsprojects.com/en/3.1.x/), or some other flavor of template engine. Don't get me wrong, Jinja is a great template engine, but it feels a bit lacking once you've tried [JSX](https://react.dev/learn/writing-markup-with-jsx) in one of the large JavaScript frameworks.
 
-If you've used a framework like [Django](https://djangoproject.com), you're likely already familiar with the "batteries included" idea, meaning that it comes with everything you could need right out of the box. View takes a different approach: batteries-detachable. It aims to provide you everything you need, but gives you a choice to use it or not, as well as actively supporting external libraries. This ideology is what makes View special. In batteries detachable, you can use whatever you like right out of the box, but if you don't like View's approach to something or like another library instead, you may easily use it.
+A year later, in 2022, I enrolled in a coding class at my school, which was basically a course for the basics of Python. For most Python developers, including me, it would have felt like sitting down and going over your ABC's. Long story short, my teacher let me do some sort of project instead of the actual class (this was in 8th grade, mind you).
 
-## Should I use it?
+At the time, my [pointers.py](https://github.com/ZeroIntensity/pointers.py) library had gained a lot of traction on GitHub, which was quite cool to me, but I felt like I didn't make any real world contributions (it is a joke library, anyway). I wanted to contribute something to the world, and since I was being allocated school time during the week to work on a project of my choice, I decided that a full web framework was what I wanted to do.
 
-For a big project, **not yet**, as View is not currently ideal for working with a big codebase. However, **that doesn't mean you should forget about it**. view.py will soon be stable and production ready, and you should keep it in mind. To support view.py's development, you can either [sponsor me](https://github.com/sponsors/ZeroIntensity) or [star the project](https://github.com/zerointensity/view.py/stargazers).
+In my eyes, Python's web ecosystem was nowhere near that of JavaScript's. I had grown particularly fond of [NextJS](https://nextjs.org/), which served as an inspiration for a lot of view.py's features. To this day, [FastAPI](https://fastapi.tiangolo.com/) remains as my favorite Python web framework, apart from View. In fact, if you don't like view.py, I highly recommend trying it. Anyways, at the time, FastAPI was somewhat lacking when it comes to batteries-included parts, compared to [Django](https://www.djangoproject.com/), at least.
 
-## Developing View
+Now, this opinion is a bit controversial, but I really don't like Django's approach to a lot of things (such as it's way of routing), as well as the massive boilerplate that comes with Django projects. It just doesn't feel [pythonic](https://ifunny.co/picture/other-programmers-python-programmer-that-s-not-the-most-pythonic-EUE0IBzz8) to me. Although, what I do admire about Django (and probably why so many people like it), is it's batteries-included philosophy. So, I wanted to develop a web framework with the speed and elegancy of FastAPI, with the sheer robust-ness of Django. view.py is the result of that idea.
 
-As stated earlier, view.py is very new and not yet at a stable 1.0.0 release. Whether you're completely new to GitHub contribution or an experienced developer, view.py has something you could help out with. If you're interested in contributing or helping out with anything, be sure to read [the contributors file](https://github.com/ZeroIntensity/view.py/blob/master/CONTRIBUTING.md) and/or joining the [discord](https://discord.gg/tZAfuWAbm2).
+Note that I don't want to replace Django or FastAPI. In fact, if you're already familiar with one of those, learning view.py might not be a good idea! However, I would like to fill the gap that you might feel when using a Python framework after coming from JavaScript. Nowadays, JavaScript web frameworks get rewritten every year (for example, Next's move from `pages` to the `app` router), and are filled with big companies fighting each other to "be the best." In my eyes, development in all fields, especially open source, should be _collaborative_, not competitive, and I'm glad that Python has stayed true to that, but the gap in web development is visible.