eac_rails_utils 0.0.1

data/lib/eac/common_form_helper/form_builder/fields_for.rb

@@ -0,0 +1,44 @@
+module Eac
+  module CommonFormHelper
+    class FormBuilder
+      module FieldsFor
+        def fields_for(association, &block)
+          fieldset(association) do
+            nested_fields(association, &block) << add_link(association)
+          end
+        end
+
+        private
+
+        def nested_fields(association, &block)
+          form.nested_fields_for(association) do |nested_form|
+            helper.content_tag(:div, class: 'nested_form_row') do
+              helper.capture(FormBuilder.new(nested_form, helper), &block) <<
+                remove_link(nested_form)
+            end
+          end
+        end
+
+        def add_link(association)
+          form.add_nested_fields_link(association, 'Adicionar', class: 'btn btn-primary',
+                                                                role: 'button')
+        end
+
+        def remove_link(nested_form)
+          nested_form.remove_nested_fields_link('Remover', class: 'btn btn-danger',
+                                                           role: 'button')
+        end
+
+        def fieldset(association, &block)
+          helper.content_tag(:fieldset, class: 'nested_form') do
+            helper.content_tag(:legend, fieldset_legend(association)) << block.call
+          end
+        end
+
+        def fieldset_legend(association)
+          I18n.t("helpers.label.#{form.object.class.name.underscore}.#{association}")
+        end
+      end
+    end
+  end
+end

data/lib/eac/common_form_helper/form_builder/radio_select_field.rb

@@ -0,0 +1,44 @@
+module Eac
+  module CommonFormHelper
+    class FormBuilder
+      module RadioSelectField
+        def radio_select_field(field_name, radios_values, options = {})
+          field(field_name, options) do
+            radios(field_name, radios_values)
+          end
+        end
+
+        private
+
+        def radios(field_name, radios_values)
+          b = ActiveSupport::SafeBuffer.new
+          radios_values.each do |r|
+            b << radio(field_name, r[0], r[1])
+          end
+          b
+        end
+
+        def radio(field_name, value, label)
+          helper.content_tag(:div, class: 'radio') do
+            helper.content_tag(:label) do
+              form.radio_button(field_name, value) << label
+            end
+          end
+        end
+
+        def extract_select_options(options)
+          options.extract!(:prompt, :include_blank)
+        end
+
+        def extract_association_key(field_name, options, key, method)
+          return options.delete(key) if options.key?(key)
+          if model_instance.class.respond_to?(:reflect_on_association)
+            return model_instance.class.reflect_on_association(field_name).send(method)
+          end
+          fail "#{model_instance.class} não possui um método \"reflect_on_association\". " \
+            "Defina explicitamente a opção :#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/eac/common_form_helper/form_builder/searchable_association_field.rb

@@ -0,0 +1,77 @@
+module Eac
+  module CommonFormHelper
+    class FormBuilder
+      class SearchableAssociationField
+        def initialize(form_builder, field_name, options)
+          @form_builder = form_builder
+          @field_name = field_name
+          @options = options
+        end
+
+        def hidden_input
+          @form_builder.form.hidden_field(hidden_input_name, id: hidden_input_id)
+        end
+
+        def visible_input
+          @form_builder.helper.text_field_tag(visible_input_name, '', id: visible_input_id,
+                                                                      class: 'form-control')
+        end
+
+        def javascript_tag
+          @form_builder.helper.content_tag(:script) do
+            @form_builder.helper.raw("new InputSearchable(#{json_options});")
+          end
+        end
+
+        private
+
+        def hidden_input_id
+          @hidden_input_id ||= SecureRandom.hex(5)
+        end
+
+        def hidden_input_name
+          "#{@field_name}_id"
+        end
+
+        def visible_input_id
+          @visible_input_id ||= SecureRandom.hex(5)
+        end
+
+        def visible_input_name
+          "#{@field_name}_search"
+        end
+
+        def association_column
+          @form_builder.model_instance && @form_builder.model_instance.send(@field_name)
+        end
+
+        def initial_id
+          return association_column.id if association_column
+          ''
+        end
+
+        def initial_label
+          return association_column.to_s if association_column
+          return params[visible_input_name] if params.key?(visible_input_name)
+          ''
+        end
+
+        def params
+          @form_builder.helper.params
+        end
+
+        def url
+          @options[:url]
+        end
+
+        def json_options
+          r = {}
+          [:hidden_input_id, :visible_input_id, :initial_id, :initial_label, :url].each do |k|
+            r[k] = send(k)
+          end
+          r.to_json
+        end
+      end
+    end
+  end
+end

