para 0.5.4 → 0.6.2

data/lib/para/attribute_field/enum.rb

@@ -6,16 +6,20 @@ module Para
       def value_for(instance)
         if (raw_value = instance.send(name)) &&
           path = enum_path_for(instance, raw_value)
-          translation = ::I18n.t("activerecord.#{ path }", default: false)
+          translation = ::I18n.t("activerecord.#{ path }", default: '')
 
-          translation || raw_value
+          translation.presence || raw_value
         end
       end
 
+      def field_type
+        :selectize
+      end
+
       private
 
       def enum_path_for(instance, key)
-        ['enums', instance.class.model_name.i18n_key, name, key].join('.')
+        ['enums', instance.model_name.i18n_key, name, key].join('.')
       end
     end
   end

data/lib/para/component/importable.rb

@@ -8,14 +8,14 @@ module Para
       end
 
       def importable?
-        @importable ||= imports.length > 0
+        @importable ||= importers.length > 0
       end
 
       # TODO : Move :configuration column store to JSON instead of HStore
       # which handles more data types and will help us avoid eval here
-      def imports
-        @imports ||= if importers.present?
-          eval(importers)
+      def importers
+        @importers ||= if (importers = configuration['importers'].presence)
+          eval(importers).map(&:constantize)
         else
           []
         end

data/lib/para/component.rb

@@ -25,5 +25,5 @@ require 'para/component/subclassable'
 require 'para/component/base'
 require 'para/component/resource'
 require 'para/component/crud'
-require 'para/component/singleton_resource'
+require 'para/component/form'
 require 'para/component/settings'

data/lib/para/components_cleaner.rb

@@ -0,0 +1,66 @@
+module Para
+  class ComponentsCleaner
+    # Hide class instanciation
+    def self.run; new.run; end
+
+    def run
+      components.each do |component|
+        unless component == Para.components.component_for(component.identifier)
+          component.destroy
+        end
+      end
+
+      Para::ComponentSection.find_each do |section|
+        unless Para.components.section_for(section.identifier)
+          section.destroy
+        end
+      end
+    end
+
+    private
+
+    def components
+      Para::Component::Base.all.to_a
+    rescue ActiveRecord::SubclassNotFound => e
+      # When a subclass is not found, define it and try loading all components.
+      #
+      # Since we're probably about to destroy this class, this sould not
+      # produce errors for the end user
+      #
+      if (match = e.message.match(/the subclass: '([\w:]+)'/))
+        define_temporary_component_subclass(match[1])
+        return components
+      end
+
+      raise e
+    end
+
+    def define_temporary_component_subclass(subclass_name)
+      subclass_path = subclass_name.split('::')
+
+      subclass_path.each_with_index.each_with_object([]) do |(const_name, index), path|
+        parent_name = path.join('::').presence
+
+        begin
+          [parent_name, const_name].compact.join('::').constantize
+        rescue NameError
+          # Last iterated constnat is the actual component subclass, others must
+          # be modules namespacing the component class
+          object = if index == (subclass_path.length - 1)
+            Class.new(Para::Component::Base)
+          else
+            Module.new
+          end
+
+          parent = parent_name ? parent_name.constantize : Object
+          # Define module or class in parent namespace
+          parent.const_set(const_name, object)
+        end
+
+        # Add const name to the path to allow namespaced constants to be
+        # defined in next loop iteration
+        path << const_name
+      end
+    end
+  end
+end

data/lib/para/components_configuration.rb

@@ -86,6 +86,8 @@ module Para
       end
 
       tables_exist
+    rescue ActiveRecord::NoDatabaseError
+      false # Do not load components when the database is not installed
     end
 
     # Eager loads every file ending with _component.rb that's included in a
@@ -151,7 +153,7 @@ module Para
 
       def refresh(attributes = {})
         self.model = type.where(identifier: identifier).first_or_initialize
-        model.assign_attributes(attributes.merge(options_with_defaults))
+        model.update_with(attributes.merge(options_with_defaults))
         model.save!
       end
 

data/lib/para/engine.rb

@@ -29,7 +29,7 @@ module Para
     end
 
     initializer 'Extend paperclip attachment definition' do
-      return unless Kernel.const_defined?('Paperclip')
+      next unless Kernel.const_defined?('Paperclip')
 
       ActiveSupport.on_load(:active_record) do
         ::Paperclip::HasAttachedFile.send(
@@ -39,7 +39,7 @@ module Para
     end
 
     initializer 'Extend cancan ControllerResource class' do
-      return unless Kernel.const_defined?('CanCan')
+      next unless Kernel.const_defined?('CanCan')
 
       ActiveSupport.on_load(:active_record) do
         ::CanCan::ControllerResource.send(
@@ -56,6 +56,14 @@ module Para
       end
     end
 
+    initializer 'Extend active job status\' status class' do
+      ActiveSupport.on_load(:active_job) do
+        ::ActiveJob::Status::Status.send(
+          :include, Para::Ext::ActiveJob::StatusMixin
+        )
+      end
+    end
+
     initializer 'Build components tree' do |app|
       components_config_path = Rails.root.join('config', 'components.rb')
 
@@ -65,7 +73,32 @@ module Para
     end
 
     initializer 'Load page sections' do |app|
-      Para::Page::Section.eager_load!
+      app.config.to_prepare do
+        Para::Page::Section.eager_load!
+      end
+    end
+
+    initializer 'Check for extensions installation' do
+      Para::PostgresExtensionsChecker.check_all
+    end
+
+    initializer 'Configure ActiveJob' do
+      if ActiveSupport::Cache::NullStore === ActiveJob::Status.store
+        ActiveJob::Status.store = :memory_store
+      end
+
+      Para::Logging::ActiveJobLogSubscriber.attach_to :active_job
+    end
+
+    # Allow generating resources in the gem without having all the unnecessary
+    # files generated
+    #
+    config.generators do |generators|
+      generators.skip_routes     true if generators.respond_to?(:skip_routes)
+      generators.helper          false
+      generators.stylesheets     false
+      generators.javascripts     false
+      generators.test_framework  false
     end
   end
 end

data/lib/para/ext/active_job_status.rb

@@ -0,0 +1,13 @@
+module Para
+  module Ext
+    module ActiveJob
+      module StatusMixin
+        extend ActiveSupport::Concern
+
+        included do
+          delegate :failed?, to: :status_inquiry
+        end
+      end
+    end
+  end
+end

data/lib/para/ext/paperclip.rb

@@ -78,3 +78,13 @@ module Para
     end
   end
 end
+
+require 'paperclip/media_type_spoof_detector'
+
+module Paperclip
+  class MediaTypeSpoofDetector
+    def spoofed?
+      false
+    end
+  end
+end

data/lib/para/ext/simple_form_extension.rb

@@ -14,6 +14,12 @@ module Para
               return name
             end
           end
+
+          if option.respond_to?(:model_name)
+            [option.model_name.human, option.id].join(' - ')
+          else
+            option.to_s
+          end
         end
       end
     end

data/lib/para/ext.rb

@@ -12,3 +12,4 @@ end
 require 'para/ext/cancan'
 require 'para/ext/paperclip'
 require 'para/ext/simple_form_extension'
+require 'para/ext/active_job_status'

data/lib/para/form_builder/nested_form.rb

@@ -56,7 +56,7 @@ module Para
         return false unless nested?
 
         reflection = parent_object.class.reflect_on_association(nested_attribute_name)
-        reflection && (reflection.options[:inverse_of] == field_name)
+        reflection && (reflection.options[:inverse_of].to_s == field_name.to_s)
       end
 
       def nested?
@@ -64,7 +64,10 @@ module Para
       end
 
       def nested_attribute_name
-        options[:nested_attribute_name]
+        options[:nested_attribute_name] ||=
+          if (match = object_name.match(/\[(\w+)_attributes\]/))
+            match[1]
+          end
       end
 
       def parent_object

data/lib/para/importer/base.rb

@@ -1,23 +1,100 @@
 module Para
   module Importer
-    class Base
-      attr_reader :sheet
+    class Base < ActiveJob::Base
+      include ActiveJob::Status
+      # Used to store import errors on the object
+      include ActiveModel::Validations
+      # Used to translate importer name with rails default `activemodel` i18n keys
+      extend  ActiveModel::Naming
 
-      def initialize(file)
-        @sheet = Roo::Spreadsheet.open(file.path)
-      end
+      rescue_from Exception, with: :rescue_exception
+
+      class_attribute :allows_import_errors
+
+      attr_reader :file, :sheet
+
+      def perform(file, options = {})
+        @file = file
+        @sheet = Roo::Spreadsheet.open(file.attachment_path, options)
+        progress.total = sheet.last_row - 1
 
-      def run
         ActiveRecord::Base.transaction do
           (2..(sheet.last_row)).each do |index|
-            import_from_row(sheet.row(index))
+            begin
+              progress.increment
+              import_from_row(sheet.row(index))
+            rescue ActiveRecord::RecordInvalid => error
+              if allows_import_errors?
+                add_errors_from(index, error.record)
+              else
+                raise
+              end
+            end
           end
         end
+
+        status.update(errors: errors.full_messages)
       end
 
+      private
+
       def import_from_row(row)
         raise '#import_from_row(row) must be defined'
       end
+
+      def add_errors_from(index, record)
+        # The file's row number starts at 1 and headers are striped, so we
+        # add 2 to the index to obtain the row number
+        row_name = I18n.t('para.import.row_error_prefix', number: index)
+
+        record.errors.messages.each do |attribute, messages|
+          messages.each do |message|
+            full_message = record.errors.full_message(attribute, message)
+
+            if (value = record.send(attribute)).presence
+              full_message << ' (<b>' <<  value << '</b>)'
+            end
+
+            errors.add(row_name, full_message)
+          end
+        end
+      end
+
+      def allows_import_errors?
+        !!self.class.allows_import_errors
+      end
+
+      def self.allow_import_errors!
+        self.allows_import_errors = true
+      end
+
+      def headers
+        @headers ||= sheet.row(1)
+      end
+
+      def rescue_exception(exception)
+        status.update(status: :failed)
+
+        tag_logger(self.class.name, self.job_id) do
+          ActiveSupport::Notifications.instrument "failed.active_job",
+              adapter: self.class.queue_adapter, job: self, exception: exception
+        end
+
+        if defined?(ExceptionNotifier)
+          ExceptionNotifier.notify_exception(
+            exception, data: {
+              importer: self.class.name,
+              payload: {
+                file_type: file.class,
+                file_id: file.id,
+                file_name: file.attachment_file_name
+              }
+            }
+          )
+        end
+
+        raise exception
+      end
     end
   end
 end

data/lib/para/inputs/nested_many_input.rb

@@ -11,7 +11,7 @@ module Para
         # Load existing resources
         resources = object.send(attribute_name)
         # Order them if the list should be orderable
-        resources = resources.order(:position) if orderable
+        resources = resources.sort_by(&:position) if orderable
 
         locals = options.fetch(:locals, {})
 

data/lib/para/logging/active_job_log_subscriber.rb

@@ -0,0 +1,48 @@
+module Para
+  module Logging
+    class ActiveJobLogSubscriber < ActiveSupport::LogSubscriber
+      def failed(event)
+        fatal do
+          job = event.payload[:job]
+          buffer = []
+          buffer << "#{ job.class.name } (Job ID: #{ job.job_id }) failed" + args_info(job)
+          buffer << ''
+          buffer << [event.payload[:exception].class, event.payload[:exception].message].join(' - ')
+          buffer << ''
+          buffer << '-------------------'
+          buffer << ''
+          buffer += event.payload[:exception].backtrace
+          buffer << ''
+          buffer.compact.join("\n")
+        end
+      end
+
+      private
+
+      def args_info(job)
+        if job.arguments.any?
+          ' with arguments: ' +
+            job.arguments.map { |arg| format(arg).inspect }.join(', ')
+        end
+      end
+
+      def format(arg)
+        case arg
+        when Hash
+          arg.transform_values { |value| format(value) }
+        when Array
+          arg.map { |value| format(value) }
+        when GlobalID::Identification
+          arg.to_global_id rescue arg
+        else
+          arg
+        end
+      end
+
+      def logger
+        ActiveJob::Base.logger
+      end
+    end
+  end
+end
+

data/lib/para/logging.rb

@@ -0,0 +1,8 @@
+module Para
+  module Logging
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveJobLogSubscriber
+  end
+end
+

data/lib/para/markup/resources_table.rb

@@ -79,8 +79,6 @@ module Para
           field_name = nil
         end
 
-        sort = options.delete(:sort) || field_name
-
         label = if Symbol === field_name
           model.human_attribute_name(field_name)
         elsif block
@@ -90,7 +88,7 @@ module Para
         end
 
         content_tag(:th, options) do
-          if sort != field_name
+          if (sort = options.delete(:sort))
               view.sort_link(search, *sort, label, hide_indicator: true)
           elsif searchable?(field_name)
             view.sort_link(search, field_name, label, hide_indicator: true)
@@ -155,7 +153,7 @@ module Para
         }
 
         view.link_to(path, options) do
-          content_tag(:i, '', class: 'fa fa-refresh')
+          content_tag(:i, '', class: 'fa fa-copy')
         end
       end
 

data/lib/para/model_field_parsers/enums.rb

@@ -0,0 +1,19 @@
+module Para
+  module ModelFieldParsers
+    class Enums < Para::ModelFieldParsers::Base
+      register :enums, self
+
+      def parse!
+        model.defined_enums.each do |key, _|
+          fields_hash[key] = AttributeField::EnumField.new(
+            model, name: key, type: 'enum'
+          )
+        end
+      end
+
+      def applicable?
+        model.respond_to?(:defined_enums) && !model.defined_enums.empty?
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/relations.rb

@@ -38,7 +38,7 @@ module Para
               fields_hash[name] = AttributeField::HasManyField.new(
                 model, name: name, type: 'has_many', field_type: 'selectize'
               )
-            else
+            elsif !reflection.options[:through]
               fields_hash[name] = AttributeField::BelongsToField.new(
                 model, name: name, type: 'belongs_to', field_type: 'selectize'
               )

data/lib/para/model_field_parsers/store.rb

@@ -14,7 +14,7 @@ module Para
 
           field_names.each do |field_name|
             fields_hash[field_name] = AttributeField::Base.new(
-              model, name: field_name, type: :string
+              model, name: field_name, type: :string, searchable: false
             )
           end
         end

data/lib/para/model_field_parsers.rb

@@ -21,3 +21,4 @@ require 'para/model_field_parsers/relations'
 require 'para/model_field_parsers/redactor'
 require 'para/model_field_parsers/globalize'
 require 'para/model_field_parsers/store'
+require 'para/model_field_parsers/enums'

data/lib/para/plugins/routes.rb

@@ -13,10 +13,8 @@ module Para
         router = self.router
 
         router.instance_eval do
-          namespace :admin do
-            scope module: [:para, identifier].join('/').to_sym, as: identifier do
-              router.instance_eval(&block)
-            end
+          scope module: [:para, identifier].join('/').to_sym do
+            router.instance_eval(&block)
           end
         end
       end

data/lib/para/postgres_extensions_checker.rb

@@ -0,0 +1,30 @@
+module Para
+  class PostgresExtensionsChecker
+    class << self
+      def check_all
+        %w(hstore unaccent).each do |extname|
+          unless extension_exists?(extname)
+            # Could not use Rails.logger here, using puts as a temporary
+            # solution.
+            puts "[Warning] PostgreSQL \"#{ extname }\" extension is not " +
+                 "installed in your database. This means that you " +
+                 "missing some migrations that you can install " +
+                 "with the following command : " +
+                 "`rake para_engine:install:migrations` and then migrate."
+          end
+        end
+      end
+
+      private
+
+      def extension_exists?(extname)
+        ActiveRecord::Base.connection.execute(
+          "SELECT COUNT(*) FROM pg_catalog.pg_extension " +
+          "WHERE extname = '#{ extname }'"
+        ).first['count'].to_i > 0
+      rescue ActiveRecord::NoDatabaseError
+        true # Do not issue warning when no database is installed
+      end
+    end
+  end
+end

data/lib/para/routes.rb

@@ -14,11 +14,12 @@ module Para
           scope module: :para do
             namespace :admin do
               get '/' => 'main#index'
-
-              crud_component :crud, scope: ':model'
-              singleton_resource_component :singleton, scope: ':model'
-              component :settings
             end
+
+            # Components are namespaced into :admin in their respective methods
+            crud_component
+            form_component
+            component :settings
           end
 
           block.call if block

data/lib/para/routing/component_controller_constraint.rb

@@ -0,0 +1,36 @@
+# Allows constraining routing to components that explicitly declares to use a
+# given controller to manage their resources.
+#
+# It's mainly used to allow users to override the default controller for the
+# resources of a given Crud or Form components without having to
+# subclass the component and declare all the routes again
+#
+module Para
+  module Routing
+    class ComponentControllerConstraint
+      attr_reader :controller
+
+      def initialize(controller)
+        @controller = controller.to_sym
+      end
+
+      def matches?(request)
+        component = component_for(request.params[:component_id])
+        return false unless component
+        component.controller.to_sym == controller
+      end
+
+      private
+
+      def component_for(component_slug)
+        self.class.components[component_slug] ||= Para::Component::Base.find_by_slug(component_slug)
+      end
+
+      # Request based components cache
+      #
+      def self.components
+        RequestStore.store['para.components_by_id'] ||= {}
+      end
+    end
+  end
+end

data/lib/para/routing.rb

@@ -0,0 +1,7 @@
+module Para
+  module Routing
+    extend ActiveSupport::Autoload
+
+    autoload :ComponentControllerConstraint
+  end
+end

data/lib/para/sti/root_model.rb

@@ -16,8 +16,8 @@ module Para
 
       module ClassMethods
         def eager_load!
-          return if @eager_loaded
-          @eager_loaded = true
+          return if RequestStore.store[descendants_eager_load_key]
+          RequestStore.store[descendants_eager_load_key] = true
 
           models_dir = Rails.root.join('app', 'models')
 
@@ -38,6 +38,12 @@ module Para
 
         private
 
+        def descendants_eager_load_key
+          @descendants_eager_load_key ||= [
+            'para', 'root_model', 'descendants_eager_loaded', name
+          ].join(':')
+        end
+
         # Allows the including class to define `.subclasses_namespace` class
         # method to override the namespace and directory used to eager load the
         # subclasses.

data/lib/para/version.rb

@@ -1,3 +1,3 @@
 module Para
-  VERSION = "0.5.4"
+  VERSION = '0.6.2'
 end