require 'pliny/version'
require 'thor'

module Pliny::Commands
  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'

      ep = Endpoint.new(name, options)
      ep.create
      ep.create_test
      ep.create_acceptance_test
    end

    desc 'mediator [NAME]', 'Generates a mediator'
    def mediator(*name)
      require_relative 'generator/mediator'

      md = Mediator.new(name, options)
      md.create
      md.create_test
    end

    desc 'migration [NAME]', 'Generates a migration'
    def migration(*name)
      require_relative 'generator/migration'

      mg = Migration.new(name, options)
      mg.create
    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'

      md = Model.new(name, options)
      md.create
      md.create_migration
      md.create_test
    end

    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

    desc 'schema [NAME]', 'Generates a schema'
    def schema(*name)
      require_relative 'generator/schema'

      sc = Schema.new(name, options)
      sc.create
      sc.rebuild
    end

    desc 'serializer [NAME]', 'Generates a serializer'
    def serializer(*name)
      require_relative 'generator/serializer'

      se = Serializer.new(name, options)
      se.create
      se.create_test
    end
  end
end