praxis 2.0.pre.15 → 2.0.pre.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9391f2cd6fb2c5a605a4b4c9f492371ef1d7f01849e94a9d17fdc51b95c211a9
-  data.tar.gz: 70c9f00cd12c7b3e99cebd10f86a98ac913433b8b96a41b658893b63ddc4b31b
+  metadata.gz: 58ae0c1f92272e7fd0aaaa779fb679db4b14f6e8d2f9df08efaec211bd3cc4f0
+  data.tar.gz: 19b73ba6239911b4b0f6d3097e58671f556f7835514b7fa52269c1a81f47d837
 SHA512:
-  metadata.gz: edfc42021b347aea6bd7b84853ebd901f55e4963612da2a6870e00b956b3352e51efd8cd3c360123625af48f89553bff6fa0ad7766e076bc164ba8ccf770ba7b
-  data.tar.gz: da2df887a849f03be390f7218f931807670a58addc8eb3d101b293e0827a522680ca1824f47bafcff2c3f26bfb45bd13e8ad0c6f02577edad12c5c8cfca60904
+  metadata.gz: f488d80d4e1495b3574bce59a20826c418ac663d6417838a24f7ef92770e73dd789fe3b9d432a5663b4e6cd5abe665be5d4fc96919c20d93dac0cd981732b4ec
+  data.tar.gz: b8ffc24d28567d4b00a83c8b03bfd00539791af3a675ec315858a800d9e7890bf5bbcb1b811cd91ef8a13c9edc10be96eefb605e34139c789b5ec174b6975342

data/.rubocop.yml

@@ -0,0 +1,54 @@
+# require:
+#   - rubocop-thread_safety
+
+AllCops:
+  Exclude:
+    - "_site/**/*"
+    - "coverage/**/*"
+    - "docs_docusaurus/**/*"
+    - "tmp/**/*"
+    - "pkg/**/*"
+    - "vendor/cache/**/*"
+    - "tasks/thor/templates/**/*"
+  TargetRubyVersion: 2.5
+  NewCops: disable
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false  
+
+Layout/LineLength:
+  Enabled: false  
+
+Style/Documentation:
+  Enabled: false
+
+#### RE-ENABLE PLEASE
+Metrics/BlockNesting:
+  Enabled: false
+
+Style/OptionalBooleanParameter:
+  Enabled: false
+  
+Lint/Void:
+  Enabled: false
+  
+Lint/MissingSuper:
+  Enabled: false    

data/.simplecov

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 SimpleCov.profiles.define 'praxis' do
   add_filter '/config/'
   add_filter '/spec/'
 
   add_group 'lib', 'lib'
   add_group 'app', 'app'
-end
+end

data/.travis.yml

@@ -2,7 +2,8 @@ sudo: false
 language: ruby
 rvm:
   - 2.6
-  - 2.7  
+  - 2.7
+  # - 3.1 # Not available in TravisCI out of the box yet
 script:
   - bundle exec rspec spec
 branches:

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## next
 
+## 2.0.pre.19
+* Introduced a new DSL for the `FilteringParams` type that allows filters for common attributes in your Media Types:
+  * The new `any` DSL allows you to define which final leaf attribute to always allow, and with which operators and/or fuzzy restrictions.
+  * For example, you can add `any updated_at, using: ['>','<']` which would allow the type to accept filters like `updated_at>2000-01-01`, or any existing nested fields like `posts.comments.updated_at>2000-01-01`
+  * Note that the path of attributes passed in, will still need to exist and will be validated. Also, you still need to make sure that you have the right `filters_mapping` defined in your resources.
+* Changed `filters_mapping` to allow implicitly any filter path that is a valid representation of existing columns and associations. I.e., you do not have to explicitly define long nested filters that correspond to the same underlying path of associations and columns.
+## 2.0.pre.18
+* Upgraded to newest Attributor, which cleans up the required: true semantics to only work on keys, and introduces null: true for nullability of values (independent from presence of keys or not)
+* Fixed a selector generator bug that would occur when using deep nested resource dependencies as strings 'foo.bar.baz.bam'. In this cases only partial tracking of relationships would be built, which could cause to not fully eager load DB queries.
+## 2.0.pre.17
+* Changed the Parameter Filtering to use left outer joins (and extra conditions), to allow for the proper results when OR clauses are involved in certain configurations.
+* Built support for allowing filtering directly on associations using `!` and `!!` operators. This allows to filter results where 
+there are no associated rows (`!!`) or if there are some associated rows (`!`)
+* Allow implicit definition of `filters_mapping` for filter names that match top-level associations of the model (i.e., like we do for the columns)
+## 2.0.pre.16
+
+* Updated `Resource.property` signature to only accept known named arguments (`dependencies` and `though` at this time) to spare anyone else from going insane wondering why their `depednencies` aren't working.
+* Fixed issue with Filtering Params, that occurred with using the ! or !! operators on String-typed fields.
+
 ## 2.0.pre.14
 
 * More encoding/decoding robustness for filters. 

