formular 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d70a328fd35abcbc14db333621126deb14c40e1
+  data.tar.gz: a8563cdc4aa0a144b1d11d9ef960ce8337c12c52
+SHA512:
+  metadata.gz: 11d0350fe322bfed668ce7794d5711f1cab046fe6afed225d541e191680ab7fe2035c9b3b6adc109616e95aea269bce87cd79cda79a0e862a404918a4aec1993
+  data.tar.gz: 3abaae426105020622039d566ef3d947613dd2f67197d212c8783a818f94bd817aa03b97e1ea70919b8c9e3455157843d00e48ccfb9292751cf37f91f52e6d81

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,29 @@
+language: ruby
+sudo: false
+cache: bundler
+bundler_args: --without console benchmarks
+script:
+  - bundle exec rake test
+rvm:
+  - 2.0
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - rbx-2
+  - jruby-9.1.1.0
+  - ruby-head
+env:
+  global:
+    - JRUBY_OPTS='--dev -J-Xmx1024M'
+matrix:
+  allow_failures:
+    - rvm: jruby-9.1.1.0
+    - rvm: rbx-2
+    - rvm: ruby-head
+    - rvm: jruby-head
+  include:
+    - rvm: jruby-head
+      before_install: gem install bundler --no-ri --no-rdoc
+
+notifications:
+  email: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# v0.2.0 2016-09-27
+
+First public release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in formular.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nick Sutterer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+# Formular
+
+_Framework-Agnostic Form Renderer for Ruby._
+[![Build Status](https://travis-ci.org/trailblazer/formular.svg?branch=master)](https://travis-ci.org/trailblazer/formular)
+[![Gitter Chat](https://badges.gitter.im/trailblazer/chat.svg)](https://gitter.im/trailblazer/chat)
+[![TRB Newsletter](https://img.shields.io/badge/TRB-newsletter-lightgrey.svg)](http://trailblazer.to/newsletter/)
+
+
+## Overview
+
+Formular renders HTML forms in a similar fashion to [SimpleForm](https://github.com/plataformatec/simple_form) and other gems. It is lightning-fast, has zero coupling to any ORM or web framework, and makes no magical assumptions about the rendered form object.
+
+
+## Example
+
+While you can instantiate the form builder manually, it's easiest to use the `form` helper to do so. Include `Formular::Helper` into your cell, view, or in a Rails controller as a helper.
+
+```ruby
+module Post::Cell
+  class New < Cell::ViewModel
+    include Formular::Helper
+```
+
+or
+
+```ruby
+class PostsController < ApplicationController
+  helper Formular::Helper
+```
+
+You should also configure what builder you want to use. This will wrap inputs correctly, and so on.
+
+```ruby
+Formular::Helper.builder= :bootstrap3
+```
+
+In your view, you're now ready to use Formular's API to render forms.
+
+```slim
+= form(model.contract, url) do |f|
+
+  = f.input :title, placeholder: "Title"
+  = f.input :url_slug, placeholder: "URL slug"
+  .form-group
+    = f.checkbox :is_public, label: "Public?"
+  .form-group
+    = f.radio :owner, label: "Flori", value: 1
+    = f.radio :owner, label: "Konsti", value: 2
+
+  .row
+    .col-md-2
+      = f.radio :owner, collection: [["Flori", 1], ["Konsti", 2]], label: "Owners"
+    .col-md-3
+      = f.radio :owner, collection: [["Flori", 1], ["Konsti", 2]], label: "Owners, inline", inline: true
+    = f.checkbox :roles, collection: [["Admin", 1], ["Owner", 2], ["Maintainer", 3]], checked: model.contract.roles, label: "Roles"
+
+  = f.select :select_roles, collection: [["Admin", 1], ["Owner", 2], ["Maintainer", 3]], selected: model.contract.select_roles, label: "Selectable Roles"
+
+  .form-group
+    = f.textarea :content, placeholder: "And your story...", rows: 9
+  .form-group
+    = f.button type: :submit, value: "Submit!", class: [:btn, :'btn-lg', :'btn-default']
+```
+
+Note that a lot of this code can be done automatically by Formular.
+
+## Documentation
+
+Formular's API docs and information on how to extend it can be found on the [Trailblazer project page](http://trailblazer.to/gems/formular).
+
+Formular's rendering is easily customizable. It provides built-in support for Foundation 6, Bootstrap 3 and Bootstrap 4 so far with more to come.
+
+The list of builders provided by default can be seen in the BUILDERS constant. Try the following in an IRB session with your project loaded (rails console).
+
+```ruby
+Formular::Helper::BUILDERS
+```
+
+
+
+## Key Features
+
+* Incredibly fast.
+* Customization: "Wrappers" are self-explaining objects. Ships with renderers for Foundation 5 and Bootstrap 3
+* No magic. No `respond_to?`, no guessing, no hidden semantics.
+* A well-designed API instead of a configuration DSL. If you need to change behavior, program it.
+
+## Limitations
+
+* Currently, nested hashes aren't suffixed with `_attributes`, as it's usually done in ActiveRecord.
+* Capturing only works with Slim and Hamlit. A 'blockless' API is provided to enable use in ERB
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'formular'
+```
+
+Requires Ruby >= 2.1.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+  t.warning = false
+end
+
+task :default => :test

data/formular.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'formular/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "formular"
+  spec.version       = Formular::VERSION
+  spec.authors       = ["Nick Sutterer", "Fran Worley"]
+  spec.email         = ["apotonick@gmail.com", "frances@safetytoolbox.co.uk"]
+
+  spec.summary       = %q{Form builder based on Cells. Fast, Furious, and Framework-Agnostic.}
+  spec.description   = %q{Customizable, fast form builder based on Cells. Framework-agnostic.}
+  spec.homepage      = "http://trailblazer.to/gems/formular.html"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "declarative",    '~> 0.0.4'
+  spec.add_dependency             "uber",           "~> 0.0.11"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "reform"
+  spec.add_development_dependency "dry-validation"
+  spec.add_development_dependency "trailblazer-cells"
+  spec.add_development_dependency "cells-slim"
+  spec.add_development_dependency "cells-erb"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-line"
+end

data/lib/formular.rb

@@ -0,0 +1,8 @@
+require 'formular/version'
+
+module Formular
+  # Your code goes here...
+end
+
+require 'formular/helper'
+require 'formular/builder'

data/lib/formular/attributes.rb

@@ -0,0 +1,45 @@
+module Formular
+  class Attributes < Hash
+    def self.[](hash)
+      hash ||= {}
+      super
+    end
+
+    def merge(hash)
+      dup.merge!(hash)
+    end
+
+    def merge!(hash)
+      classes     = self[:class]
+      new_classes = hash[:class]
+      return super unless classes && new_classes
+
+      hash[:class] += classes
+      super
+    end
+
+    # converts the hash into a string k1=v1 k2=v2
+    # replaces underscores with - so we can use regular keys
+    # allows one layer of nestedhashes so we can define data options as a hash.
+    def to_html
+      map do |key,val|
+        if val.is_a?(Hash)
+          val.map do |k,v|
+            %(#{key_to_attr_name(key)}-#{key_to_attr_name(k)}="#{val_to_string(v)}")
+          end.join(" ")
+        else
+           %(#{key_to_attr_name(key)}="#{val_to_string(val)}")
+        end
+      end.join(" ")
+    end
+
+    private
+    def key_to_attr_name(key)
+      key.to_s.gsub('_', '-')
+    end
+
+    def val_to_string(value)
+      value.is_a?(Array) ? value.join(' ') : value
+    end
+  end # class Attributes
+end # module Formular

data/lib/formular/builder.rb

@@ -0,0 +1,52 @@
+require 'formular/path'
+require 'uber/inheritable_attr'
+module Formular
+  class Builder
+    extend Uber::InheritableAttr
+    inheritable_attr :elements
+    self.elements = {}
+
+
+    def self.element_set(**elements)
+      self.elements.merge!(elements)
+      define_element_methods(self.elements)
+    end
+
+    def self.define_element_methods(**elements)
+      elements.each { |k, v| define_element_method(k, v) }
+    end
+
+    def self.define_element_method(element_name, element_class)
+      define_method(element_name) do |*args, &block|
+        if args.size > 1
+          name, options = args
+        else
+          case args.first
+          when Symbol then name = args.first
+          when Hash then options = args.first
+          end
+        end
+
+        options ||= {}
+        options[:builder] = self
+        options[:attribute_name] = name if name
+
+        element_class.(options, &block)
+      end
+    end
+
+    def initialize(**elements)
+      @elements = self.class.elements.merge(elements)
+      self.class.define_element_methods(elements) if elements
+    end
+    attr_reader :elements
+
+    def capture(*args)
+      yield(*args)
+    end
+
+    def call(&block)
+      capture(self, &block)
+    end
+  end # class Builder
+end # module Formular

data/lib/formular/builders/basic.rb

@@ -0,0 +1,64 @@
+require 'formular/builder'
+require 'formular/elements'
+module Formular
+  module Builders
+    # I'm not quite sure why I made this a seperate class
+    # But I kind of see myself having Builder as a generic
+    # viewbuilder and this basic class as Form
+    class Basic < Formular::Builder
+      element_set(
+        error_notification: Formular::Element::ErrorNotification,
+        form: Formular::Element::Form,
+        fieldset: Formular::Element::Fieldset,
+        legend: Formular::Element::Legend,
+        div: Formular::Element::Div,
+        span: Formular::Element::Span,
+        p: Formular::Element::P,
+        input: Formular::Element::Input,
+        hidden: Formular::Element::Hidden,
+        label: Formular::Element::Label,
+        error: Formular::Element::Error,
+        hint: Formular::Element::P,
+        textarea: Formular::Element::Textarea,
+        submit: Formular::Element::Submit,
+        select: Formular::Element::Select,
+        checkbox: Formular::Element::Checkbox,
+        radio: Formular::Element::Radio,
+        wrapper: Formular::Element::Div,
+        error_wrapper: Formular::Element::Div
+      )
+
+      def initialize(model: nil, path_prefix: nil, errors: nil, elements: {})
+        @model = model
+        @path_prefix = path_prefix
+        @errors = errors || (model ? model.errors : {})
+        super(elements)
+      end
+      attr_reader :model, :errors
+
+      def collection(name, models: nil, builder: nil, &block)
+        models ||= model ? model.send(name) : []
+
+        models.map.with_index do |model, i|
+          nested(name, nested_model: model, path_appendix: [name,i], builder: builder, &block)
+        end.join('')
+      end
+
+      def nested(name, nested_model: nil, path_appendix: nil, builder: nil, &block)
+        nested_model ||= model.send(name) if model
+        path_appendix ||= name
+        builder ||= self.class
+        builder.new(model: nested_model, path_prefix: path(path_appendix)).(&block)
+      end
+
+      # these can be called from an element
+      def path(appendix = nil)
+        appendix ? Path[*@path_prefix, appendix] : Path[@path_prefix]
+      end
+
+      def reader_value(name)
+        model ? model.send(name) : nil
+      end
+    end # class Basic
+  end # module Builders
+end # module Formular

data/lib/formular/builders/bootstrap3.rb

@@ -0,0 +1,28 @@
+require 'formular/builders/basic'
+require 'formular/element/bootstrap3'
+require 'formular/element/bootstrap3/input_group'
+module Formular
+  module Builders
+    class Bootstrap3 < Formular::Builders::Basic
+      element_set(
+        error_notification: Formular::Element::Bootstrap3::ErrorNotification,
+        error: Formular::Element::Bootstrap3::Error,
+        hint: Formular::Element::Bootstrap3::Hint,
+        input: Formular::Element::Bootstrap3::Input,
+        input_group: Formular::Element::Bootstrap3::InputGroup,
+        checkbox: Formular::Element::Bootstrap3::Checkbox,
+        radio: Formular::Element::Bootstrap3::Radio,
+        select: Formular::Element::Bootstrap3::Select,
+        inline_radio: Formular::Element::Bootstrap3::InlineRadio,
+        inline_checkbox: Formular::Element::Bootstrap3::InlineCheckbox,
+        label: Formular::Element::Bootstrap3::Label,
+        checkable_group_label: Formular::Element::Bootstrap3::Label,
+        textarea: Formular::Element::Bootstrap3::Textarea,
+        wrapper: Formular::Element::Bootstrap3::Wrapper,
+        error_wrapper: Formular::Element::Bootstrap3::ErrorWrapper,
+        submit: Formular::Element::Bootstrap3::Submit,
+        row: Formular::Element::Bootstrap3::Row
+      )
+    end # class Bootstrap3
+  end # module Builders
+end # module Formular

data/lib/formular/builders/bootstrap3_horizontal.rb

@@ -0,0 +1,32 @@
+require 'formular/builders/bootstrap3'
+require 'formular/element/bootstrap3/horizontal'
+module Formular
+  module Builders
+    class Bootstrap3Horizontal < Formular::Builders::Bootstrap3
+      element_set(
+        form: Formular::Element::Bootstrap3::Horizontal::Form,
+        input: Formular::Element::Bootstrap3::Horizontal::Input,
+        input_group: Formular::Element::Bootstrap3::Horizontal::InputGroup,
+        select: Formular::Element::Bootstrap3::Horizontal::Select,
+        checkbox: Formular::Element::Bootstrap3::Horizontal::Checkbox,
+        radio: Formular::Element::Bootstrap3::Horizontal::Radio,
+        inline_radio: Formular::Element::Bootstrap3::Horizontal::InlineRadio,
+        inline_checkbox: Formular::Element::Bootstrap3::Horizontal::InlineCheckbox,
+        label: Formular::Element::Bootstrap3::Horizontal::Label,
+        checkable_group_label: Formular::Element::Bootstrap3::Horizontal::Label,
+        textarea: Formular::Element::Bootstrap3::Horizontal::Textarea,
+        error_wrapper: Formular::Element::Bootstrap3::ErrorWrapper,
+        input_column_wrapper: Formular::Element::Bootstrap3::Horizontal::InputColumnWrapper,
+        submit: Formular::Element::Bootstrap3::Horizontal::Submit
+      )
+      inheritable_attr :column_classes
+
+      #these options should be easily configurable
+      self.column_classes = {
+        left_column: ['col-sm-2'],
+        right_column: ['col-sm-10'],
+        left_offset: ['col-sm-offset-2']
+      }
+    end # class Bootstrap3Horizontal
+  end # module Builders
+end # module Formular