Initial

Author: Harry Lawrence

.gitignore

@@ -0,0 +1,3 @@
+build/httpu
+.env
+

LICENSE

@@ -0,0 +1,46 @@
+GOCMD         := go
+GOBUILD       := $(GOCMD) build
+GOTEST        := $(GOCMD) test
+GOGET         := $(GOCMD) get
+GOINSTALL     := $(GOCMD) install
+BUILD_WD      := cmd/httpu
+BIN_PATH      := build
+BIN_NAME      := httpu
+BIN_OUT       := $(BIN_PATH)/$(BIN_NAME)
+BIN_OUT_LINUX := $(BIN_OUT)-linux
+GIT_COMMIT    := `git rev-parse HEAD`
+GIT_BRANCH    := `git rev-parse --abbrev-ref HEAD`
+META_PACKAGE  := github.com/hazbo/httpu/meta.Commit
+
+# Running tests on build for now as it's quick and helpful during development.
+all: deps build
+
+build: build/httpu
+
+build/httpu:
+	cd $(BUILD_WD) && \
+		$(GOBUILD) -v \
+		-o ../../$(BIN_OUT) \
+		-ldflags "-X $(META_PACKAGE)=$(GIT_COMMIT)"
+
+test:
+	$(GOTEST) -cover -v \
+		./ \
+		./resource \
+		./resource/request \
+		./utils/varparser
+
+run: $(BIN_OUT)
+	./$(BIN_OUT) version
+
+clean:
+	rm -f $(BIN_OUT)
+	rm -f $(BIN_OUT_LINUX)
+
+deps:
+	$(GOGET) -v ./...
+
+install: build
+	cp $(BIN_OUT) $(GOPATH)/bin/$(BIN_NAME)
+
+.PHONY: all build test clean deps install

Makefile

@@ -0,0 +1,156 @@
+# httpu
+
+httpu is a terminal first, general purpose HTTP client, designed to get you
+interacting with all aspects of an HTTP API within just a few seconds. This
+makes it a good tool for testing out various endpoints, methods, payloads - so
+you are able to see what's being sent, and what response you are then getting.
+
+![httpu](docs/demo.gif)
+
+## Getting started
+
+### Installing
+
+#### macOS
+
+```
+brew install hazbo/httpu
+```
+
+#### Linux x86_64
+
+
+### Basic usage
+
+I started writing this project whilst working with the [Moltin API][1], which is
+a headless commerce API, so there are a few examples using that, if you want to
+play around with that, just head to the website, get your API keys and you are
+good to go!
+
+Once httpu has been installed, you can get started either by first pulling down
+the preconfigured packages:
+
+```
+httpu pull
+```
+
+And then loading the configuration of a package into httpu like so:
+
+```
+httpu new moltin
+```
+
+*or* by creating your own configuration. A basic project may look like the
+following:
+
+```
+mkdir -p httpbin/requests
+touch httpbin/project.json httpbin/requests/ip.json
+```
+
+> httpbin/project.json
+```
+{
+  "project": {
+    "url": "https://nghttp2.org/httpbin",
+    "resourceFiles": [
+      "httpbin/requests/ip.json"
+    ]
+  }
+}
+```
+
+> httpbin/requests/ip.json
+```
+{
+  "kind": "request",
+  "name": "ip",
+  "spec": {
+    "uri": "/ip",
+    "method": "GET"
+  }
+}
+```
+
+Once you have that setup, you're ready to run httpu!
+
+```
+httpu new httpbin
+```
+
+When the UI has loaded, typing in `ip` (the `name` of the request) into the
+prompt, followed by hitting enter will run that request and you will be able to
+see the response body in the right-hand window. In this case, it will simply
+just return your IP address from which the request has been made.
+
+### Advanced usage
+
+httpu is able to look at a JSON response, take a given value and store it in
+memory, to then be used for another request. This in-memory store is called the
+stash. So for example, in the previous example, if you wanted to store the IP
+address that is returned, and use it else where, the request file may look like
+this:
+
+> httpbin/requests/ip.json
+```
+{
+  "kind": "request",
+  "name": "ip",
+  "spec": {
+    "uri": "/ip",
+    "method": "GET",
+    "stashValues": [
+      {
+        "name": "my-ip",
+        "jsonPath": "origin"
+      }
+    ]
+  }
+}
+```
+
+and then in a seperate request you can then access it, once the `ip` request has
+been made, like so:
+
+> httpbin/requests/get.json
+```
+{
+  "kind": "request",
+  "name": "get",
+  "spec": {
+    "uri": "/get?ip=${stash[ip]}",
+    "method": "GET"
+  }
+}
+```
+
+with `${stash[ip]}` being a variable created after running the `ip` request.
+
+For more examples for advanced usage including the stash, sending request data,
+using environment variables etc... head over to the [packages repo][2] and check
+out the example I've started creating for the [Moltin API][3].
+
+## Coming soon
+  - A view to display response headers (priority)
+  - Creating a request flow
+  - Creating tests for a request or set of requests
+  - Various UI tweaks
+  - An HTTP API interface
+
+## Known issues
+
+This project is in its very early stages, so there will be things that need
+fixing. One issue at the moment is a problem with parsing stashed variables
+into request data before a request has been made. If this happens, and you are
+seeing `${stash[var_name]}`, just fire the request again and it should work.
+
+## Contributing
+  - Fork httpu
+  - Create a new branch (`git checkout -b my-feature`)
+  - Commit your changes (`git commit`)
+  - Push to your new branch (`git push origin my-feature`)
+  - Create new pull request
+
+[1]: https://moltin.com/
+[2]: https://github.com/httpu/packages
+[3]: https://github.com/httpu/packages/tree/master/moltin/requests