data/lib/eac/cpf_validator.rb

@@ -0,0 +1,60 @@
+module Eac
+  class CpfValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      return if Cpf.new(value).valid?
+      record.errors[attribute] << (options[:message] ||
+          'CPF inválido (9 caracteres, somente dígitos)')
+    end
+
+    class Cpf
+      def initialize(input)
+        @input = input
+      end
+
+      def valid?
+        return false if input_invalid?
+        digito_verificador1_calculo == values[9] && digito_verificador2_calculo == values[10]
+      end
+
+      private
+
+      attr_reader :input
+
+      def input_invalid?
+        input.nil? || digits.length != 11 || digits.length != input.length || null?
+      end
+
+      def null?
+        %w(12345678909 11111111111 22222222222 33333333333 44444444444 55555555555
+           66666666666 77777777777 88888888888 99999999999 00000000000).member?(digits.join)
+      end
+
+      def digits
+        @digits ||= input.scan(/[0-9]/)
+      end
+
+      def values
+        @values ||= digits.collect(&:to_i)
+      end
+
+      def digito_verificador1_calculo
+        digito_verificador_calculo(9, 10)
+      end
+
+      def digito_verificador2_calculo
+        digito_verificador_calculo(10, 11)
+      end
+
+      def digito_verificador_calculo(valores_count, coeficiente_inicial)
+        s = 0
+        c = coeficiente_inicial
+        (0..valores_count - 1).each do |i|
+          s += values[i] * c
+          c -= 1
+        end
+        s -= (11 * (s / 11))
+        (s == 0 || s == 1) ? 0 : 11 - s
+      end
+    end
+  end
+end

data/lib/eac/formatter_helper.rb

@@ -0,0 +1,27 @@
+module Eac
+  module FormatterHelper
+    include ActionView::Helpers::NumberHelper
+
+    def format_real(value)
+      number_to_currency(
+        value,
+        unit: 'R$ ',
+        separator: ',',
+        delimiter: '.',
+        raise: true
+      )
+    end
+
+    def format_percentage(float_value)
+      number_to_percentage(float_value * 100, precision: 0)
+    end
+
+    def brl_currency_to_float(currency)
+      currency.to_s.gsub(/[R$ .]/, '').tr(',', '.').to_f
+    end
+
+    def format_cep(cep)
+      "#{cep[0, 5]}-#{cep[5, 3]}"
+    end
+  end
+end

data/lib/eac/htmlbeautifier.rb

@@ -0,0 +1,25 @@
+require 'htmlbeautifier'
+
+module Eac
+  class Htmlbeautifier
+    def self.beautify(string)
+      ::HtmlBeautifier.beautify(string, tab_stops: 2) + "\n"
+    end
+
+    def self.file_beautified?(file)
+      input = File.read(file)
+      input == beautify(input)
+    end
+
+    def self.beautify_file(file)
+      input = File.read(file)
+      output = beautify(input)
+      if input == output
+        false
+      else
+        File.write(file, output)
+        true
+      end
+    end
+  end
+end

data/lib/eac/menus_helper.rb

@@ -0,0 +1,17 @@
+module Eac
+  module MenusHelper
+    def dropdown_menu(entries)
+      entries = DataBuilder.new(self).build(entries)
+      return nil unless entries
+      id = SecureRandom.hex(5)
+      GuiBuilder.new(self).build(entries, id: id, class: 'jMenu') <<
+        content_tag(:script) { raw("$(document).ready(function(){$('\##{id}').jMenu();});") }
+    end
+
+    def bootstrap_dropdown_menu(entries, options = {})
+      entries = DataBuilder.new(self).build(entries)
+      return nil unless entries
+      BootstrapGuiBuilder.new(self, options).build(entries)
+    end
+  end
+end

data/lib/eac/menus_helper/bootstrap_gui_builder.rb

