From 3c9d959ee083854d8a42de415ff4173dfcbdc70c Mon Sep 17 00:00:00 2001
From: Michael Aaron Murphy <mmstickman@gmail.com>
Date: Tue, 8 Aug 2017 20:59:44 -0400
Subject: [PATCH] Implement String Namespace Plugins Support
The current API is subject to change, however, as the current feature set is a bit limited.
However, you can test out the existing support by installing the new git plugin, which is
recorded at the bottom of the newly-updated README.
---
Cargo.lock | 22 +
Cargo.toml | 2 +
README.md | 649 +++-----------------------
src/main.rs | 1 +
src/shell/plugins/library_iter/mod.rs | 44 ++
src/shell/plugins/mod.rs | 27 ++
src/shell/plugins/namespaces/mod.rs | 9 +
src/shell/plugins/namespaces/redox.rs | 50 ++
src/shell/plugins/namespaces/unix.rs | 162 +++++++
src/shell/variables.rs | 44 +-
10 files changed, 406 insertions(+), 604 deletions(-)
create mode 100644 src/shell/plugins/library_iter/mod.rs
create mode 100644 src/shell/plugins/mod.rs
create mode 100644 src/shell/plugins/namespaces/mod.rs
create mode 100644 src/shell/plugins/namespaces/redox.rs
create mode 100644 src/shell/plugins/namespaces/unix.rs
diff --git a/Cargo.lock b/Cargo.lock
index c137b074..44a2091f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,6 +10,7 @@ dependencies = [
"glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.29 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libloading 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"liner 0.4.0 (git+https://github.com/MovingtoMars/liner/)",
"nix 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
"permutate 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -81,6 +82,15 @@ name = "glob"
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "lazy_static"
version = "0.2.8"
@@ -91,6 +101,16 @@ name = "libc"
version = "0.2.29"
source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
+name = "libloading"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
[[package]]
name = "liner"
version = "0.4.0"
@@ -283,8 +303,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
"checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
"checksum fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6cc484842f1e2884faf56f529f960cc12ad8c71ce96cc7abba0a067c98fee344"
"checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb"
+"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
"checksum lazy_static 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "3b37545ab726dd833ec6420aaba8231c5b320814b9029ad585555d2a03e94fbf"
"checksum libc 0.2.29 (registry+https://github.com/rust-lang/crates.io-index)" = "8a014d9226c2cc402676fbe9ea2e15dd5222cd1dd57f576b5b283178c944a264"
+"checksum libloading 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "be99f814beb3e9503a786a592c909692bb6d4fc5a695f6ed7987223acfbd5194"
"checksum liner 0.4.0 (git+https://github.com/MovingtoMars/liner/)" = "<none>"
"checksum memchr 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1dbccc0e46f1ea47b9f17e6d67c5a96bd27030519c519c9c91327e31275a47b4"
"checksum nix 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "47e49f6982987135c5e9620ab317623e723bd06738fd85377e8d55f57c8b6487"
diff --git a/Cargo.toml b/Cargo.toml
index 3c7137d9..90a80035 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -62,6 +62,8 @@ libc = "0.2"
nix = "0.8"
# Obtains user directories
users = "0.5.1"
+# Enables loading plugins
+libloading = "0.4"
[build-dependencies]
ansi_term = "0.9"
diff --git a/README.md b/README.md
index 3fc36a5f..8db566aa 100644
--- a/README.md
+++ b/README.md
@@ -5,6 +5,59 @@
[](https://crates.io/crates/ion-shell)
+# New Ion MdBook
+
+See the **manual** directory contained within the repository. Navigating to that directory and executing `mdbook build` will build HTML documentation for Ion.
+Obtain mdbook [here](https://github.com/azerupi/mdBook).
+
+# Introduction
+
+Ion is a modern system shell that features a simple, yet powerful, syntax. It is written entirely
+in Rust, which greatly increases the overall quality and security of the shell, eliminating the
+possibilities of a [ShellShock](http://www.wikiwand.com/en/Shellshock_(software_bug))-like vulnerability, and making development easier. It also
+offers a level of performance that exceeds that of Dash, when taking advantage of Ion's features.
+While it is developed alongside, and primarily for, RedoxOS, it is a fully capable on other *nix
+platforms, and we are currently searching for a Windows developer to port it to Windows.
+
+# Goals
+
+Syntax and feature decisions for Ion are made based upon three measurements: is the feature useful,
+is it simple to use, and will it's implementation be efficient to parse and execute? A feature is
+considered useful if there's a valid use case for it, in the concept of a shell language. The
+syntax for the feature should be simple for a human to read and write, with extra emphasis on
+readability, given that most time is spent reading scripts than writing them. The implementation
+should require minimal to zero heap allocations, and be implemented in a manner that requires
+minimal CPU cycles (so long as it's also fully documented and easy to maintain!).
+
+It should also be taken into consideration that shells operate entirely upon strings, and therefore
+should be fully equipped for all manner of string manipulation capabilities. That means that users
+of a shell should not immediately need to grasp for tools like **cut**, **sed**, and **awk**. Ion
+offers a great deal of control over slicing and manipulating text. Arrays are treated as first
+class variables with their own unique **@** sigil. Strings are also treated as first class
+variables with their own unique **$** sigil. Both support being sliced with **[range]**, and they
+each have their own supply of methods.
+
+# Why Not POSIX?
+
+If Ion had to follow POSIX specifications, it wouldn't be half the shell that it is today, and
+there'd be no solid reason to use Ion over any other existing shell, given that it'd basically be
+the same as every other POSIX shell. Redox OS itself doesn't follow POSIX specifications, and
+neither does it require a POSIX shell for developing Redox's userspace. It's therefore not meant
+to be used as a drop-in replacement for Dash or Bash. You should retain Dash/Bash on your system
+for execution of Dash/Bash scripts, but you're free to write new scripts for Ion, or use Ion as
+the interactive shell for your user session. Redox OS, for example, also contains Dash for
+compatibility with software that depends on POSIX scripts.
+
+That said, Ion's foundations are heavily inspired by POSIX shell syntax. If you have experience
+with POSIX shells, then you already have a good idea of how most of Ion's core features operate. A
+quick sprint through this documentation will bring you up to speed on the differences between our
+shell and POSIX shells. Namely, we carry a lot of the same operators: **$**, **|**, **||**, **&**,
+**&&**, **>**, **<**, **<<**, **<<<**, **$()**, **$(())**. Yet we also offer some functionality
+of our own, such as **@**, **@()**, **$method()**, **@method()**, **^|**, **^>**, **&>**, **&|**.
+Essentially, we have taken the best components of the POSIX shell specifications, removed the bad
+parts, and implemented even better features on top of the best parts. That's how open source
+software evolves: iterate, deploy, study, repeat.
+
# Compile / Install Instructions
Rust 1.19 is the minimum requirement for compiling Ion. Simplest way to obtain Rust/Cargo is by
@@ -35,598 +88,20 @@ cd ion
cargo build --release
```
-# New Ion MdBook
-
-See the **manual** directory contained within the repository. Navigating to that directory and executing `mdbook build` will build HTML documentation for Ion.
-Obtain mdbook [here](https://github.com/azerupi/mdBook).
-
-# Summary
-
-**NOTE:** The following content will eventually be removed as we are now developing an mdBook for Ion.
-
-Ion is a modern system shell that is written entirely in Rust, features a simple (and powerful) syntax, and offers performance that exceeds the level of Dash. While it is developed alongside RedoxOS as the default shell for RedoxOS, it is equally supported on UNIX platforms (Linux/Mac/BSDs), on which it is developed and tested. Windows support could also easily be obtained, but we currently do not have any developers that use Windows. Ion's design is influenced by many other successful shells, which can be seen in its borrowing of ideas from Bash, Fish, and Oil; whilst also offering some unique ideas of its own. It is still a work in progress, but most of the core functionality is complete. It is also currently significantly faster than Dash, even though it contains many more features and abilities, making it the fastest system shell to date. Finally, as it is written in Rust, we can guarantee that our codebase offers a high degree of memory safety compared to Bash, Dash, Zsh, Fish and other shells that are written in unsafe languages. That means no chance for a shellshock-like vulnerability to arise.
-
-# Ion's Goals
-
-Syntax and feature decisions for Ion are made based upon three specific measurements: *"is the feature useful, is it simple to use, and will its implementation be efficient to parse and execute?"*. The language should be efficient to parse, with zero room for ambiguities, and implemented in a zero-cost manner as much as possible. In addition, we believe that as a shell is effectively a string-based language, the shell should also have first-class string manipulation capabilities, in order to eliminate the need for external utilities. The `awk` command should not be required as often when writing Ion scripts, as many basic uses of it are incorporated into Ion's syntax in a manner that is simple to use and learn.
-
-## Ion Is Not POSIX
-
-While Ion's foundations are heavily influenced by POSIX shell syntax, it does offer some critical features and differentiations that you won't find in a POSIX shell. The similarities only exist because POSIX syntax already had some good ideas, but it also came with a number of bad design decisions that have lead to inflexibility, and so we have taken the good ideas and implemented even better ideas on top of them, and as a replacement to the bad parts. Hence, while syntax may look familiar, it is not, nor will it ever be, compliant with POSIX.
-
-In example, we have carried a lot of the same basic features such as strings (**$string**) and process expansions that return strings (**$(command args...)***), but we have also implemented support for first class arrays (**@array**) and array-based process expansions (**@(command args..)**), rather than compounding the string variables, and utilize the distinction between the two types to implement methods (**$join(array)**, **@split(string)**) and slicing (**$string[..5]**, **@array[..5]**). In addition, we implement better syntax for redirecting/piping stderr (**^>**, **^|**), and both stderr/stdout (**&>**, **&|**); as well as dropping the **do** keyword, and using the **end** keyword to end a block.
-
-# Features
-
-Below is an overview of features that Ion has either already implemented, or aims to implement in the future. If you have ideas for features that you would like to see on this list, then you are welcome to open an issue to describe the feature and what you would like to use it for / why you think it's useful.
-
-- [x] Expansions
- - [x] String Expansions
- - [x] Array Expansions
- - [x] Glob Expansions
- - [x] Brace Expansions
- - [x] Ranges
- - [x] Permutations
- - [x] Nested Braces
- - [x] Process Expansions
- - [x] String-based Command Substitution (**$()**)
- - [x] Array-based Command Substitution (**@()**)
- - [x] Arithmetic Expansions
-- [x] Flow Control
- - [x] For Loops
- - [ ] Foreach Loops
- - [x] While Loops
- - [x] If Conditionals
- - [x] Match Statements
-- [x] Functions
- - [x] Optionally-typed Function Parameters
-- [x] Script Execution
- - [x] Handling arguments w/ @args Array
-- [x] Mutables
- - [x] Aliases
- - [x] Strings (**$variable**)
- - [x] Multiple Variable Assignments
- - [ ] Optionally-typed Variable Assignments
- - [x] Grapheme-based String Slicing
- - [x] String Methods (**$join(array, ', ')**)
- - [x] **$join(array)**
- - [x] **$len(string)**
- - [x] **$len_bytes(string)**
- - [x] Arrays (**@array**)
- - [x] Array Expressions (**[]**)
- - [x] Array Slicing
- - [x] Array Methods (**@split(var, ' ')**)
- - [x] **@split(string)**
- - [x] **@len(array)**
- - [ ] HashMaps
-- [x] Line Editor (Provided by [Liner](https://github.com/MovingtoMars/liner))
- - [x] Multiline Comments and Commands
- - [ ] Multi-line Editing
- - [x] Tab Completion
- - [x] Auto-suggestions
- - [x] History suggestions
- - [x] vi and emacs keybindings (`set -o (vi|emacs)`)
- - [ ] Syntax Highlighting
-- [x] Implicit cd
-- [x] Signal Handling
-- [x] **&&** and **||** Conditionals
-- [x] Redirecting Stdout / Stderr
-- [x] Redirecting Stdout & Stderr
-- [x] Piping Builtins
-- [x] Background Jobs
-- [ ] Piping Functions
-- [ ] Redirecting Functions
-- [x] Background Job Control
-- [ ] XDG App Dirs
-- [ ] Plugins Support
- - [ ] Builtins
- - [ ] Prompt
- - [ ] Syntax
-
-## Shell Syntax
-
-### Implicit Directory Changing
-
-Like the [Friendly Interactive Shell](https://fishshell.com/), Ion also supports implicitly executing the cd command when given
-a path, so long as that path begins with either `.`/`/`/`~`, or ends with a `/`. This will thereby invoke
-the internal built-in cd command with that path as the argument.
-
-```ion
-~/Documents # cd ~/Documents
-.. # cd ..
-.config # cd .config
-examples/ # cd examples/
-```
-
-### Job Control
-
-#### Disowning Processes
-
-Ion features a `disown` command which supports the following flags:
-
-- **-r**: Remove all running jobs from the background process list.
-- **-h**: Specifies that each job supplied will not receive the `SIGHUP` signal when the shell receives a `SIGHUP`.
-- **-a**: If no job IDs were supplied, remove all jobs from the background process list.
-
-Unlike Bash, job arguments are their specified job IDs.
-
-#### Foreground & Background Tasks
-
-This area is still a work in progress. When a foreground task is stopped with the **Ctrl+Z** signal, that process will
-be added to the background process list as a stopped job. When a supplied command ends with the **&** operator, this
-will specify to run the task the background as a running job. To resume a stopped job, executing the `bg <job_id>`
-command will send a `SIGCONT` to the specified job ID, hence resuming the job. The `fg` command will similarly do the
-same, but also set that task as the foreground process.
-
-#### Exiting the Shell
-
-The `exit` command will exit the shell, sending a `SIGTERM` to any background tasks that are still active.
-
-#### Suspending the Shell
-
-While the shell ignores `SIGTSTP` signals, you can forcefully suspend the shell by executing the `suspend` command,
-which forcefully stops the shell via a `SIGSTOP` signal.
-
-### Defining Variables
-
-The `let` keyword is utilized to create local variables within the shell. The `export` keyword performs
-a similar action, only setting the variable globally as an environment variable for the operating system.
-
-```ion
-let git_branch = $(git rev-parse --abbrev-ref HEAD ^> /dev/null)
-```
-
-It is also possible to assign multiple variables at once, or swap variables.
-
-```ion
-let a b = 1 2
-let a b = [1 2]
-let a b = [$b $a]
-```
-
-If the command is executed without any arguments, it will simply list all available variables.
-
-### Using Variables
-
-Variables may be called with the **$** sigil, where the value that follows may be a local or global value.
-They may also be optionally defined using a braced syntax, which is useful in the event that you need the value
-integrated alongside other characters that do not terminate the variable parsing.
-
-```ion
-let A = one
-let B = two
-echo $A:$B
-echo ${A}s and ${B}s
-```
-
-### Substrings from Variables
-
-Ion natively supports splitting supplied strings by graphemes using the same slicing syntax for arrays:
-
-```ion
-$ let string = "one two three"
-$ echo $string[0]
-o
-$ echo $string[..3]
-one
-$ echo $string[4..7]
-two
-$ echo $string[8..]
-three
-```
-
-### Dropping Variables
-
-To drop a value from the shell, the `drop` keyword may be used:
-
-```ion
-drop git_branch
-```
-
-### Variable Arithmetic
-
-The `let` command also supports basic arithmetic.
-
-```ion
-let a = 1
-echo $a
-let a += 4
-echo $a
-let a *= 10
-echo $a
-let a /= 2
-echo $a
-let a -= 5
-echo $a
-```
-
-### Export
-
-The `export` command works similarly to the `let` command, but instead of defining a local variable, it defines a
-global variable that other processes can access.
-
-```ion
-export PATH = ~/.cargo/bin:${PATH}
-```
-
-### Export Arithmetic
-
-The `export` command also supports basic arithmetic.
-
-```ion
-export a = 1
-echo $a
-export a += 4
-echo $a
-export a *= 10
-echo $a
-export a /= 2
-echo $a
-export a -= 5
-echo $a
-```
-
-### Aliases
-
-The `alias` command is used to set an alias for running other commands under a different name. The most common usages of the `alias` keyword are to shorten the keystrokes required to run a command and its specific arguments, and to rename a command to something more familiar.
-
-```ion
-alias ls = 'exa'
-```
-
-If the command is executed without any arguments, it will simply list all available aliases.
-
-The `unalias` command performs the reverse of `alias` in that it drops the value from existence.
-
-```ion
-unalias ls
-```
-
-### Brace Expansion
-
-Brace expansions are used to create permutations of a given input. In addition to simple permutations, Ion supports
-brace ranges and nested branches.
-
-```ion
-echo abc{3..1}def{1..3,a..c}
-echo ghi{one{a,b,c},two{d,e,f}}
-```
-
-### Defining Arrays
-
-Arrays can be create with the let keyword when the supplied expression evaluates to a vector of values:
-
-#### Array Syntax
-
-The basic syntax for creating an array of values is to wrap the values in between **[]** characters. The syntax within
-will be evaluated into a flat-mapped vector, and the result can therefore be stored as an array.
-
-```ion
-let array = [ one two 'three four' ]
-```
-
-One particular use case for arrays is setting command arguments
-
-```ion
-let lsflags = [ -l -a ]
-ls @lsflags
-```
-
-### Copying Arrays
-
-Do note, however, that arrays must always be explicitly created with **[]**.
-
-```ion
-let array = [ 1 2 3 ]
-let copy_of_array = [ @array ]
-```
-
-```ion
-let string = @array
-```
-
-When an array variable is passed by itself, it will coerced into a string.
-
-#### Braces Can Create Arrays
-
-Brace expansions actually create a vector of values under the hood, and thus they can be used to create an array.
-
-```ion
-let braced_array = [ {down,up}vote ]
-```
-
-#### Array-based Command Substitution
-
-Whereas the standard command substitution syntax will create a single string from the output, this variant will create
-a whitespace-delimited vector of values from the output of the command.
-
-```ion
-let word_split_process = [ @(echo one two three) ]
-```
-
-### Using Arrays
-
-Arrays may be called with the **@** sigil, which works identical to the variable syntax:
-
-```ion
-echo @braced_array
-echo @{braced_array}
-```
-
-Arrays may also be sliced when an index or index range is supplied:
-
-#### Slice by Index
-
-Slicing by an index will take a string from an array:
-
-```ion
-let array = [ 1 2 3 ]
-echo @array[0]
-echo @array[1]
-echo @array[2]
-
-echo [ 1 2 3 ][0]
-echo [ 1 2 3 ][1]
-echo [ 1 2 3 ][2]
-
-echo @(echo 1 2 3)[0]
-echo @(echo 1 2 3)[1]
-echo @(echo 1 2 3)[2]
-```
-
-#### Slice by Range
+# Git Plugin
-Slicing by range will take a subsection of an array as a new array:
+Plugins support within Ion is still a work in progress, and so the plugin architecture is likely to change. That said,
+there's an official git plugin that can be installed to experiment with the existing plugin namespaces plugin support.
+To install the git plugin, first install ion, and then execute the following:
```ion
-let array = [ 1 2 3 4 5 ]
-echo @array[0..1]
-echo @array[0...1]
-echo @array[..3]
-echo @array[3..]
-echo @array[..]
+git clone https://github.com/mmstick/ion-plugins
+cd ion-plugins
+./install.ion
```
-### Methods
-
-There are two types of methods -- string-based and array-based methods. The type that a method returns is denoted
-by the sigil that is used to invoke the method. Currently, there are only two supported methods: **$join()** and
-**@split**.
+It can be tested out by navigating to a directory within a git repository, and running the following:
```ion
-let results = [ 1 2 3 4 5 ]
-echo $join(results) @join # Both of these effectively do the same thing
-echo $join(results, ', ') # You may provide a custom pattern instead
-
-let line = "one two three four five"
-echo @split(line) # Splits a line by whitespace
-
-let row = "one,two,three,four,five"
-echo @split(row, ',') # Splits by commas
-```
-
-### Substring Slicing on String Methods
-
-```ion
-echo $join(array)[3..6]
-```
-
-### Array Slicing on Array Methods
-
-```ion
-let cpu_model = $(grep "model name" /proc/cpuinfo | head -1)
-echo @split(cpu_model)[3..5]
-```
-
-### Commands
-
-Commands may be written line by line or altogether on the same line with semicolons separating them.
-
-```ion
-command arg1 arg2 arg3
-command arg1 arg2 arg3
-command arg1 arg2 arg3; command arg1 arg2 arg3; command arg1 arg2 arg3
-```
-
-### Piping & Redirecting Standard Output
-
-The pipe (`|`) and redirect (`>`) operators are used for manipulating the standard output.
-
-```ion
-command arg1 | other_command | another_command arg2
-command arg1 > file
-```
-
-### Piping & Redirecting Standard Error
-
-The `^|` and `^>` operators are used for manipulating the standard error.
-
-```ion
-command arg1 ^| other_command
-command arg1 ^> file
-```
-
-### Piping & Redirecting Both Standard Output & Standard Error
-
-The `&|` and `&>` operators are used for manipulating both the standard output and error.
-
-```ion
-command arg1 &| other_command # Not supported yet
-command arg1 &> file
-```
-
-### Conditional Operators
-
-The Ion shell supports the `&&` and `||` operators in the same manner as the Bash shell. The `&&` operator
-executes the following command if the previous command exited with a successful exit status. The `||`
-operator performs the reverse -- executing if the previous command exited in failure.
-
-```ion
-test -e .git && echo Git directory exists || echo Git directory does not exist
-```
-
-### If Conditions
-
-It is also possible to perform more advanced conditional expressions using the `if`, `else if`, and `else` keywords.
-
-```ion
-let a = 5;
-if test $a -lt 5
- echo "a < 5"
-else if test $a -eq 5
- echo "a == 5"
-else
- echo "a > 5"
-end
-```
-
-### While Loops
-
-While loops will evaluate a supplied expression for each iteration and execute all the contained statements if it
-evaluates to a successful exit status.
-
-```ion
-let a = 1
-while test $a -lt 100
- echo $a
- let a += 1
-end
-```
-
-### For Loops
-
-For loops, on the other hand, will take a variable followed by a list of values or a range expression, and
-iterate through all contained statements until all values have been exhausted. If the variable is `_`, it
-will be ignored. Take note that quoting rules are reversed for for loops, and values from string-based command
-substitutions are split by lines.
-
-```ion
-# Obtaining Values From a Subshell
-for a in $(seq 1 10)
- echo $a
-end
-
-# Values Provided Directly
-for a in 1 2 3 4 5
- echo $a
-end
-
-# Exclusive Range
-for a in 1..11
- echo $a
-end
-
-# Inclusive Range
-for a in 1...10
- echo $a
-end
-
-# Ignore Value
-for _ in 1..10
- do_something
-end
-
-# Brace Ranges
-for a in {1..10}
- echo $a
-end
-
-# Globbing
-for a in *
- echo $a
-end
-```
-
-### Command Substitution
-
-Command substitution allows the user to execute commands within a subshell, and have the data written to standard
-output used as the substitution for the expansion. There are two methods of performing command substitution: string and
-array-based command substitution. String-based command substitutions are the standard, and they are created by wrapping
-the external command between **$(** and **)**. Array-based command substitution is denoted by wrapping the command
-between **@(** and **)**. The first merely captures the result as a single string, precisely as it was written, while
-the second splits the data recieved into words delimited by whitespaces.
-
-Try comparing the following:
-
-```ion
-for i in $(echo 1 2 3)
- echo $i
-end
-```
-
-```ion
-for i in @(echo 1 2 3)
- echo $i
-end
-```
-
-### Slicing String-Based Command Substitutions
-
-You may slice the string returned to obtain its substring:
-
-```ion
-echo $(echo one two three)[..3]
-```
-
-### Slicing Array-Based Command Substitutions
-
-You may slice the array returned to obtained a specific set of elements:
-
-```ion
-echo @(grep "model name" /proc/cpuinfo | head -1)[3..5]
-```
-
-### Functions
-
-Functions in the Ion shell are defined with a name along with a set of variables. The function
-will check if the correct number of arguments were supplied and execute if all arguments
-were given.
-
-```ion
-fn fib n
- if test $n -le 1
- echo $n
- else
- let output = 1
- let previous = 1
- for _ in 2..$n
- let temp = $output
- let output += $previous
- let previous = $temp
- end
- echo $output
- end
-end
-
-for i in 1..20
- fib $i
-end
-```
-
-
-### Executing Scripts with Array Arguments
-
-Arguments supplied to a script are stored in the `@args` array.
-
-#### Command executed
-
-```ion
-script.ion one two three
-```
-
-#### Script Contents
-
-```ion
-for argument in @args
- echo $argument
-end
-```
-
-#### Output
-
-```
-script.ion
-one
-two
-three
+echo Current Branch: ${git::branch}
```
diff --git a/src/main.rs b/src/main.rs
index 80ef2e66..21ad1cc8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -19,6 +19,7 @@ extern crate regex;
#[cfg(all(unix, not(target_os = "redox")))] extern crate libc;
#[cfg(all(unix, not(target_os = "redox")))] extern crate nix;
#[cfg(all(unix, not(target_os = "redox")))] extern crate users as users_unix;
+#[cfg(all(unix, not(target_os = "redox")))] extern crate libloading;
#[cfg(target_os = "redox")] extern crate syscall;
#[cfg(target_os = "redox")]
diff --git a/src/shell/plugins/library_iter/mod.rs b/src/shell/plugins/library_iter/mod.rs
new file mode 100644
index 00000000..eb8366e2
--- /dev/null
+++ b/src/shell/plugins/library_iter/mod.rs
@@ -0,0 +1,44 @@
+use libloading::Library;
+use std::fs::ReadDir;
+use types::Identifier;
+
+
+/// Grabs `Library` entries found within a given directory
+pub struct LibraryIterator {
+ directory: ReadDir,
+}
+
+impl LibraryIterator {
+ pub fn new(directory: ReadDir) -> LibraryIterator { LibraryIterator { directory } }
+}
+
+impl Iterator for LibraryIterator {
+ type Item = (Identifier, Library);
+
+ fn next(&mut self) -> Option<(Identifier, Library)> {
+ while let Some(entry) = self.directory.next() {
+ let entry = if let Ok(entry) = entry { entry } else { continue };
+ let path = entry.path();
+ if path.is_file() && path.extension().map_or(false, |ext| ext == "so") {
+ let identifier = match path.file_stem().unwrap().to_str() {
+ Some(filename) => Identifier::from(filename),
+ None => {
+ eprintln!("ion: namespace plugin has invalid filename");
+ continue;
+ }
+ };
+
+ match Library::new(path.as_os_str()) {
+ Ok(library) => return Some((identifier, library)),
+ Err(why) => {
+ eprintln!("ion: failed to load library: {:?}, {:?}", path, why);
+ continue;
+ }
+ }
+ } else {
+ continue;
+ }
+ }
+ None
+ }
+}
diff --git a/src/shell/plugins/mod.rs b/src/shell/plugins/mod.rs
new file mode 100644
index 00000000..a3870861
--- /dev/null
+++ b/src/shell/plugins/mod.rs
@@ -0,0 +1,27 @@
+pub mod namespaces;
+#[cfg(all(unix, not(target_os = "redox")))]
+mod library_iter;
+#[cfg(all(unix, not(target_os = "redox")))]
+pub use self::library_iter::*;
+
+use app_dirs::{AppDataType, AppInfo, app_root};
+use std::path::PathBuf;
+
+pub fn config_dir() -> Option<PathBuf> {
+ match app_root(
+ AppDataType::UserConfig,
+ &AppInfo {
+ name: "ion",
+ author: "Redox OS Developers",
+ },
+ ) {
+ Ok(mut path) => {
+ path.push("plugins");
+ Some(path)
+ }
+ Err(why) => {
+ eprintln!("ion: unable to get config directory: {:?}", why);
+ None
+ }
+ }
+}
diff --git a/src/shell/plugins/namespaces/mod.rs b/src/shell/plugins/namespaces/mod.rs
new file mode 100644
index 00000000..a5d9420e
--- /dev/null
+++ b/src/shell/plugins/namespaces/mod.rs
@@ -0,0 +1,9 @@
+#[cfg(target_os = "redox")]
+mod redox;
+#[cfg(target_os = "redox")]
+pub use self::redox::*;
+
+#[cfg(all(unix, not(target_os = "redox")))]
+mod unix;
+#[cfg(all(unix, not(target_os = "redox")))]
+pub use self::unix::*;
diff --git a/src/shell/plugins/namespaces/redox.rs b/src/shell/plugins/namespaces/redox.rs
new file mode 100644
index 00000000..aafb46ee
--- /dev/null
+++ b/src/shell/plugins/namespaces/redox.rs
@@ -0,0 +1,50 @@
+use std::ffi::CString;
+use std::fmt::{self, Display, Formatter};
+use std::io;
+use types::Identifier;
+
+#[derive(Debug)]
+pub enum NamespaceError {
+ SymbolErr(io::Error),
+ UTF8Function,
+ UTF8Result,
+ FunctionMissing(Identifier),
+}
+
+impl Display for NamespaceError {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match *self {
+ NamespaceError::SymbolErr(ref error) => write!(f, "symbol error: {}", error),
+ NamespaceError::UTF8Function => write!(f, "function has invalid UTF-8 name"),
+ NamespaceError::UTF8Result => write!(f, "result is not valid UTF-8"),
+ NamespaceError::FunctionMissing(func) => write!(f, "{} doesn't exist in namespace", func),
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+struct NamespaceResult {
+ exists: bool,
+ data: *mut i8,
+}
+
+impl NamespaceResult {
+ fn into_option(self) -> Option<CString> {
+ if self.exists { Some(unsafe { CString::from_raw(self.data) }) } else { None }
+ }
+}
+
+pub struct StringNamespace {}
+
+impl StringNamespace {
+ pub fn new() -> Result<StringNamespace, NamespaceError> { Err(NamespaceError::FunctionMissing) }
+
+ pub fn execute(&self, function: Identifier) -> Result<Option<String>, NamespaceError> { Ok(None) }
+}
+
+pub fn collect() -> FnvHashMap<Identifier, StringNamespace> {
+ eprintln!("ion: Redox doesn't support plugins yet");
+ let mut hashmap = FnvHashMap::default();
+ hashmap
+}
diff --git a/src/shell/plugins/namespaces/unix.rs b/src/shell/plugins/namespaces/unix.rs
new file mode 100644
index 00000000..2ec1804d
--- /dev/null
+++ b/src/shell/plugins/namespaces/unix.rs
@@ -0,0 +1,162 @@
+use super::super::{LibraryIterator, config_dir};
+use fnv::FnvHashMap;
+use libloading::{Library, Symbol};
+use libloading::os::unix::Symbol as RawSymbol;
+use std::ffi::CString;
+use std::fmt::{self, Display, Formatter};
+use std::fs::read_dir;
+use std::io;
+use std::slice;
+use std::str;
+use types::Identifier;
+
+#[derive(Debug)]
+pub enum NamespaceError {
+ SymbolErr(io::Error),
+ UTF8Function,
+ UTF8Result,
+ FunctionMissing(Identifier),
+}
+
+impl Display for NamespaceError {
+ fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+ match *self {
+ NamespaceError::SymbolErr(ref error) => write!(f, "symbol error: {}", error),
+ NamespaceError::UTF8Function => write!(f, "function has invalid UTF-8 name"),
+ NamespaceError::UTF8Result => write!(f, "result is not valid UTF-8"),
+ NamespaceError::FunctionMissing(ref func) => write!(f, "{} doesn't exist in namespace", func),
+ }
+ }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+struct NamespaceResult {
+ exists: bool,
+ data: *mut i8,
+}
+
+impl NamespaceResult {
+ fn into_option(self) -> Option<CString> {
+ if self.exists { Some(unsafe { CString::from_raw(self.data) }) } else { None }
+ }
+}
+
+pub struct StringNamespace {
+ /// Do not remove this field, as it ensures that the library remains loaded.
+ #[allow(dead_code)]
+ library: Library,
+ /// A hash map of symbols collected from the `Library` stored in the `library` field.
+ symbols: FnvHashMap<Identifier, RawSymbol<unsafe extern "C" fn() -> NamespaceResult>>,
+}
+
+impl StringNamespace {
+ pub fn new(library: Library) -> Result<StringNamespace, NamespaceError> {
+ unsafe {
+ let mut symbols = FnvHashMap::default();
+ {
+ let index: Symbol<unsafe extern "C" fn() -> *const u8> =
+ library.get(b"index\0").map_err(NamespaceError::SymbolErr)?;
+ let symbol_list = index();
+
+ let (mut start, mut counter) = (0, 0usize);
+ let symbol_list: &[u8] = {
+ let mut byte = *symbol_list.offset(0);
+ while byte != b'\0' {
+ counter += 1;
+ byte = *symbol_list.offset(counter as isize);
+ }
+ slice::from_raw_parts(symbol_list, counter)
+ };
+
+ counter = 0;
+ for &byte in symbol_list {
+ if byte == b' ' {
+ if start == counter {
+ start += 1;
+ } else {
+ let slice = &symbol_list[start..counter];
+ let identifier = str::from_utf8(slice).map(Identifier::from).map_err(|_| {
+ NamespaceError::UTF8Function
+ })?;
+ let mut symbol = Vec::new();
+ symbol.reserve_exact(slice.len() + 1);
+ symbol.extend_from_slice(slice);
+ symbol.push(b'\0');
+ let symbol: Symbol<unsafe extern "C" fn() -> NamespaceResult> =
+ library.get(symbol.as_slice()).map_err(
+ NamespaceError::SymbolErr,
+ )?;
+ symbols.insert(identifier, symbol.into_raw());
+ start = counter + 1;
+ }
+ }
+ counter += 1;
+ }
+
+ if counter != start {
+ let slice = &symbol_list[start..];
+ let identifier = str::from_utf8(slice).map(Identifier::from).map_err(|_| {
+ NamespaceError::UTF8Function
+ })?;
+ let mut symbol = Vec::new();
+ symbol.reserve_exact(slice.len() + 1);
+ symbol.extend_from_slice(slice);
+ symbol.push(b'\0');
+ let symbol: Symbol<unsafe extern "C" fn() -> NamespaceResult> =
+ library.get(symbol.as_slice()).map_err(
+ NamespaceError::SymbolErr,
+ )?;
+ symbols.insert(identifier, symbol.into_raw());
+ }
+ }
+ Ok(StringNamespace { library, symbols })
+ }
+ }
+
+ pub fn execute(&self, function: Identifier) -> Result<Option<String>, NamespaceError> {
+ let func = self.symbols.get(&function).ok_or(
+ NamespaceError::FunctionMissing(
+ function.clone(),
+ ),
+ )?;
+ unsafe {
+ match (*func)().into_option() {
+ None => Ok(None),
+ Some(cstring) => {
+ match cstring.to_str() {
+ Ok(string) => Ok(Some(string.to_owned())),
+ Err(_) => Err(NamespaceError::UTF8Result),
+ }
+ }
+ }
+ }
+ }
+}
+
+pub fn collect() -> FnvHashMap<Identifier, StringNamespace> {
+ let mut hashmap = FnvHashMap::default();
+ if let Some(mut path) = config_dir() {
+ path.push("namespaces");
+ path.push("strings");
+ match read_dir(&path).map(LibraryIterator::new) {
+ Ok(iterator) => {
+ for (identifier, library) in iterator {
+ match StringNamespace::new(library) {
+ Ok(namespace) => {
+ hashmap.insert(identifier, namespace);
+ }
+ Err(why) => {
+ eprintln!("ion: string namespace error: {}", why);
+ continue;
+ }
+ }
+ }
+ }
+ Err(why) => {
+ eprintln!("ion: unable to read namespaces plugin directory: {}", why);
+ }
+ }
+ }
+ hashmap
+}
diff --git a/src/shell/variables.rs b/src/shell/variables.rs
index 61d14859..ef977849 100644
--- a/src/shell/variables.rs
+++ b/src/shell/variables.rs
@@ -1,12 +1,13 @@
-use fnv::FnvHashMap;
-use std::env;
-use std::io::{self, BufRead};
-use std::process;
use super::directory_stack::DirectoryStack;
+use super::plugins::namespaces::{self, StringNamespace};
use super::status::{FAILURE, SUCCESS};
use app_dirs::{AppDataType, AppInfo, app_root};
+use fnv::FnvHashMap;
use liner::Context;
+use std::env;
+use std::io::{self, BufRead};
+use std::process;
use types::{Array, ArrayVariableContext, HashMap, HashMapVariableContext, Identifier, Key, Value, VariableContext};
#[cfg(target_os = "redox")]
@@ -18,6 +19,10 @@ use sys::getpid;
use sys;
use sys::variables as self_sys;
+lazy_static! {
+ static ref STRING_NAMESPACES: FnvHashMap<Identifier, StringNamespace> = namespaces::collect();
+}
+
#[derive(Debug)]
pub struct Variables {
pub hashmaps: HashMapVariableContext,
@@ -63,12 +68,9 @@ impl Default for Variables {
);
// Initialize the HOME variable
- env::home_dir().map_or_else(
- || env::set_var("HOME", "?"),
- |path| {
- env::set_var("HOME", path.to_str().unwrap_or("?"))
- },
- );
+ env::home_dir().map_or_else(|| env::set_var("HOME", "?"), |path| {
+ env::set_var("HOME", path.to_str().unwrap_or("?"))
+ });
Variables {
hashmaps: FnvHashMap::with_capacity_and_hasher(64, Default::default()),
arrays: FnvHashMap::with_capacity_and_hasher(64, Default::default()),
@@ -143,12 +145,22 @@ impl Variables {
pub fn unset_array(&mut self, name: &str) -> Option<Array> { self.arrays.remove(name) }
pub fn get_var(&self, name: &str) -> Option<Value> {
- if let Some((namespace, variable)) = name.find("::").map(|pos| (&name[..pos], &name[pos+2..])) {
- match namespace {
+ if let Some((name, variable)) = name.find("::").map(|pos| (&name[..pos], &name[pos + 2..])) {
+ match name {
"env" => env::var(variable).map(Into::into).ok(),
_ => {
- eprintln!("ion: unsupported namespace: '{}'", namespace);
- None
+ if let Some(namespace) = STRING_NAMESPACES.get(name.into()) {
+ match namespace.execute(variable.into()) {
+ Ok(value) => value.map(Into::into),
+ Err(why) => {
+ eprintln!("ion: string namespace erorr: {}: {}", name, why);
+ None
+ }
+ }
+ } else {
+ eprintln!("ion: unsupported namespace: '{}'", name);
+ None
+ }
}
}
} else {
@@ -289,9 +301,7 @@ mod tests {
struct VariableExpander(pub Variables);
impl Expander for VariableExpander {
- fn variable(&self, var: &str, _: bool) -> Option<Value> {
- self.0.get_var(var)
- }
+ fn variable(&self, var: &str, _: bool) -> Option<Value> { self.0.get_var(var) }
}
#[test]
--
GitLab