padrino/padrino-framework

This system is the Padrino web framework for Ruby, structured as a multi-gem collection that provides core application scaffolding, routing, and middleware capabilities. It includes a dedicated admin module for generating role-based access control, authentication, and CRUD interfaces across multiple ORMs and template engines. Additionally, the framework offers specialized components for caching, email delivery, and performance benchmarking, all managed through a unified CLI and build infrastructure.

48 changes.

The project underwent a comprehensive modernization to support Sinatra 4 and Rack 3, involving a major architectural refactor of the core library and a migration of all sub-gems to a shared, Jeweler-free build system. This period saw the consolidation of routing into the core, the replacement of legacy caching and mailer implementations with Moneta and the mail gem, and the removal of deprecated ORM and test framework generators. Additionally, the test suites were migrated to Minitest, and the Admin panel was enhanced with role-based access control and a standardized ORM abstraction layer.

31 changes.

This period focused on significantly enhancing the Padrino Admin generator by introducing Bootstrap 3 styling, robust authentication with BCrypt, and support for multiple ORMs and template engines. The project also expanded its scaffolding capabilities by adding generators for various JavaScript libraries, CSS preprocessors, and testing frameworks, while restructuring core CLI and application setup modules for better security and modularity.

41 changes.

This period focused on modernizing the Padrino Admin interface by upgrading to Bootstrap 3, adding comprehensive Slim and Haml template support, and implementing localized error pages. Concurrently, the core framework underwent significant refactoring, including the replacement of the router with a new PathRouter engine, restructuring of the file reloading system, and the removal of deprecated ActiveSupport dependencies in favor of native Ruby utilities.

The Padrino Admin generator now includes Slim template versions of the main application layout and error pages. These new files provide the structural HTML for the admin interface, including the navigation bar, flash message handling, footer, and JavaScript includes, ensuring that users generating admin apps with the Slim templating engine have properly formatted layout files.

padrino-admin/lib/padrino-admin/generators/templates/slim/app/layouts · high confidence

Introduces a new Slim template for the Padrino Admin login interface, providing the HTML structure for user authentication. The template includes a login form with email and password fields, flash message display mapped to Bootstrap alert classes, and includes necessary JavaScript libraries (jQuery and Bootstrap components) for functionality.

padrino-admin/lib/padrino-admin/generators/templates/slim/app/sessions · high confidence

The Padrino Admin generator now includes support for Slim templates, providing new template files for the standard resource pages (index, new, edit, and form). These templates generate admin interfaces styled with Twitter Bootstrap, featuring tabbed navigation, data tables with row selection and bulk delete capabilities, and form fields with error handling and autofocus on the first input.

padrino-admin/lib/padrino-admin/generators/templates/slim/page · high confidence

The admin interface generator now includes a new base layout written in Slim syntax. This template provides a styled landing page that highlights key framework capabilities—such as ORM agnosticism, authentication, template support, and multi-language options—using a grid of icon buttons, replacing previous HTML or ERB-based base structures.

padrino-admin/lib/padrino-admin/generators/templates/slim/app/base · high confidence

The application now includes dedicated, localized templates for common HTTP error responses (403 Forbidden, 404 Not Found, and 500 Internal Server Error) for both Haml and Slim view engines. These new generator templates replace generic error handling with specific pages that display distinct icons and pull their text content from i18n keys (e.g., \custom\_errors.403.title\), allowing users to easily customize the error messages through their locale files.

padrino-admin/lib/padrino-admin/generators/templates/haml/app/errors, padrino-admin/lib/padrino-admin/generators/templates/slim/app/errors · high confidence

The performance analysis tool now includes two new detection suites. The JSON suite hooks into Ruby's require method to detect when multiple JSON libraries (such as json, json\_pure, yajl-ruby, oj, or crack) are loaded simultaneously, warning users about the resulting memory overhead and providing call stacks to identify the source. The memory suite automatically reports the application's memory usage before and after loading by executing OS-specific commands (vmmap on macOS, pmap on Linux, or tasklist on Windows).

padrino-performance/lib/suites · high confidence

The application now includes specific generator components for four distinct stylesheet technologies: Compass, Less, SASS, and SCSS. Each component provides a dedicated initializer and dependency setup—Compass integrates with the compass-blueprint gem, Less relies on rack-less and therubyracer, while SASS and SCSS both utilize the sass gem with the latter explicitly setting the syntax to SCSS. This allows users to scaffold projects with pre-configured middleware and directory structures for their preferred CSS preprocessor.

padrino-gen/lib/padrino-gen/generators/components/stylesheets · high confidence

The application now includes dedicated, i18n-enabled templates for common HTTP error responses. When a user encounters a 403 Forbidden, 404 Not Found, or 500 Internal Server Error, they will see a specific page featuring a relevant Font Awesome icon and a title/description pulled from the \custom\_errors\ translation keys, rather than a generic error message.

padrino-admin/lib/padrino-admin/generators/templates/erb/app/errors · high confidence

The application generator now includes dedicated script components for five JavaScript libraries: Dojo, Ext Core, jQuery, MooTools, and Prototype. When a user selects one of these frameworks during project generation, the tool automatically downloads the corresponding library and its Unobtrusive JavaScript (UJS) adapter from the padrino-static repository, falling back to local template copies if the download fails. This ensures that the necessary JavaScript files are placed in the public/javascripts directory and an application.js file is created for custom code.

padrino-gen/lib/padrino-gen/generators/components/scripts · high confidence

