binco 2.0.1 → 3.0.1

data/app/assets/stylesheets/binco.scss

@@ -1,13 +1,41 @@
-@import "bootstrap-sprockets";
+@import "bootstrap_variables";
 @import "bootstrap";
 @import "select2";
 @import "select2-bootstrap";
-@import "bootstrap-datepicker3";
+@import "datepicker";
 
 .field_with_errors {
-  @extend .has-error;
-
-  .form-control {
-    border-width: 1px;
+  input, select {
+    @extend .is-invalid;
+    @extend .was-validated;
   }
 }
+
+.form-group > .field_with_errors {
+  display: inline;
+}
+
+.form-group > .field_with_errors:last-child {
+  display: block;
+}
+
+select.custom-select {
+  width: 100%;
+}
+
+.select2-container {
+  width: 100% !important;
+}
+
+.field_with_errors .select2-container .select2-selection--single {
+  border-color: $form-feedback-invalid-color;
+}
+
+.field_with_errors .custom-select {
+  border-color: $form-feedback-invalid-color;
+}
+
+.pagination {
+  margin-top: 1rem;
+  margin-bottom: 1rem;
+}

data/app/helpers/binco/bootstrap_form_builder.rb

@@ -1,31 +1,58 @@
 module Binco
   class BootstrapFormBuilder < ActionView::Helpers::FormBuilder
     alias_method :collection_select_original, :collection_select
+    alias_method :check_box_original, :check_box
     alias_method :select_original, :select
+    alias_method :submit_original, :submit
+
+    CHECK_BOX_GROUP_CLASS = 'form-check'
+    CHECK_BOX_LABEL_CLASS = 'form-check-label'
+    FORM_ELEMENT_CLASS = 'form-control'
+    CHECK_BOX_INPUT_CLASS = 'form-check-input'
+
+    def initialize(object_name, object, template, options)
+      ActionView::Base::field_error_proc = Proc.new do |html_tag, instance|
+        if instance.respond_to?(:error_message) && instance.class.to_s != 'ActionView::Helpers::Tags::Label'
+          error_messages = instance.error_message.collect{ |error| "<div class=\"invalid-feedback\">#{error}</div>" }.join
+
+          "<div class=\"field_with_errors\">#{html_tag} #{error_messages}</div>".html_safe
+        else
+          "<div class=\"field_with_errors\">#{html_tag}</div>".html_safe
+        end
+      end
+
+      super(object_name, object, template, options)
+    end
 
     def text_field(name, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super name, options
     end
 
     def telephone_field(name, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super name, options
     end
+    alias_method :phone_field, :telephone_field
 
     def select(method, choices = nil, options = {}, html_options = {}, &block)
-      html_options = add_class_to_options('form-control', html_options)
+      html_options = add_class_to_options('custom-select', html_options)
       super method, choices, options, html_options, &block
     end
 
+    def select2(method, choices = nil, options = {}, html_options = {}, &block)
+      html_options = add_class_to_options('select2-rails', html_options)
+      select_original method, choices, options, html_options, &block
+    end
+
     def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
       if block_given?
         super(method, collection, value_method, text_method, options, html_options, &block)
       else
         super method, collection, value_method, text_method, options, html_options do |b|
-          group_tag class: 'checkbox' do
-            b.label do
-              b.check_box + b.text
+          group_tag class: CHECK_BOX_GROUP_CLASS do
+            b.label class: CHECK_BOX_LABEL_CLASS do
+              b.check_box(class: CHECK_BOX_INPUT_CLASS) + " " + b.text
             end
           end
         end
@@ -40,27 +67,27 @@ module Binco
     end
 
     def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
-      html_options = add_class_to_options('form-control', html_options)
+      html_options = add_class_to_options('custom-select', html_options)
       super method, collection, value_method, text_method, options, html_options
     end
 
     def collection_select2(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
       html_options = add_class_to_options('select2-rails', html_options)
-      collection_select(method, collection, value_method, text_method, options, html_options)
+      collection_select_original(method, collection, value_method, text_method, options, html_options)
     end
 
     def email_field(name, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super name, options
     end
 
     def number_field(name, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super name, options
     end
 
     def password_field(name, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super name, options
     end
 
@@ -70,20 +97,34 @@ module Binco
     end
 
     def text_area(method, options = {})
-      options = add_class_to_options('form-control', options)
+      options = add_class_to_options(FORM_ELEMENT_CLASS, options)
       super(method, options)
     end
 
     def radio_button(method, tag_value, options = {})
-      options = add_class_to_options('radio', options)
       super method, tag_value, options
     end
 
     def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
-      options = add_class_to_options('checkbox', options)
+      options = add_class_to_options(CHECK_BOX_INPUT_CLASS, options)
       super method, options, checked_value, unchecked_value
     end
 
+    def custom_check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      options = add_class_to_options('custom-control-input', options)
+      base_proc = ActionView::Base::field_error_proc
+      ActionView::Base::field_error_proc = Proc.new { |html_tag, instance| html_tag }
+      html = check_box_original(method, options, checked_value, unchecked_value)
+      ActionView::Base::field_error_proc = base_proc
+
+      return html
+    end
+
+    def file_field(method, options = {})
+      options = add_class_to_options('form-control-file', options)
+      super method, options
+    end
+
     def submit(value = nil, options = {})
       options = add_class_to_options('btn btn-success', options)
       add_data_to_options({ disable_with: 'Enviando' }, options)
@@ -100,16 +141,28 @@ module Binco
       group_tag options, &block
     end
 
-    def checkbox_group(options = {}, &block)
-      options = add_class_to_options('checkbox', options)
+    def form_check(options = {}, &block)
+      options = add_class_to_options(CHECK_BOX_GROUP_CLASS, options)
       group_tag options, &block
     end
+    alias_method :check_box_group, :form_check
+
+    def check_label(method, options = {}, &block)
+      options = add_class_to_options(CHECK_BOX_LABEL_CLASS, options)
+      @template.label(@object_name, method, nil, objectify_options(options), &block)
+    end
+    alias_method :check_box_label, :check_label
 
     def input_group(options = {}, &block)
       options = add_class_to_options('input-group', options)
       group_tag options, &block
     end
 
+    def addon(icon, options = {})
+      options = add_class_to_options('input-group-addon', options)
+      @template.content_tag(:span, icon, options)
+    end
+
     private
 
       # Add the specified class_name the the options hash

data/app/helpers/binco/image_helper.rb

@@ -0,0 +1,9 @@
+module Binco
+  module ImageHelper
+    def image_fluid(source, options={})
+      tag_class = "img-fluid #{options[:class]}"
+      options[:class] = tag_class
+      image_tag(source, options)
+    end
+  end
+end

data/app/helpers/binco/pagination_renderer.rb

@@ -1,159 +1,64 @@
+require 'will_paginate/view_helpers/action_view'
+
 module Binco
-  class PaginationRenderer < ::WillPaginate::ViewHelpers::LinkRendererBase
-    # * +collection+ is a WillPaginate::Collection instance or any other object
-    #   that conforms to that API
-    # * +options+ are forwarded from +will_paginate+ view helper
-    # * +template+ is the reference to the template being rendered
-    def prepare(collection, options, template)
-      super(collection, options)
-      @template = template
-      @container_attributes = @base_url_params = nil
-    end
+  class PaginationRenderer < WillPaginate::ActionView::LinkRenderer
+    ELLIPSIS = '&hellip;'
 
-    # Process it! This method returns the complete HTML string which contains
-    # pagination links. Feel free to subclass LinkRenderer and change this
-    # method as you see fit.
     def to_html
-      html = pagination.map do |item|
-        item.is_a?(Fixnum) ?
-          page_number(item) :
-          send(item)
+      list_items = pagination.map do |item|
+        case item
+          when Fixnum
+            page_number(item)
+          else
+            send(item)
+        end
       end.join(@options[:link_separator])
 
-      @options[:container] ? html_container(html) : html
+      list_wrapper = tag :ul, list_items, class: 'pagination', role: 'group'
+      tag :nav, list_wrapper, class: @options[:class]
     end
 
-    # Returns the subset of +options+ this instance was initialized with that
-    # represent HTML attributes for the container element of pagination links.
     def container_attributes
-      @container_attributes ||= @options.except(*(ViewHelpers.pagination_options.keys + [:renderer] - [:class]))
+      super.except(*[:link_options])
     end
 
-  protected
+    protected
 
     def page_number(page)
-      unless page == current_page
-        tag(:li, link(page, page, rel: rel_value(page)))
-      else
-        tag(:li, link(page, '#'), class: 'active')
-      end
-    end
-
-    def gap
-      text = @template.will_paginate_translate(:page_gap) { '&hellip;' }
-      %(<li><a>#{text}</a></li>)
-    end
-
-    def previous_page
-      num = @collection.current_page > 1 && @collection.current_page - 1
-      previous_or_next_page(num, @options[:previous_label], 'previous_page')
-    end
+      link_options = @options[:link_options] || {}
 
-    def next_page
-      num = @collection.current_page < total_pages && @collection.current_page + 1
-      previous_or_next_page(num, @options[:next_label], 'next_page')
-    end
-
-    def previous_or_next_page(page, text, classname)
-      if page
-        tag(:li, link(text, page, class: classname))
+      if page == current_page
+        tag :li, tag(:span, page, class: 'page-link'), class: 'page-item active'
       else
-        tag(:li, link(text, '#'), class: classname + ' disabled')
+        link_options.merge! class: 'page-link', rel: rel_value(page)
+        tag :li, link(page, page, link_options), class: 'page-item'
       end
     end
 
-    def html_container(html)
-      tag(:ul, html, class: 'pagination pagination-xs')
-    end
-
-    # Returns URL params for +page_link_or_span+, taking the current GET params
-    # and <tt>:params</tt> option into account.
-    def default_url_params
-      {}
-    end
-
-    def url(page)
-      @base_url_params ||= begin
-        url_params = merge_get_params(default_url_params)
-        url_params[:only_path] = true
-        merge_optional_params(url_params)
-      end
-
-      url_params = @base_url_params.dup
-      add_current_page_param(url_params, page)
-
-      @template.url_for(url_params)
-    end
-
-    def merge_optional_params(url_params)
-      symbolized_update(url_params, @options[:params]) if @options[:params]
-      url_params
-    end
-
-    def merge_get_params(url_params)
-      if @template.respond_to? :request and @template.request and @template.request.get?
-        symbolized_update(url_params, @template.params)
-      end
-      url_params
-    end
+    def previous_or_next_page(page, text, classname)
+      link_options = @options[:link_options] || {}
 
-    def add_current_page_param(url_params, page)
-      unless param_name.index(/[^\w-]/)
-        url_params[param_name.to_sym] = page
+      if page
+        link_wrapper = link(text, page, link_options.merge(class: 'page-link'))
+        tag :li, link_wrapper, class: '%s page-item' % classname
       else
-        page_param = parse_query_parameters("#{param_name}=#{page}")
-        symbolized_update(url_params, page_param)
+        span_wrapper = tag(:span, text, class: 'page-link')
+        tag :li, span_wrapper, class: '%s page-item disabled' % classname
       end
     end
 
-  private
-
-    def parse_query_parameters(params)
-      Rack::Utils.parse_nested_query(params)
-    end
-
-    def param_name
-      @options[:param_name].to_s
-    end
-
-    def link(text, target, attributes = {})
-      if target.is_a? Fixnum
-        attributes[:rel] = rel_value(target)
-        target = url(target)
-      end
-      attributes[:href] = target
-      tag(:a, text, attributes)
-    end
-
-    def tag(name, value, attributes = {})
-      string_attributes = attributes.inject('') do |attrs, pair|
-        unless pair.last.nil?
-          attrs << %( #{pair.first}="#{CGI::escapeHTML(pair.last.to_s)}")
-        end
-        attrs
-      end
-      "<#{name}#{string_attributes}>#{value}</#{name}>"
+    def gap
+      tag :li, tag(:i, ELLIPSIS, class: 'page-link'), class: 'page-item disabled'
     end
 
-    def rel_value(page)
-      case page
-      when @collection.current_page - 1; 'prev' + (page == 1 ? ' start' : '')
-      when @collection.current_page + 1; 'next'
-      when 1; 'start'
-      end
+    def previous_page
+      num = @collection.current_page > 1 && @collection.current_page - 1
+      previous_or_next_page num, @options[:previous_label], 'previous'
     end
 
-    def symbolized_update(target, other)
-      other.each do |key, value|
-        key = key.to_sym
-        existing = target[key]
-
-        if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
-          symbolized_update(existing || (target[key] = {}), value)
-        else
-          target[key] = value
-        end
-      end
+    def next_page
+      num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
+      previous_or_next_page num, @options[:next_label], 'next'
     end
   end
 end

data/app/views/binco/_breadcrumb.html.erb

@@ -1,6 +1,6 @@
 <ol class="breadcrumb">
   <% breadcrumb.each do |route| %>
-    <li class="<%= 'active' if breadcrumb.last == route %>">
+    <li class="<%= 'active' if breadcrumb.last == route %> breadcrumb-item">
       <% if route[:url] %>
         <%= link_to route[:title], route[:url] %>
       <% else %>

data/lib/binco/engine.rb

@@ -1,6 +1,8 @@
-require 'bootstrap-datepicker-rails'
+require 'jquery-rails'
+require 'bootstrap'
 require 'select2-rails'
 require 'will_paginate'
+require 'bootstrap-datepicker-rails'
 
 module Binco
   class Engine < ::Rails::Engine

data/lib/binco/version.rb

@@ -1,3 +1,3 @@
 module Binco
-  VERSION = '2.0.1'
+  VERSION = '3.0.1'
 end

data/lib/generators/binco/install/install_generator.rb

@@ -13,7 +13,7 @@ module Binco
     end
 
     def create_overrides
-      copy_file '_bootstrap-overrides.scss', 'app/assets/stylesheets/_bootstrap-overrides.scss'
+      copy_file '_bootstrap_variables.scss', 'app/assets/stylesheets/_bootstrap_variables.scss'
     end
 
     def add_javascripts