Rename DinoSQL to sqlc (sqlc-dev#63)

kyleconroy · web-flow · commit 3858065224bd · 2019-08-18T19:20:56.000-07:00
* Rename DinoSQL to sqlc

* Publish sqlc using Equinox
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -1,4 +1,4 @@
-name: dinosql test suite
+name: sqlc test suite
 on: [push]
 jobs:
 
@@ -26,10 +26,10 @@ jobs:
       with:
         version: 1.12
 
-    - name: Test dinosql
+    - name: Test sqlc
       run: go test -v ./...
 
-    - name: Test dinosql/ondeck
+    - name: Test sqlc/ondeck
       run: go test -v ./...
       working-directory: internal/dinosql/testdata/ondeck
       env:
diff --git a/.github/workflows/equinox.yml b/.github/workflows/equinox.yml
@@ -0,0 +1,36 @@
+name: Publish to Equinox
+
+on:
+  push:
+    branches:
+    - master
+
+jobs:
+
+  macos:
+    name: Build on macOS
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@master
+    - run: brew install eqnxio/equinox/release-tool
+    - name: equinox release
+      env:
+        EQUINOX_API_TOKEN: ${{ secrets.EQUINOX_API_TOKEN }}
+        EQUINOX_SIGNING_KEY: ${{ secrets.EQUINOX_SIGNING_KEY }}
+      run: equinox release --channel devel --version=$GITHUB_SHA --draft --platforms=darwin_amd64 --app=app_i4iCp1SuYfZ --token=$EQUINOX_API_TOKEN github.com/kyleconroy/sqlc
+
+  linux:
+    name: Build on Linux
+    runs-on: ubuntu-latest
+    needs: [macos]
+    steps:
+    - uses: actions/checkout@master
+    - run: curl -O https://bin.equinox.io/c/mBWdkfai63v/release-tool-stable-linux-amd64.tgz
+    - run: tar -xzvf release-tool-stable-linux-amd64.tgz
+    - name: equinox release
+      env:
+        EQUINOX_API_TOKEN: ${{ secrets.EQUINOX_API_TOKEN }}
+        EQUINOX_SIGNING_KEY: ${{ secrets.EQUINOX_SIGNING_KEY }}
+      run: ./equinox release --channel devel --version=$GITHUB_SHA --platforms=linux_amd64 --app=app_i4iCp1SuYfZ --token=$EQUINOX_API_TOKEN github.com/kyleconroy/sqlc
+
+
diff --git a/.semaphore/semaphore.yml b/.semaphore/semaphore.yml
diff --git a/README.md b/README.md
@@ -1,51 +1,51 @@
 > 🚨 
 >
-> DinoSQL is **very new** and under rapid development.
+> sqlc is **very new** and under rapid development.
 >
 > The code it generates is correct and safe for production use, but
 > there is currently no garantee of stability or backwards-compatibility of
 > the command line interface, configuration file format or generated code.
 >
 > 🚨 
 
-# Dino: A SQL Compiler
+# sqlc: A SQL Compiler
 
 > And lo, the Great One looked down upon the people and proclaimed:
 > 
 >   "SQL is actually pretty great"
 
-DinoSQL generates **fully-type safe idiomatic Go code** from SQL. Here's how it works:
+sqlc generates **fully-type safe idiomatic Go code** from SQL. Here's how it works:
 
 1. You write SQL queries
-1. You run the DinoSQL tool to generate Go code that presents type-safe interfaces to those queries
-1. You write application code that calls the methods DinoSQL generated.
+1. You run sqlc to generate Go code that presents type-safe interfaces to those queries
+1. You write application code that calls the methods sqlc generated.
 
 Seriously, it's that easy. You don't have to write any boilerplate SQL querying code ever again.
 
 ## Preventing Errors
-But DinoSQL doesn't just make you more productive by generating boilerplate for you.
-DinoSQL **also prevents entire classes of common errors in SQL code**. Have you ever:
+But sqlc doesn't just make you more productive by generating boilerplate for you.
+sqlc **also prevents entire classes of common errors in SQL code**. Have you ever:
 
 - Mixed up the order of the arguments when invoking the query so they didn't match up with the SQL text
 - Updated the name of a column in one query both not another
 - Mistyped the name of a column in a query
 - Changed the number of arguments in a query but forgot to pass the additional values
 - Changed the type of a column but forgot to change the type in your code?
 
-All of these errors are *impossible* with DinoSQL. Wait, what? How?
+All of these errors are *impossible* with sqlc. Wait, what? How?
 
-DinoSQL parses your all of your queries and the DDL (e.g. `CREATE TABLE`) statements during the code generation processes
+sqlc parses your all of your queries and the DDL (e.g. `CREATE TABLE`) statements during the code generation processes
 so that it knows the names and types of every column in your tables and every expression in your queries.
-If any of them do not match, DinoSQL *will fail to compile your queries*, preventing entire classes of runtime problems
+If any of them do not match, sqlc *will fail to compile your queries*, preventing entire classes of runtime problems
 at compile time.
 
-Likewise, the methods that DinoSQL generates for you have a stricty arity and correct Go type definitions that match your columns. So if you
+Likewise, the methods that sqlc generates for you have a stricty arity and correct Go type definitions that match your columns. So if you
 change a query's arguments or a column's type but don't update your code, it will fail to compile.
 
 ## Getting Started
 Okay, enough hype, let's see it in action.
 
-First you pass the following SQL to `dinosql generate`:
+First you pass the following SQL to `sqlc generate`:
 
 ```sql
 CREATE TABLE authors (
@@ -105,7 +105,7 @@ if err != nil {
 fmt.Println(reflect.DeepEqual(insertedAuthor, fetchedAuthor))
 ```
 
-To make that possible, DinoSQL generates readable, **idiomatic** Go code that you otherwise would have had to write yourself. Take a look:
+To make that possible, sqlc generates readable, **idiomatic** Go code that you otherwise would have had to write yourself. Take a look:
 
 ```go
 package db
@@ -240,31 +240,31 @@ Your favorite PostgreSQL / Go features are supported:
   - [Goose migrations](./examples/goose.md)
 
 A full, end-to-end example can be found in the sample
-[`ondeck`](./internal/dinosql/testdata/ondeck) package.
+[`ondeck`](./internal/sqlc/testdata/ondeck) package.
 
 ## Usage
 
 ```
 Usage:
-  dinosql [command]
+  sqlc [command]
 
 Available Commands:
   compile     Statically check SQL for syntax and type errors
   generate    Generate Go code from SQL
   help        Help about any command
-  init        Create an empty dinosql.json settings file
-  version     Print the DinoSQL version number
+  init        Create an empty sqlc.json settings file
+  version     Print the sqlc version number
 
 Flags:
-  -h, --help   help for dinosql
+  -h, --help   help for sqlc
 
-Use "dinosql [command] --help" for more information about a command.
+Use "sqlc [command] --help" for more information about a command.
 ```
 
 ## Settings
 
-The `dinosql` tool is configured via a `dinosql.json` file. This file must be
-in the directory where the `dinosql` command is run.
+The `sqlc` tool is configured via a `sqlc.json` file. This file must be
+in the directory where the `sqlc` command is run.
 
 ```json
 {
@@ -297,19 +297,19 @@ Each package document has the following keys:
 
 ## Downloads
 
-Each commit is deployed to the [`devel` channel on Equinox](https://dl.equinox.io/dinosql/dinosql/devel):
-- [Linux](https://bin.equinox.io/c/jUfda88XW4i/dinosql-devel-linux-amd64.tgz)
-- [macOS](https://bin.equinox.io/c/jUfda88XW4i/dinosql-devel-darwin-amd64.zip)
+Each commit is deployed to the [`devel` channel on Equinox](https://dl.equinox.io/sqlc/sqlc/devel):
+- [Linux](https://bin.equinox.io/c/jUfda88XW4i/sqlc-devel-linux-amd64.tgz)
+- [macOS](https://bin.equinox.io/c/jUfda88XW4i/sqlc-devel-darwin-amd64.zip)
 
 ## Other Database Engines
 
-DinoSQL currently only supports PostgreSQL. If you'd like to support another database, we'd welcome a contribution.
+sqlc currently only supports PostgreSQL. If you'd like to support another database, we'd welcome a contribution.
 
 ## Other Language Backends
 
-DinoSQL currently only generates Go code, but if you'd like to build another language backend, we'd welcome a contribution.
+sqlc currently only generates Go code, but if you'd like to build another language backend, we'd welcome a contribution.
 
 ## Acknowledgements
 
-DinoSQL was inspired by [PugSQL](https://pugsql.org/) and
+sqlc was inspired by [PugSQL](https://pugsql.org/) and
 [HugSQL](https://www.hugsql.org/).
diff --git a/cmd/sqlc/main.go b/cmd/sqlc/main.go
diff --git a/internal/cmd/cmd.go b/internal/cmd/cmd.go
@@ -18,7 +18,7 @@ import (
 
 // Do runs the command logic.
 func Do(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int {
-	rootCmd := &cobra.Command{Use: "dinosql", SilenceUsage: true}
+	rootCmd := &cobra.Command{Use: "sqlc", SilenceUsage: true}
 	rootCmd.AddCommand(checkCmd)
 	rootCmd.AddCommand(genCmd)
 	rootCmd.AddCommand(initCmd)
@@ -42,7 +42,7 @@ func Do(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) int
 
 var versionCmd = &cobra.Command{
 	Use:   "version",
-	Short: "Print the DinoSQL version number",
+	Short: "Print the sqlc version number",
 	Run: func(cmd *cobra.Command, args []string) {
 		fmt.Println("v0.0.1")
 	},
@@ -69,24 +69,24 @@ var parseCmd = &cobra.Command{
 
 var initCmd = &cobra.Command{
 	Use:   "init",
-	Short: "Create an empty dinosql.json settings file",
+	Short: "Create an empty sqlc.json settings file",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if _, err := os.Stat("dinosql.json"); !os.IsNotExist(err) {
+		if _, err := os.Stat("sqlc.json"); !os.IsNotExist(err) {
 			return nil
 		}
 		blob, err := json.MarshalIndent(dinosql.GenerateSettings{}, "  ", "")
 		if err != nil {
 			return err
 		}
-		return ioutil.WriteFile("dinosql.json", blob, 0644)
+		return ioutil.WriteFile("sqlc.json", blob, 0644)
 	},
 }
 
 var genCmd = &cobra.Command{
 	Use:   "generate",
 	Short: "Generate Go code from SQL",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		blob, err := ioutil.ReadFile("dinosql.json")
+		blob, err := ioutil.ReadFile("sqlc.json")
 		if err != nil {
 			return err
 		}
@@ -127,7 +127,7 @@ var checkCmd = &cobra.Command{
 	Use:   "compile",
 	Short: "Statically check SQL for syntax and type errors",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		blob, err := ioutil.ReadFile("dinosql.json")
+		blob, err := ioutil.ReadFile("sqlc.json")
 		if err != nil {
 			return err
 		}
