rexport 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b93bfa7c3dea7a0a9df8dce1e59681aa8de412825556ad9c8b1c743d08c29b
-  data.tar.gz: ac601552d8d3b65b106bab210dc142eda8d88fc489742021100364f1dfc0707b
+  metadata.gz: 645738a1ea2afb2feee13d71a5c4e5e01ce10fe6e872f1bb5f01077e6db05638
+  data.tar.gz: 37c36f6d85dd9a877e8e8de45642c3e8536aab04c71ea1aeb231abf750ed24f5
 SHA512:
-  metadata.gz: 85cb6d95f199755c44ade632a1cedbe3c6c8834a9d9da9ea1938d1749ee3a4f7045b4fa5ccc091245c0c6471cf24a0d435964621fc93f4f7ab431e4eb8bf2a01
-  data.tar.gz: e69b135131c1484152e10cfc4e0b580888b308084c06b050962dd690dc6917e730be489dedb88265e218ea11ca75635e6d375f89b5c77de84f7800985f901c49
+  metadata.gz: 9f9b3fcc9a4823a79ea2341aa22d918acd1fbad669d6eae62fec6fcc386923f49616d977745bfd81a179b92c3b9fdc65b058c53bf8cb1d9f4cfe6e66e9f41546
+  data.tar.gz: 19f28b327e48fcf962f17bd91c3100dd6bd912872ed822d6cb8ce2224ca4985d36d448a5af0895dcc0bceef803fd1719310deab6e402af2e9d87415adfa25f12

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/setup"
 
 require "bundler/gem_tasks"

data/app/helpers/exports_helper.rb

@@ -1,28 +1,50 @@
+# frozen_string_literal: true
+
 module ExportsHelper
+  BOOLEAN_OPTIONS = [nil, ["true", 1], ["false", 0]].freeze
+  FORM_TAG_CLASS = "form-control"
+
   def filter_value_field(rexport_model, field)
+    ActiveSupport::Deprecation.warn(
+      "Calling #filter_value_field is deprecated. Use #rexport_filter_form_tag instead"
+    )
+    rexport_filter_tag(@export, rexport_model, field) # rubocop:disable Rails/HelperInstanceVariable
+  end
+
+  def rexport_filter_tag(export, rexport_model, field) # rubocop:disable Metrics/MethodLength
     filter_field = rexport_model.field_path(rexport_model.filter_column(field))
-    tag_name = "export[export_filter_attributes][#{filter_field.to_s}]"
-    value = @export.filter_value(filter_field)
+    tag_name = "export[export_filter_attributes][#{filter_field}]"
+    value = export.filter_value(filter_field)
 
     case field.type
-    when :boolean
-      select_tag(tag_name, options_for_select([nil, ['true', 1], ['false', 0]], (value.to_i unless value.nil?)), class: 'form-control')
     when :association
