Forms

Helper of form select options.

A gem that shortcuts typing out forms and tables for SQL users. Assuming your model is named ModelName, just type Make.form.model("ModelName").now! in your controller and it will return an html-safe form based on your column names for creating a new record in your view. In addition, you can type Make.table.model("ModelName").now! to automatically generate a table.

Forms for Nguyên is Ruby library that could merge PDF fields by XFDF/FDF via pdftk.

RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.

RedParse is a ruby parser (and parser-compiler) written in pure ruby. Instead of YACC or ANTLR, it's parse tool is a home-brewed language. (The tool is (at least) LALR(1)-equivalent and the 'parse language' is pretty nice, even in it's current form.) My intent is to have a completely correct parser for ruby, in 100% ruby. And I think I've more or less succeeded. Aside from some fairly minor quibbles (see below), RedParse can parse all known ruby 1.8 and 1.9 constructions correctly. Input text may be encoded in ascii, binary, utf-8, iso-8859-1, and the euc-* family of encodings. Sjis is not yet supported.

Rails Form Builder supports Client-side validation using jQuery BootstrapValidator plugin. https://github.com/nghuuphuoc/bootstrapvalidator

Helpful form builder used by Rocketeers

A smart submit button extension for the Simple Form gem.

This gem adds ability to construct search objects for indexed models, build search forms and execute searches. It works with sunspot, inherited_resources and simple_form/formtastic

Reworked the contact_us gem to add a basic contact us form to Spree.

Tolaria is a content management system (CMS) framework for Ruby on Rails. It greatly speeds up the necessary—but repetitive—task of creating useful admin panels, forms, and model workflow. Includes a library of rich form components, passwordless authentication, and text search tools. Make your editors happy!

Lipsiadmin is a new revolutionary admin for your projects.Lipsiadmin is based on Ext Js 2.0. framework (with prototype adapter) and is ready for Rails 2.0. This admin is for newbie developper but also for experts, is not entirely written in javascript because the aim of developper wose build in a agile way web/site apps so we use extjs in a new intelligent way a mixin of 'old' html and new ajax functions, for example ext manage the layout of page, grids, tree and errors, but form are in html code.

This gem can read proprietary MathType binary equations that are usually embedded in Word documents and convert these equations into an XML form. This XML form can then be used for further processing, e.g. to convert the equation to MathML.

Forms for Pakyow

Hirb provides a mini view framework for console applications and uses it to improve ripl(irb)'s default inspect output. Given an object or array of objects, hirb renders a view based on the object's class and/or ancestry. Hirb offers reusable views in the form of helper classes. The two main helpers, Hirb::Helpers::Table and Hirb::Helpers::Tree, provide several options for generating ascii tables and trees. Using Hirb::Helpers::AutoTable, hirb has useful default views for at least ten popular database gems i.e. Rails' ActiveRecord::Base. Other than views, hirb offers a smart pager and a console menu. The smart pager only pages when the output exceeds the current screen size. The menu is used in conjunction with tables to offer two dimensional menus.

RubyNEAT -- Neural Evolution of Augmenting Topologies for Ruby. By way of an enhanced form of Genetic Algorithms -- the NEAT algorithm, populations of neural nets are evolved to handle pre-defined goals. RubyNEAT is the first implementation of the NEAT algorithm for Ruby, and it leverages Ruby's power to implement the NEAT algorithm in a way that would be difficult to do in other languages. The 'activation function' is largely standalone. Basically, activation is achieved by functional programming. Meaning, once your network is evolved, you can extract it as source code you can then utilize without the RubyNEAT engine. RubyNEAT can be used for nearly any Machine Learning task you can dream of, because it's also extensible and modular. See http://rubyneat.com for the details.

Add a contact form for your spree website, you can setup topics and when the user submits the form, it is emailed to the site admin

Initialises Simple Form to automatically produce Bootstrap 3-friendly markup

Allow user duplication of ActiveAdmin resources using the power of the Amoeba gem. Resource duplication can be performed by either persisting the model and its relations, or by pre-filling a new resource's form fields.

Collection of Form Inputs

Provides Rails-helper methods for referrer-style backlinks and setting redirect URLs after form submission

A Rack middleware for form-based authentication. It works roughly like Basic HTTP Authentication except that the authentication page can be styled with the middleware options.

Multipart form post thru Ruby script, headers content-type and content-length properly set

auto_complete plugin refactored to handle complex forms and named scopes

Private Rack middleware purpose is to protect your Rack application from anonymous via a secret code form.

A jQuery Plugin that monitors forms for change to prevent users from losing data when editing forms.

This rubygem does not have a description or summary.

Gem that helps rails project to route to different controller actions based on commit param of the form

Functionality for building custom forms

Enables the creation of scenarios that involve creating a rails project, starting and stoppping of servers, generating projects, editing files, issuing http requests, running of commands, etc. Output is captured as a single HTML file that can be viewed locally or uploaded. Additionally, there is support for verification, in the form of defining assertions based on selections (typically CSS) against the generated HTML.

