basepack 0.0.2

data/lib/basepack/forms/diff.rb

@@ -0,0 +1,66 @@
+module Basepack
+  module Forms
+    class Diff < Forms::Edit
+      attr_reader :form2
+      attr_accessor :path
+
+      def initialize(factory, chain1, chain2, options = {})
+        super(factory, chain1, options)
+        @path = options[:path]
+        @form2 = Basepack::Forms::Show.new(factory, chain2)
+
+        @compare = {}
+        compare '*' do |f1, f2|
+          if f1.association?
+            a1, a2 = Array.wrap(f1.value).compact, Array.wrap(f2.value).compact
+            a1, a2 = a2, a1 if a1.size < a2.size
+            a1.zip(a2).all? {|v1, v2| v2 ? v1.same_as?(v2) : false }
+          else
+            f1.value.presence == f2.value.presence
+          end
+        end
+      end
+
+      def build_from_factory
+        factory.build_form(@form2)
+        factory.build_form(self)
+      end
+
+      def resource2
+        @form2.resource
+      end
+
+      def field2(name, attributes = nil)
+        if field(name)
+          @form2.field(name, attributes)
+        else
+          nil
+        end
+      end
+
+      def visible_field2(name)
+        visible_field(name) ? @form2.visible_field(name) : nil
+      end
+
+      def compare(field_name, &block)
+        if block_given?
+          @compare[field_name] = block
+        else
+          @compare[field_name]
+        end
+      end
+
+      def field_show_values(name, &block)
+        f1 = field(name)
+        f2 = field2(name)
+        f1.pretty_value = yield(f1, f2)
+        f2.pretty_value = yield(f2, f1)
+      end
+
+      def default_partial
+        'forms/diff'
+      end
+
+    end
+  end
+end

data/lib/basepack/forms/edit.rb

@@ -0,0 +1,145 @@
+require 'rails_admin/i18n_support'
+
+module Basepack
+  module Forms
+    class Edit < Forms::Base
+      class << self
+        include RailsAdmin::I18nSupport
+
+        def data_picker_options
+          {
+            dateFormat:        date_format, # TODO - without %d -> dd, ...
+            dayNames:          day_names,
+            dayNamesShort:     abbr_day_names,
+            dayNamesMin:       abbr_day_names,
+            firstDay:          "1",
+            monthNames:        month_names,
+            monthNamesShort:   abbr_month_names,
+          }
+        end
+      end
+
+      delegate :input, :association, :object, :input_field, :check_box,
+               :link_to_add, :link_to_remove, :hidden_field, :object_name, to: :simple_form
+
+      attr_reader :simple_form
+      attr_accessor :builder_default_options
+      attr_accessor :path
+
+      def initialize(factory, chain, options = {})
+        super
+        @path = options[:path]
+        @builder_default_options = {
+          html:     { multipart: true, class: 'form-horizontal denser' },
+          defaults: { input_html: { class: 'span6'} }
+        }
+
+        if options[:method].present?
+          @builder_default_options[:method] = options[:method]
+        end
+      end
+
+      def path
+        @path ||= view.url_for(chain)
+      end
+
+      def default_partial
+        'forms/edit'
+      end
+
+      def builder
+        simple_form
+      end
+
+      def with_simple_form(simple_form, &block)
+        @simple_form = simple_form
+        begin
+          yield(self)
+        ensure
+          @simple_form = nil
+        end
+      end
+
+      render :form do |options = nil, &block|
+        options = (options || {}).dup.reverse_merge!(@builder_default_options)
+        options[:url] ||= path
+
+        view.simple_nested_form_for(chain, options) do |simple_form|
+          with_simple_form(simple_form) do
+            view.safe_concat render_setup_form
+            view.safe_concat(view.capture(self, &block)) if block
+          end
+        end
+      end
+
+      render :setup_form do
+        view.form_setup_simple_form(simple_form)
+      end
+
+      render :nested_form do |field, options = nil, &block|
+        options = (options || {}).reverse_merge( defaults: @builder_default_options[:defaults] )
+
+        resource.send("build_#{field.name}") unless field.multiple? or field.value
+
+        simple_form.fields_for(field.name, options) do |nested_form|
+          # this block is called out of order of superiors nested_forms in case of field.multiple?
+          nested_form.object ||= field.value.build if field.multiple? # TODO is this necessary? can be #new_form moved outside of this block?
+          new_form(nested_form.object, nested_in: field).with_simple_form(nested_form) {|form| view.capture(form, &block) }
+        end
+      end
+
+      render :fields do
+        view.render "forms/form_fields", form: self
+      end
+
+      render :filteringselect do |field, value = nil|
+        value ||= Array.wrap(field.value)
+        p_key = field.associated_primary_key || :id
+
+        options = (field.html_attributes || {}).dup
+        options[:value] = value.map {|v| v.send(p_key) }.join(',')
+        options[:data] ||= {}
+        options[:data].reverse_merge!(
+          filteringselect: true,
+          options: {
+            multiple:       field.multiple,
+            placeholder:    I18n.t('admin.misc.search'),
+            required:       field.required?,
+            remote_source:  field.options_source,
+            remote_source_params: field.options_source_params || {},
+            init:           Hash[value.map {|v| [v.send(p_key), view.html_escape(v.to_label)] }],
+          }
+        )
+        options.reverse_merge!(@builder_default_options[:defaults][:input_html]) if @builder_default_options[:defaults]
+        simple_form.hidden_field field.method_name, options
+      end
+
+      def textfield_options(field)
+        options = (field.html_attributes || {}).dup
+        options.reverse_merge!(@builder_default_options[:defaults][:input_html]) if @builder_default_options[:defaults]
+        options
+      end
+
+      render :textfield do |field, options = {}|
+        simple_form.input_field field.method_name, textfield_options(field).reverse_merge(options)
+      end
+
+      render :actions do
+        view.render "forms/buttons/submit"
+      end
+
+      def render_field!(field)
+        if field.read_only?
+          simple_form.input field.name, label: field.label, hint: field.help, required: field.required? do
+            field.pretty_value
+          end
+        else
+          view.render field.partial, form: self, field: field
+        end
+      end
+
+    end
+  end
+end
+
+

