pliny 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 59e9993f316b4360e09b0e9e60c9227daad19a00
-  data.tar.gz: 4de44f2103e728082c0c611d97d5e4a43695588e
-SHA512:
-  metadata.gz: 4361dee922785399136ce3a3a76e3ac6ec6d075700a4eb485fe6f6536bd9535676bee13424d41e7593110d8ef55843d9de23cce7da8c0ee155645f1ea1951fbf
-  data.tar.gz: 1a72822bb718edb5d5c5918b18b8b032272cc4c19c25c415cfb50a0cd1fa19700822bb1a01683034bd4f73922e8c3756f2b6ea09b1a134e4f58a764170d6540f
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Mjk3OWZlMTRiYjE4MmU4M2JkZDQzNjA5ODllZTNhNDQxYTBjZjRlZA==
+  data.tar.gz: !binary |-
+    YjExMTc1Yzk3ZTNkODY1OTFiMWMzOGVhM2YzZTViNjk2ZGIwNDk3Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Mzg5NWFkY2NlNzA0Y2U4MmQwYTExNTBmZGUwY2Y2YzJkMDRhNzY0ODVkM2Mz
+    NzVhM2JmN2U0ZTc0MmViYjEyM2NhZjhhYTVmOTVlNTRiNzMzMzhhMzRhN2Fj
+    MjBiMDQ0NjY3M2E1MTUwOTM3YjE2YWFkMDU3MzMzZTI3NWE0ZGI=
+  data.tar.gz: !binary |-
+    YWQyMzBjMWEwNmMyOWU4ZDc5MTllOGZjM2U4NGNiZDNkMzBkOGE2NDMzNzIw
+    NGI4ZDFlMDk1OWJjNTQ2YzdjMmI3MTE5YThkMmQ5NTRiMjQwMjFmN2Q1MTU5
+    NzQyZjk4Y2I5NDlmMzdlYWM4NTEwNDBhOTNkMGUxYzc1M2NhNmY=

data/README.md

@@ -15,7 +15,7 @@ It bundles some of the patterns we like to develop these apps:
 And gems/helpers to tie these together and support operations:
 
 - [CORS middleware](lib/pliny/middleware/cors.rb) to allow JS developers to consume your API
