napa 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 411eb368134bee542c4fb51fa4a180c5b1a65ccc
-  data.tar.gz: d2ca60df98d4c3f260e5c0df9864087bbda48dcd
+  metadata.gz: 91335a0b0cd0c3a0efd87528894698508f26f51f
+  data.tar.gz: 04c64e2dd763c45a38a89d8a84e0f5bdaf80dbad
 SHA512:
-  metadata.gz: c950462ba0a5d7c8e8c249a4d23243e1d91e742ead2aef1ca760af45b2bf8412340e1474f433a5fa1c0280c9ac18bb74cef37ed471ec4c82a54abc49b5eb31d9
-  data.tar.gz: 56aa083725ab045cfcafd55ff579e0ad617fdadbd90aa5df16eee7db7efc1929b26ff30040cfaf50b708e5603d31d9ef74707bee01ad92bcbacf8b40341fd0d1
+  metadata.gz: 1f25478d3900145201937e2b3f79c2f3cc7fd8d4c0ce8c2a0656137773d557eb2f34dd3e976bf5a6f5698c395c6b4a762e917a5388585891a7f24a549e10461d
+  data.tar.gz: d257e109aed088d50f701873bdf1d56cfff66f2f9df2fb4f2b2d4b6bcd07f0aecd26c9cd1b906b5c2c15e46575e834f11a8dfbf2f729133e7284cc67508957d9

data/.dockerignore

