Skip to content

Latest commit

 

History

History
269 lines (221 loc) · 10.9 KB

FEATURES.md

File metadata and controls

269 lines (221 loc) · 10.9 KB

Hanami

The web, with simplicity.

Features

v2.0.0 - 2021-11-22

  • Renamed apps into slices, and project into app
  • The core of new applications is going to be app/. Slices are now optional.
  • App class built around a container for managing app components; code from app/ is loaded into the app
  • Apps may have multiple Slices; code from slices/[slice_name]/ is loaded into the corresponding slice
  • MyApp::Deps or MySlice::Deps mixin for auto-registering dependencies from the app or a slice
  • Code autoloading using Zeitwerk
  • Code reloading via Guard
  • Providers for setting up and managing the lifecycle of your app's critical components and integrations
  • Type-safe app settings
  • Rebuilt high-performance router
  • Redesigned stateless Hamami::Action classes supporting the Deps mixin; add your behavior to #handle(request, response)
  • Simplified action format configuration via config.format and config.formats
  • Rewritten CLI and console

v1.3.3 - 2019-09-20

v1.3.2 - 2019-07-26

v1.3.1 - 2019-01-18

v1.3.0 - 2018-10-24

  • Default testing framework is RSpec
  • Introduced Hanami::Middleware::BodyParser Rack middleware
  • Log payload (body) for non-GET HTTP requests coming from body parsers
  • Added support for reply_to in mailers
  • Variadic arguments for hanami-cli
  • Array as argument or option for hanami-cli

v1.2.0 - 2018-04-11

  • HTTP/2 Early Hints
  • Unobtrusive JavaScript (UJS) (via hanami-ujs gem)
  • Interactive console for development error page (via hanami-webconsole gem)
  • CLI: register callbacks for hanami commands (Hanami::CLI.after("db migrate", MyCallback.new) or Hanami::CLI.after("db migrate") { ... })
  • Project level Rack middleware stack (Hanami.configure { middleware.use MyRackMiddleware })
  • Plugins can hook into project configuration (Hanami.plugin { middleware.use AnotherRackMiddleware })
  • Custom repository commands
  • Coloured logging

v1.1.1 - 2018-02-27

v1.1.0 - 2017-10-25

  • One-To-Many association (aka belongs_to)
  • One-To-One association (aka has_one)
  • Many-To-Many association (aka has_many :through)
  • Allow third-party developers to register commands for CLI (eg hanami generate webpack)
  • Initial support for plugins via :plugins group in Gemfile
  • CLI: hanami db rollback to rollback database migrations
  • Introduced new extra behaviors for entity manual schema: :schema (default), :strict, :weak, and :permissive
  • Custom logger for Hanami.logger
  • Selectively boot apps via HANAMI_APPS=web env var
  • Log payload (params) for non-GET HTTP requests
  • Filter sensitive data in logs

v1.0.0 - 2017-04-06

  • Logger rotation
  • Added: Action#unsafe_send_file to send files outside of the public directory
  • CLI: hanami generate model now also generates a migration
  • Project logger Hanami.logger
  • Automatic logging of HTTP requests, migrations, and SQL queries

v0.9.2 - 2016-12-19

v0.9.1 - 2016-11-18

v0.9.0 - 2016-11-15

  • Experimental repositories associations (only "has many")
  • Database automapping for SQL databases
  • Entities schema
  • Immutable entities
  • Removed dirty tracking for entities
  • Repositories CRUD operations can accept both entities and/or data
  • Removed Memory and File System adapters
  • SQLite is the default adapter for new projects
  • Native support for PostgreSQL types
  • CLI: hanami secret to generate and print a new session secret for a single Hanami app

v0.8.0 - 2016-07-22

  • New validation syntax based on predicates
  • Custom and shared predicates for validations
  • High level rules for validations
  • Validations error messages with I18n support (via optional i18n gem)
  • Mount applications in subdomains
  • Added support for Content Security Policy 1.1 and 2.0
  • Subresurce Integrity
  • Include X-Content-Type-Options and X-XSS-Protection in default response headers
  • Support for several JSON engines (via optional multi_json gem)
  • JSON Logging for production
  • Per environment logging levels, stream (file, stdout), formatters
  • Introduced #local for views, layouts and templates to safely access locals by avoiding nil values
  • Added datalist form helper
  • CC and BCC support for mailers
  • Experimental code reloading via entr(1)
  • CLI: hanami new can be used with --template argument to generate a new project with (erb/haml/slim) templates

v0.7.3 - 2016-05-23

v0.7.2 - 2016-02-09

v0.7.1 - 2016-02-05

v0.7.0 - 2016-01-22

  • Renamed from Lotus to Hanami

v0.6.1 - 2016-01-19

v0.6.0 - 2016-01-12

  • Assets preprocessors support (eg. Sass, ES6, Opal, Less, CoffeeScript..)
  • Assets compressors (eg. YUI, UglifyJS2, Google Closure Compiler, Sass..)
  • Assets helpers:
    • javascript
    • stylesheet
    • favicon
    • image
    • video
    • audio
    • asset_path
    • asset_url
  • Content Delivery Network (CDN) support for static assets (CDN mode)
  • Checksum suffix for static assets in production mode (Digest mode)
  • Support for third party gems as assets distribution channel (eg. lotus-jquery)
  • CLI: lotus assets command precompile: preprocess, minify and append checksum suffix
  • CLI: lotus destroy destroy apps, models, actions, migrations and mailers
  • Custom initializers (apps/web/config/initializers)
  • Rake tasks :preload and :environment