RSence is a different and unique development model and software frameworks designed first-hand for real-time web applications. RSence consists of separate, but tigtly integrated data- and user interface frameworks. RSence could be classified as a thin server - thick client system. Applications and submobules are installed as indepenent plugin bundles into the plugins folder of a RSence environment, which in itself is a self-contained bundle. A big part of RSence itself is implemented as shared plugin bundles. The user interface framework of RSence is implemented in high-level user interface widget classes. The widget classes share a common foundation API and access the browser's native API's using an abstracted event- and element layer, which provides exceptional cross-browser compatibility. The data framework of RSence is a event-driven system, which synchronized shared values between the client and server. It's like a realtime bidirectional form-submission engine that handles data changes intelligently. On the client, changed values trigger events on user interface widgets. On the server, changed values trigger events on value responder methods of server plugin modules. It doesn't matter if the change originates on client or server, it's all synchronized and propagated automatically. The server framework is implemented as a high-level, modular data-event-driven system, which handles delegation of tasks impossible to implement using a client-only approach. Client sessions are selectively connected to other client sessions and legacy back-ends via the server by using the data framework. The client is written in Javascript and the server is written in Ruby. The client also supports CoffeeScript for custom logic. In many cases, no custom client logic is needed; the user interfaces can be defined in tree-like data models. By default, the models are parsed from YAML files, and other structured data formats are possible, including XML, JSON, databases or any custom logic capable of producing similar objects. The server can connect to custom environments and legacy backends accessible on the server, including software written in other languages.

A Rails View Helper. Base on Twitter Bootstrap v2.0.4. Fast show model/s as view, form, table.

Capistrano extension for deploying form local directory

Build filter forms easily

Rich-pluralization is a module of E9s (http://github.com/archan937/e9s) which provides localized pluralization in combination with i18n. Doing this enables you to only translate words in singular form as the module pluralizes the translation for you.

Selection list management and form and view helpers. Manages one table to hold all selections items/dropdown lists ( tree ). Dynamic lookup to find parent or children ( eg. Selection.priorities ). Form helper to display lists ( eg. f.selections :priorities ). Handling of archived items ( displaying if selected only ).

Distributes the V8 JavaScript engine in binary and source forms in order to support fast builds of The Ruby Racer

Acquire stock infomations form yahoofinance, I am so sorry to Yahoo!.

Configurable adds methods to declare class configurations. Configurations are inheritable, delegate to methods, and have hash-like access. Configurable constructs configs such that they easily map to config files, web forms, and the command line.

Padrino Bootstrap Forms is a port of Seth Vargo's Bootstrap Forms for Rails. It makes Twitter's Bootstrap on Padrino easy to use by creating helpful form builders that minimize markup in your views. Currently supports Bootstrap 2.

Build bootstrapped forms with next to no effort

Datetime picker wrapper of https://github.com/TrevorS/bootstrap3-datetimepicker-rails, for use with simple_form on Rails 4+.

LogicTools is a set of command-line tools for processing logic expressions. The tools include: simplify_qm for simplifying a logic expression, simplify_es for simplifying a logic expression much more quickly than simplify_qm, std_conj for computing the conjunctive normal form of a logic expression, std_dij for computing the disjunctive normal form a of logic expression, truth_tbl for generating the truth table of a logic expression, is_tautology for checking if a logic expression is a tautology or not, and complement for computing the complement of a logic expression.

Detects #uck F|_|__C_K and other variations of hidden swear words in text. Usage: ``` finder = BadWordDetector.new finder.find("What the #uck") it will return BadWord object ``` Transformation rules is defined in form: {"#" => {"symbol"=>"f", "weight" => 2}} (where weight is optional) in file conf/rules.yaml List of swear words is located in conf/library.yaml Whitelist of english words in conf/whitelist.yaml You can also set own rules: finder = BadWordDetector.new rules, library, whitelist

Mingle 3.3 introduced a new Events API in the form of an "Atom feed":http://www.thoughtworks-studios.com/mingle/3.3/help/mingle_api_events.html. The Mingle team and ThoughtWorks Studios are big believers in the use of Atom for exposing events. Atom is a widely used standard, and this event API style puts the issue of robust event delivery in the hands of the consumer, where it belongs. In fact, we'd argue this is the only feasible means of robust, scalable event delivery, short of spending hundreds of thousands or millions of dollars on enterprise buses and such. Atom-delivered events are cheap, scalable, standards-based, and robust. However, we do accept that asking integrators wishing to consume events to implement polling is not ideal. Writing polling consumers can be tedious. And this tedium gets in the way of writing sweet Mingle integrations. We are addressing this by publishing libraries such as this, which if effective, fully hide the mechanics of event polling from the consumer. The consumer only need worry about the processing of events. Said processing is modeled in the style of 'pipes and filters.'

handy toolset for sinatra and datamapper - sinatra modules: tracking, view_helpers - datamapper modules: form_helpers, name_url, paginable

UberKit is a set of tools for common UI problems in Rails including menus and forms.

Flexible form builder

Wrapper for the Formstack API

The edit mode is activated by pressing an 'edit' button on a show view. This shows additional editing tools and switches on the best_in_place form fields. When editing is finished, use 'save' or 'cancel' buttons to quit the edit mode and return to a normal show view. Several editing groups per page are supported. Thus, you can have several 'boxes' to edit on a page.