pliny 0.2.0 → 0.3.0

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

data/lib/pliny/config_helpers.rb

@@ -1,4 +1,55 @@
 module Pliny
+  module CastingConfigHelpers
+    def mandatory(name, method=nil)
+      value = cast(ENV.fetch(name.to_s.upcase), method)
+      create(name, value)
+    end
+
+    def optional(name, method=nil)
+      value = cast(ENV[name.to_s.upcase], method)
+      create(name, value)
+    end
+
+    def override(name, default, method=nil)
+      value = cast(ENV.fetch(name.to_s.upcase, default), method)
+      create(name, value)
+    end
+
+    def int
+      ->(v) { v.to_i }
+    end
+
+    def float
+      ->(v) { v.to_f }
+    end
+
+    def bool
+      ->(v) { v.to_s=='true'}
+    end
+
+    def string
+      nil
+    end
+
+    def symbol
+      ->(v) { v.to_sym }
+    end
+
+    private
+
+    def cast(value, method)
+      method ? method.call(value) : value
+    end
+
+    def create(name, value)
+      instance_variable_set(:"@#{name}", value)
+      instance_eval "def #{name}; @#{name} end", __FILE__, __LINE__
+      if value.kind_of?(TrueClass) || value.kind_of?(FalseClass) || value.kind_of?(NilClass)
+        instance_eval "def #{name}?; !!@#{name} end", __FILE__, __LINE__
+      end
+    end
+  end
+
   module ConfigHelpers
     def optional(*attrs)
       attrs.each do |attr|
@@ -28,6 +79,7 @@ module Pliny
       end
     end
   end
+
 end
 
 # Supress the "use RbConfig instead" warning.

data/lib/pliny/errors.rb

@@ -3,6 +3,12 @@ module Pliny
     class Error < StandardError
       attr_accessor :id
 
+      def self.render(error)
+        headers = { "Content-Type" => "application/json; charset=utf-8" }
+        data = { id: error.id, message: error.message, status: error.status }
+        [error.status, headers, [MultiJson.encode(data)]]
+      end
+
       def initialize(message, id)
         @id = id
         super(message)
@@ -10,10 +16,7 @@ module Pliny
     end
 
     class HTTPStatusError < Error
-      attr_reader :status
-
-      # so that Sinatra respects are status code when catching an exception
-      alias :http_status :status
+      attr_accessor :status
 
       def initialize(message = nil, id = nil, status = nil)
         meta    = Pliny::Errors::META[self.class]

data/lib/pliny/helpers/encode.rb

@@ -0,0 +1,7 @@
+module Pliny::Helpers
+  module Encode
+    def encode(object)
+      MultiJson.encode(object, pretty: params[:pretty] == 'true' || Config.pretty_json)
+    end
+  end
+end

data/lib/pliny/log.rb

@@ -1,10 +1,19 @@
 module Pliny
   module Log
     def log(data, &block)
-      data = log_context.merge(data)
+      data = log_context.merge(local_context.merge(data))
       log_to_stream(stdout || $stdout, data, &block)
     end
 
+    def context(data, &block)
+      old = local_context
+      self.local_context = old.merge(data)
+      res = block.call
+    ensure
+      local_context = old
+      res
+    end
+
     def stdout=(stream)
       @stdout = stream
     end
@@ -15,6 +24,14 @@ module Pliny
 
     private
 
+    def local_context
+      RequestStore.store[:local_context] ||= {}
+    end
+
+    def local_context=(h)
+      RequestStore.store[:local_context] = h
+    end
+
     def log_context
       RequestStore.store[:log_context] || {}
     end

data/lib/pliny/middleware/rescue_errors.rb

@@ -8,13 +8,13 @@ module Pliny::Middleware
     def call(env)
       @app.call(env)
     rescue Pliny::Errors::Error => e
-      render(e, env)
+      Pliny::Errors::Error.render(e)
     rescue Exception => e
       if @raise
         raise
       else
         dump_error(e, env)
