praxis 2.0.pre.8 → 2.0.pre.13

data/tasks/thor/app.rb

@@ -13,41 +13,15 @@ module PraxisGen
     # Generator for a blank new app (with a full skeleton ready to get you going)
     def new
       puts "Creating new blank Praxis app under #{app_name}"
-      create_root_files
-      create_config
-      create_app
-      create_design
-      create_spec
-      create_docs
-    end
-
-    private
-    def create_root_files
-      ['config.ru','Gemfile','Guardfile','Rakefile','README.md'].each do |file|
-        copy_file file, "#{app_name}/#{file}"
+      # Copy example files
+      ['config.ru','Gemfile','Rakefile','README.md'].each do |file|
+        copy_file file, verbose: true
+      end
+      # Copy example directories
+      root_dirs = ['config','app','design','spec','docs']
+      root_dirs.each do |dir|
+        directory dir, recursive: true
       end
     end
-
-    def create_config
-      copy_file "config/environment.rb", "#{app_name}/config/environment.rb"
-      copy_file "config/rainbows.rb", "#{app_name}/config/rainbows.rb"
-    end
-
-    def create_app
-      directory "app", "#{app_name}/app", :recursive => true
-    end
-
-    def create_design
-      directory "design", "#{app_name}/design", :recursive => true
-    end
-
-    def create_spec
-      directory "spec", "#{app_name}/spec", :recursive => true
-    end
-
-    def create_docs
-      directory "docs", "#{app_name}/docs", :recursive => true
-    end
-
   end
 end

data/tasks/thor/example.rb

@@ -1,291 +1,57 @@
 
 module PraxisGen