v0.5.0 - 2015-09-30

  • Mailers
  • CLI: lotus generate mailer
  • SQL joins
  • Custom coercers for data mapper

v0.4.1 - 2015-07-10

v0.4.0 - 2015-06-23

  • Application architecture
  • Database migrations
  • CLI: lotus db commands: create, drop, prepare, migrate, version, apply.
  • HTML5 Form helpers
  • Cross Site Request Forgery (CSRF) protection
  • Force SSL
  • Number formatting helper

v0.3.2 - 2015-05-22

  • Automatic secure cookies
  • Routing helpers for actions
  • Send files from actions
  • Lotus.root returns top level directory of the project.

v0.3.1 - 2015-05-15

  • CLI: lotus generate app admin creates a new application (apps/admin).
  • CLI: lotus generate model user. It generates entity, repository and related unit test files.
  • Lotus.env and Lotus.env? for current environment introspection (eg. Lotus.env?(:test) or Lotus.env?(:staging, :production))
  • Allow repositories to execute raw query/commands against database
  • Automatic timestamps update for entities – Dirty Tracking for entities (via Lotus::Entity::DirtyTracking)
  • Nested RESTful resource(s)
  • String pluralization and singularization

v0.3.0 - 2015-03-23

  • CLI: lotus generate action web dashboard#index. It generates an action, a view, a template, a route and related unit test files.
  • CLI: lotus db console. It starts a database REPL.
  • Full featured HTML5 markup generator for views (Eg. html.div { p "Hello World" })
  • Routing helpers in views and templates (Eg. routes.home_path).
  • lotus new supports --database (Eg. lotus new bookshelf --database=postgresql).
  • Initialize a Git repository when generate a new application
  • Security: XSS (Cross Site Scripting) protections
  • Security: Clickhijacking protection
  • Security: Cookies are set as HttpOnly by default.
  • Security: enable by default X-Frame-Options and Content-Security-Policy HTTP headers for new generated applications.
  • Security: auto-escape output of presenters.
  • Security: auto-escape output of virtual an concrete view methods.
  • Security: view and template helpers for HTML, HTML attributes and URL escape. It's based on OWASP/ESAPI recommendations.
  • Access nested action params with a safe API (params.get('address.city')).
  • Interactors (aka Service Objects)
  • Database transactions

v0.2.1 - 2015-02-06

  • Allow entities to include validations.
  • lotus new . to generate a Lotus project for an existing code base (Eg. a gem that needs a web UI).
  • lotus new supports --path (for destination directory), --test (to generate Minitest or RSpec boilerplate).
  • Lotus logger

v0.2.0 - 2014-12-23

  • Support Minitest as default testing framework (bundle exec rake runs the entire test suite of an application).
  • Support for Method Override technique.
  • Custom templates for non successful responses (Eg. 404.html.erb).
  • Support distinct .env files for each Lotus environment.
  • Allow to configure multiple applications and handle Lotus environments accordingly.
  • Allow to configure middleware stack, routes, database mapping and adapter for each application.
  • Show a welcome page with instructions for new generated apps.
  • CLI: lotus routes. It prints all the routes available for all the applications.
  • CLI: lotus new. It generates a new application which can run multiple Lotus applications (Container architecture).
  • CLI: lotus console. It starts a Ruby REPL. It supports IRB (default), Pry and Ripl.
  • CLI: lotus server. It starts a web server that supports code reloading. It supports all the Rack web servers (default: WEBRick).
  • Database adapters: File system (default for new apps)
  • Allow to share code for all the views and actions of an application
  • Reusable validations framework (mixin). It supports: coercions and presence, format, acceptance, size, inclusion, exclusion, confirmation validations.
  • Default Content-Type and Charset for responses
  • Whitelist accepted MIME Types
  • Custom exception handlers for actions
  • Unique identifier for incoming HTTP requests
  • Nested action params
  • Action params indifferent access, whitelisting, validations and coercions
  • HTTP caching (Cache-Control, Last-Modified, ETAG, Conditional GET, expires)
  • JSON body parser for non-GET HTTP requests
  • Routes inspector for CLI

v0.1.0 - 2014-06-23

  • Run multiple Lotus applications in the same Ruby process
  • Serve static files
  • Render default pages for non successful responses (404, 500, etc.)
  • Support multiple Lotus environments (development, test and production)
  • Full stack applications
  • Data mapper
  • Database adapters: Memory and SQL
  • Reusable scopes for repositories
  • Repositories
  • Entities
  • Custom rendering implementation via #render override in views
  • Render partials and templates
  • Presenters
  • Layouts
  • Views are able to handle multiple MIME Types according to the defined templates
  • Support for all the most common template engines for Ruby. Including ERb, Slim, HAML, etc.
  • Basic view rendering with templates
  • Bypass rendering by setting a response body in actions (self.body = "Hello")
  • Single actions are able to mount Rack middleware
  • Automatic MIME Type handling for request and responses
  • HTTP sessions
  • HTTP cookies
  • HTTP redirect
  • Action before/after callbacks
  • Handle exceptions with HTTP statuses
  • Action exposures, to expose a payload to pass to the other application layers
  • Actions compatible with Rack
  • Mount Rack applications
  • Nested route namespaces
  • RESTful resource(s), including collection and member actions
  • Named routes, routes constraints, variables, catch-all
  • Compatibility with Lotus::Controller
  • HTTP redirect from the router
  • HTTP routing compatible with Rack
  • Thread safety
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy