para 0.4.0

data/lib/para/component.rb

@@ -0,0 +1,27 @@
+module Para
+  module Component
+    def self.registered_components
+      @registered_components ||= {}
+    end
+
+    def self.registered_component?(model_name)
+      registered_components.any? do |name, component|
+        component.name == model_name
+      end
+    end
+
+    def self.config
+      @config ||= Para::ComponentsConfiguration.new
+    end
+  end
+end
+
+# Require concerns
+require 'para/component/exportable'
+
+# Require models
+require 'para/component/base'
+require 'para/component/resource'
+require 'para/component/crud'
+require 'para/component/singleton_resource'
+require 'para/component/settings'

data/lib/para/components_configuration.rb

@@ -0,0 +1,156 @@
+module Para
+  class ComponentsConfiguration
+    def draw(&block)
+      return unless components_installed?
+      eager_load_components!
+      instance_eval(&block)
+      build
+    end
+
+    def section(*args, &block)
+      sections << Section.new(*args, &block)
+    end
+
+    def sections
+      @sections ||= []
+    end
+
+    def method_missing(method, *args, &block)
+      component_for(method) || super
+    end
+
+    def section_for(identifier)
+      if (section = sections_cache[identifier])
+        section
+      elsif (section_id = sections_ids_hash[identifier])
+        sections_cache[identifier] = Para::ComponentSection.find(section_id)
+      end
+    end
+
+    def component_for(identifier)
+      if (component = components_cache[identifier])
+        component
+      elsif (component_id = components_ids_hash[identifier])
+        components_cache[identifier] = Para::Component::Base.find(component_id)
+      end
+    end
+
+    private
+
+    def build
+      sections.each_with_index do |section, index|
+        section.refresh(position: index)
+        sections_ids_hash[section.identifier] = section.model.id
+
+        section.components.each do |component|
+          components_ids_hash[component.identifier] = component.model.id
+        end
+      end
+    end
+
+    def sections_ids_hash
+      @sections_ids_hash ||= {}.with_indifferent_access
+    end
+
+    def components_ids_hash
+      @components_ids_hash ||= {}.with_indifferent_access
+    end
+
+    # Only store sections cache for the request duration to avoid expired
+    # references to AR objects between requests
+    #
+    def sections_cache
+      RequestStore.store[:sections_cache] ||= {}.with_indifferent_access
+    end
+
+    # Only store components cache for the request duration to avoid expired
+    # references to AR objects between requests
+    #
+    def components_cache
+      RequestStore.store[:components_cache] ||= {}.with_indifferent_access
+    end
+
+    def components_installed?
+      tables_exist = %w(component/base component_section).all? do |name|
+        Para.const_get(name.camelize).table_exists?
+      end
+
+      unless tables_exist
+        Rails.logger.warn(
+          "Para migrations are not installed.\n" \
+          "Skipping components definition until next app reload."
+        )
+      end
+
+      tables_exist
+    end
+
+    def eager_load_components!
+      $LOAD_PATH.each do |path|
+        next unless path.match(/\/components$/)
+
+        glob = File.join(path, '**', '*_component.rb')
+
+        Dir[glob].each do |file|
+          load(file)
+        end
+      end
+    end
+
+    class Section
+      attr_accessor :identifier, :model
+
+      def initialize(identifier, &block)
+        self.identifier = identifier.to_s
+        instance_eval(&block)
+      end
+
+      def component(*args)
+        components << Component.new(*args)
+      end
+
+      def components
+        @components ||= []
+      end
+
+      def refresh(attributes = {})
+        self.model = ComponentSection.where(identifier: identifier).first_or_initialize
+        model.assign_attributes(attributes)
+        model.save!
+
+        components.each_with_index do |component, index|
+          component.refresh(component_section: model, position: index)
+        end
+      end
+    end
+
+    class Component
+      attr_accessor :identifier, :type, :options, :model
+
+      def initialize(identifier, type, options = {})
+        self.identifier = identifier.to_s
+        self.type = Para::Component.registered_components[type]
+        self.options = options
+      end
+
+      def refresh(attributes = {})
+        self.model = type.where(identifier: identifier).first_or_initialize
+        model.assign_attributes(attributes.merge(options_with_defaults))
+        model.save!
+      end
+
+      # Ensures unset :configuration store options are set to nil to allow
+      # removing a configuration option from the components.rb file
+      #
+      def options_with_defaults
+        configurable_keys = type.local_stored_attributes.try(:[], :configuration) || []
+        configurable_keys += options.keys
+        configurable_keys.uniq!
+
+        configurable_keys.each_with_object({}) do |key, hash|
+          hash[key] = options[key]
+        end
+      end
+    end
+  end
+end