-      class Example < Thor
-        include Thor::Actions
-
-        namespace "praxis:example"
-
-        argument :app_name, required: true
-        desc "new", "Generates a new 'hello world' example application under an <app_name> directory"
-
-        def new
-          puts "GENERATION COMMENCED!! (for #{app_name})"
-          # Fix weird symbols in the app name (if they are)
-          @app_name = app_name.downcase.gsub(/[^a-z0-9_\/.]/, '')
-          # Generate a new app
-          empty_directory path('app')
-          empty_directory path('design')
-          empty_directory path('lib')
-          empty_directory path('spec')
-          generate_config_environment_rb
-          generate_gemfile
-          generate_rakefile
-          generate_config_ru
-          generate_app_definitions_hello_world
-          generate_app_controllers_hello_world
-          #
-          puts
-          puts "To run the example application:"
-          puts
-          puts "  # terminal 1:"
-          puts "  cd #{app_name}"
-          puts "  bundle"
-          puts "  bundle exec rackup"
-          puts
-          puts "  # terminal 2:"
-          puts "  # Index: list the hello words (especifying api version through the query string) "
-          puts "  curl -i 'http://localhost:8888/api/hello?api_version=1.0' -H 'Authorization: Bearer XYZ' "
-          puts ""
-          puts "  # Show: list one of the hello words (especifying api version through a header) "
-          puts "  curl -i 'http://localhost:8888/api/hello/1' -H 'X-Api-Version: 1.0' -H 'Authorization: Bearer XYZ'"
-          puts ""
-          puts "  # NotFound: Hello word will not be found under API 2.0"
-          puts "  curl -i 'http://localhost:8888/api/hello/1' -H 'X-Api-Version: 2.0' -H 'Authorization: Bearer XYZ'"
-          puts "  #Note: The Authorization header is made required in the application to emulate OAuth2 (but not used)"
-          nil
-        end
-private
-    # Returns relative path for the new application
-    #
-    # @return [String]
-    #
-    # @example
-    #  # > /praxis generate My-test_praxisApp
-    #  app_dir_pathname #=> 'mytest_praxisapp'
-    #
-    #
-    def app_dir_pathname
-      @app_dir_pathname ||= Pathname.new(app_name)
-    end
-
-
-    # Returns path string built from the set of the given strings
-    #
-    # @param [String,Array] strings
-    #
-    # @return [String]
-    #
-    # @example
-    #   path('a', 'b', 'c') #=> 'my_test_app/a/b/c'
-    #
-    def path(*strings)
-      app_dir_pathname.join(*strings).to_s
-    end
-
-
-    # Creates './config/environment.rb' file
-    #
-    # @return [void]
-    #
-    def generate_config_environment_rb
-      create_file path('config/environment.rb') do
-  <<-RUBY
-# Main entry point - DO NOT MODIFY THIS FILE
-ENV['RACK_ENV'] ||= 'development'
-
-Bundler.require(:default, ENV['RACK_ENV'])
-
-# Default application layout.
-# NOTE: This layout need NOT be specified explicitly.
-# It is provided just for illustration.
-Praxis::Application.instance.layout do
-  map :initializers, 'config/initializers/**/*'
-  map :lib, 'lib/**/*'
-  map :design, 'design/' do
-    map :api, 'api.rb'
-    map :media_types, '**/media_types/**/*'
-    map :resources, '**/resources/**/*'
-  end
-  map :app, 'app/' do
-    map :models, 'models/**/*'
-    map :controllers, '**/controllers/**/*'
-    map :responses, '**/responses/**/*'
-  end
-end
-RUBY
-      end
-      nil
-    end
-
-
-    # Creates './Gemfile' file
-    #
-    # @return [void]
-    #
-    def generate_gemfile
-      create_file path('Gemfile') do
-  <<-RUBY
-source 'https://rubygems.org'
-
-gem 'praxis'
-gem 'rack', '~> 1.0'
-gem 'rake'
-
-group :development, :test do
-  gem 'rspec'
-end
-RUBY
-      end
-      nil
-    end
-
-
-    # Creates './Rakefile' file
-    #
-    # @return [void]
-    #
-    def generate_rakefile
-      create_file path('Rakefile') do
-  <<-RUBY
-require 'praxis'
-require 'praxis/tasks'
-RUBY
-      end
-      nil
-    end
-
-
-    # Creates './config.ru' file
-    #
-    # @return [void]
-    #
-    def generate_config_ru
-      create_file path('config.ru') do
-  <<-RUBY
-#\\ -p 8888
-
-require 'bundler/setup'
-require 'praxis'
-
-application = Praxis::Application.instance
-application.logger = Logger.new(STDOUT)
-application.setup
-
-run application
-RUBY
-      end
+  class Example < Thor
+    include Thor::Actions
+
+    namespace "praxis:example"
+
+    def self.source_root
+      File.dirname(__FILE__) + "/templates/generator/example_app"
+    end
+
+    argument :app_name, required: true
+    desc "example", "Generates a new example application under an <app_name> directory to showcase some features"
+
+    def example
+      sanitized = app_name.downcase.gsub(/[^a-z0-9_\-.]/, '')
+      puts "APP_NAME: #{app_name}"
+      raise "Please use only letters, numbers, underscores, dashes or periods for the app name" unless sanitized == app_name
+
+      # Copy example files
+      root_files = ['Gemfile','config.ru','Rakefile']
+      root_files.each do |file|
+        copy_file file, verbose: true
+      end
+      # Copy example directories
+      root_dirs = ['app','config','design','db','spec']
+      root_dirs.each do |dir|
+        directory dir, recursive: true
+      end
+
+      puts
+      puts "To run the example application:"
+      puts
+      puts "  cd #{app_name}"
+      puts "  bundle"
+      puts "  bundle exec rake db:recreate   # To create/migrate/seed the dev DB"
+      puts "  bundle exec rackup             # To start the web server"
+      puts  
+      puts "From another terminal/app, use curl (or your favorite HTTP client) to retrieve data from the API"
+      puts "  For example: "
+      puts "  Get all users without filters or limit, and display only id, and first_name fields"
+      puts "  curl -G -H 'X-Api-Version: 1' http://localhost:9292/users \\"
+      puts "    --data-urlencode \"fields=id,first_name\""
+      puts
+      puts "  Get the last 5 users, with last_names starting with \"L\" ordered by first_name (descending)"
+      puts "  and display only id, first_name, last_name, and email fields"
+      puts "  curl -G -H 'X-Api-Version: 1' http://localhost:9292/users \\"
+      puts "    --data-urlencode \"filters=last_name=L*\" \\"
+      puts "    --data-urlencode \"pagination=by=first_name,items=5\" \\"
+      puts "    --data-urlencode \"order=-first_name\" \\"      
+      puts "    --data-urlencode \"fields=id,first_name,last_name,email\""
+      puts "  (Note: To list all routes use: bundle exec rake praxis:routes)"
+      puts
       nil
     end
