napa 0.1.29 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b908b554665776da48de53dd708fa5aab073f75
-  data.tar.gz: 22d74ccfd70d4864121f527266e7de4b062a7068
+  metadata.gz: e1c303631113443a38699bded25a0f869222f86a
+  data.tar.gz: 33c810492456288eba6f4e0bfc041db253fa8aef
 SHA512:
-  metadata.gz: 09c3b747af4ec25f35adbc5f65296139d365907901276c0dfcde2f9ebd8f86243ab55edad8ce83849869dde2f20d3487394ea745a222a79340b698ffc6ba4e4c
-  data.tar.gz: 4634f451434e794ad7ec3aa3767272e803348e799de9a8412e7cec54320069074ad95c0b03885022e7d36475491228b79fd8e196491458b66bc31b66aeda9e56
+  metadata.gz: 3b7bb38860e58f64c4909d5647bb4f3d3ade3fb6f685cd3f0fdbdad72573018d316992068fd346b06d274e8bd3f7d872a6af364348efa699de66932f126c4a5c
+  data.tar.gz: 0c85828fa6035881434a92aa4d43d29103476d620233cab74ef951f68e1b3605b9e5cf9b4710a92a9c735f2153d8996f021d4db612f3a9d189182c33f372d50f

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+master
+===
+
+0.2.0
+===
+* The console is now run with `napa console`, added support for racksh
+* Scaffold generator now supports the `--database (-d)` flag
+* Scaffold generator now supports Mysql or Postgres with ActiveRecord
+* Scaffold generator now uses Roar instead of Grape Entity
+* Fixed a bug in `rake routes`
+* Fixed a bug in `rake db:reset`
+* Added StatsD instrumentation (experimental)
+* Added a CHANGELOG

data/README.md

@@ -3,14 +3,7 @@
 
 # Napa
 
-The Napa gem is a simple framework for building APIs with Grape. These features include:
-
-* Generator
-* Console
-* Identity
-* Logging
-* Deployment
-* Grape Specific Features (Cache management and Route inspection) i.e. `rake routes`
+Napa is a simple framework for building Rack based APIs using Grape, Roar and ActiveRecord. It's designed to make it easy to quickly create and deploy new API services by providing **generators**, **middlewares** and a **console** similar to what you would expect from a Rails app.
 
 ## Installation
 
@@ -34,73 +27,72 @@ $ bundle install
 
 ## Getting Started
 
-Napa comes with a useful generator to quickly scaffold up a new project. Simply run:
-
-```
-$ napa new your_project_name
-```
+See the [Quickstart Guide](https://github.com/bellycard/napa/blob/master/docs/quickstart.md) for an intro to creating a simple service with Napa.
 
-This will generate a basic application framework for you. It includes everything you need to get started including a Hello World API.
+## Usage
 
-1) To get started, run Bundler to make sure you have all the gems for the project:
+Run `napa` terminal prompt to see available features:
 
 ```
-$ bundle install
+Commands:
+  napa console                              # Start the Napa console
+  napa generate api <api_name>              # Create a Grape API, Model and Representer
+  napa generate migration <migration_name>  # Create a Database Migration
+  napa help [COMMAND]                       # Describe available commands or one specific command
+  napa new <app_name> [app_path]            # Create a scaffold for a new Napa service
+  napa version                              # Shows the Napa version number
 ```
 
-2) Then, make sure your database connections are setup correctly. The configuration is set in the `.env` and `.env.test`. Then create your database by running:
 
-```
-$ rake db:create
-```
-
-3) Now you're ready to start up the server:
+### Console
+Similar to the Rails console, load an IRB sesson with your applications environment by running:
 
 ```
-$ shotgun
+napa console
 ```
 
-4) Once the server is started, run the following command to load your service in a browser:
-
-```
-$ open http://127.0.0.1:9393/hello
-```
+### Rake Tasks
 
-...and you should see:
+`rake -T` will give you a list of all available rake tasks:
 
 ```
-{
-  message: "Hello Wonderful World!"
-}
+rake db:create          # Create the database
+rake db:drop            # Delete the database
+rake db:migrate         # Migrate the database through scripts in db/migrate
+rake db:reset           # Create the test database
+rake db:schema:dump     # Create a db/schema.rb file that can be portably used against any DB supported by AR
+rake db:schema:load     # Load a schema.rb file into the database
+rake deploy:production  # Deploy to production
+rake deploy:staging     # Deploy to staging
+rake git:set_tag[tag]   # Set tag, which triggers deploy
+rake git:verify         # Verify git repository is in a good state for deployment
+rake routes             # display all routes for Grape
 ```
 
-5) We've also provided a sample spec file. You can run the tests by running:
+## Middlewares
+Napa includes a number of Rack middlewares that can be enabled to add functionality to your project.
 
-```
-RACK_ENV='test' rake db:test:prepare
-rspec spec
-```
+### Authentication
+The Authentication middleware will add a simple header based authentication layer to all requests. This is just looking for a header of `'Password' = 'Your Password'`. The passwords are defined in the `.env` file. You can allow multiple passwords by supplying a comma separated list. For example:
+
+`HEADER_PASSWORDS='password1,password2'`
 