data/lib/para/config.rb

@@ -0,0 +1,21 @@
+module Para
+  module Config
+    mattr_accessor :authenticate_admin_method
+    @@authenticate_admin_method = :authenticate_admin_user!
+
+    mattr_accessor :current_admin_method
+    @@current_admin_method = :current_admin_user
+
+    mattr_accessor :pagination_theme
+    @@pagination_theme = 'twitter-bootstrap-3'
+
+    mattr_accessor :admin_title
+    @@admin_title = nil
+
+    mattr_accessor :default_tree_max_depth
+    @@default_tree_max_depth = 3
+
+    mattr_accessor :resource_name_methods
+    @@resource_name_methods = [:name, :title]
+  end
+end

data/lib/para/engine.rb

@@ -0,0 +1,59 @@
+module Para
+  class Engine < ::Rails::Engine
+    initializer 'add vendor path to assets pipeline' do |app|
+      %w(javascripts stylesheets).each do |folder|
+        app.config.assets.paths << File.expand_path(
+          "../../../vendor/assets/#{ folder }",
+          __FILE__
+        )
+      end
+    end
+
+    initializer 'Para precompile hook', group: :all do |app|
+      app.config.assets.precompile += %w(
+        para/admin.js
+        para/admin.css
+      )
+    end
+
+    initializer 'Para Orderable Mixin' do
+      ActiveSupport.on_load(:active_record) do
+        include Para::ActiveRecordOrderableMixin
+      end
+    end
+
+    initializer 'Para Cloneable' do
+      ActiveSupport.on_load(:active_record) do
+        include Para::Cloneable
+      end
+    end
+
+    initializer 'Extend paperclip attachment definition' do
+      return unless Kernel.const_defined?('Paperclip')
+
+      ActiveSupport.on_load(:active_record) do
+        ::Paperclip::HasAttachedFile.send(
+          :include, Para::Ext::Paperclip::HasAttachedFileMixin
+        )
+      end
+    end
+
+    initializer 'Extend cancan ControllerResource class' do
+      return unless Kernel.const_defined?('CanCan')
+
+      ActiveSupport.on_load(:active_record) do
+        ::CanCan::ControllerResource.send(
+          :include, Para::Ext::Cancan::ControllerResource
+        )
+      end
+    end
+
+    initializer 'Build components tree' do |app|
+      components_config_path = Rails.root.join('config', 'components.rb')
+
+      app.config.to_prepare do
+        require components_config_path if File.exist?(components_config_path)
+      end
+    end
+  end
+end

data/lib/para/errors.rb

@@ -0,0 +1,15 @@
+module Para
+  class BaseException < StandardError; end
+
+  class ComponentNotFound < BaseException
+    attr_accessor :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def message
+      "Component not found for type : #{ type }"
+    end
+  end
+end

data/lib/para/exporter/base.rb

@@ -0,0 +1,27 @@
+module Para
+  module Exporter
+    class Base
+      attr_reader :resources
+
+      def initialize(resources)
+        @resources = resources
+      end
+
+      def disposition
+        'inline'
+      end
+
+      def extension
+        raise '#extension must be defined to create the export file name'
+      end
+
+      def file_name
+        @file_name ||= [name, extension].join('.')
+      end
+
+      def self.register_base_exporter(type, exporter)
+        Exporter.base_exporters[type] = exporter
+      end
+    end
+  end
+end

data/lib/para/exporter/csv.rb

@@ -0,0 +1,49 @@
+require 'csv'
+
+module Para
+  module Exporter
+    class Csv < Base
+      register_base_exporter :csv, self
+
+      def extension
+        'csv'
+      end
+
+      def mime_type
+        'text/csv'
+      end
+
+      def export_type
+        :excel
+      end
+
+      def render
+        CSV.generate do |csv|
+          csv << headers
+
+          resources.each do |resource|
+            csv << row_for(resource)
+          end
+        end
+      end
+
+      private
+
+      def headers
+        fields.map do |field|
+          encode(User.human_attribute_name(field))
+        end
+      end
+
+      def row_for(resource)
+        fields.map do |field|
+          encode(resource.send(field))
+        end
+      end
+
+      def encode(string)
+        string.presence && string.to_s.encode('UTF-8')
+      end
+    end
+  end
+end

data/lib/para/exporter.rb