-      association, text_method = field.method.split('.')
-      select_tag(tag_name,
-        ('<option value=""></option>' +
-        options_from_collection_for_select(
+      association, text_method = field.method.split(".")
+      association_filter_select_tag(
+        tag_name,
+        association_filter_options(
           rexport_model.collection_from_association(association),
-          :id,
           text_method,
-          value.to_i
-        )).html_safe,
-        class: 'form-control'
+          value
+        )
       )
-    when :datetime, nil
-      '&nbsp;'.html_safe
-    else
-      text_field_tag(tag_name, value, class: 'form-control')
+    when :boolean
+      boolean_filter_select_tag(tag_name, value)
+    when :date, :integer, :string
+      text_field_tag(tag_name, value, class: FORM_TAG_CLASS)
     end
   end
+
+  private
+
+  def boolean_filter_select_tag(tag_name, value)
+    select_tag(tag_name, options_for_select(BOOLEAN_OPTIONS, value&.to_i), class: FORM_TAG_CLASS)
+  end
+
+  def association_filter_options(collection, text_method, value)
+    options_from_collection_for_select(collection, :id, text_method, value&.to_i)
+  end
+
+  def association_filter_select_tag(tag_name, options)
+    select_tag(tag_name, options, include_blank: true, class: FORM_TAG_CLASS)
+  end
 end

data/app/views/exports/_rexport_model.html.erb

@@ -7,10 +7,10 @@
   </tr>
   <% for field in rexport_model.rexport_fields_array %>
     <tr class="<%= cycle('odd','even') %>">
-      <td><%= check_box_tag "export[rexport_fields][#{rexport_model.field_path(field.name)}]", 1, @export.has_rexport_field?(rexport_model.field_path(field.name))  %></td>
+      <td><%= check_box_tag "export[rexport_fields][#{rexport_model.field_path(field.name)}]", 1, @export.rexport_field?(rexport_model.field_path(field.name)) %></td>
       <td class="row_title"><%= field.name.titleize %></td>
       <td class='row_title'>
-        <%= filter_value_field(rexport_model, field) %>
+        <%= rexport_filter_tag(@export, rexport_model, field) %>
       </td>
     </tr>
   <% end %>

data/config/routes.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 Rails.application.routes.draw do
   # singleton resources
   resource :export_item_sorting,  only: :update
 
   # collection resources
-  resources :export_items,        only: %i(edit update destroy)
-  resources :export_filters,      only: %i(edit update destroy)
+  resources :export_items,        only: %i[edit update destroy]
+  resources :export_filters,      only: %i[edit update destroy]
   resources :exports do
     resources :export_filters, only: :new
   end

data/lib/rexport/data_field.rb

@@ -1,17 +1,38 @@
+# frozen_string_literal: true
+
 module Rexport
   class DataField
     include Comparable
-    attr_accessor :name, :method, :type
+    attr_reader :name, :method, :type
 
     # Stores the name and method of the export data item
     def initialize(name, options = {})
-      self.name = name.to_s
-      self.method = options[:method].blank? ? self.name : options[:method].to_s
-      self.type = options[:type]
+      @name   = name.to_s
+      @method = options[:method].blank? ? self.name : options[:method].to_s
+      @type   = options[:type]
+    end
+
+    # Sort by name
+    def <=>(other)
+      name <=> other.name
     end
 
-    def <=>(rf)
-      self.name <=> rf.name
+    # Returns the first association name from a method chain string. If the string does not contain
+    # the dot operator a nil is returned.
+    #
+    # Examples:
+    #
+    #   "assocation.method" # => "association"
+    #   "assocation_one.assocation_two.method" # => "assocation_one"
+    #   "method" # => nil
+    def association_name
+      method[0..(first_dot_index - 1)] if first_dot_index.present?
+    end
+
+    private
+
+    def first_dot_index
+      @first_dot_index ||= method.index(".")
     end
   end
 end

data/lib/rexport/data_fields.rb

@@ -1,4 +1,6 @@
-module Rexport #:nodoc:
+# frozen_string_literal: true
+
+module Rexport # :nodoc:
   module DataFields
     extend ActiveSupport::Concern
 
@@ -7,6 +9,7 @@ module Rexport #:nodoc:
       def get_klass_from_associations(*associations)
         associations.flatten!
         return self if associations.empty?
+
         reflect_on_association(associations.shift.to_sym).klass.get_klass_from_associations(associations)
       end
     end
@@ -14,21 +17,15 @@ module Rexport #:nodoc:
     # Return an array of formatted export values for the passed methods
     def export(*methods)
       methods.flatten.map do |method|
-        case value = (eval("self.#{method}", binding) rescue nil)
-          when Date, Time
-            value.strftime("%m/%d/%y")
-          when TrueClass
-            'Y'
-          when FalseClass
-            'N'
-          else value.to_s
-        end
+        Rexport::Formatter.convert(instance_eval(method))
+      rescue NameError
+        ""
       end
     end
 
     # Returns string indicating this field is undefined
     def undefined_rexport_field
-      'UNDEFINED EXPORT FIELD'
+      "UNDEFINED EXPORT FIELD"
     end
   end
 end

data/lib/rexport/export_filter_methods.rb

@@ -1,4 +1,6 @@
-module Rexport #:nodoc:
+# frozen_string_literal: true
+
+module Rexport # :nodoc:
   module ExportFilterMethods
     extend ActiveSupport::Concern
 
@@ -12,23 +14,24 @@ module Rexport #:nodoc:
     end
 
     def attributes_for_copy
-      attributes.slice('filter_field', 'value')
+      attributes.slice("filter_field", "value")
     end
 
     private
 
     def associated_object_value
-      return 'UNDEFINED ASSOCIATION' unless filter_association
+      return "UNDEFINED ASSOCIATION" unless filter_association
+
       begin
         object = filter_association.klass.find(value)
-        return object.respond_to?(:name) ? object.name : object.to_s
+        object.respond_to?(:name) ? object.name : object.to_s
       rescue ActiveRecord::RecordNotFound
-        return 'ASSOCIATED OBJECT NOT FOUND'
+        "ASSOCIATED OBJECT NOT FOUND"
       end
     end
 
     def filter_association
-      @filter_on_assocation ||= find_filter_association
+      @filter_association ||= find_filter_association
     end
 
     def find_filter_association
@@ -42,11 +45,11 @@ module Rexport #:nodoc:
     end
 
     def filter_path
-      filter_field.split('.')[0..-2]
+      filter_field.split(".")[0..-2]
     end
 
     def filter_foreign_key
-      filter_field.split('.').last
+      filter_field.split(".").last
     end
 
     def filter_on_associated_object?

data/lib/rexport/export_filters_controller_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rexport
   module ExportFiltersControllerMethods
     def destroy

data/lib/rexport/export_item_methods.rb

@@ -1,4 +1,6 @@
-module Rexport #:nodoc:
+# frozen_string_literal: true
+
+module Rexport # :nodoc:
   module ExportItemMethods
     extend ActiveSupport::Concern
 
@@ -17,14 +19,14 @@ module Rexport #:nodoc:
       def resort(export_item_ids)
         transaction do
           export_item_ids.each_with_index do |id, index|
-            find(id.gsub(/[^0-9]/, '')).update_attribute(:position, index + 1)
+            find(id.gsub(/[^0-9]/, "")).update_attribute(:position, index + 1)
           end
         end
       end
     end
 
     def attributes_for_copy
-      attributes.slice('position', 'name', 'rexport_field')
+      attributes.slice("position", "name", "rexport_field")
     end
 
     private
@@ -34,7 +36,7 @@ module Rexport #:nodoc:
     end
 
     def generate_name_from_rexport_field
-      rexport_field.split('.').last(2).map(&:titleize).join(' - ')
+      rexport_field.split(".").last(2).map(&:titleize).join(" - ")
     end
   end
 end

data/lib/rexport/export_item_sortings_controller_methods.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Rexport
   module ExportItemSortingsControllerMethods
     def update
       ExportItem.resort(params[:sorted_items])
-    
+
       respond_to do |format|
         format.js do
           head :ok

data/lib/rexport/export_items_controller_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rexport
   module ExportItemsControllerMethods
     def edit
@@ -6,7 +8,7 @@ module Rexport
 
     def update
       if export_item.update(export_item_params)
-        redirect_to export_path(export_item.export), notice: 'ExportItem was successfully updated.'
+        redirect_to export_path(export_item.export), notice: "ExportItem was successfully updated."
       else
         render :edit
       end

data/lib/rexport/export_methods.rb

@@ -1,6 +1,8 @@
-require 'csv'
+# frozen_string_literal: true
 
-module Rexport #:nodoc:
+require "csv"
+
+module Rexport # :nodoc:
   module ExportMethods
     extend ActiveSupport::Concern
 
@@ -18,7 +20,7 @@ module Rexport #:nodoc:
 
     module ClassMethods
       def models
-        %w(override_this_method)
+        %w[override_this_method]
       end
     end
 
@@ -28,12 +30,7 @@ module Rexport #:nodoc:
 
     # Returns a string with the export data
     def to_s
-      String.new.tap do |result|
-        result << header * '|' << "\n"
-        records.each do |record|
-          result << record * '|' << "\n"
-        end
-      end
+      records.unshift(header).map { |line| line.join("|") }.join("\n")
     end
 
     # Returns a csv string with the export data
@@ -80,33 +77,35 @@ module Rexport #:nodoc:
     # Returns a class based on a path array
     def get_klass_from_path(path, klass = export_model)
       return klass unless (association_name = path.shift)
+
       get_klass_from_path(path, klass.reflect_on_association(association_name.to_sym).klass)
     end
 
-    def has_rexport_field?(rexport_field)
+    def has_rexport_field?(rexport_field) # rubocop:disable Naming/PredicateName
+      ActiveSupport::Deprecation.warn("Calling #has_rexport_field? is deprecated. Use #rexport_field? instead")
+      rexport_field?(rexport_field)
+    end
+
+    def rexport_field?(rexport_field)
       rexport_fields.include?(rexport_field)
     end
 
-    def rexport_fields=(rexport_fields)
-      @rexport_fields = if rexport_fields.respond_to?(:keys)
-        @set_position = false
-        rexport_fields.keys.map(&:to_s)
-      else
-        @set_position = true
-        rexport_fields.map(&:to_s)
-      end
+    # Stores rexport_field names to update the export_items association after save
+    # Expects fields to be a hash with field names as the keys or an array of field names:
+    # { "field_one" => "1", "field_two" => "1" }
+    # ["field_one", "field_two"]
+    def rexport_fields=(fields)
+      @rexport_fields = extract_rexport_fields(fields).map(&:to_s)
     end
 
     def export_filter_attributes=(attributes)
       attributes.each do |field, value|
         if value.blank?
-          filter = export_filters.find_by(filter_field: field)
-          filter.destroy if filter
+          export_filters.find_by(filter_field: field)&.destroy
         elsif new_record?
           export_filters.build(filter_field: field, value: value)
         else
-          filter = export_filters.find_or_create_by(filter_field: field)
-          filter.update_attribute(:value, value)
+          export_filters.find_or_create_by(filter_field: field).update_attribute(:value, value)
         end
       end
     end
@@ -140,31 +139,33 @@ module Rexport #:nodoc:
 
     def get_rexport_models(model, results = [], path = nil)
       return unless model.include?(Rexport::DataFields)
+
       results << RexportModel.new(model, path: path)
       get_associations(model).each do |associated_model|
         # prevent infinite loop by checking if this class is already in the results set
         next if results.detect { |result| result.klass == associated_model.klass }
-        get_rexport_models(associated_model.klass, results, [path, associated_model.name].compact * '.')
+
+        get_rexport_models(associated_model.klass, results, [path, associated_model.name].compact * ".")
       end
-      return results
+      results
     end
 
     def get_associations(model)
-      %i(belongs_to has_one).map do |type|
+      %i[belongs_to has_one].map do |type|
         model.reflect_on_all_associations(type)
       end.flatten.reject(&:polymorphic?)
     end
 
     def build_include
-      root = Rexport::TreeNode.new('root')
-      (rexport_methods + filter_fields).select {|m| m.include?('.')}.each do |method|
-        root.add_child(method.split('.').values_at(0..-2))
+      root = Rexport::TreeNode.new("root")
+      (rexport_methods + filter_fields).select { |m| m.include?(".") }.each do |method|
+        root.add_child(method.split(".").values_at(0..-2))
       end
       root.to_include
     end
 
     def build_conditions
-      Hash.new.tap do |conditions|
+      {}.tap do |conditions|
         export_filters.each do |filter|
           conditions[get_database_field(filter.filter_field)] = filter.value
         end
@@ -172,7 +173,7 @@ module Rexport #:nodoc:
     end
 
     def get_database_field(field)
-      path = field.split('.')
+      path = field.split(".")
       field = path.pop
       "#{get_klass_from_path(path).table_name}.#{field}"
     end
@@ -194,27 +195,38 @@ module Rexport #:nodoc:
     end
 
     def save_export_items
-      export_items.each do |export_item|
-        unless rexport_fields.include?(export_item.rexport_field)
-          export_item.destroy
-        end
-      end
+      export_items.where.not(rexport_field: rexport_fields).destroy_all
 
       rexport_fields.each.with_index(1) do |rexport_field, position|
-        export_item = export_items.detect { |i| i.rexport_field == rexport_field } || export_items.create(rexport_field: rexport_field)
-        export_item.update_attribute(:position, position) if set_position
+        find_or_create_export_item(rexport_field).tap do |export_item|
+          export_item.update_attribute(:position, position) if set_position
+        end
       end
 
-      return true
+      true
+    end
+
+    # Uses array find to search in memory export_items assocation instead of performing a SQL query on every iteration
+    def find_or_create_export_item(rexport_field)
+      export_items.find { |export_item| export_item.rexport_field == rexport_field } || export_items.create(rexport_field: rexport_field)
     end
 
     def attributes_for_copy
-      attributes.slice('model_class_name', 'description').merge(name: find_unique_name(name))
+      attributes.slice("model_class_name", "description").merge(name: find_unique_name(name))
     end
 
     def find_unique_name(original_name, suffix = 0)
-      new_name = suffix == 0 ? "#{original_name} Copy" : "#{original_name} Copy [#{suffix}]"
-      self.class.find_by(name: new_name) ? find_unique_name(original_name, suffix += 1) : new_name
+      new_name = suffix.zero? ? "#{original_name} Copy" : "#{original_name} Copy [#{suffix}]"
+      self.class.find_by(name: new_name) ? find_unique_name(original_name, suffix + 1) : new_name
+    end
+
+    def extract_rexport_fields(fields)
+      # When fields is a hash return the keys and do not update export_item positions on save
+      return fields.keys if fields.respond_to?(:keys)
+
+      # When fields is an array update export item positions on save
+      @set_position = true
+      fields
     end
 
     def set_position

data/lib/rexport/exports_controller_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rexport
   module ExportsControllerMethods
     def index
@@ -9,7 +11,7 @@ module Rexport
 
       respond_to do |format|
         format.html # show.html.erb
-        format.csv { send_data(export.to_csv, type: export_content_type, filename: filename) }
+        format.csv { send_data(export.to_csv, filename: filename) }
       end
     end
 
@@ -25,7 +27,7 @@ module Rexport
       @export = params[:original_export_id] ? Export.find(params[:original_export_id]).copy : Export.new(export_params)
 
       if @export.save
-        redirect_to @export, notice: 'Export was successfully created.'
+        redirect_to @export, notice: "Export was successfully created."
       else
         render :new
       end
@@ -33,7 +35,7 @@ module Rexport
 
     def update
       if export.update(export_params)
-        redirect_to export, notice: 'Export was successfully updated.'
+        redirect_to export, notice: "Export was successfully updated."
       else
         render :edit
       end
@@ -60,17 +62,15 @@ module Rexport
         :name,
         :model_class_name,
         :description,
-        rexport_fields: {},
-        export_filter_attributes: {}
+        {
+          rexport_fields:           {},
+          export_filter_attributes: {}
+        }
       ]
     end
 