The application now provides direct access to the current controller and action name within the Sinatra request object via the new \controller\ and \action\ methods. This enhancement allows middleware and extensions to inspect routing context more easily, improving debugging and request handling capabilities.

padrino-core/lib/padrino-core/ext · high confidence

The project generator now includes a template for creating a standalone Padrino gem, complete with a README explaining usage via Gemfile and mounting in apps.rb. The generated gemspec is updated to include author name and email from git configuration, sets the binary directory to 'exe', and adds a dependency on 'padrino-core'.

padrino-gen/lib/padrino-gen/generators/templates/gem · high confidence

The main library file for the Padrino Performance gem has been created, establishing the entry point by requiring the version and OS modules.

padrino-performance/lib · high confidence

The repository is initialized with a comprehensive Rakefile that manages the multi-gem structure (padrino-core, padrino-gen, etc.), providing tasks for version bumping, publishing to RubyGems, running tests, and generating YARD documentation. The setup includes a .gitignore for build artifacts, a .rubocop.yml for code style enforcement, a .yardopts file for documentation generation, and a gem\_rake\_helper.rb for bundler integration. The initial CHANGES.rdoc documents the 0.16.1 release, and the README.rdoc is expanded with installation and usage guides.

(repo-wide) · high confidence

The Padrino Admin module now includes a built-in AccessControl system that allows developers to define roles (such as :admin or :worker) and restrict access to specific paths, with the ability to hide unauthorized links from the navigation menu. Additionally, a generic ORM generator layer has been added to standardize how the Admin panel interacts with different database adapters (ActiveRecord, Mongoid, Sequel, Ohm, etc.), ensuring consistent behavior for model operations like finding, saving, and destroying records across supported ORMs.

ruby · high confidence

The admin generator now includes a complete set of ERB templates (\_form, index, new, edit) for scaffolding admin pages. These templates generate a Bootstrap-styled interface featuring a tabbed navigation header, a data table with row selection and bulk delete capabilities, and forms with field-level error handling and autofocus on the first input.

padrino-admin/lib/padrino-admin/generators/templates/erb/page · high confidence

The Padrino Admin generator now includes a new ERB template for the login view (sessions/new). This page uses Twitter Bootstrap 3 for styling, includes a logo, and maps flash messages to Bootstrap alert classes. It also adds a 'bypass' checkbox to allow login without credentials in development mode, and sets autofocus on the email field.

padrino-admin/lib/padrino-admin/generators/templates/erb/app/sessions · high confidence

The Padrino Admin generator now includes a new HAML template for the login page (sessions/new), providing users with a modern, responsive login interface. This template integrates Twitter Bootstrap 3 for styling and layout, includes specific JavaScript inclusions for jQuery and various Bootstrap components (affix, alert, modal, etc.), and implements a 'bypass login' checkbox for development environments. It also features proper HTML5 structure, viewport meta tags for mobile responsiveness, and uses HAML syntax for rendering flash messages and form fields.

padrino-admin/lib/padrino-admin/generators/templates/haml/app/sessions · high confidence

The Haml generator templates for the admin application's main layout (application.haml.tt) and error pages (error.haml.tt) have been added. These templates provide the structural foundation for the admin interface, including a fixed-top navbar with user profile and logout actions, a flash message area mapped to Bootstrap alert classes, and a footer with site links. The error layout offers a centered, minimal view for displaying custom error messages with a 'Go back' button.

padrino-admin/lib/padrino-admin/generators/templates/haml/app/layouts · high confidence

The admin interface now includes dedicated helper modules for authentication and view rendering. The new AuthenticationHelpers module provides methods to manage user sessions (logged\_in?, current\_account, set\_current\_account), enforce access control (allowed?, login\_required), and handle redirects after login, including support for the RACK\_BASE\_URI environment variable to correctly construct return URLs. The ViewHelpers module adds utilities for generating Font Awesome icon tags and translating model names, attributes, and general admin strings using I18n, with convenient aliases like pat, mat, and t\_attr for easier usage in templates.

padrino-admin/lib/padrino-admin/helpers · high confidence

The padrino-cache library introduces new helper modules to provide finer control over caching. The \cache\_object\ helper allows caching arbitrary Ruby objects with optional expiration options. The \cache\ helper in the Fragment module enables caching of specific view fragments, automatically handling HTML safety and content capture. The Page module now includes \expires\ and \cache\_key\ helpers, allowing developers to set expiration times and custom cache keys for entire page responses, with automatic storage and retrieval of both the response body and content type.

padrino-cache/lib/padrino-cache · high confidence

The base admin template now includes a new index page that introduces users to the framework's core capabilities. This page displays a brief description of Padrino and highlights key features such as ORM agnosticism, authentication support, template flexibility, multi-language support, and scaffolding, using styled buttons with icons for visual emphasis.

padrino-admin/lib/padrino-admin/generators/templates/erb/app/base · high confidence

A new executable script \padrino-performance\ has been added to the project, allowing users to run performance benchmarks directly from the command line. The tool supports two specific modes: using the \-j\ or \--json\ flag to check for multiple loaded JSON libraries, and using the \-m\ or \--mem\ flag to print memory consumption. It constructs the appropriate Ruby execution command to load the relevant test suites located in the \lib/suites\ directory.

padrino-performance/bin · high confidence

The project generator now includes new template files for \config/apps.rb\ and \config/boot.rb\. The \apps.rb\ template initializes global app settings, including a securely generated session secret, CSRF protection, and path traversal protection. The \boot.rb\ template sets up the environment, loads dependencies via Bundler, configures initializers, and defines before/after load hooks.

padrino-gen/lib/padrino-gen/generators/project/config · high confidence