@@ -0,0 +1,57 @@
+module Para
+  module Exporter
+    class MissingExporterError < StandardError
+      attr_accessor :model_name, :format, :exporter_name
+
+      def initialize(model_name, format, exporter_name)
+        @model_name = model_name
+        @format = format
+        @exporter_name = exporter_name
+      end
+
+      def message
+        "No exporter found for model \"#{ model_name }\" and format " +
+        "\"#{ format }\". Please create the #{ exporter_name } class " +
+        "manually or with the following command : " +
+        "`rails g para:exporter #{ model_name.underscore } #{ format }"
+      end
+    end
+
+    def self.for(model_name, format)
+      exporter_name = name_for(model_name, format)
+
+      begin
+        const_get(exporter_name)
+      rescue NameError => e
+        if e.message == "uninitialized constant Para::Exporter::#{ exporter_name }"
+          raise MissingExporterError.new(model_name, format, exporter_name)
+        else
+          raise e
+        end
+      end
+    end
+
+    def self.name_for(model_name, format)
+      [
+        '',
+        format_exporter_name(format),
+        model_exporter_name(model_name)
+      ].join('::')
+    end
+
+    def self.model_exporter_name(model_name)
+      [model_name.to_s.pluralize, 'Exporter'].join
+    end
+
+    def self.format_exporter_name(format)
+      format.to_s.camelize
+    end
+
+    def self.base_exporters
+      @base_exporters ||= {}.with_indifferent_access
+    end
+  end
+end
+
+require 'para/exporter/base'
+require 'para/exporter/csv'

data/lib/para/ext/cancan.rb

@@ -0,0 +1,26 @@
+module Para
+  module Ext
+    module Cancan
+      module ControllerResource
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :assign_attributes, :parent_missing_management
+        end
+
+        # Todo : Document why this extension was added ?
+        def assign_attributes_with_parent_missing_management(resource)
+          if @options[:singleton] && parent_resource && resource.respond_to?(:"#{ parent_name }=")
+            resource.send(:"#{ parent_name }=", parent_resource)
+          end
+
+          initial_attributes.each do |attr_name, value|
+            resource.send(:"#{ attr_name }=", value)
+          end
+
+          resource
+        end
+      end
+    end
+  end
+end

data/lib/para/ext/paperclip.rb

