para 0.7.1 → 0.7.2

data/lib/para/inputs/nested_one_input.rb

@@ -1,17 +1,21 @@
 module Para
   module Inputs
-    class NestedOneInput < SimpleForm::Inputs::Base
+    class NestedOneInput < NestedBaseInput
       def input(wrapper_options = nil)
         input_html_options[:class] << "nested-one"
 
         parent_model = object.class
         association = object.association(attribute_name)
         relation = parent_model.reflect_on_association(attribute_name)
-        model = relation.klass
 
-        unless (resource = object.send(:"#{ attribute_name }"))
+        resource = object.send(attribute_name)
+        model = (resource && resource.class) || relation.klass
+
+        unless resource
           # Build association without trying to save the new record
           resource = case association
+          when ActiveRecord::Associations::HasOneThroughAssociation
+            association.replace(model.new)
           when ActiveRecord::Associations::HasOneAssociation
             association.replace(model.new, false)
           else
@@ -19,16 +23,26 @@ module Para
           end
         end
 
+        locals = options.fetch(:locals, {})
+
         template.render(
           partial: 'para/inputs/nested_one',
           locals: {
             form: @builder,
             model: model,
             resource: resource,
-            attribute_name: attribute_name
+            attribute_name: attribute_name,
+            nested_locals: locals,
+            collapsible: collapsible
           }
         )
       end
+
+      private
+
+      def collapsible
+        options.fetch(:collapsible, false)
+      end
     end
   end
 end

data/lib/para/inputs.rb

@@ -2,6 +2,7 @@ module Para
   module Inputs
     extend ActiveSupport::Autoload
 
+    autoload :NestedBaseInput
     autoload :NestedOneInput
     autoload :NestedManyInput
     autoload :MultiSelectInput

data/lib/para/log_config.rb

@@ -0,0 +1,14 @@
+module Para
+  class LogConfig
+    def self.with_log_level(level, &block)
+      begin
+        log_level = Rails.logger.level
+        Rails.logger.level = :fatal
+
+        block.call
+      ensure
+        Rails.logger.level = log_level
+      end
+    end
+  end
+end

data/lib/para/markup/resources_table.rb

@@ -169,7 +169,7 @@ module Para
       end
 
       def delete_button(resource)
-        path = component.relation_path(resource)
+        path = component.relation_path(resource, return_to: view.request.fullpath)
 
         options = {
           method: :delete,
@@ -178,7 +178,7 @@ module Para
           },
           class: 'btn btn-sm btn-icon-danger btn-shadow hint--left',
           aria: {
-            label: ::I18n.t('para.shared.destroy')  
+            label: ::I18n.t('para.shared.destroy')
           }
         }
 

data/lib/para/model_field_parsers/relations.rb

@@ -11,13 +11,24 @@ module Para
           )
         end
 
-        # Catch multi select inputs from form attributes mappings
         find_attributes_for_mapping(:nested_many).each do |attribute|
           fields_hash[attribute] = AttributeField::NestedManyField.new(
             model, name: attribute, type: 'has_many', field_type: 'nested_many'
           )
         end
 
+        find_attributes_for_mapping(:nested_one).each do |attribute|
+          fields_hash[attribute] = AttributeField::NestedOneField.new(
+            model, name: attribute, type: 'has_one', field_type: 'nested_one'
+          )
+        end
+
+        find_attributes_for_mapping(:selectize).each do |attribute|
+          fields_hash[attribute] = AttributeField::BelongsToField.new(
+            model, name: attribute, type: 'belongs_to', field_type: 'selectize'
+          )
+        end
+
         model.reflections.each do |name, reflection|
           # We ensure that name is a symbol and not a string for 4.2+
           # versions of AR

data/lib/para/page/model.rb

@@ -6,7 +6,8 @@ module Para
       included do
         has_many :sections, -> { ordered }, class_name: '::Para::Page::Section',
                                             as: :page,
-                                            dependent: :destroy
+                                            dependent: :destroy,
+                                            inverse_of: :page
         accepts_nested_attributes_for :sections, allow_destroy: true
       end
     end

data/lib/para/postgres_extensions_checker.rb

@@ -2,15 +2,17 @@ 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."
+        Para::LogConfig.with_log_level(:fatal) do
+          %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
       end
@@ -18,10 +20,12 @@ module Para
       private
 
       def extension_exists?(extname)
-        ActiveRecord::Base.connection.execute(
+        result = ActiveRecord::Base.connection.execute(
           "SELECT COUNT(*) FROM pg_catalog.pg_extension " +
           "WHERE extname = '#{ extname }'"
-        ).first['count'].to_i > 0
+        ).first
+
+        result && result['count'].to_i > 0
       rescue ActiveRecord::NoDatabaseError
         true # Do not issue warning when no database is installed
       end