-
-
-    def generate_app_definitions_hello_world
-      create_file path('design/api.rb') do
-  <<-RUBY
-# Use this file to define your response templates and traits.
-#
-# For example, to define a response template:
-#   response_template :custom do |media_type:|
-#     status 200
-#     media_type media_type
-#   end
-Praxis::ApiDefinition.define do
-  # Trait that when included will require a Bearer authorization header to be passed in.
-  trait :authorized do
-    headers do
-      key "Authorization", String, regexp: /^.*Bearer\s/, required: true
-    end
-  end
-end
-RUBY
-      end
-
-      create_file path('design/resources/hello.rb') do
-  <<-RUBY
-module V1
-  module ApiResources
-    class Hello
-      include Praxis::ResourceDefinition
-
-      media_type V1::MediaTypes::Hello
-      version '1.0'
-
-      prefix '/api/hello'
-
-      # Will apply to all actions of this resource
-      trait :authorized
-
-      action_defaults do
-        response :ok
-      end
-
-      action :index do
-
-        routing do
-          get ''
-        end
-      end
-
-      action :show do
-
-        routing do
-          get '/:id'
-        end
-        params do
-          attribute :id, Integer, required: true, min: 0
-        end
-        response :not_found
-      end
-    end
-  end
-end
-RUBY
-      end
-
-      create_file path('design/media_types/hello.rb') do
-  <<-RUBY
-  module V1
-    module MediaTypes
-      class Hello < Praxis::MediaType
-
-        identifier 'application/json'
-
-        attributes do
-          attribute :string, String
-        end
-
-        view :default do
-          attribute :string
-        end
-      end
-    end
-  end
-  RUBY
-      end
-    end
-
-
-    def generate_app_controllers_hello_world
-        create_file path('app/controllers/hello.rb') do
-  <<-RUBY
-module V1
-  class Hello
-    include Praxis::Controller
-
-    implements V1::ApiResources::Hello
-
-    HELLO_WORLD = [ 'Hello world!', 'Привет мир!', 'Hola mundo!', '你好世界!', 'こんにちは世界！' ]
-
-    def index(**params)
-      response.headers['Content-Type'] = 'application/json'
-      response.body = HELLO_WORLD.to_json
-      response
-    end
-
-    def show(id:, **other_params)
-      hello = HELLO_WORLD[id]
-      if hello
-        response.body = { id: id, data: hello }
-      else
-        self.response = Praxis::Responses::NotFound.new(body: "Hello word with index \#{id} not found in our DB")
-      end
-      response.headers['Content-Type'] = 'application/json'
-      response
-    end
   end
 end
-RUBY
-      end
-    end
-
-  end
-end

data/tasks/thor/model.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PraxisGen
+  class Model < Thor
+    require 'active_support/inflector'
+    include Thor::Actions
+    
+    def self.source_root
+      File.dirname(__FILE__) + "/templates/generator/scaffold"
+    end
+
+    desc "gmodel", "Generates a skeleton model file under app/models for ActiveRecord or Sequel."
+    argument :model_name, required: true
+    option :orm, required: false, default: 'activerecord', enum: ['activerecord','sequel']
+    def g
+      #self.class.check_name(model_name)
+      template_file = \
+        if options[:orm] == 'activerecord'
+          'models/active_record.rb'
+        else
+          'models/sequel.rb'
+        end
+      puts "Generating Model for #{model_name}"        
+      template template_file, "app/models/#{model_name}.rb"
+      nil
+    end
+    # Helper functions (which are available in the ERB contexts)
+    no_commands do
+      def model_class
+        model_name.camelize
+      end
+    end
+
+    # TODO: do we want the argument to be camelcase? or snake case?
+    def self.check_name(name)
+      sanitized = name.downcase.gsub(/[^a-z0-9_]/, '')
+      raise "Please use only downcase letters, numbers and underscores for the model" unless sanitized == name
+    end
+  end
+end