The project generator now includes dedicated components for six testing frameworks: Bacon, Cucumber, Minitest, RSpec, Shoulda, and Test::Unit. Selecting any of these options during project creation will automatically scaffold the corresponding test suite structure, including setup files (e.g., \spec\_helper.rb\, \test\_config.rb\), rake tasks for running tests, and initial template files for controller, model, and helper tests. Each generator also configures the necessary dependencies, such as \rack-test\, \capybara\, and the specific testing library, ensuring a ready-to-run test environment out of the box.

padrino-gen/lib/padrino-gen/generators/components/tests · high confidence

The specific generator modules for ERB (ErbGen) and HAML (HamlGen) have been removed from the codebase. These modules previously handled the setup of their respective rendering dependencies (erubis and haml). Their deletion indicates that the generator logic for these template engines is no longer maintained in this location, likely as part of a consolidation or restructuring of the Padrino generator components.

padrino-gen/lib/generators/components/renderers · high confidence

The generator components for ActiveRecord, CouchRest, DataMapper, MongoMapper, and Sequel have been removed from the codebase. This eliminates the ability to scaffold new applications using these specific ORM backends via the legacy generator structure, as the corresponding initializer and setup files for each ORM are no longer present.

padrino-gen/lib/generators/components/orms · high confidence

The \Padrino::Routing::Helpers\ module, which provided the \url\_for\ method for generating URLs from named route aliases, and the \Padrino::Routing::NamedRoute\ class, used to define and map route aliases, have been removed from the codebase. This deletion eliminates the previous implementation of URL generation and route aliasing logic in favor of newer routing mechanisms.

padrino-routing/lib/padrino-routing · high confidence

The standalone padrino-routing gem files (README, Rakefile, and VERSION) have been deleted, indicating that this component is no longer maintained as a separate gem and has likely been integrated into the main padrino-core or a unified gem structure.

padrino-routing · high confidence

The test generator files for Bacon, Riot, RSpec, Shoulda, and Test::Spec have been removed from the codebase. These files previously handled the setup and configuration for their respective testing frameworks within the Padrino generator system. Their removal indicates that support for generating tests using these specific legacy frameworks is no longer maintained in this component.

padrino-gen/lib/generators/components/tests · high confidence

The padrino-mailer gem has replaced its legacy Jeweler-based Rakefile with a shared gem\_rake\_helper, removing the static VERSION file in favor of dynamic gemspec generation. Documentation generation is now configured via .yardopts and .document files to properly include the updated README and LICENSE.txt (renamed from LICENSE with an updated copyright year), ensuring YARD parses the correct source files.

padrino-mailer · high confidence

The main entry file for the padrino-routing library has been deleted. This file previously handled the loading of routing components and defined the core routing module, including helpers for named paths, URL mapping, and namespaced routes. Its removal indicates a structural change to how the routing functionality is loaded or organized within the application.

padrino-routing/lib · high confidence

The account model templates for ActiveRecord, Mongoid, Sequel, Minirecord, Dynamoid, and Ohm have been updated to use BCrypt for password hashing instead of the previous implementation. This change introduces case-insensitive email authentication (using lower-case comparisons in queries) and ensures passwords are only encrypted when actually provided, preventing blank password overwrites. Additionally, the admin seed script now prompts for the password without echoing it to the terminal for better security.

padrino-admin/lib/padrino-admin/generators/templates/account · high confidence

The generated admin application template (app.rb.tt) has been updated to explicitly enable sessions and disable store\_location by default, while also registering the Admin::AccessControl module. Additionally, the template now includes built-in handlers for common HTTP errors (403 Forbidden, 404 Not Found, and 500 Internal Server Error), rendering specific error views for each status code to improve user experience during error conditions.

padrino-admin/lib/padrino-admin/generators/templates · high confidence

The generated admin controller templates have been updated to improve error handling and add bulk operations. When a specific record is not found during edit, update, or destroy actions, the system now explicitly halts with a 404 status instead of proceeding with empty data. Additionally, a new \destroy\_many\ action has been added to the template, enabling the deletion of multiple records at once via a list of IDs, with specific checks to prevent deleting the current admin account.

padrino-admin/lib/padrino-admin/generators/templates/page · high confidence

The admin generator has been refactored to dynamically support multiple Object-Relational Mappers (ActiveRecord, Minirecord, Mongoid, Sequel, Ohm, and Dynamoid) and rendering engines (Haml, Slim, and Erb). Users can now specify their preferred ORM and renderer via command-line options, and the generator will validate the selection against supported options before proceeding. The generator also allows custom template overrides by looking for a \generators/templates\ directory in the project root, enabling users to customize the generated admin interface without modifying the core library files.

padrino-admin/lib/padrino-admin/generators · high confidence

The admin generator's application.js has been rewritten to enhance user interaction with data lists and forms. Users can now select or deselect all records in a list via dedicated actions, with the 'Delete selected' button automatically enabling or disabling based on selection state. Clicking a list row toggles its selection, and a confirmation popover appears when deleting individual items. Additionally, forms now automatically focus the first input field containing an error upon validation failure, improving usability. The script also includes automatic dismissal of alert messages after a short delay.

padrino-admin/lib/padrino-admin/generators/templates/assets/javascripts · high confidence

The base admin template now includes a dedicated section on the index page that visually highlights key framework capabilities. Users will see a set of styled buttons with icons representing ORM agnosticism, authentication support, template engine flexibility, multi-language support, and scaffolding, replacing the previous plain text description.

padrino-admin/lib/padrino-admin/generators/templates/haml/app/base · high confidence