-    def export_content_type
-      request.user_agent =~ /windows/i ? 'application/vnd.ms-excel' : 'text/csv'
-    end
-
     def filename
-      "#{export.model_class_name}_#{export.name.gsub(/ /, '_')}_#{Time.now.strftime('%Y%m%d')}.csv"
+      "#{export.model_class_name}_#{export.name.tr(' ', '_')}_#{Time.current.strftime('%Y%m%d')}.csv"
     end
   end
 end

data/lib/rexport/formatter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rexport
+  module Formatter
+    def self.convert(value)
+      case value
+      when Date, Time
+        value.strftime("%m/%d/%y")
+      when TrueClass
+        "Y"
+      when FalseClass
+        "N"
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/rexport/rexport_model.rb

@@ -1,15 +1,19 @@
-module Rexport #:nodoc:
+# frozen_string_literal: true
+
+module Rexport # :nodoc:
   class RexportModel
     attr_accessor :klass, :path
 
+    delegate :name, to: :klass
+
     def initialize(klass, path: nil)
       self.klass = klass
-      self.path = path.to_s unless path.blank?
+      self.path = path&.to_s
       initialize_rexport_fields
     end
 
     def rexport_fields
-      @rexport_fields ||= HashWithIndifferentAccess.new
+      @rexport_fields ||= ActiveSupport::HashWithIndifferentAccess.new
     end
 
     def rexport_fields_array