@@ -0,0 +1,90 @@
+module Eac
+  module MenusHelper
+    # http://bootsnipp.com/snippets/featured/multi-level-dropdown-menu-bs3
+    class BootstrapGuiBuilder
+      def initialize(view, options = {})
+        @view = view
+        @options = options
+      end
+
+      def build(entries)
+        fail "Argument \"entries\" is not a array" unless entries.is_a?(Array)
+        @view.content_tag(:ul, class: "nav navbar-nav #{@options[:class]}".strip) do
+          menu_entries(entries)
+        end
+      end
+
+      private
+
+      def menu_entries(entries)
+        b = ActiveSupport::SafeBuffer.new
+        entries.map { |v| b << menu_entry(v) }
+        b
+      end
+
+      def menu_entry(entry)
+        if entry[:type] == :group
+          menu_group(entry)
+        elsif entry[:type] == :item
+          menu_item(entry)
+        else
+          fail "Unknown menu entry type: \"#{entry[:type]}\""
+        end
+      end
+
+      def menu_group(entry)
+        if entry[:level] == 0
+          menu_group_root(entry)
+        else
+          menu_group_sub(entry)
+        end
+      end
+
+      def menu_group_root(entry)
+        @view.content_tag(:li, class: 'dropdown') do
+          menu_group_root_button(entry) << menu_group_root_children(entry)
+        end
+      end
+
+      def menu_group_root_button(entry)
+        @view.content_tag(:a, :role => 'button', 'data-toggle' => 'dropdown',
+                              :class => "btn #{@options[:button_class]}",
+                              :'data-target' => '#') do
+          ActiveSupport::SafeBuffer.new(entry[:label]) << ' ' << @view.tag(:span, class: 'caret')
+        end
+      end
+
+      def menu_group_root_children(entry)
+        @view.content_tag(:ul, class: 'dropdown-menu multi-level', role: 'menu',
+                               'aria-labelledby': 'dropdownMenu') do
+          menu_entries(entry[:children])
+        end
+      end
+
+      def menu_group_sub(entry)
+        @view.content_tag(:li, class: 'dropdown-submenu') do
+          @view.link_to(entry[:label], '#', tabindex: -1) <<
+            @view.content_tag(:ul, class: 'dropdown-menu') do
+              menu_entries(entry[:children])
+            end
+        end
+      end
+
+      def menu_item(entry)
+        @view.content_tag(:li) do
+          @view.link_to(entry[:label], entry[:path], menu_item_options(entry))
+        end
+      end
+
+      def menu_item_options(entry)
+        options = entry[:options].dup
+        if options.key?(:link_method)
+          options[:method] = options[:link_method]
+          options.delete(:link_method)
+        end
+        options[:class] = "#{@options[:button_class]}".strip if entry[:level] == 0
+        options
+      end
+    end
+  end
+end

data/lib/eac/menus_helper/data_builder.rb

@@ -0,0 +1,57 @@
+module Eac
+  module MenusHelper
+    class DataBuilder
+      def initialize(view)
+        @view = view
+      end
+
+      def build(entries)
+        build_entries(entries, 0)
+      end
+
+      private
+
+      def build_entries(entries, level)
+        fail 'Argument "entries" is not a hash' unless entries.is_a?(Hash)
+        r = entries.map { |k, v| build_entry(k, v, level) }.select { |e| e }
+        r.empty? ? nil : r
+      end
+
+      def build_entry(key, value, level)
+        if value.is_a?(Hash)
+          build_group(key, value, level)
+        else
+          build_item(key, value, level)
+        end
+      end
+
+      def build_group(label, menu_entries, level)
+        e = build_entries(menu_entries, level + 1)
+        return nil unless e
+        { type: :group, label: label, children: e, level: level }
+      end
+
+      def build_item(label, value, level)
+        path, options = menu_item_options(value)
+        return nil unless can_access_path?(path, options[:link_method])
+        { type: :item, label: label, path: path, options: options, level: level }
+      end
+
+      def menu_item_options(item_value)
+        if item_value.is_a?(Array)
+          [item_value[0], item_value[1] || {}]
+        else
+          [item_value, {}]
+        end
+      end
+
+      def can_access_path?(path, method)
+        if @view.respond_to?(:'can_by_path?')
+          @view.can_by_path?(path, method)
+        else
+          true
+        end
+      end
+    end
+  end
+end