README.md

@@ -0,0 +1,13 @@
+package api
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/hazbo/httpu/api/requests"
+)
+
+func StartServer() {
+	http.HandleFunc("/requests", requests.GetRequests)
+	log.Fatal(http.ListenAndServe(":3000", nil))
+}

api/api.go

@@ -0,0 +1,29 @@
+package requests
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/hazbo/httpu/resource"
+	"github.com/hazbo/httpu/resource/request"
+)
+
+func GetRequests(rw http.ResponseWriter, r *http.Request) {
+	var rs request.Requests
+	for _, r := range resource.Requests {
+		rs = append(rs, r)
+	}
+	j, err := json.Marshal(rs)
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	var out bytes.Buffer
+	json.Indent(&out, j, "", "  ")
+
+	fmt.Fprint(rw, string(out.String()))
+}

api/requests/requests.go

@@ -0,0 +1,24 @@
+package commands
+
+// Command defines the functionality and useage text for any given subcommand.
+// These may be from either built-in commands, inline or external commands.
+type Command struct {
+	Usage     func(string)
+	RunMethod func([]string) error
+}
+
+// Run will run the given command with the arguments passed
+func (cmd *Command) Run(args []string) error {
+	return cmd.RunMethod(args)
+}
+
+// CommandMap defines the string key for a given command, which is then used
+// when invoking the cnf commands.
+type CommandMap map[string]*Command
+
+// Commands is the list of commands within a map
+var Commands = CommandMap{
+	"new":     newCmd,
+	"pull":    pullCmd,
+	"version": versionCmd,
+}

build/.gitkeep

@@ -0,0 +1,60 @@
+package commands
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/hazbo/httpu"
+	"github.com/hazbo/httpu/ui"
+	"github.com/joho/godotenv"
+)
+
+var newFlagSet = flag.NewFlagSet("new", flag.ExitOnError)
+
+var (
+	newEnvFile = newFlagSet.String(
+		"e", "", "Loads .env file to start httpu with environment variables")
+)
+
+func newValue(args []string) error {
+	newFlagSet.Parse(args)
+
+	// Get the first argument for the `new` command
+	p := args[0]
+
+	if *newEnvFile != "" {
+		err := godotenv.Load(*newEnvFile)
+		if err != nil {
+			return fmt.Errorf("Could not find .env file: %s", *newEnvFile)
+		}
+
+		// If an env file has been passed, this becomes argument 2, over 0.
+		p = args[2]
+	}
+
+	if len(args) == 0 {
+		fmt.Printf("Expecting 1 argument, 0 passed")
+		os.Exit(1)
+	}
+
+	err := httpu.ConfigureFromFile(p)
+	if err != nil {
+		return err
+	}
+
+	// Start the terminal user interface!
+	ui.New().Start()
+
+	return nil
+}
+
+var newCmd = &Command{
+	Usage: func(arg0 string) {
+		fmt.Printf("Usage: %s list [<option>...]\n\nOptions:\n", arg0)
+		newFlagSet.PrintDefaults()
+	},
+	RunMethod: func(args []string) error {
+		return newValue(args)
+	},
+}