@@ -17,7 +21,7 @@ module Rexport #:nodoc:
     end
 
     def field_path(field_name)
-      [path, field_name].compact * '.'
+      [path, field_name].compact * "."
     end
 
     def collection_from_association(association)
@@ -29,13 +33,7 @@ module Rexport #:nodoc:
     end
 
     def filter_column(field)
-      return field.method unless field.method.include?('.')
-      association = field.method.split('.').first
-      klass.reflect_on_association(association.to_sym).foreign_key
-    end
-
-    def name
-      klass.name
+      foreign_key_for(field.association_name) || field.method
     end
 
     # Adds a data item to rexport_fields
@@ -55,33 +53,23 @@ module Rexport #:nodoc:
     #   :filter - if true will send type: :association to add_report_field
     def add_association_methods(options = {})
       options.stringify_keys!
-      options.assert_valid_keys(%w(associations methods filter))
-
-      methods = options.reverse_merge('methods' => 'name')['methods']
-      methods = [methods] if methods.kind_of?(String)
-
-      associations = options['associations']
-      associations = [associations] if associations.kind_of?(String)
+      options.assert_valid_keys(%w[associations methods filter])
 
-      type = options['filter'] ? :association : nil
-
-      associations.each do |association|
-        methods.each do |method|
-          add_rexport_field("#{association}_#{method}", method: "#{association}.#{method}", type: type)
-        end
-      end
+      add_rexport_fields_for(
+        associations: [options["associations"]].flatten,
+        methods:      [options["methods"] || "name"].flatten,
+        type:         (options["filter"] ? :association : nil)
+      )
     end
 
     # Returns an array of export methods corresponding with field_names
     def get_rexport_methods(*field_names)
       field_names.flatten.map do |f|