@@ -0,0 +1,6 @@
+.env
+.env.test
+.git
+.rubocop.yml
+.travis.yml
+log/*

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 master
 ===
+* [Support for Rails style Model Generation](https://github.com/bellycard/napa/pull/207)
+* [Resolves issue #205 by adding hashie-forbidden_attributes gem to generated Gemfile](https://github.com/bellycard/napa/pull/206)
+* [use RAILS_ENV if RACK_ENV not found](https://github.com/bellycard/napa/pull/200)
+* [Support for creating and dropping databases on non-standard ports](https://github.com/bellycard/napa/pull/166)
+* Added an rspec response helper `expect_error_code` for easier testing of API methods which are supposed to send back a JSON representation of an error
 
 0.4.3
 ===

data/Dockerfile

@@ -0,0 +1,29 @@
+FROM ruby:2.0.0-p643
+
+# Install deps
+RUN apt-get update \
+  && apt-get install -y libreadline-dev nano vim \
+  && apt-get purge -y --auto-remove
+
+# Ensure Gemfile.lock is up to date
+RUN bundle config --global frozen 1
+
+# Install latest released Napa to get baseline dependencies
+RUN gem install napa
+
+# Add a simple Procfile parser
+ADD contrib/start.rb /start
+
+# Create directory for app
+RUN mkdir -p /usr/src/app
+WORKDIR /usr/src/app
+
+# Copy Gemfile and Gemfile.lock and run bundle install
+ONBUILD COPY Gemfile /usr/src/app/
+ONBUILD COPY Gemfile.lock /usr/src/app/
+ONBUILD RUN bundle install
+
+# Copy rest of app
+ONBUILD COPY . /usr/src/app
+
+CMD ["/start", "web"]

data/contrib/start.rb

@@ -0,0 +1,19 @@
+#!/usr/local/bin/ruby
+
+require 'yaml'
+
+# attempt to parse Procfile
+begin
+  proc = YAML.load_file('Procfile')
+  command = proc[ARGV[0]]
+
+  if command
+    exec(command)
+  else
+    puts "Could not find #{ARGV[0]} in Procfile"
+    exit 1
+  end
+rescue
+  puts 'Failed to parse Procfile'
+  exit 2
+end

data/docs/quickstart.md

@@ -69,63 +69,52 @@ Once your databases are setup, you can run `rspec` to verify everything is worki
 rspec spec
 ```
 
-## API Generator
+## Model Generator
 
-Now that we have our service scaffolded up, let's generate an API.
+Now that we have our service scaffolded up, let's generate the data model for our service.
 
-Napa includes an API generator which will create a Grape API, Model and Representer by running:
+Napa includes a Model generator that will create an ActiveRecord model, the associated database migration, a factory stub for testing, and an initial rspec test. To invoke this, run:
 
 ```
-napa generate api person
+napa generate model Person name:string job_title:string email:string
 ```
 
-**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
+Generating model...
+      create  db/migrate/20140411163743_create_people.rb
       create  app/models/person.rb
-      create  app/representers/person_representer.rb
+      create  spec/factories/people.rb
+      create  spec/models/person_spec.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:
+Now we're ready to create and setup our databases by running:
 
 ```
-napa generate migration CreatePerson name job_title email 
+rake db:migrate
+RACK_ENV=test rake db:migrate
 ```
 
-You will see the following output:
+## API Generator
+
+Next, let's generate an API to expose this information. Napa also includes an API generator which will create a Grape API, Model and Representer by running:
 
 ```
-Generating migration...
-      create  db/migrate
-      create  db/migrate/20140411163743_create_person.rb
-Done!
+napa generate api person
 ```
 
-Open up that migration file and see the generated migration for 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
-```
+**Note:** the generator will pluralize the name of your resource for the API, so use the singular version in the generator.
 
-Then you can run:
+You will see the following output:
 
 ```
-rake db:migrate
+Generating api...
+      create  app/apis/people_api.rb
+      create  app/representers/person_representer.rb
+      create  spec/apis/people_api_spec.rb
+Done!
 ```
 
 ## Declare these attributes in the API and Representer
@@ -201,17 +190,7 @@ 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"
-  }
-}
-```
-
+**SIDENOTE:** Napa ships with authentication support via the `Napa::Middleware::Authentication` middleware. This middleware is disabled by default, but can be enabled by uncommenting the `use Napa::Middleware::Authentication` line in `config.ru` and restarting shotgun. Also, see the Napa::Middleware::Authentication docs for more details.
 
 All response from Napa include the `data` key. In this case the newly created person object is returned nested within the `data` key.
 

data/lib/napa/cli/generate.rb

@@ -1,6 +1,7 @@
 require "napa/cli/generate/api"
 require "napa/cli/generate/readme"
 require "napa/cli/migration"
+require "napa/cli/model"
 
 module Napa
   module CLI
@@ -13,6 +14,13 @@ module Napa
         'Create a Database Migration'
       )
 
+      register(
+        Model,
+        'model',
+        'model <NAME> [field[:type][:index] field[:type][:index]] [options]',
+        'Create a Model, including its database migration and test scaffolding'
+      )
+
     end
   end
 end

data/lib/napa/cli/generated_attribute.rb

@@ -0,0 +1,170 @@
+module Napa
+  module CLI
+    # directly ported with slight modification from
+    # https://github.com/rails/rails/blob/76883f92374c6395f13c16628e1d87d40b6d2399/railties/lib/rails/generators/generated_attribute.rb
+    class GeneratedAttribute # :nodoc:
+      INDEX_OPTIONS = %w(index uniq)
+      UNIQ_INDEX_OPTIONS = %w(uniq)
+
+      attr_accessor :name, :type
+      attr_reader   :attr_options
+      attr_writer   :index_name
+
+      class << self
+        def parse(column_definition)
+          name, type, has_index = column_definition.split(':')
+
+          # if user provided "name:index" instead of "name:string:index"
+          # type should be set blank so GeneratedAttribute's constructor
+          # could set it to :string
+          has_index, type = type, nil if INDEX_OPTIONS.include?(type)
+
+          type, attr_options = *parse_type_and_options(type)
+          type = type.to_sym if type
+
+          if type && reference?(type)
+            references_index = UNIQ_INDEX_OPTIONS.include?(has_index) ? { unique: true } : true
+            attr_options[:index] = references_index
+          end
+
+          new(name, type, has_index, attr_options)
+        end
+
+        def reference?(type)
+          [:references, :belongs_to].include? type
+        end
+
+        private
+
+        # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
+        # when declaring options curly brackets should be used
+        def parse_type_and_options(type)
+          case type
+          when /(string|text|binary|integer)\{(\d+)\}/
+            return $1, limit: $2.to_i
+          when /decimal\{(\d+)[,.-](\d+)\}/
+            return :decimal, precision: $1.to_i, scale: $2.to_i
+          when /(references|belongs_to)\{polymorphic\}/
+            return $1, polymorphic: true
+          else
+            return type, {}
+          end
+        end
+      end
+
+      def initialize(name, type=nil, index_type=false, attr_options={})
+        @name           = name
+        @type           = type || :string
+        @has_index      = INDEX_OPTIONS.include?(index_type)
+        @has_uniq_index = UNIQ_INDEX_OPTIONS.include?(index_type)
+        @attr_options   = attr_options
+      end
+
+      def field_type
+        @field_type ||= case type
+          when :integer              then :number_field
+          when :float, :decimal      then :text_field
+          when :time                 then :time_select
+          when :datetime, :timestamp then :datetime_select
+          when :date                 then :date_select
+          when :text                 then :text_area
+          when :boolean              then :check_box
+          else
+            :text_field
+        end
+      end
+
+      def default
+        @default ||= case type
+          when :integer                     then 1
+          when :float                       then 1.5
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then Time.now.to_s(:db)
+          when :date                        then Date.today.to_s(:db)
+          when :string                      then name == "type" ? "" : "MyString"
+          when :text                        then "MyText"
+          when :boolean                     then false
+          when :references, :belongs_to     then nil
+          else
+            ""
+        end
+      end
+
+      def factory_stub
+        case type
+          when :integer                     then "1"
+          when :float                       then "1.5"
+          when :decimal                     then "9.99"
+          when :datetime, :timestamp, :time then "{ Time.now }"
+          when :date                        then "{ Date.today }"
+          when :string                      then '"MyString"'
+          when :text                        then '"MyText"'
+          when :boolean                     then "false"
+          when :digest                      then '"password"'
+          else
+            '"Unknown"'
+        end
+      end
+
+      def plural_name
+        name.sub(/_id$/, '').pluralize
+      end
+
+      def singular_name
+        name.sub(/_id$/, '').singularize
+      end
+
+      def human_name
+        name.humanize
+      end
+
+      def index_name
+        @index_name ||= if polymorphic?
+          %w(id type).map { |t| "#{name}_#{t}" }
+        else
+          column_name
+        end
+      end
+
+      def column_name
+        @column_name ||= reference? ? "#{name}_id" : name
+      end
+
+      def foreign_key?
+        !!(name =~ /_id$/)
+      end
+
+      def reference?
+        self.class.reference?(type)
+      end
+
+      def polymorphic?
+        self.attr_options.has_key?(:polymorphic)
+      end
+
+      def required?
+        self.attr_options[:required]
+      end
+
+      def has_index?
+        @has_index
+      end
+
+      def has_uniq_index?
+        @has_uniq_index
+      end
+
+      def password_digest?
+        name == 'password' && type == :digest
+      end
+
+      def inject_options
+        "".tap { |s| @attr_options.each { |k,v| s << ", #{k}: #{v.inspect}" } }
+      end
+
+      def inject_index_options
+        has_uniq_index? ? ", unique: true" : ""
+      end
+    end
+  end
+end

data/lib/napa/cli/migration.rb

@@ -1,5 +1,6 @@
 require 'thor'
 require 'active_support/all'
+require 'napa/cli/generated_attribute'
 
 module Napa
   module CLI
@@ -31,7 +32,7 @@ module Napa
       end
 
       def set_local_assigns!
-        @migration_template = "migration"
+        @migration_template = "migration/migration.rb.tt"
         filename = migration_name.underscore
         case filename
         when /^(add|remove)_.*_(?:to|from)_(.*)/
@@ -46,14 +47,14 @@ module Napa
           end
         when /^create_(.+)/
           @table_name = $1.pluralize
-          @migration_template = "create_table_migration"
+          @migration_template = "model/db/migrate/migration.rb.tt"
         end
       end
 
       def migration
-        self.class.source_root "#{File.dirname(__FILE__)}/templates/#{@migration_template}"
+        self.class.source_root "#{File.dirname(__FILE__)}/templates/"
         say 'Generating migration...'
-        directory '.', output_directory
+        template @migration_template, "#{output_directory}/#{migration_filename}.rb"
         say 'Done!', :green
       end
 
@@ -76,152 +77,5 @@ module Napa
           end.to_sym
         end
     end
-
-    # directly ported from
-    # https://github.com/rails/rails/blob/76883f92374c6395f13c16628e1d87d40b6d2399/railties/lib/rails/generators/generated_attribute.rb
-    class GeneratedAttribute # :nodoc:
-      INDEX_OPTIONS = %w(index uniq)
-      UNIQ_INDEX_OPTIONS = %w(uniq)
-
-      attr_accessor :name, :type
-      attr_reader   :attr_options
-      attr_writer   :index_name
-
-      class << self
-        def parse(column_definition)
-          name, type, has_index = column_definition.split(':')
-
-          # if user provided "name:index" instead of "name:string:index"
-          # type should be set blank so GeneratedAttribute's constructor
-          # could set it to :string
-          has_index, type = type, nil if INDEX_OPTIONS.include?(type)
-
-          type, attr_options = *parse_type_and_options(type)
-          type = type.to_sym if type
-
-          if type && reference?(type)
-            references_index = UNIQ_INDEX_OPTIONS.include?(has_index) ? { unique: true } : true
-            attr_options[:index] = references_index
-          end
-
-          new(name, type, has_index, attr_options)
-        end
-
-        def reference?(type)
-          [:references, :belongs_to].include? type
-        end
-
-        private
-
-        # parse possible attribute options like :limit for string/text/binary/integer, :precision/:scale for decimals or :polymorphic for references/belongs_to
-        # when declaring options curly brackets should be used
-        def parse_type_and_options(type)
-          case type
-          when /(string|text|binary|integer)\{(\d+)\}/
-            return $1, limit: $2.to_i
-          when /decimal\{(\d+)[,.-](\d+)\}/
-            return :decimal, precision: $1.to_i, scale: $2.to_i
-          when /(references|belongs_to)\{polymorphic\}/
-            return $1, polymorphic: true
-          else
-            return type, {}
-          end
-        end
-      end
-
-      def initialize(name, type=nil, index_type=false, attr_options={})
-        @name           = name
-        @type           = type || :string
-        @has_index      = INDEX_OPTIONS.include?(index_type)
-        @has_uniq_index = UNIQ_INDEX_OPTIONS.include?(index_type)
-        @attr_options   = attr_options
-      end
-
-      def field_type
-        @field_type ||= case type
-          when :integer              then :number_field
-          when :float, :decimal      then :text_field
-          when :time                 then :time_select
-          when :datetime, :timestamp then :datetime_select
-          when :date                 then :date_select
-          when :text                 then :text_area
-          when :boolean              then :check_box
-          else
-            :text_field
-        end
-      end
-
-      def default
-        @default ||= case type
-          when :integer                     then 1
-          when :float                       then 1.5
-          when :decimal                     then "9.99"
-          when :datetime, :timestamp, :time then Time.now.to_s(:db)
-          when :date                        then Date.today.to_s(:db)
-          when :string                      then name == "type" ? "" : "MyString"
-          when :text                        then "MyText"
-          when :boolean                     then false
-          when :references, :belongs_to     then nil
-          else
-            ""
-        end
-      end
-
-      def plural_name
-        name.sub(/_id$/, '').pluralize
-      end
-
-      def singular_name
-        name.sub(/_id$/, '').singularize
-      end
-
-      def human_name
-        name.humanize
-      end
-
-      def index_name
-        @index_name ||= if polymorphic?
-          %w(id type).map { |t| "#{name}_#{t}" }
-        else
-          column_name
-        end
-      end
-
-      def column_name
-        @column_name ||= reference? ? "#{name}_id" : name
-      end
-
-      def foreign_key?
-        !!(name =~ /_id$/)
-      end
-
-      def reference?
-        self.class.reference?(type)
-      end
-
-      def polymorphic?
-        self.attr_options.has_key?(:polymorphic)
-      end
-
-      def has_index?
-        @has_index
-      end
-
-      def has_uniq_index?
-        @has_uniq_index
-      end
-
-      def password_digest?
-        name == 'password' && type == :digest
-      end
-
-      def inject_options
-        "".tap { |s| @attr_options.each { |k,v| s << ", #{k}: #{v.inspect}" } }
-      end
-
-      def inject_index_options
-        has_uniq_index? ? ", unique: true" : ""
-      end
-    end
   end
 end