data/lib/basepack/forms/export.rb

@@ -0,0 +1,109 @@
+module Basepack
+  module Forms
+    class Export < Forms::Base
+      attr_reader :query_form
+
+      def initialize(factory, chain, options = {})
+        super(factory, chain, options)
+        @query_form = options[:query_form]
+      end
+
+      def view=(view)
+        super
+        @query_form.view = view if @query_form
+      end
+
+      def path
+        view.polymorphic_path([:export, association_chain, resource_class].flatten)
+      end
+
+      def default_partial
+        'forms/export'
+      end
+
+      def collection
+        @query_form ? @query_form.collection : []
+      end
+
+      def schema_from_params(params = nil)
+        schema_from_fields(fields_from_params(params))
+      end
+
+      def schema_from_fields(fields)
+        schema = { only: [], methods: [], include: {} }
+
+        fields.each do |nfields|
+          if nfields.is_a? Array
+            # nested form
+            f = nfields.first.form.nested_in
+            schema[:include][f.name] = schema_from_fields(nfields)
+          else
+            f = nfields
+            if f.polymorphic?
+              schema[:methods] << f.method_name << f.association[:foreign_type]
+            else
+              schema[:only] << f.name
+            end
+          end
+        end
+
+        schema
+      end
+
+      def fields_from_params(params = nil)
+        if params.present?
+          fields = []
+          Array.wrap(params).each do |name|
+            if name.is_a? Hash
+              name.each {|n, v| fields << fields_for_field(visible_field(n.to_sym), v) }
+            else
+              fields << fields_for_field(visible_field(name.to_sym))
+            end
+          end
+          fields
+        else
+          visible_fields.map {|f| fields_for_field(f)}
+        end
+      end
+
+      def csv_header(fields)
+        fields.flatten.map {|field| field.nested_label}
+      end
+
+      def csv_row_for_resource(resource, fields)
+        with_resource(resource) do
+          row = []
+          fields.each do |nfields|
+            if nfields.is_a? Array
+              # nested form
+              nform = nfields.first.form
+              f = nform.nested_in
+              values = f.multiple? ? f.value : [f.value]
+              values = values.map {|v| nform.csv_row_for_resource(v, nfields)}
+              nfields.zip(*values) {|nf, *v| row << v.join(',') }
+            else
+              f = nfields
+              if f.polymorphic?
+                row << resource.try(f.method_name) << resource.try(f.association[:foreign_type])
+              else
+                row << f.export_value
+              end
+            end
+          end
+          row
+        end
+      end
+
+      private
+
+      def fields_for_field(field, params = nil)
+        if field and !field.form.nested_in and !field.inverse_of_nested_in? and nform = field.nform
+            nform.fields_from_params(params)
+        else
+          field
+        end
+      end
+    end
+  end
+end
+

data/lib/basepack/forms/factories/base.rb