data/CONTRIBUTING.md

@@ -19,13 +19,8 @@ Before submitting any contributions, please read the below description of what
 the problems Praxis aims to solve. Contributions that are not aligned with
 Praxis' goals will not be accepted.
 
-Praxis is a web framework for developing usable, consistent and
-self-documenting HTTP APIs for
-[SOA](http://en.wikipedia.org/wiki/Service-oriented_architecture) systems.
-
 Praxis is not a Rails plugin or extension. If you want to use Praxis with
-Rails, please create a separate gem or equivalent. We will not enhance Praxis
-with Rails-specific functionality.
+Rails, please look at the MiddlewareApp class on how to embed it on an existing Rails project.
 
 Praxis is also not designed for service any kind of UI, although UIs can
 certainly be powered by Praxis apps.
@@ -36,10 +31,6 @@ We are always thrilled to receive pull requests, and do our best to process
 them as fast as possible. Not sure if that typo is worth a pull request? Do it!
 We will appreciate it.
 
-If your pull request is not accepted on the first try, don't be discouraged! If
-there's a problem with the implementation, hopefully you received feedback on
-what to improve.
-
 We're trying very hard to keep Praxis lean and focused. We don't want it to do
 everything for everybody. This means that we might decide against incorporating
 a new feature. However, there might be a way to implement that feature *on top
@@ -72,13 +63,7 @@ help prioritize the most common problems and requests.
 
 ### Conventions
 
-Fork the repository and make changes on your fork in a feature branch:
-
-- If it's a bug fix branch, name it XXXX-something where XXXX is the number of
-  the issue.
-- If it's a feature branch, create an enhancement issue to announce your
-  intentions, and name it XXXX-something where XXXX is the number of the issue.
-
+Fork the repository and make changes on your fork in a feature branch.
 Submit unit tests for your changes. Take a look at existing tests for
 inspiration. Run the full test suite on your branch before submitting a pull
 request.
@@ -115,68 +100,6 @@ github team.
 
 Add a quick summary of your change to the changelog, under the `next` heading.
 
-### Sign your work
-
-The sign-off is a simple line at the end of the explanation for the
-patch, which certifies that you wrote it or otherwise have the right to
-pass it on as an open-source patch.  The rules are pretty simple: if you
-can certify the below (from
-[developercertificate.org](http://developercertificate.org/)):
-
-```
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
-```
-
-Then you just add a line to every git commit message:
-
-Signed-off-by: Joe Smith <joe.smith@email.com> Using your real name
-(sorry, no pseudonyms or anonymous contributions.)
-
-If you set your user.name and user.email git configs, you can sign your
-commit automatically with git commit -s.
-
-#### Small patch exception
-
-There are several exceptions to the signing requirement. Currently these are:
-
-* Your patch fixes spelling or grammar errors.
-* Your patch is a single line change to documentation.
-* Your patch fixes Markdown formatting or syntax errors in the documentation.
-
 ### How can I become a maintainer?
 
 * Step 1: Learn the component inside out

data/Gemfile

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 gemspec
 
+gem 'rubocop'
+
 group :test do
   gem 'builder'
 
-  gem 'parslet'
   gem 'link_header'
+  gem 'parslet'
 end

data/Guardfile

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 guard :rspec, cmd: 'bundle exec rspec --format=Fuubar', \
               all_after_pass: false, all_on_start: false, failed_mode: :focus do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec/" }
-  watch('spec/functional_spec.rb')  { "spec/" }
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/functional_spec.rb" }
-  watch(%r{^app/(.+)\.rb$})     { "spec/" }
+  watch('spec/spec_helper.rb')  { 'spec/' }
+  watch('spec/functional_spec.rb') { 'spec/' }
+  watch(%r{^lib/(.+)\.rb$})     { |_m| 'spec/functional_spec.rb' }
+  watch(%r{^app/(.+)\.rb$})     { 'spec/' }
   watch(%r{^spec/support}) { 'spec/' }
 end

data/LICENSE

@@ -1,5 +1,3 @@
-Copyright (c) 2014 RightScale
-
 MIT License
 
 Permission is hereby granted, free of charge, to any person obtaining

data/MAINTAINERS.md

@@ -31,6 +31,7 @@ It is every maintainer's responsibility to:
   list.
 4. Make sure their component respects the philosophy, design and
   road map of the project.
+5. Be inclusive of the different ways to develop and use the framework
 
 ## How are decisions made?
 

data/README.md

@@ -1,42 +1,35 @@
 # Praxis [![TravisCI][travis-img-url]][travis-ci-url] [![Coverage Status][coveralls-img-url]][coveralls-url] 
 
-[//]: # ( COMMENTED OUT UNTIL GEMNASIUM CAN SEE THE REPOS: [![Dependency Status][gemnasium-img-url]][gemnasium-url])
-
-[travis-img-url]: https://travis-ci.org/praxis/praxis.svg?branch=master
-[travis-ci-url]:https://travis-ci.org/praxis/praxis
+[travis-img-url]: https://app.travis-ci.com/praxis/praxis.svg?branch=master
+[travis-ci-url]: https://app.travis-ci.com/praxis/praxis
 [coveralls-img-url]:https://coveralls.io/repos/github/praxis/praxis/badge.svg?branch=master
 [coveralls-url]:https://coveralls.io/github/praxis/praxis?branch=master
-[gemnasium-img-url]:https://gemnasium.com/praxis/praxis.svg
-[gemnasium-url]:https://gemnasium.com/praxis/praxis
-
-Praxis is a framework for both _designing_ and _implementing_ APIs.
 
-An important part of the framework is geared towards the _design_ aspect of building an API. This functionality empowers architects with tools to design every last aspect of their API, resulting in a complete, web-browsable documentation, which includes automatic generation of examples for resources, parameters, headers, etc...as well as requests and responses for the supported encodings. The design process is iterative, and flows from defining new resources, parameters, etc...to reviewing the resulting docs (usually with some of the potential clients of the API), back to updating the design based on feedback, or expanding it with more resources. The design language (i.e. DSL) of Praxis follows a clean 'ruby-type-syntax' and its final outcome is to generates an output that is both a set of schema documents as well as a web-based API browser (driven by those schemas). This allows Praxis to design APIs that can potentially be implemented in any language.
+A fast and highly efficient paradigm to build beautiful service APIs
 
-Another important part of the framework is geared towards helping in the _implementation_ of the API service. In particular, Praxis provides help to Ruby developers for building a service conforming to the designed API. Aside from Ruby there is also sister-project called [Goa](http://goa.design/) that assists in implementing Praxis-like design API using Golang. Since the API design generates schema files very similar in nature to other API document formats like (Swagger, Google Discovery, RAML, etc...) supporting other implementation languages could be easily accomplished in the future by building converters to/from them.
+Praxis is built to empower development teams with extreme productivty tools to create fast, and modern APIs that will delight their customers. Some of the salient features are:
 
-The part of the framework that helps with the ruby service implementation takes an approach that is different from other existing ruby (micro)frameworks such as [Grape](http://www.ruby-grape.org), [Sinatra](https://github.com/sinatra/sinatra), [Scorched](http://scorchedrb.com/), [Lotus](http://lotusrb.org/) or even [RailsAPI](https://github.com/rails-api/rails-api) (now part of Rails). Instead of being developer-centric, it takes an integrated approach treating both designers and implementors as first class citizens throughout the complete API building process. With Praxis you create an API by iterating through the design, review and implementation phases. While Praxis can help Ruby developers in a lot of aspects involved in building a service, the framework is completely componentized as to allow developers to pick and choose which parts to use, which ones not to use, and which other technologies to integrate with. The framework provides help in many areas, for example: all aspects of request and response validation, automatic type-coercion, consistent error-responses, routing and url generation, advanced template/media-type definition and rendering, domain-modeling, optional database ORM (for high-perfomance large datasets), DB integration (with an efficient identityMap), a plugin and extensible framework to easily hook into, available integrations such as newrelic, statsd, etc...
+* **Truthful & Beautiful Docs:** Automatically generate Open API 3.x documents from the actual functioning code, and rest assured they're always correct.
 
-There is a long list of benefits that come from using Praxis. From those, here are a couple of the salient themes:
-* Designing APIs with Praxis result in a very precise, consistent and beautiful API documentation that it is apt for both human (web browsable) or machine consumption (JSON spec files).
-* Building Ruby APIs with Praxis will result in much faster developer times, and more importantly with a resulting service that will ensure that its implementation is always consistent with its design, and it is enforced at all times.
+* **GraphQL Flexibility, REST Simplicity:** Allow customers to specify which fields they want to receive using the GraphQL syntax, but exposing them through well known REST endpoints.
+* **Fast Runtime and Blazing Fast Development:** Deploy your API using one of the best Ruby performing frameworks and take advantage of an unprecedented development speed.
+* **API Design-First Philosophy:** Craft and visualize your API design upfont, without writing a single line of code. Forget about implementing any of the API validations, the framework fully takes care of it from your design specification.
+* **Feature Rich yet Fully Customizable:** Fully take advantage of the tons of best practices, proven methods, standards and features that the frameworks comes with, or pick and choose only the ones you want to enable.
+* **Hardnened & Battle Tested:** Rest assured you'll get the advertised results as this framework has been deployed in production environments since before 2014.
 
 ## Quickstart
 ```bash
 # Install the praxis gem
 gem install praxis
 
-# Generate a praxis application named my-app in ./my-app
-praxis example my-app
+# Generate and bundle a praxis application named my-app in ./my-app
+praxis example my-app && cd my-app && bundle
 
 # Run it!
-cd my-app
-bundle
 rackup
 ```
 
-Or better yet, checkout a simple, but functional [blog example app](https://github.com/praxis/praxis-example-app) which showcases a few of the main design and implementation aspects that Praxis has to offer.
-
+Or check the getting started tutorial and reference docs at https://www.praxis-framework.io all that Praxis has to offer.
 
 ## Mailing List
 Join our Google Groups for discussion, support and announcements.
@@ -59,10 +52,10 @@ for further details on what contributions are accepted and how to go about
 contributing.
 
 ## Requirements
-Praxis requires Ruby 2.1.0 or greater.
+Praxis requires Ruby 2.5.0 or greater.
 
 ## License
 
 This software is released under the [MIT License](http://www.opensource.org/licenses/MIT). Please see  [LICENSE](LICENSE) for further details.
 
-Copyright (c) 2014 RightScale
+This framework was initially developed and used at RightScale, and was open sourced in 2014, after a few years of its production use.

data/Rakefile

@@ -1,4 +1,6 @@
-$:.unshift File.expand_path('lib',__dir__)
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
 
 require 'praxis'
 require 'praxis/tasks'
@@ -9,4 +11,4 @@ require 'bundler/gem_tasks'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/praxis

@@ -1,4 +1,5 @@
 #! /usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler'
 
@@ -9,119 +10,116 @@ rescue Bundler::GemfileNotFound
   # no-op: we might be installed as a system gem
 end
 
-if ARGV[0] == "version"
+if ARGV[0] == 'version'
   require 'praxis/version'
   puts "Praxis version #{Praxis::VERSION}"
   exit 0
 end
 
-if ["routes","docs","console"].include? ARGV[0]
+if %w[routes docs console].include? ARGV[0]
   require 'rake'
   require 'praxis'
   require 'praxis/tasks'
   load 'Rakefile' # Ensure that we read the App's Rakefile, to pickup any definitions etc.
 
   case ARGV[0]
-    when "routes"
-      Rake::Task['praxis:routes'].invoke(ARGV[1])
-    when "docs"
-      task_name = case ARGV[1]
-      when nil,'browser'
-        'praxis:docs:preview'
-      when 'generate'
-        'praxis:docs:generate'
-      when 'package'
-        'praxis:docs:package'        
-      end
-      Rake::Task[task_name].invoke
-    when "console"
-      Rake::Task['praxis:console'].invoke
+  when 'routes'
+    Rake::Task['praxis:routes'].invoke(ARGV[1])
+  when 'docs'
+    task_name = case ARGV[1]
+                when nil, 'browser'
+                  'praxis:docs:preview'
+                when 'generate'
+                  'praxis:docs:generate'
+                when 'package'
+                  'praxis:docs:package'
+                end
+    Rake::Task[task_name].invoke
+  when 'console'
+    Rake::Task['praxis:console'].invoke
   end
   exit 0
 end
 # Thor tasks
 path_to_praxis = File.expand_path(File.dirname(File.dirname(__FILE__)))
-path_to_loader = '%s/tasks/loader.thor' % path_to_praxis
+path_to_loader = format('%<path>s/tasks/loader.thor', path: path_to_praxis)
 
 load path_to_loader
 
 class PraxisGenerator < Thor
-  
   # Include a few fake thor action descriptions (for the rake tasks above) so they can show up in the same usage messages
-  desc "routes [json]", "Prints the route table of the application. Defaults to table format, but can produce json"
-  def routes
-  end
+  desc 'routes [json]', 'Prints the route table of the application. Defaults to table format, but can produce json'
+  def routes; end
 
-  desc "docs [generate|browser|package]", <<~EOF
-  Generates API documentation and a Web App to inspect it
-    generate - Generates the JSON docs
-    browser  - (default) Generates JSON docs, and automatically starts a Web app to browse them.
-    package  - Generates JSON docs, and neatly packages all the necessary static files ready for exporting the browsing app.
-  EOF
-  def docs
-  end
-  
-  desc "console", "Open a console to the application, with its environment loaded"
-  def console
-  end
+  desc 'docs [generate|browser|package]', <<~HELP
+    Generates API documentation and a Web App to inspect it
+      generate - Generates the JSON docs
+      browser  - (default) Generates JSON docs, and automatically starts a Web app to browse them.
+      package  - Generates JSON docs, and neatly packages all the necessary static files ready for exporting the browsing app.
+  HELP
+  def docs; end
+
+  desc 'console', 'Open a console to the application, with its environment loaded'
+  def console; end
 
   # Simple helper to go get the existing description for the real action
-  # Usage must still be provided rather than retrieved (since it is not a 
+  # Usage must still be provided rather than retrieved (since it is not a
   # straight "usage" from the remote action when arguments are defined )
-  def self.desc_for( usage_string, klass, action_name, description_prefix="")
+  def self.desc_for(usage_string, klass, action_name, description_prefix = '')
     action_name = action_name.to_s
     cmd = klass.commands[action_name]
     raise "Error, could not find description for #{klass.name}##{action_name}" if cmd.nil?
+
     desc usage_string, "#{description_prefix}#{cmd.description}"
   end
 
-  desc_for "new APP_NAME", ::PraxisGen::App, :new
+  desc_for 'new APP_NAME', ::PraxisGen::App, :new
   def new(app_name)
     gen = ::PraxisGen::App.new([app_name])
     gen.destination_root = app_name
     gen.invoke_all
   end
 
-  desc_for "example APP_NAME", ::PraxisGen::Example, :example
+  desc_for 'example APP_NAME', ::PraxisGen::Example, :example
   def example(app_name)
     gen = ::PraxisGen::Example.new([app_name])
     gen.destination_root = app_name
     gen.invoke(:example)
   end
 
-  desc_for "g COLLECTION_NAME", ::PraxisGen::Scaffold, :g
+  desc_for 'g COLLECTION_NAME', ::PraxisGen::Scaffold, :g
   # Cannot use the argument below or it will apply to all commands (the action in the class has it)
   # argument :collection_name, required: false
   # The options, however, since they're optional are fine (But need to be duplicated from the class :( )
   option :version, required: false, default: '1',
-          desc: 'Version string for the API endpoint. This also dictates the directory structure (i.e., v1/endpoints/...))'
+                   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'
+                  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)'
+                          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'
+                    desc: 'Disable (or enable) the creation of the Resource files when generating implementation'
+  option :model, type: :string, enum: %w[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: %w[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(*args)
     # Because we cannot share the :collection_name argument, we need to do this check here, before
     # we "parse" it and pass it to the g command
     unless args.size == 1
-      ::PraxisGen::Scaffold.command_help(shell,:g)
+      ::PraxisGen::Scaffold.command_help(shell, :g)
       exit 1
     end
 
-    collection_name,_ = args
-    ::PraxisGen::Scaffold.new([collection_name],options).invoke(:g)
-    if options[:model]
-      # Make it easy to be able to both enable or not enable the creation of the model, by passing --model=...
-      # but also make it easy so that if there is no value for it, it default to activerecord
-      opts = {orm: options[:model] }
-      opts[:orm] = 'activerecord' if opts[:orm] == 'model' # value is model param passed by no value
-      ::PraxisGen::Model.new([collection_name.singularize],opts).invoke(:g)
-    end
+    collection_name, = args
+    ::PraxisGen::Scaffold.new([collection_name], options).invoke(:g)
+    return unless options[:model]
+
+    # Make it easy to be able to both enable or not enable the creation of the model, by passing --model=...
+    # but also make it easy so that if there is no value for it, it default to activerecord
+    opts = { orm: options[:model] }
+    opts[:orm] = 'activerecord' if opts[:orm] == 'model' # value is model param passed by no value
+    ::PraxisGen::Model.new([collection_name.singularize], opts).invoke(:g)
   end
 
   # Initially, the idea was to build some quick model generator, but I think it's better to keep it
@@ -144,7 +142,6 @@ class PraxisGenerator < Thor
   #   model_name,_ = args
   #   ::PraxisGen::Model.new([model_name],options).invoke(:g)
   # end
-
 end
-    
+
 PraxisGenerator.start(ARGV)

data/lib/praxis/action_definition/headers_dsl_compiler.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Praxis
   class ActionDefinition
     class HeadersDSLCompiler < Attributor::DSLCompiler
-
       # it allows to define expectations on incoming headers. For example:
       # header :X_SpecialCookie                        => implies the header is required
       # header :X_Something, /matching_this/           => implies that if the name header exists, it should match the regexp
@@ -11,10 +12,8 @@ module Praxis
       #                     required: true             => to make it required
       #                     description: "lorem ipsum" => to describe it (like any other attribute)
 
-      def header(name, val=nil, **options)
-        if val.kind_of?(Class)
-          return key name, val, **options  
-        end
+      def header(name, val = nil, **options)
+        return key name, val, **options if val.is_a?(Class)
 
         case val
         when Regexp
@@ -25,7 +24,7 @@ module Praxis
           # Defining the existence without any other options can only mean that it is required (otherwise it is a useless definition)
           options[:required] = true if options.empty?
         end
-        key name , String, **options
+        key name, String, **options
       end
     end
   end