-        begin
-          components = f.to_s.split('.')
-          field_name = components.pop
-          components.push(get_rexport_model(components).get_rexport_method(field_name)) * '.'
-        rescue NoMethodError
-          'undefined_rexport_field'
-        end
+        components = f.to_s.split(".")
+        field_name = components.pop
+        components.push(get_rexport_model(components).get_rexport_method(field_name)) * "."
+      rescue NoMethodError
+        "undefined_rexport_field"
       end
     end
 
@@ -101,15 +89,23 @@ module Rexport #:nodoc:
 
     # Returns the export method for a given field_name
     def get_rexport_method(field_name)
-      if rexport_fields[field_name]
-        rexport_fields[field_name].method
-      else
-        raise NoMethodError
-      end
+      rexport_fields[field_name]&.method || raise(NoMethodError)
     end
 
     private
 
+    def add_rexport_fields_for(associations:, methods:, type:)
+      associations.each do |association|
+        methods.each do |method|
+          add_rexport_field("#{association}_#{method}", method: "#{association}.#{method}", type: type)
+        end
+      end
+    end
+
+    def foreign_key_for(association_name)
+      klass.reflect_on_association(association_name).foreign_key if association_name.present?
+    end
+
     def initialize_rexport_fields
       klass.content_columns.each { |field| add_rexport_field(field.name, type: field.type) }
       klass.initialize_local_rexport_fields(self) if klass.respond_to?(:initialize_local_rexport_fields)