data/tasks/thor/scaffold.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module PraxisGen
+  class Scaffold < Thor
+    require 'active_support/inflector'
+    include Thor::Actions
+    
+    attr_reader :actions_hash
+
+    def self.source_root
+      File.dirname(__FILE__) + "/templates/generator/scaffold"
+    end
+
+    desc "g","Generates an API design and implementation scaffold for managing a collection of <collection_name>"
+    argument :collection_name, required: true
+    option :version, required: false, default: '1',
+    desc: 'Version string for the API endpoint. This also dictates the directory structure (i.e., v1/endpoints/...))'
+    option :design, type: :boolean, default: true,
+        desc: 'Include the Endpoint and MediaType files for the collection'
+    option :implementation, type: :boolean, default: true,
+        desc: 'Include the Controller and (possibly the) Resource files for the collection (see --no-resource)'
+    option :resource, type: :boolean, default: true,
+        desc: 'Disable (or enable) the creation of the Resource files when generating implementation'
+    option :model, type: :string, enum: ['activerecord','sequel'],
+        desc: 'It also generates a model for the given ORM. An empty --model flag will default to activerecord'
+    option :actions, type: :string, default: 'crud', enum: ['cr','cru','crud','u','ud','d'],
+        desc: 'Specifies the actions to generate for the API. cr=create, u=update, d=delete. Index and show actions are always generated'
+    def g
+      self.class.check_name(collection_name)
+      @actions_hash = self.class.compose_actions_hash(options[:actions])
+      env_rb = Pathname.new(destination_root)+Pathname.new("config/environment.rb")
+      @pagination_plugin_found = File.open(env_rb).grep(/Praxis::Plugins::PaginationPlugin.*/).reject{|l| l.strip[0] == '#'}.present?
+      if options[:design]
+        say_status 'Design', "Generating scaffold for #{plural_class}", :blue
+        template 'design/media_types/item.rb', "design/#{version_dir}/media_types/#{collection_name.singularize}.rb"
+        template 'design/endpoints/collection.rb', "design/#{version_dir}/endpoints/#{collection_name}.rb"
+      end
+      if options[:implementation]
+        say_status 'Implement', "Generating scaffold for #{plural_class}", :blue
+        if options[:resource]
+          base_resource = Pathname.new(destination_root)+Pathname.new("app/#{version_dir}/resources/base.rb")
+          unless base_resource.exist?
+            # Copy an appropriate base resource for the version (resources within same version must share same base)
+            say_status "NOTE:", 
+              "Creating a base resource file for resources to inherit from (at 'app/#{version_dir}/resources/base.rb')", 
+              :yellow
+            say_status "", 
+              "If you had already other resources in the app, change them to derive from this Base"
+            template 'implementation/resources/base.rb', "app/#{version_dir}/resources/base.rb"
+          end
+          template 'implementation/resources/item.rb', "app/#{version_dir}/resources/#{collection_name.singularize}.rb"
+        end
+        template 'implementation/controllers/collection.rb', "app/#{version_dir}/controllers/#{collection_name}.rb"
+      end
+      nil
+    end
+
+    # Helper functions (which are available in the ERB contexts)
+    no_commands do
+      def plural_class
+        collection_name.camelize
+      end
+    
+      def singular_class
+        collection_name.singularize.camelize
+      end
+      
+      def version
+        options[:version]
+      end
+
+      def version_module
+        "V#{version}"
+      end
+    
+      def version_dir
+        version_module.camelize(:lower)
+      end
+
+      def action_enabled?(action)
+        @actions_hash[action.to_sym]
+      end
+
+      def pagination_enabled?
+        @pagination_plugin_found
+      end
+    end
+
+    def self.compose_actions_hash(actions_opt)
+      required = { index: true, show: true }
+      case actions_opt
+      when nil
+        required
+      when 'cr'
+        required.merge(create: true)
+      when 'cru'
+        required.merge(create: true, update: true)
+      when 'crud'
+        required.merge(create: true, update: true, delete: true)
+      when 'u'
+        required.merge(update: true)
+      when 'ud'
+        required.merge(update: true, delete: true)
+      when 'd'
+        required.merge(delete: true)
+      else
+        raise "actions option does not support the string #{actions_opt}"
+      end
+    end
+
+    def self.check_name(name)
+      sanitized = name.downcase.gsub(/[^a-z0-9_]/, '')
+      # TODO: bail or support CamelCase collections (for now only snake case)
+      raise "Please use only downcase letters, numbers and underscores for the collection" unless sanitized == name
+    end
+  end
+end