data/lib/para/routes.rb

@@ -18,9 +18,9 @@ module Para
             end
 
             # Components are namespaced into :admin in their respective methods
-            crud_component
-            form_component
-            component :settings
+            crud_component scoped_in_para: true
+            form_component scoped_in_para: true
+            component :settings, scoped_in_para: true
           end
 
           block.call if block

data/lib/para/search/distinct.rb

@@ -17,7 +17,7 @@ module Para
 
       def result
         selects = build_selects
-        search.result.select(selects).uniq
+        search.result.select(selects).distinct
       end
 
       private

data/lib/para/version.rb

@@ -1,3 +1,3 @@
 module Para
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

data/lib/para.rb

@@ -33,6 +33,7 @@ require 'vertebra'
 require 'rails/routing_mapper'
 require 'rails/relation_length_validator'
 
+require 'para/log_config'
 require 'para/postgres_extensions_checker'
 
 module Para
@@ -50,6 +51,7 @@ module Para
     autoload :Breadcrumbs
     autoload :Cache
     autoload :Logging
+    autoload :IframeTransport
   end
 
   def self.config(&block)

data/lib/rails/routing_mapper.rb

@@ -20,8 +20,6 @@ module ActionDispatch
         )
 
         controller = options.fetch(:controller, "#{ component_name }_component")
-        imports_controller = options.fetch(:imports_controller, '/para/admin/imports')
-        exports_controller = options.fetch(:exports_controller, '/para/admin/exports')
 
         constraints Para::Routing::ComponentNameConstraint.new(component) do
           namespace :admin do
@@ -33,13 +31,7 @@ module ActionDispatch
               instance_eval(&block) if block
               add_extensions_for(:component)
 
-              scope ':importer' do
-                resources :imports, controller: imports_controller
-              end
-
-              scope ':exporter' do
-                resources :exports, controller: exports_controller
-              end
+              common_component_routes(options)
             end
           end
         end
@@ -60,8 +52,6 @@ module ActionDispatch
         # namespacing issues in plugins and other module namespaced scenarios
         #
         controller = options.fetch(:controller, '/para/admin/crud_resources')
-        imports_controller = options.fetch(:imports_controller, '/para/admin/imports')
-        exports_controller = options.fetch(:exports_controller, '/para/admin/exports')
 
         constraints Para::Routing::ComponentNameConstraint.new(component) do
           constraints Para::Routing::ComponentControllerConstraint.new(controller) do
@@ -82,13 +72,7 @@ module ActionDispatch
                     add_extensions_for(:crud_component)
                   end
 
-                  scope ':importer' do
-                    resources :imports, controller: imports_controller
-                  end
-
-                  scope ':exporter' do
-                    resources :exports, controller: exports_controller
-                  end
+                  common_component_routes(options)
                 end
               end
             end
@@ -108,8 +92,6 @@ module ActionDispatch
         )
 
         controller = options.fetch(:controller, '/para/admin/form_resources')
-        imports_controller = options.fetch(:imports_controller, '/para/admin/imports')
-        exports_controller = options.fetch(:exports_controller, '/para/admin/exports')
 
         constraints Para::Routing::ComponentNameConstraint.new(component) do
           constraints Para::Routing::ComponentControllerConstraint.new(controller) do
@@ -119,13 +101,7 @@ module ActionDispatch
                   add_extensions_for(:form_component)
                 end
 
-                scope ':importer' do
-                  resources :imports, controller: imports_controller
-                end
-
-                scope ':exporter' do
-                  resources :exports, controller: exports_controller
-                end
+                common_component_routes(options)
               end
             end
           end
@@ -159,6 +135,22 @@ module ActionDispatch
           instance_eval(&extension)
         end
       end
+
+      def common_component_routes(options)
+        nested_forms_controller = options.fetch(:nested_forms_controller, '/para/admin/nested_forms')
+        imports_controller = options.fetch(:imports_controller, '/para/admin/imports')
+        exports_controller = options.fetch(:exports_controller, '/para/admin/exports')
+
+        resource 'nested_form', controller: nested_forms_controller, only: [:show]
+
+        scope ':importer' do
+          resources :imports, controller: imports_controller
+        end
+
+        scope ':exporter' do
+          resources :exports, controller: exports_controller
+        end
+      end
     end
   end
 end

data/vendor/assets/javascripts/jquery.iframe-transport.js