The admin panel's stylesheet has been upgraded to Twitter Bootstrap 3.0, replacing the previous version to provide a modern, responsive grid system and UI components. This change ensures the admin interface adapts correctly to different screen sizes, including mobile devices, and aligns with current web standards for layout and styling.

padrino-admin/lib/padrino-admin/generators/templates/assets/stylesheets · high confidence

The Padrino Admin generator now produces Haml templates for scaffolded pages (index, new, edit, and form partials) instead of the previous default. These templates are styled with Twitter Bootstrap 3 classes (e.g., 'form-horizontal', 'btn-primary', 'table-striped') and include specific UI behaviors: the first form field automatically receives autofocus, text areas preserve whitespace using the tilde syntax, and the index view features a dropdown menu for bulk 'Delete selected' actions with a confirmation popover, alongside individual row delete popovers. Navigation is presented via tabs with icons, and error states are displayed inline using Bootstrap's 'has-error' control group styling.

padrino-admin/lib/padrino-admin/generators/templates/haml/page · high confidence

The admin generator now includes a base controller for the main index route and a sessions controller that handles login, logout, and bypass authentication. The login flow renders the session form directly on failure to display inline errors, and supports a development-only bypass mode that retrieves the first account record (using ORM-specific methods for Ohm vs others) to log in without credentials.

padrino-admin/lib/padrino-admin/generators/templates/app · high confidence

The caching system now uses the Moneta library as its underlying storage engine, replacing the previous custom implementation. This change allows users to configure the cache backend via the \Padrino.cache\ setter, supporting multiple store types such as LRUHash (in-memory), File, Memcached, Redis, and Mongo. The \Padrino::Cache.new\ method now delegates directly to \Moneta.new\, enabling flexible store selection and configuration through standard Moneta options.

padrino-cache/lib · high confidence

The AbstractFormBuilder has been significantly refactored to support nested forms, allowing parent form context and indices to be passed via options. It now includes helpers for new HTML5 input types such as datetime, date, time, color, search, URL, email, and telephone fields. The check\_box helper behavior has changed to ensure the hidden uncheck field is rendered before the checkbox itself, and the builder now automatically sets the form to multipart when a file field is present.

_padrino-helpers/lib/padrino-helpers/form\builder · high confidence