-        render(Pliny::Errors::InternalServerError.new, env)
+        Pliny::Errors::Error.render(Pliny::Errors::InternalServerError.new)
       end
     end
 
@@ -25,11 +25,5 @@ module Pliny::Middleware
       message = ["#{e.class} - #{e.message}:", *e.backtrace].join("\n\t")
       env['rack.errors'].puts(message)
     end
-
-    def render(e, env)
-      headers = { "Content-Type" => "application/json; charset=utf-8" }
-      error = { id: e.id, message: e.message, status: e.status }
-      [e.status, headers, [MultiJson.encode(error)]]
-    end
   end
 end

data/lib/pliny/middleware/versioning.rb

@@ -22,7 +22,7 @@ module Pliny::Middleware
       version = nil
       media_types.map! do |media_type|
         if accept_headers.include?(media_type.format)
-          if !media_type.params["version"]
+          unless media_type.params['version']
             error = { id: :bad_version, message: <<-eos }
 Please specify a version along with the MIME type. For example, `Accept: application/vnd.#{@app_name}+json; version=1`.
             eos
@@ -30,7 +30,7 @@ Please specify a version along with the MIME type. For example, `Accept: applica
               [MultiJson.encode(error)]]
           end
 
-          if !version
+          unless version
             version = media_type.params["version"]
           end
 
@@ -41,7 +41,7 @@ Please specify a version along with the MIME type. For example, `Accept: applica
         end
         media_type.to_s
       end
-      env["HTTP_ACCEPT"] = media_types.map(&:to_s).join(", ")
+      env['HTTP_ACCEPT'] = media_types.join(', ')
 
       version ||= @default
       set_api_version(env, version)

data/lib/pliny/tasks/db.rake

@@ -78,19 +78,33 @@ namespace :db do
   namespace :schema do
     desc "Load the database schema"
     task :load do
-      schema = File.read("./db/schema.sql")
-      database_urls.each do |database_url|
-        db = Sequel.connect(database_url)
-        db.run(schema)
-        puts "Loaded `#{name_from_uri(database_url)}`"
+      if File.exists?("./db/schema.sql")
+        schema = File.read("./db/schema.sql")
+        database_urls.each do |database_url|
+          db = Sequel.connect(database_url)
+          db.run(schema)
+          puts "Loaded `#{name_from_uri(database_url)}`"
+        end
+      else
+        puts "Skipped schema load, schema.sql not present"
       end
     end
 
     desc "Dump the database schema"
     task :dump do
+      file = File.join("db", "schema.sql")
       database_url = database_urls.first
-      `pg_dump -i -s -x -O -f ./db/schema.sql #{database_url}`
-      puts "Dumped `#{name_from_uri(database_url)}` to db/schema.sql"
+      `pg_dump -i -s -x -O -f #{file} #{database_url}`
+
+      schema = File.read(file)
+      # filter all COMMENT ON EXTENSION, only owners and the db
+      # superuser can execute these, making it impossible to just
+      # replay such statements in certain production databases
+      schema.gsub!(/^COMMENT ON EXTENSION.*\n/, "")
+
+      File.open(file, "w") { |f| f.puts schema }
+
+      puts "Dumped `#{name_from_uri(database_url)}` to #{file}"
     end
 
     desc "Merges migrations into schema and removes them"

data/lib/pliny/tasks/schema.rake

@@ -1,5 +1,5 @@
 desc "Rebuild schema.json"
 task :schema do
-  require 'pliny'
-  Pliny::Commands::Generator.new.rebuild_schema
+  require 'pliny/commands/generator/schema'
+  Pliny::Commands::Generator::Schema.new(nil).rebuild
 end

data/lib/pliny/templates/endpoint.erb

@@ -6,24 +6,24 @@ module Endpoints
       end
 
       get do
-        "[]"
+        encode []
       end
 
       post do
         status 201
-        "{}"
+        encode {}
       end
 
       get "/:id" do
-        "{}"
+        encode {}
       end
 
       patch "/:id" do |id|