@@ -0,0 +1,260 @@
+// This [jQuery](https://jquery.com/) plugin implements an `<iframe>`
+// [transport](https://api.jquery.com/jQuery.ajax/#extending-ajax) so that
+// `$.ajax()` calls support the uploading of files using standard HTML file
+// input fields. This is done by switching the exchange from `XMLHttpRequest`
+// to a hidden `iframe` element containing a form that is submitted.
+
+// The [source for the plugin](https://github.com/cmlenz/jquery-iframe-transport)
+// is available on [Github](https://github.com/) and licensed under the [MIT
+// license](https://github.com/cmlenz/jquery-iframe-transport/blob/master/LICENSE).
+
+// ## Usage
+
+// To use this plugin, you simply add an `iframe` option with the value `true`
+// to the Ajax settings an `$.ajax()` call, and specify the file fields to
+// include in the submssion using the `files` option, which can be a selector,
+// jQuery object, or a list of DOM elements containing one or more
+// `<input type="file">` elements:
+
+//     $("#myform").submit(function() {
+//         $.ajax(this.action, {
+//             files: $(":file", this),
+//             iframe: true
+//         }).complete(function(data) {
+//         });
+//     });
+
+// The plugin will construct hidden `<iframe>` and `<form>` elements, add the
+// file field(s) to that form, submit the form, and process the response.
+
+// If you want to include other form fields in the form submission, include
+// them in the `data` option, and set the `processData` option to `false`:
+
+//     $("#myform").submit(function() {
+//         $.ajax(this.action, {
+//             data: $(":text", this).serializeArray(),
+//             files: $(":file", this),
+//             iframe: true,
+//             processData: false
+//         }).complete(function(data) {
+//         });
+//     });
+
+// ### Response Data Types
+
+// As the transport does not have access to the HTTP headers of the server
+// response, it is not as simple to make use of the automatic content type
+// detection provided by jQuery as with regular XHR. If you can't set the
+// expected response data type (for example because it may vary depending on
+// the outcome of processing by the server), you will need to employ a
+// workaround on the server side: Send back an HTML document containing just a
+// `<textarea>` element with a `data-type` attribute that specifies the MIME
+// type, and put the actual payload in the textarea:
+
+//     <textarea data-type="application/json">
+//       {"ok": true, "message": "Thanks so much"}
+//     </textarea>
+
+// The iframe transport plugin will detect this and pass the value of the
+// `data-type` attribute on to jQuery as if it was the "Content-Type" response
+// header, thereby enabling the same kind of conversions that jQuery applies
+// to regular responses. For the example above you should get a Javascript
+// object as the `data` parameter of the `complete` callback, with the
+// properties `ok: true` and `message: "Thanks so much"`.
+
+// ### Handling Server Errors
+
+// Another problem with using an `iframe` for file uploads is that it is
+// impossible for the javascript code to determine the HTTP status code of the
+// servers response. Effectively, all of the calls you make will look like they
+// are getting successful responses, and thus invoke the `done()` or
+// `complete()` callbacks. You can only communicate problems using the content
+// of the response payload. For example, consider using a JSON response such as
+// the following to indicate a problem with an uploaded file:
+
+//     <textarea data-type="application/json">
+//       {"ok": false, "message": "Please only upload reasonably sized files."}
+//     </textarea>
+
+// ### Compatibility
+
+// This plugin has primarily been tested on Safari 5 (or later), Firefox 4 (or
+// later), and Internet Explorer (all the way back to version 6). While I
+// haven't found any issues with it so far, I'm fairly sure it still doesn't
+// work around all the quirks in all different browsers. But the code is still
+// pretty simple overall, so you should be able to fix it and contribute a
+// patch :)
+
+// ## Annotated Source
+
+(function($, undefined) {
+  // Register a prefilter that checks whether the `iframe` option is set, and
+  // switches to the "iframe" data type if it is `true`.
+  $.ajaxPrefilter(function(options, origOptions, jqXHR) {
+    if (options.iframe) {
+      options.originalURL = options.url;
+      return "iframe";
+    }
+  });
+
+  // Register a transport for the "iframe" data type. It will only activate
+  // when the "files" option has been set to a non-empty list of enabled file
+  // inputs.
+  $.ajaxTransport("iframe", function(options, origOptions, jqXHR) {
+    var form = null,
+        iframe = null,
+        name = "iframe-" + $.now(),
+        files = $(options.files).filter(":file:enabled"),
+        markers = null,
+        accepts = null;
+
+
+    // This function gets called after a successful submission or an abortion
+    // and should revert all changes made to the page to enable the
+    // submission via this transport.
+    function cleanUp() {
+      files.each(function(i, file) {
+        var $file = $(file);
+        $file.data("clone").replaceWith($file);
+      });
+      form.remove();
+      iframe.one("load", function() { iframe.remove(); });
+      iframe.attr("src", "about:blank");
+    }
+
+    // Remove "iframe" from the data types list so that further processing is
+    // based on the content type returned by the server, without attempting an
+    // (unsupported) conversion from "iframe" to the actual type.
+    options.dataTypes.shift();
+
+    // Use the data from the original AJAX options, as it doesn't seem to be
+    // copied over since jQuery 1.7.
+    // See https://github.com/cmlenz/jquery-iframe-transport/issues/6
+    options.data = origOptions.data;
+
+    if (files.length) {
+      form = $("<form enctype='multipart/form-data' method='post'></form>").
+        hide().attr({action: options.originalURL, target: name});
+
+      // If there is any additional data specified via the `data` option,
+      // we add it as hidden fields to the form. This (currently) requires
+      // the `processData` option to be set to false so that the data doesn't
+      // get serialized to a string.
+      if (typeof(options.data) === "string" && options.data.length > 0) {
+        $.error("data must not be serialized");
+      }
+      $.each(options.data || {}, function(name, value) {
+        if ($.isPlainObject(value)) {
+          name = value.name;
+          value = value.value;
+        }
+
+
+        $("<input type='hidden' />").attr({name:  name, value: value}).
+          appendTo(form);
+      });
+
+      // Add a hidden `X-Requested-With` field with the value `IFrame` to the
+      // field, to help server-side code to determine that the upload happened
+      // through this transport.
+      $("<input type='hidden' value='IFrame' name='X-Requested-With' />").
+        appendTo(form);
+
+      // ----------------------------------------------------------------------
+      //   Modified section
+      // ----------------------------------------------------------------------
+
+      // Add CSRF token to the form since jquery-ujs adds it to the XHR request
+      // headers and the iframe transport doesn't support them
+      $("<input type='hidden' />").attr({name: $.rails.csrfParam(), value: $.rails.csrfToken()}).
+          appendTo(form);
+
+      // ----------------------------------------------------------------------
+      //   End of modified section
+      // ----------------------------------------------------------------------
+
+      // Borrowed straight from the JQuery source.
+      // Provides a way of specifying the accepted data type similar to the
+      // HTTP "Accept" header
+      if (options.dataTypes[0] && options.accepts[options.dataTypes[0]]) {
+        accepts = options.accepts[options.dataTypes[0]] +
+                  (options.dataTypes[0] !== "*" ? ", */*; q=0.01" : "");
+      } else {
+        accepts = options.accepts["*"];
+      }
+      $("<input type='hidden' name='X-HTTP-Accept'>").
+        attr("value", accepts).appendTo(form);
+
+      // Move the file fields into the hidden form, but first remember their
+      // original locations in the document by replacing them with disabled
+      // clones. This should also avoid introducing unwanted changes to the
+      // page layout during submission.
+      markers = files.after(function(idx) {
+        var $this = $(this),
+            $clone = $this.clone().prop("disabled", true);
+        $this.data("clone", $clone);
+        return $clone;
+      }).next();
+      files.appendTo(form);
+
+      return {
+
+        // The `send` function is called by jQuery when the request should be
+        // sent.
+        send: function(headers, completeCallback) {
+          iframe = $("<iframe src='about:blank' name='" + name +
+            "' id='" + name + "' style='display:none'></iframe>");
+
+          // The first load event gets fired after the iframe has been injected
+          // into the DOM, and is used to prepare the actual submission.
+          iframe.one("load", function() {
+
+            // The second load event gets fired when the response to the form
+            // submission is received. The implementation detects whether the
+            // actual payload is embedded in a `<textarea>` element, and
+            // prepares the required conversions to be made in that case.
+            iframe.one("load", function() {
+              var doc = this.contentWindow ? this.contentWindow.document :
+                (this.contentDocument ? this.contentDocument : this.document),
+                root = doc.documentElement ? doc.documentElement : doc.body,
+                dataInput = $(root).find("[data-iframe-response-data]").remove()[0],
+                type = dataInput && dataInput.getAttribute("data-type") || null,
+                status = (dataInput && dataInput.getAttribute("data-status")) || 200,
+                statusText = dataInput && dataInput.getAttribute("data-statusText") || "OK",
+                content = {
+                  html: root.innerHTML,
+                  text: root ? (root.textContent || root.innerText) : null
+                };
+
+              jqXHR.responseText = content.html;
+
+              cleanUp();
+              completeCallback(status, statusText, content, type ?
+                ("Content-Type: " + type) :
+                null);
+            });
+
+            // Now that the load handler has been set up, submit the form.
+            form[0].submit();
+          });
+
+          // After everything has been set up correctly, the form and iframe
+          // get injected into the DOM so that the submission can be
+          // initiated.
+          $("body").append(form, iframe);
+        },
+
+        // The `abort` function is called by jQuery when the request should be
+        // aborted.
+        abort: function() {
+          if (iframe !== null) {
+            iframe.unbind("load").attr("src", "about:blank");
+            cleanUp();
+          }
+        }
+
+      };
+    }
+  });
+
+})(jQuery);