doc fixes

Author: bramtayl

README.md

@@ -4,5 +4,6 @@
 [![Build Status](https://travis-ci.org/queryverse/QuerySQLite.jl.svg?branch=master)](https://travis-ci.org/queryverse/QuerySQLite.jl)
 [![Build status](https://ci.appveyor.com/api/projects/status/vluand1dj4x7i3iy/branch/master?svg=true)](https://ci.appveyor.com/project/queryverse/querysqlite-jl/branch/master)
 [![codecov.io](http://codecov.io/github/queryverse/QuerySQLite.jl/coverage.svg?branch=master)](http://codecov.io/github/queryverse/QuerySQLite.jl?branch=master)
+[![dev](https://img.shields.io/badge/docs-latest-blue.svg)](http://www.queryverse.org/QuerySQLite.jl/dev/)
 
 This package provides a SQLite backend for [Query.jl](https://github.com/queryverse/Query.jl).

docs/src/index.md

@@ -1,44 +1,31 @@
+# QuerySQLite
+
 ```@index
 Modules = [QuerySQLite]
 ```
 
 ## User documentation
 
-QuerySQLite is an experimental package sponsored by Google Summer of Code. It's
-finally ready for public use. Although QuerySQLite is only tested on SQLite,
-it's been purposefully designed to easily incorporate other database software.
+QuerySQLite is an experimental package sponsored by Google Summer of Code. It's finally ready for public use. Although QuerySQLite is only tested using SQLite, it's been purposefully designed to easily incorporate other database software.
 
-Use [`Database`](@ref) to wrap an external database. Then, you can access its
-tables using `.`, and conduct most `Query` operations on them. In theory, most
-operations should "just work". There are a couple of exceptions.
+Use [`Database`](@ref) to wrap an external database. Then, you can access its tables using `.`, and conduct most `Query` operations on them. In theory, most operations should "just work". There are a couple of exceptions.
 
-### Non-overloadable methods
+### Non-overloadable syntax and functions
 
-Functions like `ifelse` and `typeof` can't be overloaded. Instead, QuerySQLite
-exports the [`if_else`](@ref) and [`type_of`](@ref) functions and overloads them
-instead.
+Patterns like `if` and functions like `ifelse` and `typeof` can't be overloaded. Instead, QuerySQLite exports the [`if_else`](@ref) and [`type_of`](@ref) functions and overloads them instead.
 
 ### No SQL arguments
 
-If you would like to translate code to SQL, but you do not pass any SQL
-arguments, you will need use [`BySQL`](@ref) to pass a dummy SQL object instead.
-See the `BySQL` docstring for more information.
+If you would like to translate code to SQL, but you do not pass any SQL arguments, you will need to use [`BySQL`](@ref) to pass a dummy SQL object instead. See the `BySQL` docstring for more information.
 
 ## Developer documentation
 
-QuerySQLite hijacks Julia's multiple dispatch to translate external database
-commands to SQL instead of evaluating them. To do this, it construct a
-"model_row" that represents the structure of a row of data. If you would like to
-support for a new function, there are only a few steps:
-
-- Use the `@code_instead` macro to specify the argument types for diversion
-into SQL translation.
-- If your function will modify the row structure of the
-table, define a `model_row_call` method.
-- Use the `@translate_default` macro to name the matching SQL function. If more
-involved processing is required, define a `translate_call` method instead.
-- If you would like to show your SQL expression in a non-standard way, edit the
-`show` method for `SQLExpression`s.
+QuerySQLite hijacks Julia's multiple dispatch to translate external database commands to SQL instead of evaluating them. To do this, it constructs a "model_row" that represents the structure of a row of data. If you would like to add support for a new function, there are only a few steps:
+
+- Use the `@code_instead` macro to specify the argument types for diversion into SQL translation.
+- If your function will modify the row structure of the table, define a `model_row_call` method.
+- Use the `@translate_default` macro to name the matching SQL function. If more involved processing is required, define a `translate_call` method instead.
+- If you would like to show your SQL expression in a non-standard way, edit the `show` method for `SQLExpression`s.
 
 ```@autodocs
 Modules = [QuerySQLite]

src/QuerySQLite.jl

@@ -32,15 +32,4 @@ include("model_row.jl")
 include("translate.jl")
 include("show.jl")
 
-# To add support for a new function
-# 1) Use `@code_instead` to specify the argument types
-# 2) If the function modifies the model row, define model_row_call(::typeof(function), ...)
-# 3a) If the function maps directly onto an SQL function, use @translate_default function SQL_function_symbol
-# 3b) Otherwise, define translate_call(::typeof(function), ...)
-# 4) If the SQL function uses special syntax, special case the SQLExpression show method
-
-# There are two situtations in which Julia code cannot be translated into SQL
-# 1) Patterns based on non-functions or non-overloadable functions, e.g. if, &&. Use if_else and & instead
-# 2) Separate operations in SQL that are combined in Julia by dispatch, e.g. * for string concatention. Use `string` instead
-
 end # module

src/code_instead.jl

@@ -1,7 +1,7 @@
 # All code is attached to its underlying database source
 struct SourceCode{Source}
     source::Source
-    code::Union{Expr, Nothing}
+    code::Expr
 end
 
 """
@@ -71,7 +71,6 @@ function combine_sources(a_function, source_codes...; key_source_codes...)
     end
 end
 
-# `@code_instead` hijacks call to create Julia expressions instead of evaluating functions
 function numbered_argument(number)
     Symbol(string("argument", number))
 end
@@ -89,6 +88,7 @@ function maybe_splat(argument, a_type)
     end
 end
 
+# `@code_instead` hijacks call to create Julia expressions instead of evaluating functions
 function code_instead(location, a_function, types...)
     arguments = ntuple(numbered_argument, length(types))
     keywords = Expr(:parameters, Expr(:..., :keywords))

src/database.jl

@@ -41,6 +41,16 @@ export get_column_names
 
 A wrapper for an external database. `source` need only support
 [`get_table_names`](@ref) and [`get_column_names`](@ref).
+"""
+struct Database{Source}
+    source::Source
+end
+
+"""
+    Database(filename::AbstractString)
+
+Guess the database software from the filename.
+
 
 ```jldoctest
 julia> using QuerySQLite
@@ -64,15 +74,6 @@ TrackId │ Name                                      │ AlbumId │ MediaTypeI
 ... with more rows, and 5 more columns: GenreId, Composer, Milliseconds, Bytes, UnitPrice
 ```
 """
-struct Database{Source}
-    source::Source
-end
-
-"""
-    Database(filename::AbstractString)
-
-Guess the database software from the filename.
-"""
 function Database(filename::AbstractString)
     if endswith(filename, ".sqlite")
         Database(SQLite.DB(filename))

src/functions.jl

@@ -70,7 +70,7 @@ export type_of
 """
     hex(it)
 
-Uppercase heximal representation
+Uppercase hexadecimal representation
 
 ```jldoctest
 julia> using QuerySQLite

src/show.jl

@@ -25,14 +25,6 @@ function tight_infix(io, call, argument1, argument2)
     print(io, argument2)
 end
 
-function parenthesize_infix(io, call, argument1, argument2)
-    print(io, argument1)
-    print(io, ' ')
-    print(io, call)
-    print(io, ' ')
-    print(io, argument2)
-end
-
 function infix(io, call, argument1, argument2, arguments...)
     print(io, argument1)
     print(io, ' ')
@@ -111,7 +103,7 @@ function show(io::IO, sql_expression::SQLExpression)
     elseif call === :AND
         infix(io, call, arguments...)
     elseif call === :AS
-        parenthesize_infix(io, call, arguments...)
+        infix(io, call, arguments...)
     elseif call === :CASE
         case(io, call, arguments...)
     elseif call === :DESC