-        "{}"
+        encode {}
       end
 
       delete "/:id" do |id|
-        "{}"
+        encode {}
       end
     end
   end

data/lib/pliny/templates/endpoint_acceptance_test.erb

@@ -20,7 +20,7 @@ describe Endpoints::<%= plural_class_name %> do
     end
   end
 
-  describe 'POST <%= url_path %>/:id' do
+  describe 'POST <%= url_path %>' do
     it 'returns correct status code and conforms to schema' do
       header "Content-Type", "application/json"
       post '<%= url_path %>', MultiJson.encode({})

data/lib/pliny/templates/endpoint_scaffold.erb

@@ -6,7 +6,7 @@ module Endpoints
       end
 
       get do
-        MultiJson.encode <%= singular_class_name %>.all.map { |x| serialize(x) }
+        encode serialize(<%= singular_class_name %>.all)
       end
 
       post do
@@ -14,25 +14,25 @@ module Endpoints
         <%= field_name %> = <%= singular_class_name %>.new(body_params)
         <%= field_name %>.save
         status 201
-        MultiJson.encode serialize(<%= field_name %>)
+        encode serialize(<%= field_name %>)
       end
 
       get "/:id" do |id|
         <%= field_name %> = <%= singular_class_name %>.first(uuid: id) || halt(404)
-        MultiJson.encode serialize(<%= field_name %>)
+        encode serialize(<%= field_name %>)
       end
 
       patch "/:id" do |id|
         <%= field_name %> = <%= singular_class_name %>.first(uuid: id) || halt(404)
         # warning: not safe
         #<%= field_name %>.update(body_params)
-        MultiJson.encode serialize(<%= field_name %>)
+        encode serialize(<%= field_name %>)
       end
 
       delete "/:id" do |id|
         <%= field_name %> = <%= singular_class_name %>.first(uuid: id) || halt(404)
         <%= field_name %>.destroy
-        MultiJson.encode serialize(<%= field_name %>)
+        encode serialize(<%= field_name %>)
       end
 
       private

data/lib/pliny/templates/endpoint_scaffold_acceptance_test.erb

@@ -29,7 +29,7 @@ describe Endpoints::<%= plural_class_name %> do
   end
 
 =begin
-  describe 'POST <%= url_path %>/:id' do
+  describe 'POST <%= url_path %>' do
     it 'returns correct status code and conforms to schema' do
       header "Content-Type", "application/json"
       post '<%= url_path %>', MultiJson.encode({})

data/lib/pliny/templates/endpoint_test.erb

@@ -5,6 +5,7 @@ describe Endpoints::<%= plural_class_name %> do
 
   def app
     Endpoints::<%= plural_class_name %>
+
   end
 
   describe "GET <%= url_path %>" do

data/lib/pliny/templates/migration.erb

@@ -1,9 +1,7 @@
 Sequel.migration do
   up do
-    
   end
 
   down do
-    
   end
 end

data/lib/pliny/templates/model.erb

@@ -1,8 +1,6 @@
 class <%= singular_class_name %> < Sequel::Model
-
   plugin :timestamps
 <% if paranoid %>
   plugin :paranoid
 <% end %>
-
 end

data/lib/pliny/templates/model_test.erb

@@ -1,5 +1,4 @@
 require "spec_helper"
 
 describe <%= singular_class_name %> do
-  
 end

data/lib/pliny/templates/serializer_test.erb

@@ -1,5 +1,4 @@
 require "spec_helper"
 
 describe Serializers::<%= singular_class_name %> do
-  
 end

data/lib/pliny/version.rb

@@ -1,3 +1,3 @@
 module Pliny
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

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/template/.env.sample

@@ -1,6 +1,7 @@
 DATABASE_URL=postgres://localhost/pliny-development
 RACK_ENV=development
 TZ=UTC
-RESCUE_ERRORS=false
+RAISE_ERRORS=true
 FORCE_SSL=false
 TIMEOUT=false
+PRETTY_JSON=true