@@ -0,0 +1,67 @@
+module Para
+  module Ext
+    module Paperclip
+      module HasAttachedFileMixin
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :define, :removeable_management
+        end
+
+        def define_with_removeable_management
+          define_without_removeable_management
+          define_removeable
+        end
+
+        private
+
+        def define_removeable
+          return if @options[:removeable] == false
+
+          attachment_name = @name
+          klass = @klass
+          # Define the setter to remove the attachment
+          #
+          @klass.send :define_method, :"remove_#{ attachment_name }=" do |value|
+            if value == '1'
+              removed_attachments << attachment_name
+
+              # Notify ActiveRecord that the model has changed so nested models
+              # get to run validation hooks and attachments are cleared
+              send(:"#{ attachment_name }_file_name_will_change!")
+            end
+          end
+
+          @klass.send :define_method, :"remove_#{ attachment_name }" do |value|
+            removed_attachments.include?(attachment_name) ? '1' : nil
+          end
+
+          # Lazy method initialization on attachment target class
+          #
+          unless @klass.method_defined?(:removed_attachments)
+            # List of all removed attachments for the current instance
+            #
+            @klass.send :define_method, :removed_attachments do
+              @removed_attachments ||= []
+            end
+
+            # Define before validation hook to clear removed attachments before
+            # the instance is validated
+            #
+            @klass.send :define_method, :clear_removed_attachments do
+              removed_attachments.each do |name|
+                if send(:"#{ name }?")
+                  send(name).clear
+                end
+              end
+
+              removed_attachments.clear
+            end
+
+            @klass.send(:before_validation, :clear_removed_attachments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/ext.rb

@@ -0,0 +1,13 @@
+module Para
+  # References all framework extensions to make our code work well with other
+  # libraries.
+  #
+  # One goal is to have the minimum of them, but sometimes, without them, we
+  # may need to make our own code dirty
+  #
+  module Ext
+  end
+end
+
+require 'para/ext/cancan'
+require 'para/ext/paperclip'

data/lib/para/form_builder/containers.rb

@@ -0,0 +1,70 @@
+module Para
+  module FormBuilder
+    module Containers
+      def fieldset(&block)
+        template.content_tag(:div, class: 'block form-inputs') do
+          template.capture(&block)
+        end
+      end
+
+      def actions(options = {}, &block)
+        template.content_tag(:div, class: 'block form-actions form-group') do
+          template.content_tag(:div, class: 'col-sm-9 col-sm-offset-3') do
+            if block
+              template.capture(&block)
+            else
+              if options.empty?
+                options[:only] = template.instance_variable_get(:@component).default_form_actions
+              end
+              actions_buttons_for(options).join("\n").html_safe
+            end
+          end
+        end
+      end
+
+      def actions_buttons_for(options)
+        names = [:submit, :submit_and_edit, :submit_and_add_another, :cancel]
+
+        names.select! { |name| Array.wrap(options[:only]).include?(name) } if options[:only]
+        names.reject! { |name| Array.wrap(options[:except]).include?(name) } if options[:except]
+        buttons = names.map { |name| send(:"para_#{ name }_button") }
+        buttons.unshift(return_to_hidden_field)
+        buttons
+      end
+
+      def return_to_hidden_field
+        template.hidden_field_tag(:return_to, return_to_path)
+      end
+
+      def para_submit_button(options = {})
+        button(:submit, I18n.t('para.shared.save'), name: '_save', class: 'btn-success')
+      end
+
+      def para_submit_and_edit_button
+        button(:submit, I18n.t('para.shared.save_and_edit'), name: '_save_and_edit', class: 'btn-primary')
+      end
+
+      def para_submit_and_add_another_button
+        button(:submit, I18n.t('para.shared.save_and_add_another_button'), name: '_save_and_add_another', class: 'btn-primary')
+      end
+
+      def para_cancel_button
+        template.link_to(
+          I18n.t('para.shared.cancel'),
+          return_to_path,
+          class: 'btn btn-danger'
+        )
+      end
+
+      def return_to_path
+        template.params[:return_to].presence || component_path
+      end
+
+      def component_path
+        if (component = template.instance_variable_get(:@component))
+          component.path
+        end
+      end
+    end
+  end
+end

data/lib/para/form_builder/field_mappings.rb

@@ -0,0 +1,9 @@
+module Para
+  module FormBuilder
+    module FieldMappings
+      def fields
+        @fields ||= template.model_field_mappings(object.class).fields
+      end
+    end
+  end
+end

data/lib/para/form_builder/nested_form.rb

@@ -0,0 +1,80 @@
+module Para
+  module FormBuilder
+    module NestedForm
+      def nested_fields
+        @nested_fields ||= fields.reject do |field|
+          inverse_of?(field.name)
+        end
+      end
+
+      def nested_resource_name
+        @nested_resource_name ||= begin
+          name_method = Para.config.resource_name_methods.find do |method_name|
+            object.respond_to?(method_name)
+          end
+
+          (name_method && object.try(name_method).presence) || default_resource_name
+        end
+      end
+
+      def nested_resource_dom_id
+        return "" unless nested?
+
+        @nested_resource_dom_id ||= [
+          object.class.model_name.singular,
+          (Time.now.to_f * 1000).to_i,
+          (object.id || "_new_#{ nested_attribute_name }_id")
+        ].join('-')
+      end
+
+      def remove_association_button
+        return "" unless allow_destroy?
+
+        template.content_tag(:div, class: 'panel-btns pull-right') do
+          template.link_to_remove_association(
+            self, wrapper_class: 'form-fields', class: 'btn btn-danger'
+          ) do
+            template.content_tag(:i, '', class: 'fa fa-trash') +
+            I18n.t('para.form.nested.remove')
+          end
+        end
+      end
+
+      def allow_destroy?
+        return false unless nested?
+
+        nested_options = parent_object.nested_attributes_options
+        relation = nested_options[nested_attribute_name]
+        relation && relation[:allow_destroy]
+      end
+
+      def inverse_of?(field_name)
+        return false unless nested?
+
+        reflection = parent_object.class.reflect_on_association(nested_attribute_name)
+        reflection && (reflection.options[:inverse_of] == field_name)
+      end
+
+      def nested?
+        nested_attribute_name.present?
+      end
+
+      def nested_attribute_name
+        options[:nested_attribute_name]
+      end
+
+      def parent_object
+        nested? && options[:parent_builder] && options[:parent_builder].object
+      end
+
+      private
+
+      def default_resource_name
+        model_name = object.class.model_name.human
+        id_or_new = (id = object.id) ? id : I18n.t('para.form.nested.new')
+
+        [model_name, id_or_new].join(' - ')
+      end
+    end
+  end
+end

data/lib/para/form_builder/ordering.rb

@@ -0,0 +1,15 @@
+module Para
+  module FormBuilder
+    module Ordering
+      def orderable?
+        options.fetch(:orderable, object.class.orderable?)
+      end
+
+      def reorder_anchor(options = {})
+        return "" unless orderable?
+        options[:form] = self
+        template.reorder_anchor(options)
+      end
+    end
+  end
+end