-## Usage/Features
+If your application doesn't require authentication, you can simply remove the middleware.
 
-### Console
-Similar to the Rails console, load an IRB sesson with your applications environment by running:
+### Health Check
+The Health Check middleware will add an endpoint at `/health` that will return some data about your app. This was created to allow monitoring tools a standardized way to monitor multiple services. This endpoint will return a response similar to this:
 
 ```
-ruby console
+{
+    "name": "service-name",
+    "hostname": "host-name",
+    "revision": "current-git-sha-of-app",
+    "pid": 1234,
+    "parent_pid": 1233,
+    "napa_revision": "running-version-of-napa"
+}
 ```
 
-### Identity
-The *Identity* module exists to provide and interface to get information about the application. For example:
-
-`Napa::Identity.name` => Returns the name of the app defined by `ENV['SERVICE_NAME']`.
-
-`Napa::Identity.hostname` => Returns the name of the host running the application.
-
-`Napa::Identity.revision` => Returns the current revision from Git.
-
-`Napa::Identity.pid` => Returns the current running process id.
-
 ### Logger
 The *Logger* modules is used to create a common log format across applications. The Logger is enable via a rack middleware by adding the line below to your `config.ru` file:
 
@@ -120,70 +112,8 @@ ActiveRecord::Base.logger = Napa::Logger.logger
 Napa::Logger.logger.debug 'Some Debug Message'
 ```
 
-### Deployment
-At Belly we leverage a git based deployment process, so we've included some rake tasks we use to automate deployments. These tasks will essentially just tag a commit with `production` or `staging` so that it can be picked up by a separate deployment process.
-
-The tasks currently available are:
-
-```ruby
-rake deploy:staging
-```
-
-
-```ruby
-rake deploy:production
-```
-
-**Please Note:** These tasks rely on two environment variables - `GITHUB_OAUTH_TOKEN` and `GITHUB_REPO`. For more information, see **Environment Variables** below.
-
-### Grape Specific Features
-At Belly we use the [Grape Micro-Framework](https://github.com/intridea/grape) for many services, so we've included a few common features.
-
-#### Cache Managment
-Cache control headers are sent with Grape API responses to prevent clients from caching responses unexpectedly. This feature is enabled by default, so you don't have to make any changes to enable it.
-
-#### Route Inspection
-A rake task is included to give you a Rails style list of your routes. Simpley run:
-
-```ruby
-rake routes
-```
-
-### Environment Variables
-Napa expects to find some environment variables set in your application in order for some features to work. A list is below:
-
-#### SERVICE_NAME
-The name of your app or service, used by Identity and as a label for your logs
-
-#### GITHUB\_OAUTH\_TOKEN
-Used to grant access to your application on Github for deployment tagging
-
-#### GITHUB_REPO
-Your application's Github repo. i.e. `bellycard/napa`
-
-## Middlewares
-Napa includes a number of Rack middlewares that can be enabled to add functionality to your project.
-
-### Authentication
-The Authentication middleware will add a simple header based authentication layer to all requests. This is just looking for a header of `'Password' = 'Your Password'`. The passwords are defined in the `.env` file. You can allow multiple passwords by supplying a comma separated list. For example:
-
-`HEADER_PASSWORDS='password1,password2'`
-
-If your application doesn't require authentication, you can simply remove the middleware.
-
-### Health Check
-The Health Check middleware will add an endpoint at `/health` that will return some data about your app. This was created to allow monitoring tools a standardized way to monitor multiple services. This endpoint will return a response similar to this:
-
-```
-{
-    "name": "service-name",
-    "hostname": "host-name",
-    "revision": "current-git-sha-of-app",
-    "pid": 1234,
-    "parent_pid": 1233,
-    "napa_revision": "running-version-of-napa"
-}
-```
+## Bugs & Feature Requests
+Please add an issue in [Github](https://github.com/bellycard/napa/issues) if you discover a bug or have a feature request.
 
 ## Contributing
 
@@ -192,8 +122,3 @@ The Health Check middleware will add an endpoint at `/health` that will return s
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
-
-
-## Todo/Feature Requests
-
-* Add specs for logger and logging middleware

data/Rakefile

@@ -1,3 +1,4 @@
 #!/usr/bin/env rake
 Dir.glob('./tasks/*.rake').each { |r| import r }
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'napa/active_record_extensions/stats.rb'

data/docs/quickstart.md

@@ -0,0 +1,292 @@
+#Napa Quickstart
+
+Napa was designed to make it easy to quickly create a new API service. Here we will cover the steps required to create a new simple API service using Napa, Grape, Roar and ActiveRecord.
+
+Napa is available as a Ruby gem, to install it run:
+
+```
+gem install napa
+```
+
+## Service Scaffold
+
+In this example we will create a new API to manage a directory of people. Each person will have a `name`, `job_title` and `email_address`. To get started, create a new scaffold by running:
+
+```
+napa new people_service
+```
+
+**Note:** by default, Napa will configure itself to use Mysql. If you prefer to use Postgres, simply pass in the `-d=pg` option to the `napa new` command.
+
+You will see the following output:
+
+```
+Generating scaffold...
+      create  people_service
+      create  people_service/.env.test
+      create  people_service/.env
+      create  people_service/.gitignore
+      create  people_service/.rubocop.yml
+      create  people_service/.ruby-gemset
+      create  people_service/.ruby-version
+      create  people_service/Gemfile
+      create  people_service/README.md
+      create  people_service/Rakefile
+      create  people_service/app.rb
+      create  people_service/app/apis/application_api.rb
+      create  people_service/app/apis/hello_api.rb
+      create  people_service/config.ru
+      create  people_service/config/database.yml
+      create  people_service/config/initializers/active_record.rb
+      create  people_service/config/middleware/honeybadger.rb
+      create  people_service/db/schema.rb
+      create  people_service/lib/.keep
+      create  people_service/log/.gitkeep
+      create  people_service/spec/apis/hello_api_spec.rb
+      create  people_service/spec/factories/.gitkeep
+      create  people_service/spec/spec_helper.rb
+Done!
+```
+
+Now, change into the `people_service` directory and run Bundler to get all the gems you need:
+
+```
+bundle install
+```
+
+Once Bundler is done, you can create your databases by running:
+
+```
+rake db:reset
+RACK_ENV=test rake db:reset
+```
+
+These tasks will look into the `.env` and `.env.test` files and drop, create and migrate the databases.
+
+Once your databases are setup, you can run `rspec` to verify everything is working. The Napa generator includes a sample API and spec file in it's scaffold.
+
+```
+rspec spec
+```
+
+## API Generator
+
+Now that we have our service scaffolded up, let's generate an API.
+
+Napa include an API generator which will create a Grape API, Model and Representer by running:
+
+```
+napa generate api person
+```
+
+**Note:** the generator will pluralize the name of your resource for the API, so use the singular version in the generator.
+
+You will see the following output:
+
+```
+Generating api...
+      create  app/apis/people_api.rb
+      create  app/models/person.rb
+      create  app/representers/person_representer.rb
+Done!
+```
+
+## Create a Person model
+
+From the output above, we can see that the generated create a `Person` model, so we should create a migration to actually build the table for that in our database. So, let's run:
+
+```
+napa generate migration CreatePerson
+```
+
+You will see the following output:
+
+```
+Generating migration...
+      create  db/migrate
+      create  db/migrate/20140411163743_create_person.rb
+Done!
+```
+
+Open up that migration file and add the migration to create the `people` table:
+
+```ruby
+class CreatePerson < ActiveRecord::Migration
+  def change
+    create_table :people do |t|
+      t.string :name
+      t.string :job_title
+      t.string :email
+    end
+  end
+end
+```
+
+Then you can run:
+
+```
+rake db:migrate
+```
+
+## Declare these attributes in the API and Representer
+
+To provide a more secure API, the Napa generator requires you to declare any parameters your API will accept. This is done in the `params` blocks related to the specific request. In this case we will want to declare the params in `people_api.rb` for `POST` and `PUT` to be:
+
+### POST
+
+```ruby
+desc 'Create a person'
+params do
+  optional :name, type: String, desc: 'The Name of the person'
+  optional :job_title, type: String, desc: 'The Job Title of the person'
+  optional :email, type: String, desc: 'The Email Address of the person'
+end
+```
+
+### PUT
+```ruby
+desc 'Update a person'
+params do
+  optional :name, type: String, desc: 'The Name of the person'
+  optional :job_title, type: String, desc: 'The Job Title of the person'
+  optional :email, type: String, desc: 'The Email Address of the person'
+end
+```
+
+Then, finally, add these new fields to the `person_representer.rb` so they will be returned from the API response.
+
+```ruby
+class PersonRepresenter < Napa::Representer
+  property :id, type: String
+  property :name
+  property :job_title
+  property :email
+end
+```
+
+## Wire it all up
+
+The last thing you'll need to do is mount your new endpoint into the `ApplicationApi`. Your file will look like this:
+
+```ruby
+class ApplicationApi < Grape::API
+  format :json
+  extend Napa::GrapeExtenders
+
+  mount PeopleApi => '/people'
+
+  add_swagger_documentation
+end
+```
+
+Tada, you now have an API!
+
+## Send some requests
+
+Now that the code is in place, let's start up the app and send it some requests.
+
+Napa runs on Rack, so any rack based webserver will work. Shotgun is nice to use in development because it will reload your app on each request and you don't need to restart the server when there are changes.
+
+Start the server on port 9393 by running:
+
+```
+shotgun
+```
+
+### POST /people
+
+To create a person we will send a `POST` request to our API.
+
+```
+curl -X POST -d name="Darby Frey" -d job_title="Software Engineer" -d email="darbyfrey@gmail.com" http://localhost:9393/people
+```
+
+**SIDENOTE:** At this point, you will likely get an error response like the one below. By default Napa ships with the `Napa::Middleware::Authentication` enabled. For the purposes of this guide, we will disable this middleware to make the requests easier to construct. Be sure to re-enable this before you go to production. To disable the middleware, just comment out the `use Napa::Middleware::Authentication` line in `config.ru` and restart shotgun. Also, see the Napa::Middleware::Authentication docs for more details.
+
+```json
+{
+  "error": {
+    "code": "not_configured",
+    "message": "password not configured"
+  }
+}
+```
+
+
+All response from Napa include the `data` key. In this case the newly created person object is returned nested within the `data` key.
+
+```json
+{
+  "data": {
+    "object_type": "person",
+    "id": "1",
+    "name": "Darby Frey",
+    "job_title": "Software Engineer",
+    "email": "darbyfrey@gmail.com"
+  }
+}
+```
+
+### GET /people
+
+```
+curl -X GET http://localhost:9393/people
+```
+All response from Napa include the `data` key. In this case, we see an array containing just one user object.
+
+```json
+{
+  "data": [
+    {
+      "id": 1,
+      "name": "Darby Frey",
+      "job_title": "Software Engineer",
+      "email": "darbyfrey@gmail.com"
+    }
+  ]
+}
+```
+
+### GET /people/:person_id
+
+```
+curl -X GET http://localhost:9393/people/1
+```
+
+```json
+{
+  "data": {
+    "object_type": "person",
+    "id": "1",
+    "name": "Darby Frey",
+    "job_title": "Software Engineer",
+    "email": "darbyfrey@gmail.com"
+  }
+}
+```
+
+### PUT /people/:person_id
+
+```
+curl -X PUT -d job_title="Doctor Pepper" http://localhost:9393/people/1
+```
+
+```json
+{
+  "data": {
+    "object_type": "person",
+    "id": "1",
+    "name": "Darby Frey",
+    "job_title": "Doctor Pepper",
+    "email": "darbyfrey@gmail.com"
+  }
+}
+```
+
+So, there you have it, a new API service in minutes. It's very basic, but you can continue to build it out from here. One thing to note, we don't generate a `DELETE` request from the generator, but you can easily add that. The resources section below will link you to the Grape docs where you can find those instructions.
+
+## Resources
+
+* [Code Example: people-service](https://github.com/darbyfrey/people_service)
+* [Grape](http://intridea.github.io/grape/)
+* [Roar](https://github.com/apotonick/roar)

data/lib/napa/active_record_extensions/stats.rb

@@ -0,0 +1,46 @@
+if defined?(ActiveSupport)
+  module Napa
+    module ActiveRecordStats
+      SQL_INSERT_DELETE_PARSER_REGEXP = /^(?<action>\w+)\s(\w+)\s\W*(?<table>\w+)/
+      SQL_SELECT_REGEXP = /select .*? FROM \W*(?<table>\w+)/i
+      SQL_UPDATE_REGEXP = /update \W*(?<table>\w+)/i
+
+      # Returns the table and query type
+      def self.extract_from_sql_inserts_deletes(query)
+        m = query.match(SQL_INSERT_DELETE_PARSER_REGEXP)
+        [m[:table], m[:action]]
+      end
+
+      def self.extract_sql_selects(query)
+        m = query.match(SQL_SELECT_REGEXP)
+        [m[:table], 'SELECT']
+      end
+
+      def self.guess_sql_content(query)
+        m = query.match(SQL_UPDATE_REGEXP)
+        return [m[:table], 'UPDATE'] if m
+        unless m
+          m = query.match(SQL_SELECT_REGEXP)
+          extract_sql_selects(query) if m
+        end
+      end
+
+      ActiveSupport::Notifications.subscribe 'sql.active_record' do |name, start, finish, id, payload|
+        if payload[:name] == 'SQL'
+          table, action = extract_from_sql_inserts_deletes(payload[:sql])
+        elsif payload[:name] =~ /.* Load$/
+          table, action = extract_sql_selects(payload[:sql])
+        elsif !payload[:name]
+          table, action = guess_sql_content(payload[:sql])
+        end
+
+        if table
+          stat_context = "#{Thread.current[:stats_context] || Napa::Identity.name + '.unknown'}"
+          Napa::Stats.emitter.timing(
+            "#{stat_context}.sql.#{table}.#{action.downcase}.query_time",
+            (finish - start) * 1000)
+        end
+      end
+    end
+  end
+end

data/lib/napa/cli.rb

@@ -28,6 +28,25 @@ module Napa
         say Napa::VERSION
       end
 
+      desc 'console', 'Start the Napa console'
+      def console
+        require 'racksh/init'
+
+        begin
+          require "pry"
+          interpreter = Pry
+        rescue LoadError
+          require "irb"
+          require "irb/completion"
+          interpreter = IRB
+        end
+
+        Rack::Shell.init
+
+        $0 = "#{$0} console"
+        interpreter.start
+      end
+
       register(
         Generators::ScaffoldGenerator,
         'new',
@@ -35,7 +54,7 @@ module Napa
         'Create a scaffold for a new Napa service'
       )
 
-      desc "generate api <api_name>", "Create a Grape API, Model and Entity"
+      desc "generate api <api_name>", "Create a Grape API, Model and Representer"
       subcommand "generate api", Napa::CLI::Generate
 
       desc "generate migration <migration_name>", "Create a Database Migration"

data/lib/napa/generators/scaffold_generator.rb

@@ -10,10 +10,15 @@ module Napa
 
       argument :app_name
       argument :app_path, optional: true
+      class_option :database, default: 'mysql', aliases: '-d', desc: 'Preconfigure for selected database (options: mysql/postgres/pg)'
 
       def generate
         say 'Generating scaffold...'
 
+        @database_gem     = ['pg','postgres'].include?(options[:database]) ? 'pg' : 'mysql2'
+        @database_adapter = ['pg','postgres'].include?(options[:database]) ? 'postgresql' : 'mysql2'
+        @database_user    = ['pg','postgres'].include?(options[:database]) ? '' : 'root'
+
         directory ".", (app_path || app_name)
 
         say 'Done!', :green

data/lib/napa/generators/templates/api/app/apis/%name_tableize%_api.rb.tt

@@ -1,41 +1,41 @@
 class <%= name.classify.pluralize %>Api < Grape::API
-  desc 'Get a list of <%= name.underscore.tableize %>', entity: <%= name.classify %>Entity
+  desc 'Get a list of <%= name.underscore.tableize %>'
   params do
     optional :ids, type: String, desc: 'comma separated <%= name.underscore %> ids'
   end
   get do
     <%= name.underscore.tableize %> = <%= name.classify %>.filter(declared(params, include_missing: false))
-    present <%= name.underscore.tableize %>, with: <%= name.classify %>Entity
+    represent <%= name.underscore.tableize %>, with: <%= name.classify %>Representer
   end
 
-  desc 'Create an <%= name.underscore %>', entity: <%= name.classify %>Entity
+  desc 'Create an <%= name.underscore %>'
   params do
   end
 
   post do
     <%= name.underscore %> = <%= name.classify %>.create(declared(params, include_missing: false))
     error!(present_error(:record_invalid, <%= name.underscore %>.errors.full_messages)) unless <%= name.underscore %>.errors.empty?
-    present <%= name.underscore %>, with: <%= name.classify %>Entity
+    represent <%= name.underscore %>, with: <%= name.classify %>Representer
   end
 
   params do
     requires :id, desc: 'ID of the <%= name.underscore %>'
   end
   route_param :id do
-    desc 'Get an <%= name.underscore %>', entity: <%= name.classify %>Entity
+    desc 'Get an <%= name.underscore %>'
     get do
       <%= name.underscore %> = <%= name.classify %>.find(params[:id])
-      present <%= name.underscore %>, with: <%= name.classify %>Entity
+      represent <%= name.underscore %>, with: <%= name.classify %>Representer
     end
 
-    desc 'Update an <%= name.underscore %>', entity: <%= name.classify %>Entity
+    desc 'Update an <%= name.underscore %>'
     params do
     end
     put do
       # fetch <%= name.underscore %> record and update attributes.  exceptions caught in app.rb
       <%= name.underscore %> = <%= name.classify %>.find(params[:id])
-      <%= name.underscore %>.update_attributes!(declared(params, include_missing: false)
-      present <%= name.underscore %>, with: <%= name.classify %>Entity
+      <%= name.underscore %>.update_attributes!(declared(params, include_missing: false))
+      represent <%= name.underscore %>, with: <%= name.classify %>Representer
     end
   end
 end

data/lib/napa/generators/templates/api/app/representers/%name_underscore%_representer.rb.tt

@@ -0,0 +1,4 @@
+class <%= name.classify %>Representer < Napa::Representer
+  property :id, type: String
+
+end

data/lib/napa/generators/templates/scaffold/.env.test.tt

@@ -1,7 +1,7 @@
 SERVICE_NAME=<%= app_name %>
 RACK_ENV=test
 
-DATABASE_USER=root
+DATABASE_USER='<%= @database_user %>'
 DATABASE_PASSWORD=''
 DATABASE_HOST=localhost
 DATABASE_NAME=<%= app_name.underscore %>_test

data/lib/napa/generators/templates/scaffold/.env.tt

@@ -1,6 +1,6 @@
 SERVICE_NAME=<%= app_name %>
 
-DATABASE_USER=root
+DATABASE_USER='<%= @database_user %>'
 DATABASE_PASSWORD=''
 DATABASE_HOST=localhost
 DATABASE_NAME=<%= app_name.underscore %>_development

data/lib/napa/generators/templates/scaffold/.gitignore.tt

@@ -1,5 +1,3 @@
-.ruby-gemset
-.ruby-version
 .DS_Store
 .env
 .vagrant

data/lib/napa/generators/templates/scaffold/.ruby-gemset.tt

@@ -0,0 +1 @@
+<%= app_name %>

data/lib/napa/generators/templates/scaffold/.ruby-version.tt

@@ -0,0 +1 @@
+2.0.0

data/lib/napa/generators/templates/scaffold/{Gemfile → Gemfile.tt}

@@ -1,13 +1,14 @@
 source 'https://rubygems.org'
+ruby "2.0.0"
 
 gem 'rack-cors'
-gem 'mysql2'
+gem '<%= @database_gem %>'
 gem 'activerecord', '~> 4.0.0', :require => 'active_record'
 gem 'honeybadger'
 gem 'json'
 gem 'shotgun'
 gem 'napa'
-gem 'grape-entity'
+gem 'roar'
 gem 'grape-swagger'
 
 group :development,:test do

data/lib/napa/generators/templates/scaffold/app.rb

@@ -15,5 +15,5 @@ Dir['./config/initializers/**/*.rb'].map { |file| require file }
 Dir['./config/middleware/**/*.rb'].map { |file| require file }
 
 # autoload app
-relative_load_paths = %w[app/apis app/entities app/models app/workers lib]
+relative_load_paths = %w[app/apis app/representers app/models app/workers lib]
 ActiveSupport::Dependencies.autoload_paths += relative_load_paths

data/lib/napa/generators/templates/scaffold/config/database.yml.tt

@@ -0,0 +1,18 @@
+defaults: &defaults
+  adapter: <%= @database_adapter %>
+  host: <%%= ENV['DATABASE_HOST'] %>
+  username: <%%= ENV['DATABASE_USER'] %>
+  password: <%%= ENV['DATABASE_PASSWORD'] %>
+  database: <%%= ENV['DATABASE_NAME'] %>
+
+production:
+  <<: *defaults
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+staging:
+  <<: *defaults

data/lib/napa/generators/templates/scaffold/config.ru.tt

@@ -1,5 +1,8 @@
 require './app'
 
+# Experimental StatsD Emitter for ActiveRecord
+# require 'napa/active_record_extensions/stats.rb'
+
 # use Rack::Cors do
 #   allow do
 #     origins '*'

data/lib/napa/generators/templates/scaffold/db/schema.rb

@@ -0,0 +1,11 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.

data/lib/napa/grape_extensions/grape_helpers.rb

@@ -0,0 +1,20 @@
+module Napa
+  module GrapeHelpers
+    def represent(data, with: nil, **args)
+      raise ArgumentError.new(":with option is required") if with.nil?
+
+      if data.respond_to?(:to_a)
+        return { data: data.each{ |item| with.new(item).to_hash(args) } }
+      else
+        return { data: with.new(data).to_hash(args)}
+      end
+    end
+
+    def present_error(code, message = '')
+      Napa::JsonError.new(code, message)
+    end
+
+    # extend all endpoints to include this
+    Grape::Endpoint.send :include, self
+  end
+end

data/lib/napa/grape_extensions/representer.rb

@@ -0,0 +1,12 @@
+require 'roar/decorator'
+require 'roar/representer/json'
+require 'roar/representer/feature/coercion'
+
+module Napa
+  class Representer < Roar::Decorator
+    include Roar::Representer::JSON
+    include Representable::Coercion
+
+    property :object_type, getter: lambda { |*| self.class.name.underscore }
+  end
+end

data/lib/napa/middleware/request_stats.rb

@@ -29,11 +29,11 @@ module Napa
         
         request = Rack::Request.new(env)
         path = normalize_path(request.path_info)
-        stat = "#{Napa::Identity.name}.http.#{request.request_method.downcase}.#{path}".gsub('/', '.')
+        Thread.current[:stats_context] = "#{Napa::Identity.name}.http.#{request.request_method.downcase}.#{path}".gsub('/', '.')
 
         # Emit stats to StatsD
-        Napa::Stats.emitter.increment(stat + '.requests')
-        Napa::Stats.emitter.timing(stat + '.response_time', response_time)
+        Napa::Stats.emitter.increment(Thread.current[:stats_context] + '.requests')
+        Napa::Stats.emitter.timing(Thread.current[:stats_context] + '.response_time', response_time)
         # Return the results
         [status, headers, body]
       end

data/lib/napa/version.rb

@@ -1,5 +1,5 @@
 module Napa
-  VERSION = '0.1.29'
+  VERSION = '0.2.0'
 
   class Version
     class << self

data/lib/napa.rb

@@ -17,8 +17,9 @@ require 'napa/json_error'
 require 'napa/stats'
 require 'napa/active_record_extensions/filter_by_hash'
 require 'napa/grape_extensions/error_formatter'
-require 'napa/grape_extensions/error_presenter'
+require 'napa/grape_extensions/grape_helpers'
 require 'napa/grape_extensions/entity'
+require 'napa/grape_extensions/representer'
 require 'napa/grape_extenders'
 require 'napa/middleware/logger'
 require 'napa/middleware/app_monitor'

data/lib/tasks/db.rake

@@ -16,17 +16,28 @@ unless defined?(Rails)
     desc "Create the database"
     task :create => :environment do
       db = YAML.load(ERB.new(File.read('./config/database.yml')).result)[Napa.env]
-      adapter = db.merge({'database'=> 'mysql'})
-      ActiveRecord::Base.establish_connection(adapter)
-      ActiveRecord::Base.connection.create_database(db.fetch('database'))
+
+      options = {}.tap do |o|
+        o[:adapter]                 = db['adapter']
+        o[:database]                = 'postgres' if db['adapter'] == 'postgres'
+      end
+
+      ActiveRecord::Base.establish_connection(options)
+      ActiveRecord::Base.connection.create_database(db['database'])
+
     end
 
     desc "Delete the database"
     task :drop => :environment do
       db = YAML.load(ERB.new(File.read('./config/database.yml')).result)[Napa.env]
-      adapter = db.merge({'database'=> 'mysql'})
-      ActiveRecord::Base.establish_connection(adapter)
-      ActiveRecord::Base.connection.drop_database(db.fetch('database'))
+
+      options = {}.tap do |o|
+        o[:adapter]                 = db['adapter']
+        o[:database]                = 'postgres' if db['adapter'] == 'postgres'
+      end
+
+      ActiveRecord::Base.establish_connection(options)
+      ActiveRecord::Base.connection.drop_database(db['database'])
     end
 
     desc "Create the test database"

data/lib/tasks/routes.rake

@@ -1,17 +1,10 @@
 unless defined?(Rails)
   desc "display all routes for Grape"
   task :routes do
-    grape_apis = ObjectSpace.each_object(Class).select do |klass|
-      begin
-        klass < Grape::API
-      rescue
-        false
-      end
-    end
-    grape_apis.each do |api|
-      api.routes.each do |r|
-        puts "#{r}"
-      end
+    ApplicationApi.routes.each do |api|
+      method  = api.route_method.ljust(10)
+      path    = api.route_path
+      puts    "     #{method} #{path}"
     end
   end
 end

data/napa.gemspec

@@ -24,13 +24,15 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'virtus'
   gem.add_dependency 'grape'
   gem.add_dependency 'grape-swagger'
-  gem.add_dependency 'grape-entity'
+  gem.add_dependency 'roar'
   gem.add_dependency 'unicorn'
   gem.add_dependency 'statsd-ruby'
+  gem.add_dependency 'racksh'
 
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'git'
   gem.add_development_dependency 'rubocop'
   gem.add_development_dependency 'activerecord', '~>3.2.2'
+  gem.add_development_dependency 'sqlite3'
 end

data/spec/active_record_extensions/stats_spec.rb

@@ -0,0 +1,59 @@
+require 'active_record'
+require 'spec_helper'
+require 'napa/active_record_extensions/stats.rb'
+
+# Delete any prevous instantiations of the emitter and set valid statsd env vars
+Napa::Stats.emitter = nil
+ENV['STATSD_HOST'] = 'localhost'
+ENV['STATSD_PORT'] = '8125'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table :foos do |t|
+    t.string :word
+  end
+end
+
+class Foo < ActiveRecord::Base
+end
+
+describe Napa::ActiveRecordStats do
+  before(:each) do
+    Foo.delete_all
+    @x = Foo.create(word: 'bar')
+  end
+
+  it 'should send a query_time for an insert' do
+    Napa::Stats.emitter.should_receive(:timing).with(
+      "#{Napa::Identity.name}.unknown.sql.foos.insert.query_time",
+      an_instance_of(Float)
+    )
+    Foo.create(word: 'baz')
+  end
+
+  it 'should send a query_time for a select' do
+    Napa::Stats.emitter.should_receive(:timing).with(
+      "#{Napa::Identity.name}.unknown.sql.foos.select.query_time",
+      an_instance_of(Float)
+    )
+    Foo.all
+  end
+
+  it 'should send a query_time for a delete' do
+    Napa::Stats.emitter.should_receive(:timing).with(
+      "#{Napa::Identity.name}.unknown.sql.foos.delete.query_time",
+      an_instance_of(Float)
+    )
+    @x.delete
+  end
+
+  it 'should send a query_time for an update' do
+    Napa::Stats.emitter.should_receive(:timing).with(
+      "#{Napa::Identity.name}.unknown.sql.foos.update.query_time",
+      an_instance_of(Float)
+    )
+    @x.word = 'baz'
+    @x.save
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: napa
 version: !ruby/object:Gem::Version
-  version: 0.1.29
+  version: 0.2.0
 platform: ruby
 authors:
 - Darby Frey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: grape-entity
+  name: roar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -164,6 +164,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: racksh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -234,6 +248,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 3.2.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A simple framework for building APIs with Grape
 email:
 - darby@bellycard.com
@@ -245,13 +273,16 @@ files:
 - .gitignore
 - .rubocop.yml
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - bin/napa
+- docs/quickstart.md
 - lib/napa.rb
 - lib/napa/active_record_extensions/filter_by_hash.rb
+- lib/napa/active_record_extensions/stats.rb
 - lib/napa/authentication.rb
 - lib/napa/cli.rb
 - lib/napa/generators.rb
@@ -259,24 +290,27 @@ files:
 - lib/napa/generators/migration_generator.rb
 - lib/napa/generators/scaffold_generator.rb
 - lib/napa/generators/templates/api/app/apis/%name_tableize%_api.rb.tt
-- lib/napa/generators/templates/api/app/entities/%name_underscore%_entity.rb.tt
 - lib/napa/generators/templates/api/app/models/%name_underscore%.rb.tt
+- lib/napa/generators/templates/api/app/representers/%name_underscore%_representer.rb.tt
 - lib/napa/generators/templates/migration/%migration_filename%.rb.tt
 - lib/napa/generators/templates/scaffold/.env.test.tt
 - lib/napa/generators/templates/scaffold/.env.tt
 - lib/napa/generators/templates/scaffold/.gitignore.tt
 - lib/napa/generators/templates/scaffold/.rubocop.yml
-- lib/napa/generators/templates/scaffold/Gemfile
+- lib/napa/generators/templates/scaffold/.ruby-gemset.tt
+- lib/napa/generators/templates/scaffold/.ruby-version.tt
+- lib/napa/generators/templates/scaffold/Gemfile.tt
 - lib/napa/generators/templates/scaffold/README.md
 - lib/napa/generators/templates/scaffold/Rakefile
 - lib/napa/generators/templates/scaffold/app.rb
 - lib/napa/generators/templates/scaffold/app/apis/application_api.rb
 - lib/napa/generators/templates/scaffold/app/apis/hello_api.rb.tt
 - lib/napa/generators/templates/scaffold/config.ru.tt
-- lib/napa/generators/templates/scaffold/config/database.yml
+- lib/napa/generators/templates/scaffold/config/database.yml.tt
 - lib/napa/generators/templates/scaffold/config/initializers/active_record.rb
 - lib/napa/generators/templates/scaffold/config/middleware/honeybadger.rb
-- lib/napa/generators/templates/scaffold/console
+- lib/napa/generators/templates/scaffold/db/schema.rb
+- lib/napa/generators/templates/scaffold/lib/.keep
 - lib/napa/generators/templates/scaffold/log/.gitkeep
 - lib/napa/generators/templates/scaffold/spec/apis/hello_api_spec.rb.tt
 - lib/napa/generators/templates/scaffold/spec/factories/.gitkeep
@@ -284,7 +318,8 @@ files:
 - lib/napa/grape_extenders.rb
 - lib/napa/grape_extensions/entity.rb
 - lib/napa/grape_extensions/error_formatter.rb
-- lib/napa/grape_extensions/error_presenter.rb
+- lib/napa/grape_extensions/grape_helpers.rb
+- lib/napa/grape_extensions/representer.rb
 - lib/napa/identity.rb
 - lib/napa/json_error.rb
 - lib/napa/logger/log_transaction.rb
@@ -303,6 +338,7 @@ files:
 - lib/tasks/routes.rake
 - napa.gemspec
 - spec/active_record_extensions/filter_by_hash_spec.rb
+- spec/active_record_extensions/stats_spec.rb
 - spec/authentication_spec.rb
 - spec/grape_extensions/error_formatter_spec.rb
 - spec/identity_spec.rb
@@ -333,12 +369,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A simple framework for building APIs with Grape
 test_files:
 - spec/active_record_extensions/filter_by_hash_spec.rb
+- spec/active_record_extensions/stats_spec.rb
 - spec/authentication_spec.rb
 - spec/grape_extensions/error_formatter_spec.rb
 - spec/identity_spec.rb

data/lib/napa/generators/templates/api/app/entities/%name_underscore%_entity.rb.tt

@@ -1,7 +0,0 @@
-class <%= name.classify %>Entity < Napa::Entity
-  root :data, :data
-  expose :id, proc: lambda { |o, opts| o.id.to_s }, documentation:
-    { type: 'String', description: 'ID' }
-  expose :type, proc: lambda { |o, opts| o.class.name.underscore }, documentation:
-    { type: 'String', description: '"<%= name.underscore %>"' }
-end

data/lib/napa/generators/templates/scaffold/config/database.yml

@@ -1,18 +0,0 @@
-defaults: &defaults
-  adapter: mysql2
-  host: <%= ENV['DATABASE_HOST'] %>
-  username: <%= ENV['DATABASE_USER'] %>
-  password: <%= ENV['DATABASE_PASSWORD'] %>
-  database: <%= ENV['DATABASE_NAME'] %>
-
-production:
-  <<: *defaults
-
-development:
-  <<: *defaults
-
-test:
-  <<: *defaults
-
-staging:
-  <<: *defaults

data/lib/napa/generators/templates/scaffold/console

@@ -1,9 +0,0 @@
-require './app'
-
-begin
-  require 'pry'
-  Pry.start
-rescue LoadError
-  require 'irb/completion'
-  IRB.start
-end

data/lib/napa/grape_extensions/error_presenter.rb

@@ -1,10 +0,0 @@
-module Napa
-  module ErrorPresenter
-    def present_error(code, message = '')
-      Napa::JsonError.new(code, message)
-    end
-
-    # extend all endpoints to include this
-    Grape::Endpoint.send :include, self
-  end
-end