data/lib/rexport/tree_node.rb

@@ -1,4 +1,6 @@
-module Rexport #:nodoc:
+# frozen_string_literal: true
+
+module Rexport # :nodoc:
   # A basic tree for building up ActiveRecord find :include parameters
   class TreeNode
     attr_accessor :name, :children
@@ -13,7 +15,8 @@ module Rexport #:nodoc:
     # Add one or more children to the tree
     def add_child(*names)
       names.flatten!
-      return unless name = names.shift
+      return unless (name = names.shift)
+
       node = children.find { |c| c.name == name }
       node ? node.add_child(names) : (children << TreeNode.new(name, names))
     end

data/lib/rexport/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rexport
-  VERSION = '1.3.0'
+  VERSION = "1.4.0"
 end

data/lib/rexport.rb

@@ -1,19 +1,22 @@
-require 'rexport/data_field'
-require 'rexport/data_fields'
-require 'rexport/export_filter_methods'
-require 'rexport/export_filters_controller_methods'
-require 'rexport/export_item_methods'
-require 'rexport/export_item_sortings_controller_methods'
-require 'rexport/export_items_controller_methods'
-require 'rexport/export_methods'
-require 'rexport/exports_controller_methods'
-require 'rexport/rexport_model'
-require 'rexport/tree_node'
+# frozen_string_literal: true
+
+require "rexport/data_field"
+require "rexport/data_fields"
+require "rexport/export_filter_methods"
+require "rexport/export_filters_controller_methods"
+require "rexport/export_item_methods"
+require "rexport/export_item_sortings_controller_methods"
+require "rexport/export_items_controller_methods"
+require "rexport/export_methods"
+require "rexport/exports_controller_methods"
+require "rexport/formatter"
+require "rexport/rexport_model"
+require "rexport/tree_node"
 
 module Rexport
   SAMPLE_SIZE = 5
 
   class Engine < ::Rails::Engine
-    config.paths['app/views'] << File.join(File.dirname(__FILE__),'../app/views')
+    config.paths["app/views"] << File.join(File.dirname(__FILE__), "../app/views")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rexport
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Aaron Baldwin
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-31 00:00:00.000000000 Z
+date: 2023-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -62,6 +62,7 @@ files:
 - lib/rexport/export_items_controller_methods.rb
 - lib/rexport/export_methods.rb
 - lib/rexport/exports_controller_methods.rb
+- lib/rexport/formatter.rb
 - lib/rexport/rexport_model.rb
 - lib/rexport/tree_node.rb
 - lib/rexport/version.rb