@@ -0,0 +1,53 @@
+module Basepack
+  module Forms
+    module Factories
+      class Base
+        FIELDS = {
+          has_one_association: Fields::HasOneAssociation,
+          has_many_association: Fields::HasManyAssociation,
+          belongs_to_association: Fields::BelongsToAssociation,
+          has_and_belongs_to_many_association: Fields::HasAndBelongsToManyAssociation,
+        }
+
+        def initialize(form_class = Forms::Base, group_class = Groups::Base)
+          @form_class   = form_class
+          @group_class  = group_class
+        end
+
+        def build_form(form)
+          form
+        end
+
+        def new_form(*args)
+          @form_class.new(self, *args).build_from_factory
+        end
+
+        def new_group(form, attributes)
+          @group_class.new(form, attributes)
+        end
+
+        def new_field(name, form, attributes)
+          if klass = FIELDS[field_attr(attributes, :type)]
+            klass.new(name, form, attributes)
+          else
+            Fields::Base.new(name, form, attributes)
+          end
+        end
+
+        private
+
+        def field_attr(attributes, name)
+          if attributes
+            if attributes.respond_to? name
+              attributes.send(name)
+            else
+              attributes[name]
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/basepack/forms/factories/query_rails_admin.rb

@@ -0,0 +1,31 @@
+module Basepack
+  module Forms
+    module Factories
+      class QueryRailsAdmin < Factories::RailsAdmin
+        def initialize(view, form_class = Forms::Query, group_class = Groups::Base)
+          super(:query, view, form_class, group_class)
+        end
+
+        def build_form(form)
+          super(form)
+
+          rans_assoc = form.resource_class.ransackable_associations(form.auth_object)
+          rans_attrs = form.resource_class.ransackable_attributes(form.auth_object)
+
+          form.fields.each do |f|
+            if f.association?
+              f.filterable = rans_assoc.include?(f.name.to_s)
+            elsif f.virtual?
+              #  f.filterable = false
+            else
+              f.filterable = rans_attrs.include?(f.name.to_s) if f.filterable?
+            end
+          end
+
+          form
+        end
+      end
+    end
+  end
+end
+

data/lib/basepack/forms/factories/rails_admin.rb

@@ -0,0 +1,57 @@
+module Basepack
+  module Forms
+    module Factories
+      class RailsAdmin < Factories::Base
+
+        class Bindings
+          def initialize(form, view)
+            @form = form
+            @view = view
+          end
+
+          def [](param)
+            case param
+            when :object
+              @form.resource
+            when :view
+              @view
+            when :controller
+              @view.controller
+            when :form
+              @form
+            end
+          end
+        end
+
+        def initialize(section, view, form_class = Forms::Base, group_class = Groups::Base)
+          super(form_class, group_class)
+          @section      = section
+          @view         = view
+        end
+
+        def build_form(form)
+          bindings = Bindings.new(form, @view)
+
+          Basepack::Utils.model_config(form.resource_class).send(@section).with(bindings).visible_groups.map do |g|
+            i = 0
+            fields = g.fields.sort_by {|f| [f.order, i += 1] } # stable sort
+
+            form.group(g) do |group|
+              fields.each do |f|
+                group.field(f.name, f.with(bindings)) do |field|
+                  def field.partial_delegated
+                    partial = super.to_s
+                    partial.include?('/') ? partial : File.join('forms', 'edit', partial)
+                  end
+                end
+              end
+            end
+          end
+
+          form
+        end
+
+      end
+    end
+  end
+end

data/lib/basepack/forms/fields/base.rb