The app template has been updated so that new Padrino applications have sessions enabled out of the box. Previously, sessions were disabled by default (matching Sinatra's default behavior), requiring users to manually enable them; the generated app.rb now includes 'enable :sessions' immediately, ensuring session support is available without additional configuration.

padrino-gen/lib/padrino-gen/generators/app · high confidence

Padrino now provides its own SafeBuffer implementation to ensure HTML output safety when ActiveSupport is not present, preventing potential XSS issues in minimal environments. The rendering system has been refactored to support modern template engines like Erubi and Hamlit, while also falling back to the standard library ERB if no external gems are bundled. Additionally, the framework now correctly handles layout application for templates using external engines and saves/restores layout settings to prevent state leakage between requests.

padrino-helpers/lib/padrino · high confidence

The \padrino-support\ library has been restructured to remove monkey-patching of core Ruby classes (such as \String\) and instead provides standalone utility methods in \Padrino::Utils\ (including \symbolize\_keys\, \deep\_dup\, and \build\_uri\_query\). Additionally, a new \Padrino::Inflections\ module has been introduced to handle string transformations like pluralization, singularization, and camelization, backed by a new \default\_inflections.rb\ configuration file, while a \FileSet\ helper was added to simplify file globbing and requiring.

padrino-support/lib/padrino-support · high confidence

The Padrino Mailer component now uses a lazy-loading strategy for the underlying 'mail' gem to improve startup performance, deferring its require until the mailer is actually invoked. The registration process has been restructured to explicitly load base, helpers, and mime modules, and the library now gracefully handles the 'tilt' dependency by falling back to 'sinatra/tilt' if the standalone gem is unavailable.

padrino-mailer/lib · high confidence

The helper modules in padrino-helpers have been significantly refactored to improve code organization, safety, and compatibility. Key changes include the introduction of new modules for number formatting (currency, percentages, delimiters) and translation helpers, alongside a comprehensive overhaul of form handling to support CSRF protection, multipart uploads, and nested objects more robustly. Asset and output helpers now utilize SafeBuffers to prevent double-escaping and improve HTML safety, while render helpers have been updated to better support multiple template engines like Slim and Erubis. Additionally, new HTML5 input types and formatting utilities (truncate\_words, word\_wrap) have been added.

padrino-helpers/lib/padrino-helpers · high confidence

The padrino-cache gem has been refactored to remove the Jeweler build tool in favor of a shared Rake helper, simplifying the build process. Documentation generation is now configured via a new .yardopts file and updated .document settings to ensure proper inclusion of source files while excluding the license. Additionally, the license file was renamed to LICENSE.txt, the copyright year was updated to 2011, and the static VERSION file was removed to prevent potential issues with version management.

padrino-cache, padrino-core · high confidence

The gem build process has been simplified by removing the Jeweler dependency and replacing the local Rakefile with a shared helper script, while the VERSION file is no longer used for versioning. Documentation generation is now configured via a new .yardopts file, and the .document file has been updated to include the renamed LICENSE.txt and exclude the LICENSE file from parsing.

padrino-helpers · high confidence

The padrino-gen gem replaces the Jeweler-based Rakefile with a shared gem helper, removing the static VERSION file and relying on dynamic gemspec generation. Additionally, the Mocha and RR mocking library generators have been removed from the available components, and documentation generation is now configured via a .yardopts file while the .document file is updated to exclude the license file.

padrino-gen · high confidence

The Padrino Admin generator now includes new ERB layout templates (application.erb.tt and error.erb.tt) that replace previous implementations. These templates provide a Bootstrap 3-based UI with a fixed top navigation bar, responsive viewport settings, and a full-width footer. The application layout features a navbar with links to the user profile and logout, dynamic module navigation, and mapped flash messages using Bootstrap alert classes. The error layout offers a centered, minimal design for custom error pages with a 'Go back' button. JavaScript includes are optimized for production versus development environments, loading specific Bootstrap components in dev and the minified bundle in production.

padrino-admin/lib/padrino-admin/generators/templates/erb/app/layouts · high confidence

The generator templates have been updated to provide a cleaner, more modular structure for new Padrino applications. The generated Gemfile now explicitly sources from https://rubygems.org, supports optional JSON codecs (like OJ), and offers flexible dependency management for development modes and API-only projects. The Rakefile template has been simplified to use bundler/setup and conditionally load database tasks only when an ORM is selected. Additionally, new templates for controllers, helpers, initializers, mailers, and custom tasks have been introduced to standardize code generation, including support for layout options in controllers and namespaced tasks.

padrino-gen/lib/padrino-gen/generators/templates · high confidence

A new \bin\_gen\ method has been added to the \Padrino\ module in \command.rb\. This helper constructs the path to the \padrino-gen\ executable and runs it via \Kernel\#system\, passing through any provided arguments. This provides a standardized way for the core library to invoke the generator tool, supporting the decoupling of the CLI components.

padrino-gen/lib/padrino-gen · high confidence

The padrino-admin gem now includes a .yardopts file to configure YARD documentation generation and removes the static VERSION file in favor of dynamic gemspecs, resolving issues with HAML and documentation parsing. The Rakefile has been refactored to remove the Jeweler dependency, replacing it with a shared gem helper and adding tasks to compile Bootstrap CSS assets from Less files. Additionally, the .document file is updated to exclude the LICENSE.txt file from documentation, and the README has been expanded with comprehensive usage examples for the admin dashboard, scaffolding, and access control features.

padrino-admin · high confidence

The main entry point for Padrino Admin now explicitly loads locale files when the module is registered with an application, ensuring translations are available. Additionally, it attempts to load admin generators from padrino-gen; if padrino-gen is not present, the generator loading is silently skipped rather than raising an error, making the admin module usable in environments where the generator gem is not installed.

padrino-admin/lib · high confidence

The mailer implementation has been completely rewritten to replace the deprecated 'tmail' library with the standard 'mail' gem, removing the old delivery and mail object classes. This change introduces a new rendering engine that integrates with Padrino helpers, allowing mailer templates to use partials and standard view paths. Users can now define email messages using a block-based DSL (e.g., \email :name do ... end\) and leverage \text\_part\ and \html\_part\ helpers for multipart emails. The configuration API has also shifted from \smtp\_settings\ to \delivery\_method\, supporting symbols like \:smtp\ or \:sendmail\ with a more robust settings hash.

padrino-mailer/lib/padrino-mailer · high confidence

The Padrino Performance gem has been updated to version 0.16.1. This release introduces a new OS detection module (os.rb) that provides methods to identify the current operating system (Windows, Mac, Unix, Linux) using RbConfig, enabling more precise targeting of CLI commands. The version constant and accessor method in version.rb have also been updated to reflect the new release number.

padrino-performance/lib/padrino-performance · high confidence

The application initialization flow has been reorganized into dedicated modules: \ApplicationSetup\ now centralizes configuration, middleware registration (including session and CSRF protection), and route precompilation; \AuthenticityToken\ provides a custom CSRF middleware that supports path-based exclusions; \Flash\ implements a session-backed flash message system with helper methods; \ParamsProtection\ introduces a \params\ DSL for filtering and type-casting request parameters to prevent mass-assignment; and \ShowExceptions\ enhances Sinatra's error pages by categorizing frames as framework, system, or app. These changes collectively refine how Padrino applications are bootstrapped, secured, and handle user feedback.

padrino-core/lib/padrino-core/application · high confidence

The Padrino gem's build and documentation infrastructure has been updated to remove the Jeweler dependency in favor of dynamic gemspec generation and a shared Rakefile helper. This change simplifies the release process, fixes issues with YARD documentation generation by introducing a .yardopts file and updating .document to include the new LICENSE.txt, and ensures the generated lib/padrino.rb file correctly requires only the necessary subgems.

padrino · high confidence

The padrino-support library has been restructured to remove deprecated Ruby on Rails/ActiveSupport extensions (such as symbolize\_keys, deep\_dup, reverse\_merge, and blank?) in favor of native Ruby implementations or custom Utils methods. This change improves compatibility with modern Ruby versions and reduces dependency on ActiveSupport for core functionality, while still conditionally loading ActiveSupport extensions if explicitly requested via the AS\_VERSION environment variable for legacy projects.

padrino-support/lib · high confidence

The core application loading process has been restructured to improve compatibility with Rack and Sinatra standards. Environment detection now prioritizes \RACK\_ENV\ over the deprecated \PADRINO\_ENV\, issuing a warning when the older variable is used. The \Padrino.root\ method now returns expanded absolute paths instead of relative joins. Application assembly has shifted from a direct \Rack::Builder\ construction to a new \Padrino::Router\ that maps mounted apps, allowing for middleware to be added in front of the router via a new \use\ method and \middleware\ array. Additionally, a new \configure\_apps\ block allows users to apply global configurations to all mounted applications.

padrino-core/lib · high confidence

The CLI implementation has been reorganized into a modular structure with dedicated files for the base commands, server adapter, and rake task loading. This change introduces new CLI commands including a runner (aliases 'run', 'r') to execute code in the application environment, a console shortcut ('c'), and a stop shortcut ('st'). The server adapter now handles start and stop logic explicitly, and the rake task loading mechanism has been updated to support explicit task registration while maintaining backward compatibility. Additionally, the console command now supports Pry as an alternative to IRB, and the routes task has been improved with better formatting and query filtering capabilities.

padrino-core/lib/padrino-core/cli · high confidence

The padrino executable now initializes via a dedicated binstub mechanism instead of directly requiring activesupport and thor. It explicitly adds the library directory to the load path and invokes the CLI base class, which resolves issues with bundled gem loading and prevents conflicts with different Active Support versions.

padrino-core/bin · high confidence

The String\#colorize method has been refactored to use a dedicated Colorizer class, separating color and mode definitions into explicit mappings. This change ensures that color and mode arguments are treated as distinct parameters, allowing for more precise control over text styling in shell output.

_padrino-support/lib/padrino-support/core\ext · high confidence

The application mounting logic has been reorganized into a new \ApplicationExtension\ module, which encapsulates core behaviors such as dependency resolution, prerequisite handling, and application setup. This change ensures that the \app\_file\ is explicitly excluded from the list of dependencies to prevent circular loading issues and introduces a \cascade\ attribute to support cascading configurations with Rack applications. The refactoring also standardizes how the application setup method is respected and cleaned up the internal structure by removing unnecessary methods, resulting in a more maintainable and predictable mounting process for users.

padrino-core/lib/padrino-core/mounter · high confidence

The core library has been restructured into distinct modules (Caller, Command, Configuration, Filter, Logger, Module, PathRouter, Router, Loader, Reloader) to improve organization and maintainability. The base application class now inherits from Sinatra::Base instead of Sinatra::Application, ensuring compatibility with Sinatra 3. Additionally, the legacy Stat and SupportLite modules have been removed, and the routing system has been updated to use the new PathRouter engine.

padrino-core/lib/padrino-core · high confidence

The form helpers have been reorganized into distinct modules for errors, options, and security. The new \Options\ module improves the \select\_tag\ behavior by correctly handling selected and disabled states, preventing ambiguous selections when captions match values, and properly supporting the \include\_blank\ option as a prompt. The \Errors\ module now uses \SafeBuffer\ for consistent HTML safety and supports I18n for error messages. Additionally, a new \Security\ module extracts CSRF protection helpers (\csrf\_token\_field\, \csrf\_meta\_tags\), ensuring secure form submissions by generating and managing CSRF tokens based on application settings.

_padrino-helpers/lib/padrino-helpers/form\helpers · high confidence

The generator system has been restructured to improve modularity and maintainability. A new \Cli\ class now serves as the central entry point, responsible for bootstrapping the application and loading third-party generators. Core logic has been extracted into a shared \Actions\ module, which handles common tasks like component configuration storage and file injection. Individual generators (project, app, controller, model, etc.) now explicitly include this module and the new \Components::Actions\ module, standardizing how component choices (like ORMs or test frameworks) are resolved and applied. This change also introduces a \Runner\ module to handle plugin and template execution, and adds support for new options such as \--lean\ and \--api\ for project generation, while ensuring consistent error handling and path resolution across all generators.

padrino-gen/lib/padrino-gen/generators · high confidence

The padrino-gen library now explicitly loads core extensions, including a new String inflection module that provides pluralize, underscore, camelize, classify, and constantize methods. This module falls back to Padrino's own Inflections implementation if ActiveSupport is not present, decoupling the generator from specific ActiveSupport versions. Additionally, the main library file now registers generator paths for projects, apps, mailers, controllers, helpers, models, migrations, plugins, components, and tasks, and integrates with padrino-core tasks.

padrino-gen/lib · high confidence

The Padrino Helpers module has been refactored to explicitly register the Padrino Rendering component and include additional helper modules (NumberHelpers and TranslationHelpers) when applied to an application. The registration logic now checks if a default form builder is already set before applying the standard 'StandardFormBuilder', and the main library file now loads I18n locale files and enforces available locales. This change ensures that number formatting and translation helpers are available by default in views, while maintaining backward compatibility for the form builder configuration.

padrino-helpers/lib · high confidence

The actions generator now supports configurable migration file naming formats (sequential numbers or timestamps) via the \migration\_format\ option, and improves migration removal by matching filenames rather than model names to avoid accidental deletions. Additionally, new helpers allow injecting test suite setup and mocking library includes directly into \test/test\_config.rb\, streamlining the test environment setup for generated components.

padrino-gen/lib/padrino-gen/generators/components · high confidence

The padrino-gen executable has been rewritten to replace the previous manual gem requiring and direct skeleton invocation with a structured boot process. It now utilizes a binstub mechanism from padrino-core and explicitly manages the $LOAD\_PATH to ensure both the local padrino-gen library and a potentially vendored padrino-core library are correctly discovered. This change decouples the CLI execution from specific gem versions at startup, allowing for more flexible loading of generators and preventing dependency clashes, particularly in development or multi-app scenarios.

padrino-gen/bin · high confidence

The file reloading system has been restructured to improve separation of concerns and thread safety. A new \Reloader::Rack\ middleware now handles the request-cycle logic, including cooldown periods and mutex-based synchronization for thread safety. Concurrently, a new \Reloader::Storage\ module manages the tracking of loaded files and classes, providing explicit methods to prepare, commit, and rollback changes to the application state. This refactoring isolates the storage mechanics from the reloading trigger, ensuring that module constants and loaded features are managed more reliably during development.

padrino-core/lib/padrino-core/reloader · high confidence

The output helpers have been restructured to use dedicated handler classes for ERB, Haml, and Slim templates. ERB support now unifies Erb, Erubis, and Erubi engines under a single handler. Haml support has been updated to detect and handle both Haml 5 and Haml 6+ (including Hamlit) based on the installed version. Slim templates are now supported via a dedicated handler. These changes improve compatibility with modern template engine versions and standardize how template output is captured and rendered.

_padrino-helpers/lib/padrino-helpers/output\helpers · high confidence

The \padrino-gen/lib/generators/components/actions.rb\ file has been deleted, removing the \Actions\ module that previously provided helper methods for managing Gemfile dependencies and test configuration injection. This cleanup eliminates legacy code for inserting gems and configuring test suites, aligning with the broader refactoring of the generator codebase.

padrino-gen/lib/generators/components · high confidence

The \padrino-gen\ generator infrastructure has been refactored by removing the \Actions\ and \Skeleton\ modules. This change eliminates the previous mechanism for handling component options (such as ORM, test framework, and mocking library) and the monolithic skeleton generation process, aligning the codebase with the new simple Padrino structure.

padrino-gen/lib/generators · high confidence

The project generator no longer includes the legacy \config.ru\, \config/boot.rb\, \lib/.empty\_directory\, \tmp/.emptydirectory\, and \test/test\_config.rb.tt\ template files. This simplifies the generated project structure by removing the old Rack configuration and boot sequence templates that are no longer part of the new simple Padrino structure.

padrino-gen/lib/generators/project · high confidence

The application generator no longer automatically downloads external JavaScript libraries (jQuery, Prototype, and RightJS) from remote URLs during project creation. The generator components that previously handled these remote fetches have been removed, meaning the generated application will no longer include these specific scripts by default unless added manually.

padrino-gen/lib/generators/components/scripts · high confidence

The routing system has been replaced with a new PathRouter implementation, splitting the logic into dedicated classes (Compiler, Matcher, Route, ErrorHandler) to improve performance and memory usage. This change introduces a new compilation step where routes are converted to regular expressions, supports named captures in regular expression routes, and modifies how query parameters and trailing slashes are handled (e.g., ignoring trailing slashes for consistency and disabling URI decoding in the matcher).

_padrino-core/lib/padrino-core/path\router · high confidence

The padrino-support gem has been restructured, incorporating support\_lite and locale components previously located elsewhere. This change includes moving and renaming configuration files such as .document and .gitignore from the padrino-routing gem, updating the .yardopts file for documentation generation, and refreshing the LICENSE.txt file with an updated copyright year (2011). These adjustments refine the internal organization and metadata of the support gem without altering its runtime behavior.

padrino-support · medium confidence

The database and ORM rake tasks in padrino-gen have been restructured to improve reliability and compatibility. The ActiveRecord tasks now use \ActiveRecord::Tasks::DatabaseTasks\ and handle migration contexts via \migration\_context\ for versions 5.2+, fixing deprecation issues and ensuring correct schema dumping. A new \SqlHelpers\ module standardizes database creation and dropping across PostgreSQL, MySQL, and SQLite, using \Process.spawn\ with environment variables (e.g., \PGPASSWORD\) for secure credential handling. Sequel tasks now explicitly load required models before seeding to prevent errors, and Mongoid tasks have been updated to support both Mongoid 2 and 3+ APIs for collection management and index creation.

padrino-gen/lib/padrino-gen/padrino-tasks · high confidence

The generator components for ERB, HAML, Liquid, and Slim have been updated to explicitly declare their required template engine dependencies. ERB now requires the 'erubi' gem (version \~\> 1.6), Liquid requires 'liquid' (version 2.1.2) and 'liquify', while HAML and Slim require their respective gems without pinned versions. This ensures that new applications generated with these template engines will include the correct underlying libraries.

padrino-gen/lib/padrino-gen/generators/components/renderers · high confidence

Padrino now uses a consistent SafeBuffer-based output strategy for all supported template engines, ensuring that HTML-safe strings are preserved and double-escaping is avoided. New template wrappers (ERBTemplate, ErubiTemplate, ErubisTemplate, HamlTemplate, HamlitTemplate, SlimTemplate) register with Tilt and configure engines to use a dedicated output buffer (@\_out\_buf) with safe\_concat for escaped content and regular concat for literal content. This change also adds compatibility for Haml 6+ and allows the use of Hamlit or Erubi when available, while maintaining backward compatibility with older Haml versions and standard ERB.

padrino-helpers/lib/padrino/rendering · high confidence

The Compass stylesheet generator now scaffolds a project using the Blueprint CSS framework instead of the previous default. This introduces a 24-column grid system with a 950px container width, applies a global reset, and includes specific styling for forms and two-column layouts via the Blueprint mixins.

padrino-gen/lib/padrino-gen/generators/components/stylesheets/compass · high confidence

The bundled Font Awesome library in the Padrino Admin assets has been upgraded to version 4.0.3. This update introduces a new icon set, including social icons like Twitter and Facebook, and adds new utility classes for rotating, flipping, and stacking icons. Users will see updated icon glyphs and access to the new styling options provided by this version.

padrino-admin/lib/padrino-admin/bootstrap-less/font-awesome · high confidence

The ORM generator components have been updated to align with modern framework versions and best practices. ActiveRecord generation now supports version 6.1+ connection establishment and includes a ConnectionPoolManagement middleware to ensure proper connection handling. Sequel generation has been updated to use the new-style migration syntax. Additionally, the generators for Mongoid, Ohm, MiniRecord, Dynamoid, and Mongomatic have been refreshed to support their respective latest versions and configuration standards.

padrino-gen/lib/padrino-gen/generators/components/orms · high confidence

The Padrino Admin interface has been upgraded to use Twitter Bootstrap 3. This change replaces the previous styling framework with Bootstrap 3's LESS source files, introducing a new responsive grid system, updated component styles (such as buttons, forms, and alerts), and new iconography via Glyphicons. Users will see a refreshed, mobile-friendly layout for the admin panel.

padrino-admin/lib/padrino-admin/bootstrap-less · high confidence

The generator templates for the Padrino Admin interface now include the compiled JavaScript components of Twitter Bootstrap v3.1.0. This update replaces the previous version with the latest release, providing users with the new features, bug fixes, and behavioral improvements included in the v3.1.0 release of the Bootstrap framework.

padrino-admin/lib/padrino-admin/generators/templates/assets/javascripts/bootstrap · high confidence

The main library entry point now explicitly requires the 'padrino-support' and 'padrino-cache' gems, while replacing the previous 'padrino-routing' and 'padrino-admin' requirements with 'padrino-admin'. This reflects a restructuring of the gem dependencies, moving support utilities to a dedicated gem and integrating caching support, while consolidating routing functionality into the admin gem.

padrino/lib · high confidence

The mock component generators for Mocha and RR have been updated to support multiple test frameworks. The Mocha generator now detects whether RSpec or another test framework is in use, injecting the appropriate configuration into either spec\_helper.rb or test\_config.rb. Similarly, the RR generator has been refactored to handle RSpec, Minitest, and Test::Unit, ensuring the correct mocking adapters are included for each environment.

padrino-gen/lib/padrino-gen/generators/components/mocks · high confidence

The generated project now includes a .gitignore file that excludes common development artifacts such as .DS\_Store, logs, temporary files, vendor gems, Sass caches, database files, and Vim swap files. Additionally, a config.ru file is provided to allow starting the application directly via Rack, requiring the boot configuration and running the Padrino application.

padrino-gen/lib/padrino-gen/generators/project · high confidence

The gem generator template now correctly handles project names containing dashes by downcasing the gem name and ensures the generated module extends Padrino::Module for proper loading orchestration, resolving issues where capitalized or dashed names caused errors.

padrino-gen/lib/padrino-gen/generators/templates/gem/lib · high confidence

Added Minitest and Rack::Test helper extensions; Added Sequel-based test fixtures for admin tests; Added Sinatra-based test fixtures for Padrino::Mailer; Added generator tests for admin app, account model, and admin page scaffolding; Added performance benchmarks and OS module tests; Added test coverage for Padrino::Utils and String colorization; Added test fixture classes for namespace resolution; Added test fixtures for Padrino mailer scenarios; Added test fixtures for Padrino::Rendering in padrino-helpers; Added test fixtures for complex, precompiled, and system application scenarios; Added test fixtures for mailer view rendering scenarios; Added test fixtures for partial rendering and block capture scenarios; Added test fixtures for reloadable external applications; Added test fixtures for stealthy class reloading; Added test fixtures for view and layout rendering; Added test helpers for HTML tag assertions; Added test suite for Padrino core functionality; Added test suite for padrino-gen generators; Expanded test fixtures for form helpers and Slim templates; Expanded test fixtures for rendering scenarios in render\_app; Migrate test suite from Test::Unit/Shoulda to Minitest; Migrated Padrino::Mailer tests to Minitest with expanded coverage; Migrated padrino-admin tests to Minitest and added access control coverage; Migrated padrino-cache test suite to Minitest and added Moneta store tests; Removed legacy Padrino routing test suite and fixtures; Removed simple\_app fixture from test suite; Updated test fixture for markup helpers.

The gemspecs for all Padrino sub-gems (padrino, padrino-core, padrino-admin, padrino-cache, padrino-gen, padrino-helpers, padrino-mailer, padrino-performance, and padrino-support) have been refactored to use dynamic versioning and modern packaging standards, replacing the old Jeweler-generated static files. This change updates runtime dependencies to require Sinatra \~\> 4, Thor \~\> 1.0, and Rack \~\> 3, while also adding explicit dependencies on ostruct, rackup, moneta, tilt, i18n, mime-types, and mail as appropriate for each gem. Development dependencies have been updated to use minitest, mocha, webmock, and rubocop, and the project generator no longer includes an outdated Gemfile template.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 59 → 40 (-19.4)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 59 → 61 (+2.0)
• Architecture 100 → 81 (-19.5)
• Maturity 50 → 51 (+1.8)
• Readiness 71 → 57 (-14.1)
• Security 79 → 84 (+5.3)
• Accessibility 19 (new)

• Documentation: no architecture or design documentation
• Documentation: no installation or build instructions (padrino-performance/README.md)
• Off-boarding risk: anonymized user #1

• Documentation: no project overview (padrino-performance/README.md)
• Most significant orphaned file (padrino-gen/lib/padrino-gen/generators/actions.rb)
• Most significant orphaned file (padrino-helpers/lib/padrino-helpers/form_helpers.rb)
• No ADRs found
• Off-boarding risk: anonymized user #1
• Projects may be oversized for their cohesion

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

padrino/padrino-framework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.