-- [Honeybadger](https://www.honeybadger.io/) for tracking exceptions
+- [Rollbar](https://www.rollbar.com/) for tracking exceptions
 - [Log helper](test/log_test.rb) that logs in [data format](https://www.youtube.com/watch?v=rpmc-wHFUBs) [to stdout](https://adam.heroku.com/past/2011/4/1/logs_are_streams_not_files)
 - [Mediators](http://brandur.org/mediator) to help encapsulate more complex interactions
 - [Rspec](https://github.com/rspec/rspec) for lean and fast testing
@@ -47,18 +47,17 @@ $ pliny-new myapp
 $ cd myapp && bin/setup
 ```
 
-Pliny also bundles some generators to help you get started:
+Pliny also bundles [some generators](#generators) to help you get started:
 
 ```bash
 $ bundle exec pliny-generate model artist
 created model file ./lib/models/artist.rb
-created migration ./db/migrate/1395873224_create_artist.rb
-created test ./test/models/artist_test.rb
+created migration ./db/migrate/1408995997_create_artists.rb
+created test ./spec/models/artist_spec.rb
 
 $ bundle exec pliny-generate mediator artists/creator
-created base mediator ./lib/mediators/base.rb
 created mediator file ./lib/mediators/artists/creator.rb
-created test ./test/mediators/artists/creator_test.rb
+created test ./spec/mediators/artists/creator_spec.rb
 
 $ bundle exec pliny-generate endpoint artists
 created endpoint file ./lib/endpoints/artists.rb
@@ -78,23 +77,72 @@ rebuilt ./docs/schema.json
 To test your application:
 
 ```bash
-bundle exec rake
+$ bundle exec rake
 ```
 
 Or to run a single test suite:
 
 ```bash
-bundle exec rspec spec/acceptance/artists_spec.rb
+$ bundle exec rspec spec/acceptance/artists_spec.rb
 ```
 
+### Generators
+
+```bash
+$ bin/pliny-generate
+```
+
+```
+Commands:
+  pliny-generate endpoint NAME    # Generates an endpoint
+  pliny-generate help [COMMAND]   # Describe available commands or one specific command
+  pliny-generate mediator NAME    # Generates a mediator
+  pliny-generate migration NAME   # Generates a migration
+  pliny-generate model NAME       # Generates a model
+  pliny-generate scaffold NAME    # Generates a scaffold of endpoint, model, schema and serializer
+  pliny-generate schema NAME      # Generates a schema
+  pliny-generate serializer NAME  # Generates a serializer
+```
+
+### Rake tasks
+
+Pliny comes with several rake tasks:
+
+```bash
+rake db:create        # Create the database
+rake db:drop          # Drop the database
+rake db:migrate       # Run database migrations
+rake db:nuke          # Nuke the database (drop all tables)
+rake db:reset         # Reset the database
+rake db:rollback      # Rollback the database
+rake db:schema:dump   # Dump the database schema
+rake db:schema:load   # Load the database schema
+rake db:schema:merge  # Merges migrations into schema and removes them
+rake db:seed          # Seed the database with data
+rake db:setup         # Setup the database
+rake schema           # Rebuild schema.json
+rake test             # Run tests
+```
+
+### Commands
+
+And provides the following commands:
+
+```bash
+$ foreman run bin/console                   # IRB/Pry console
+$ foreman run bin/run 'puts "hello world"'  # Run automated code
+```
+
+(hint: don't forget `foreman run` in development)
+
 ## Development
 
 Run tests:
 
 ```
-bundle install
-git submodule update --init
-rake
+$ bundle install
+$ git submodule update --init
+$ rake
 ```
 
 ## Meta

data/bin/pliny-generate

@@ -1,16 +1,4 @@
 #!/usr/bin/env ruby
 
-require "optparse"
-require_relative "../lib/pliny"
-
-ARGV.options do |options|
-  opts = {}
-
-  options.on("--paranoid", "Generate paranoid support in models") do
-    opts[:paranoid] = true
-  end
-
-  options.parse!
-
-  Pliny::Commands::Generator.run(ARGV.dup, opts)
-end
+require_relative '../lib/pliny/commands/generator'
+Pliny::Commands::Generator.start

data/bin/pliny-new

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require "optparse"
-require_relative "../lib/pliny"
+require_relative '../lib/pliny/commands/creator'
 
 ARGV.options do |options|
   opts = {}

data/lib/pliny.rb

@@ -2,10 +2,9 @@ require "multi_json"
 require "sinatra/base"
 
 require_relative "pliny/version"
-require_relative "pliny/commands/creator"
-require_relative "pliny/commands/generator"
 require_relative "pliny/errors"
 require_relative "pliny/extensions/instruments"
+require_relative "pliny/helpers/encode"
 require_relative "pliny/helpers/params"
 require_relative "pliny/log"
 require_relative "pliny/request_store"

data/lib/pliny/commands/creator.rb

@@ -1,28 +1,27 @@
-require "fileutils"
+require 'pliny/version'
+require 'fileutils'
 
 module Pliny::Commands
   class Creator
     attr_accessor :args, :opts, :stream
 
-    def self.run(args, opts={}, stream=$stdout)
+    def self.run(args, opts = {}, stream = $stdout)
       new(args, opts, stream).run!
     end
 
-    def initialize(args={}, opts={}, stream=$stdout)
+    def initialize(args = {}, opts = {}, stream = $stdout)
       @args = args
       @opts = opts
       @stream = stream
     end
 
     def run!
-      if File.exists?(app_dir)
-        abort("#{name} already exists")
-      end
+      abort("#{name} already exists") if File.exist?(app_dir)
 
       FileUtils.copy_entry template_dir, app_dir
       FileUtils.rm_rf("#{app_dir}/.git")
       setup_database_urls
-      display "Pliny app created. To start, run:"
+      display 'Pliny app created. To start, run:'
       display "cd #{app_dir} && bin/setup"
     end
 
@@ -31,16 +30,16 @@ module Pliny::Commands
     def setup_database_urls
       db = URI.parse("postgres:///#{name}")
       {
-        ".env.sample" => "development",
-        ".env.test"   => "test"
+        '.env.sample' => 'development',
+        '.env.test'   => 'test'
       }.each do |env_file, db_env_suffix|
         env_path = "#{app_dir}/#{env_file}"
         db.path  = "/#{name}-#{db_env_suffix}"
         env      = File.read(env_path)
-        File.open(env_path, "w") do |f|
+        File.open(env_path, 'w') do |f|
           # ruby's URI#to_s renders foo:/bar when there's no host
           # we want foo:///bar instead!
-          db_url = db.to_s.sub(":/", ":///")
+          db_url = db.to_s.sub(':/', ':///')
           f.puts env.sub(/DATABASE_URL=.*/, "DATABASE_URL=#{db_url}")
         end
       end

data/lib/pliny/commands/generator.rb

@@ -1,222 +1,73 @@
-require "erb"
-require "fileutils"
-require "ostruct"
-require "active_support/inflector"
-require "prmd"
+require 'pliny/version'
+require 'thor'
 
 module Pliny::Commands
-  class Generator
-    attr_accessor :args, :opts, :stream
+  class Generator < Thor
+    desc 'endpoint NAME', 'Generates an endpoint'
+    method_option :scaffold, type: :boolean, default: false, hide: true
+    def endpoint(name)
+      require_relative 'generator/endpoint'
 
-    def self.run(args, opts={}, stream=$stdout)
-      new(args, opts).run!
+      ep = Endpoint.new(name, options)
+      ep.create
+      ep.create_test
+      ep.create_acceptance_test
     end
 
-    def initialize(args={}, opts={}, stream=$stdout)
-      @args = args
-      @opts = opts
-      @stream = stream
-    end
-
-    def run!
-      unless type
-        raise "Missing type of object to generate"
-      end
-      unless name
-        raise "Missing #{type} name"
-      end
-
-      case type
-      when "endpoint"
-        create_endpoint(scaffold: false)
-        create_endpoint_test
-        create_endpoint_acceptance_test(scaffold: false)
-      when "mediator"
-        create_mediator
-        create_mediator_test
-      when "migration"
-        create_migration
-      when "model"
-        create_model
-        create_model_migration
-        create_model_test
-      when "scaffold"
-        create_endpoint(scaffold: true)
-        create_endpoint_test
-        create_endpoint_acceptance_test(scaffold: true)
-        create_model
-        create_model_migration
-        create_model_test
-        create_schema
-        rebuild_schema
-        create_serializer
-        create_serializer_test
-      when "schema"
-        create_schema
-        rebuild_schema
-      when "serializer"
-        create_serializer
-        create_serializer_test
-      else
-        abort("Don't know how to generate '#{type}'.")
-      end
-    end
-
-    def type
-      args.first
-    end
-
-    def name
-      args[1]
-    end
-
-    def paranoid
-      opts[:paranoid]
-    end
-
-    def singular_class_name
-      name.gsub(/-/, '_').singularize.camelize
-    end
-
-    def plural_class_name
-      name.gsub(/-/, '_').pluralize.camelize
-    end
-
-    def field_name
-      name.tableize.singularize
-    end
-
-    def table_name
-      name.tableize
-    end
+    desc 'mediator NAME', 'Generates a mediator'
+    def mediator(name)
+      require_relative 'generator/mediator'
 
-    def display(msg)
-      stream.puts msg
+      md = Mediator.new(name, options)
+      md.create
+      md.create_test
     end
 
-    def create_endpoint(options = {})
-      endpoint = "./lib/endpoints/#{table_name}.rb"
-      template = options[:scaffold] ? "endpoint_scaffold.erb" : "endpoint.erb"
-      render_template(template, endpoint, {
-        plural_class_name: plural_class_name,
-        singular_class_name: singular_class_name,
-        field_name: field_name,
-        url_path:   url_path,
-      })
-      display "created endpoint file #{endpoint}"
-      display "add the following to lib/routes.rb:"
-      display "  mount Endpoints::#{plural_class_name}"
-    end
-
-    def create_endpoint_test
-      test = "./spec/endpoints/#{table_name}_spec.rb"
-      render_template("endpoint_test.erb", test, {
-        plural_class_name: plural_class_name,
-        singular_class_name: singular_class_name,
-        url_path:   url_path,
-      })
-      display "created test #{test}"
-    end
-
-    def create_endpoint_acceptance_test(options = {})
-      test = "./spec/acceptance/#{table_name}_spec.rb"
-      template = options[:scaffold] ? "endpoint_scaffold_acceptance_test.erb" :
-        "endpoint_acceptance_test.erb"
-      render_template(template, test, {
-        plural_class_name: plural_class_name,
-        field_name: field_name,
-        singular_class_name: singular_class_name,
-        url_path:   url_path,
-      })
-      display "created test #{test}"
-    end
-
-    def create_mediator
-      mediator = "./lib/mediators/#{field_name}.rb"
-      render_template("mediator.erb", mediator, singular_class_name: singular_class_name)
-      display "created mediator file #{mediator}"
-    end
-
-    def create_mediator_test
-      test = "./spec/mediators/#{field_name}_spec.rb"
-      render_template("mediator_test.erb", test, singular_class_name: singular_class_name)
-      display "created test #{test}"
-    end
+    desc 'migration NAME', 'Generates a migration'
+    def migration(name)
+      require_relative 'generator/migration'
 
-    def create_migration
-      migration = "./db/migrate/#{Time.now.to_i}_#{name}.rb"
-      render_template("migration.erb", migration)
-      display "created migration #{migration}"
+      mg = Migration.new(name, options)
+      mg.create
     end
 
-    def create_model
-      model = "./lib/models/#{field_name}.rb"
-      render_template("model.erb", model,
-        singular_class_name: singular_class_name,
-        paranoid: paranoid)
-      display "created model file #{model}"
-    end
+    desc 'model NAME', 'Generates a model'
+    method_option :paranoid, type: :boolean, default: false, desc: 'adds paranoid support to model'
+    def model(name)
+      require_relative 'generator/model'
 
-    def create_model_migration
-      migration = "./db/migrate/#{Time.now.to_i}_create_#{table_name}.rb"
-      render_template("model_migration.erb", migration,
-        table_name: table_name,
-        paranoid: paranoid)
-      display "created migration #{migration}"
+      md = Model.new(name, options)
+      md.create
+      md.create_migration
+      md.create_test
     end
 
-    def create_model_test
-      test = "./spec/models/#{field_name}_spec.rb"
-      render_template("model_test.erb", test, singular_class_name: singular_class_name)
-      display "created test #{test}"
+    desc 'scaffold NAME', 'Generates a scaffold of endpoint, model, schema and serializer'
+    method_option :paranoid, type: :boolean, default: false, desc: 'adds paranoid support to model'
+    method_option :scaffold, type: :boolean, default: true, hide: true
+    def scaffold(name)
+      endpoint(name)
+      model(name)
+      schema(name)
+      serializer(name)
     end
 
-    def create_schema
-      schema = "./docs/schema/schemata/#{field_name}.yaml"
-      write_file(schema) do
-        Prmd.init(name.singularize, yaml: true)
-      end
-      display "created schema file #{schema}"
-    end
+    desc 'schema NAME', 'Generates a schema'
+    def schema(name)
+      require_relative 'generator/schema'
 
-    def rebuild_schema
-      schemata = "./docs/schema.json"
-      write_file(schemata) do
-        Prmd.combine("./docs/schema/schemata", meta: "./docs/schema/meta.json")
-      end
-      display "rebuilt #{schemata}"
+      sc = Schema.new(name, options)
+      sc.create
+      sc.rebuild
     end
 
-    def create_serializer
-      serializer = "./lib/serializers/#{name}_serializer.rb"
-      render_template("serializer.erb", serializer, singular_class_name: singular_class_name)
-      display "created serializer file #{serializer}"
-    end
-
-    def create_serializer_test
-      test = "./spec/serializers/#{name}_serializer_spec.rb"
-      render_template("serializer_test.erb", test, singular_class_name: singular_class_name)
-      display "created test #{test}"
-    end
-
-    def render_template(template_file, destination_path, vars={})
-      template_path = File.dirname(__FILE__) + "/../templates/#{template_file}"
-      template = ERB.new(File.read(template_path), 0, ">")
-      context = OpenStruct.new(vars)
-      write_file(destination_path) do
-        template.result(context.instance_eval { binding })
-      end
-    end
-
-    def url_path
-      "/" + name.pluralize.gsub(/_/, '-')
-    end
+    desc 'serializer NAME', 'Generates a serializer'
+    def serializer(name)
+      require_relative 'generator/serializer'
 
-    def write_file(destination_path)
-      FileUtils.mkdir_p(File.dirname(destination_path))
-      File.open(destination_path, "w") do |f|
-        f.puts yield
-      end
+      se = Serializer.new(name, options)
+      se.create
+      se.create_test
     end
   end
 end