@@ -0,0 +1,158 @@
+module Basepack
+  module Forms
+    module Fields
+      class Base
+        include Basepack::Delegation
+        include Basepack::Renderable
+
+        delegate_attrs :type, :method_name, :label, :value, :pretty_value, :help,
+          :type_css_class, :css_class, :associated_model_config, :polymorphic?, :association,
+          :visible?, :active?, :read_only?, :enum, :abstract_model, :export_value,
+          :filterable?, :queryable?, :searchable, :sortable, :sort_reverse, :virtual?,
+          :options_source, :options_source_params, :partial, :partial_show,
+          :view_helper, :required?, :html_attributes, :nested_form, :inverse_of, :multiple?,
+          :associated_primary_key, :optional?, :editable?, :foreign_key, :allowed_methods,
+          :errors, :cache_method, :delete_method, :orderable, :inline_add, :inline_edit,
+          :html_default_value, :js_plugin_options,
+          :css_location, :js_location, :config, :assets, :config_options, :config_js, :base_location, :location,
+          :bulk_edit_partial
+
+        ASSOC_TYPES = {
+          :belongs_to_association              => true,
+          :has_and_belongs_to_many_association => true,
+          :has_many_association                => true,
+          :has_one_association                 => true,
+          :polymorphic_association             => true,
+        }
+
+        attr_reader :name, :form
+        attr_reader :delegate
+
+        def initialize(name, form, delegate_or_attributes = nil)
+          @name = name
+          @form = form
+          update_attributes(delegate_or_attributes)
+        end
+
+        def copy(attributes = nil)
+          field = self.class.new(name, form, self)
+          field.update_attributes(attributes) if attributes.is_a? Hash
+          field
+        end
+
+        attr_default :visible do
+          true
+        end
+
+        attr_default :method_name do
+          name
+        end
+
+        attr_default :foreign_key do
+          "#{name}_id".to_sym
+        end
+
+        attr_default :queryable, [:virtual] do
+          !virtual?
+        end
+
+        attr_default :filterable, [:searchable] do
+          !!searchable
+        end
+
+        attr_default :partial do
+          File.join('forms', 'edit', 'form_field')
+        end
+
+        attr_default :bulk_edit_partial do
+          partial.to_s.sub(/\/edit\//, '/bulk_edit/')
+        end
+
+        attr_default :html_attributes do
+          {}
+        end
+
+        attr_default :allowed_methods, [:method_name] do
+          [method_name]
+        end
+
+        def association?
+          !!ASSOC_TYPES[type]
+        end
+
+        def update_attributes(delegate_or_attributes)
+          if delegate_or_attributes.is_a? Hash
+            delegate_or_attributes.each do |a, v|
+              send("#{a}=", v)
+            end
+          else
+            #raise ArgumentError, "Invalid delegate #{delegate_or_attributes}" unless
+            #  delegate_or_attributes.respond_to? :type
+            @delegate = delegate_or_attributes
+          end
+        end
+
+        def view
+          form.view
+        end
+
+        def enum_options
+          if type == :enum # TODO - into own class
+            if form.resource_class.respond_to? :enumerized_attributes
+              # enumerize
+              values = form.resource_class.enumerized_attributes[method_name].try(:values)
+              values.map {|val| [val.value, val.text]}
+            else
+              enum.map {|a| a.reverse }
+            end
+          end
+        end
+
+        render do
+          form.render_field!(self)
+        end
+
+        def value
+          form.resource.send(name)
+        end
+
+        def configure_nested_form(&block)
+          if block
+            @configure_nested_form = block
+          else
+            @configure_nested_form
+          end
+        end
+
+        def parse_input(params)
+          @delegate.parse_input(params) if @delegate
+        end
+
+        def nform
+          if association? and !polymorphic?
+            @nform ||= form.new_form(associated_model_config.abstract_model.model, nested_in: self)
+          else
+            nil
+          end
+        end
+
+        def inverse_of_nested_in?
+          (nested_in = form.nested_in) and nested_in.name == inverse_of and
+            nested_in.abstract_model.model == associated_model_config.abstract_model.model
+        end
+
+        def nested_label
+          form.nested_in ? "#{form.nested_in.nested_label}: #{label}" : label
+        end
+
+        def unique?
+          abstract_model.model.validators_on(self.name).map(&:class).include?(ActiveRecord::Validations::UniquenessValidator)
+        end
+
+        def bulk_editable?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/basepack/forms/fields/belongs_to_association.rb

@@ -0,0 +1,25 @@
+module Basepack
+  module Forms
+    module Fields
+      class BelongsToAssociation < Fields::SingleAssociation
+        # TODO
+        #register_instance_option :sortable do
+        #  @sortable ||= abstract_model.adapter_supports_joins? && associated_model_config.abstract_model.properties.map{ |p| p[:name] }.include?(associated_model_config.object_label_method) ? associated_model_config.object_label_method
+        #end
+        #
+        #register_instance_option :searchable do
+        #  @searchable ||= associated_model_config.abstract_model.properties.map{ |p| p[:name] }.include?(associated_model_config.object_label_method) ? [associated_model_config.object_label_method, {self.abstract_model.model => self.me
+        #end
+
+        attr_default :method_name, [:nested_form, :foreign_key] do
+          nested_form ? "#{name}_attributes".to_sym : foreign_key
+        end
+
+        def selected_id
+          form.resource.send(foreign_key)
+        end
+
+      end
+    end
+  end
+end

data/lib/basepack/forms/fields/has_and_belongs_to_many_association.rb

@@ -0,0 +1,12 @@
+module Basepack
+  module Forms
+    module Fields
+      class HasAndBelongsToManyAssociation < Fields::HasManyAssociation
+        def bulk_editable?
+          true
+        end
+      end
+    end
+  end
+end
+