rexport 0.5.4 → 1.2.0

data/lib/rexport/export_filter_methods.rb

@@ -1,34 +1,56 @@
 module Rexport #:nodoc:
   module ExportFilterMethods
-    def self.included(base)
-      base.class_eval do
-        include InstanceMethods
+    extend ActiveSupport::Concern
 
-        belongs_to :export
-        validates_presence_of :filter_field
-      end
+    included do
+      belongs_to :export
+      validates_presence_of :filter_field
+    end
+
+    def display_value
+      filter_on_associated_object? ? associated_object_value : value
+    end
+
+    def attributes_for_copy
+      attributes.slice('filter_field', 'value')
     end
 
-    module InstanceMethods
-      def display_value
-        return value unless filter_field[/_id$/]
-        path = filter_field.split('.')
-        foreign_key = path.pop
-        association = export.get_klass_from_path(path).reflect_on_all_associations(:belongs_to).detect do |association|
-          association.foreign_key == foreign_key
-        end
-        return 'UNDEFINED ASSOCIATION' unless association
-        begin
-          object = association.klass.find(value)
-          return object.respond_to?(:name) ? object.name : object.to_s
-        rescue ActiveRecord::RecordNotFound
-          return 'ASSOCIATED OBJECT NOT FOUND'
-        end
+    private
+
+    def associated_object_value
+      return 'UNDEFINED ASSOCIATION' unless filter_association
+      begin
+        object = filter_association.klass.find(value)
+        return object.respond_to?(:name) ? object.name : object.to_s
+      rescue ActiveRecord::RecordNotFound
+        return 'ASSOCIATED OBJECT NOT FOUND'
       end
-      
-      def attributes_for_copy
-        attributes.slice('filter_field', 'value')
+    end
+
+    def filter_association
+      @filter_on_assocation ||= find_filter_association
+    end
+
+    def find_filter_association
+      belongs_to_associations.detect do |association|
+        association.foreign_key == filter_foreign_key
       end
     end
+
+    def belongs_to_associations
+      export.get_klass_from_path(filter_path).reflect_on_all_associations(:belongs_to)
+    end
+
+    def filter_path
+      filter_field.split('.')[0..-2]
+    end
+
+    def filter_foreign_key
+      filter_field.split('.').last
+    end
+
+    def filter_on_associated_object?
+      filter_field[/_id$/]
+    end
   end
 end

data/lib/rexport/export_filters_controller_methods.rb

@@ -1,10 +1,14 @@
 module Rexport
   module ExportFiltersControllerMethods
     def destroy
-      @export_filter = ExportFilter.find(params[:id])
-      @export_filter.destroy
-      
-      redirect_to @export_filter.export
+      export_filter.destroy
+      redirect_to export_filter.export
+    end
+
+    private
+
+    def export_filter
+      @export_filter ||= ExportFilter.find(params[:id])
     end
   end
 end

data/lib/rexport/export_item_methods.rb

@@ -1,45 +1,40 @@
 module Rexport #:nodoc:
   module ExportItemMethods
-    def self.included(base)
-      base.extend ClassMethods
-      base.class_eval do
-        include InstanceMethods
-        
-        acts_as_list :scope => :export
-        belongs_to :export
-        before_validation :replace_blank_name_with_rexport_field
-        validates_presence_of :name, :rexport_field
-        scope :ordered, -> { order :position }
-      end
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_list scope: :export
+
+      belongs_to :export
+
+      before_validation :replace_blank_name_with_rexport_field
+      validates_presence_of :name, :rexport_field
+
+      scope :ordered, -> { order :position }
     end
-    
+
     module ClassMethods
       def resort(export_item_ids)
-        export_item_ids.each_index do |index|
-          position = index + 1
-          export_item = find(export_item_ids[index].gsub(/[^0-9]/,''))
-          export_item.update_attribute(:position, position) if export_item.position != position
+        transaction do
+          export_item_ids.each_with_index do |id, index|
+            find(id.gsub(/[^0-9]/, '')).update_attribute(:position, index + 1)
+          end
         end
       end
     end
-    
-    module InstanceMethods
-      def attributes_for_copy
-        attributes.slice('position', 'name', 'rexport_field')
-      end
-      
-      #######
-      private
-      #######
-      
-      def replace_blank_name_with_rexport_field
-        return unless name.blank?
-        self.name = if rexport_field.include?('.')
-          rexport_field.split('.').values_at(-2..-1).map {|v| v.titleize}.join(' - ')
-        else
-          rexport_field.titleize
-        end
-      end
+
+    def attributes_for_copy
+      attributes.slice('position', 'name', 'rexport_field')
+    end
+
+    private
+
+    def replace_blank_name_with_rexport_field
+      self.name = generate_name_from_rexport_field if name.blank?
+    end
+
+    def generate_name_from_rexport_field
+      rexport_field.split('.').last(2).map(&:titleize).join(' - ')
     end
   end
 end

data/lib/rexport/export_items_controller_methods.rb

@@ -1,28 +1,28 @@
 module Rexport
   module ExportItemsControllerMethods
     def edit
-      @export_item = ExportItem.find(params[:id])
+      export_item
     end
-    
+
     def update
-      @export_item = ExportItem.find(params[:id])
-      
-      if @export_item.update_attributes(export_item_params)
-        redirect_to export_path(@export_item.export), notice: 'ExportItem was successfully updated.'
+      if export_item.update(export_item_params)
+        redirect_to export_path(export_item.export), notice: 'ExportItem was successfully updated.'
       else
         render :edit
       end
     end
-    
+
     def destroy
-      @export_item = ExportItem.find(params[:id])
-      @export_item.destroy
-      
-      redirect_to export_path(@export_item.export)
+      export_item.destroy
+      redirect_to export_path(export_item.export)
     end
-    
+
     private
-    
+
+    def export_item
+      @export_item ||= ExportItem.find(params[:id])
+    end
+
     def export_item_params
       params.require(:export_item).permit(:name)
     end

data/lib/rexport/export_methods.rb

@@ -1,272 +1,224 @@
 require 'csv'
 
 module Rexport #:nodoc:
+  module ExportMethods
+    extend ActiveSupport::Concern
 
-  SAMPLE_SIZE = 5
-
-  class RexportModel
-    attr_accessor :klass, :path
-
-    def initialize(klass, path = nil)
-      self.klass = klass
-      self.path = path.to_s unless path.blank?
-    end
-
-    def rexport_fields_array
-      klass.rexport_fields_array
-    end
-
-    def field_path(field_name)
-      [path, field_name].compact * '.'
-    end
-
-    def collection_from_association(association)
-      return klass.send("find_#{association}_for_rexport") if klass.respond_to?("find_#{association}_for_rexport")
-      klass.reflect_on_association(association.to_sym).klass.all
-    end
+    included do
+      has_many :export_items,   dependent: :destroy
+      has_many :export_filters, dependent: :destroy
 
-    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
+      validates_presence_of :name, :model_class_name
 
-    def name
-      klass.name
-    end
-  end
+      after_save :save_export_items
 
-  module ExportMethods
-    def self.included(base)
-      base.extend ClassMethods
-      base.class_eval do
-        include InstanceMethods
-
-        has_many :export_items, :dependent => :destroy
-        has_many :export_filters, :dependent => :destroy
-        validates_presence_of :name, :model_class_name
-        after_save :save_export_items
-        scope :alphabetical,  ->              { order :name }
-        scope :categorical,   ->              { order :model_class_name }
-        scope :by_model,      ->(model_class_name)  { where(model_class_name: model_class_name) }
-      end
+      scope :alphabetical,  -> { order :name }
+      scope :categorical,   -> { order :model_class_name }
     end
 
     module ClassMethods
       def models
         %w(override_this_method)
       end
-
-      def enabled
-        find(:all).select {|export| export.enabled? }
-      end
     end
 
-    module InstanceMethods
-      def full_name
-        "#{model_class_name.pluralize} - #{name}"
-      end
+    def full_name
+      "#{model_class_name.pluralize} - #{name}"
+    end
 
-      # 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
+    # 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
+    end
 
-      # Returns a csv string with the export data
-      def to_csv(objects = nil)
-        seed_records(objects) unless objects.nil?
-        CSV.generate do |csv|
-          csv << header
-          records.each do |record|
-            csv << record
-          end
+    # Returns a csv string with the export data
+    def to_csv(objects = nil)
+      seed_records(objects) unless objects.nil?
+      CSV.generate do |csv|
+        csv << header
+        records.each do |record|
+          csv << record
         end
       end
+    end
 
-      # Returns an array with the header names from the associated export_items
-      def header
-        export_items.ordered.map {|i| i.name}
-      end
+    # Returns an array with the header names from the associated export_items
+    def header
+      export_items.ordered.map(&:name)
+    end
 
-      # Returns the export model class
-      def export_model
-        model_class_name.constantize
-      end
+    # Returns the export model class
+    def export_model
+      model_class_name.constantize
+    end
 
-      # Returns an array of RexportModels including export_model and associated rexport capable models
-      def rexport_models
-        @rexport_models ||= get_rexport_models(export_model)
-      end
+    # Returns a RexportModel for the current export_model
+    def rexport_model
+      @rexport_model ||= RexportModel.new(export_model)
+    end
 
-      # Returns the records for the export
-      def records
-        @records ||= get_records
-      end
+    # Returns an array of RexportModels including export_model and associated rexport capable models
+    def rexport_models
+      @rexport_models ||= get_rexport_models(export_model)
+    end
 
-      # Returns a limited number of records for the export
-      def sample_records
-        get_records(Rexport::SAMPLE_SIZE)
-      end
+    # Returns the records for the export
+    def records
+      @records ||= get_records
+    end
 
-      # 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
+    # Returns a limited number of records for the export
+    def sample_records
+      get_records(Rexport::SAMPLE_SIZE)
+    end
+
+    # 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)
-        rexport_fields.include?(rexport_field)
+    def has_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
+    end
 
-      def rexport_fields=(rexport_fields)
-        @rexport_fields = if rexport_fields.respond_to?(:keys)
-          @set_position = false
-          rexport_fields.keys
+    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
+        elsif new_record?
+          export_filters.build(filter_field: field, value: value)
         else
-          @set_position = true
-          rexport_fields
+          filter = export_filters.find_or_create_by(filter_field: field)
+          filter.update_attribute(:value, value)
         end
       end
+    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
-          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)
-          end
-        end
-      end
+    def filter_value(filter_field)
+      export_filters.detect { |f| f.filter_field == filter_field }&.value
+    end
 
-      def filter_value(filter_field)
-        filter = export_filters.detect {|f| f.filter_field == filter_field}
-        filter ? filter.value : nil
+    def copy
+      self.class.create(attributes_for_copy) do |new_export|
+        export_items.ordered.each { |item| new_export.export_items.build(item.attributes_for_copy) }
+        export_filters.each { |filter| new_export.export_filters.build(filter.attributes_for_copy) }
       end
+    end
 
-      def copy
-        self.class.create(attributes_for_copy) do |new_export|
-          export_items.ordered.each { |item| new_export.export_items.build(item.attributes_for_copy) }
-          export_filters.each { |filter| new_export.export_filters.build(filter.attributes_for_copy) }
-        end
-      end
+    private
 
-      def modifiable?
-        # override to disable edit and destroy links for specific exports
-        true
-      end
+    def get_records(limit = nil)
+      get_export_values(export_model.where(build_conditions).includes(build_include).limit(limit))
+    end
 
-      def enabled?
-        export_model.count > 0
-      end
+    def seed_records(objects)
+      @records = get_export_values(objects)
+    end
 
-      #########
-      protected
-      #########
+    def get_export_values(objects)
+      objects.map { |object| object.export(rexport_methods) }
+    end
 
-      def get_records(limit = nil)
-        get_export_values(export_model.where(build_conditions).includes(build_include).limit(limit))
+    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 * '.')
       end
+      return results
+    end
 
-      def seed_records(objects)
-        @records = get_export_values(objects)
-      end
+    def get_associations(model)
+      %i(belongs_to has_one).map do |type|
+        model.reflect_on_all_associations(type)
+      end.flatten.reject(&:polymorphic?)
+    end
 
-      def get_export_values(objects)
-        objects.map { |object| object.export(rexport_methods) }
+    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))
       end
+      root.to_include
+    end
 
-      def get_rexport_models(rexport_model, result = [], path = nil)
-        return unless rexport_model.respond_to?(:rexport_fields)
-        result << RexportModel.new(rexport_model, path)
-        get_associations(rexport_model).each do |associated_model|
-          # prevent infinite loop by checking if this class is already in the result set
-          unless result.detect { |rexport_model| rexport_model.klass == associated_model.klass }
-            get_rexport_models(associated_model.klass, result, [path, associated_model.name].compact * '.')
-          end
+    def build_conditions
+      Hash.new.tap do |conditions|
+        export_filters.each do |filter|
+          conditions[get_database_field(filter.filter_field)] = filter.value
         end
-        return result
-      end
-
-      def get_associations(rexport_model)
-        (rexport_model.reflect_on_all_associations(:belongs_to) + rexport_model.reflect_on_all_associations(:has_one)).reject(&:polymorphic?)
       end
+    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))
-        end
-        root.to_include
-      end
+    def get_database_field(field)
+      path = field.split('.')
+      field = path.pop
+      "#{get_klass_from_path(path).table_name}.#{field}"
+    end
 
-      def build_conditions
-        Hash.new.tap do |conditions|
-          export_filters.each do |filter|
-            conditions[get_database_field(filter.filter_field)] = filter.value
-          end
-        end
-      end
+    def rexport_methods
+      @rexport_methods ||= rexport_model.get_rexport_methods(ordered_rexport_fields)
+    end
 
-      def get_database_field(field)
-        path = field.split('.')
-        field = path.pop
-        "#{get_klass_from_path(path).table_name}.#{field}"
-      end
+    def rexport_fields
+      @rexport_fields ||= export_items.map(&:rexport_field)
+    end
 
-      def rexport_methods
-        @rexport_methods ||= export_model.get_rexport_methods(ordered_rexport_fields)
-      end
+    def ordered_rexport_fields
+      export_items.ordered.map(&:rexport_field)
+    end
 
-      def rexport_fields
-        @rexport_fields ||= export_items.map {|i| i.rexport_field}
-      end
+    def filter_fields
+      export_filters.map(&:filter_field)
+    end
 
-      def ordered_rexport_fields
-        export_items.ordered.map {|i| i.rexport_field}
+    def save_export_items
+      export_items.each do |export_item|
+        unless rexport_fields.include?(export_item.rexport_field)
+          export_item.destroy
+        end
       end
 
-      def filter_fields
-        export_filters.map {|f| f.filter_field}
+      position = 0
+      rexport_fields.each do |rexport_field|
+        position += 1
+        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
       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.reset
+      return true
+    end
 
-        position = 0
-        rexport_fields.each do |rexport_field|
-          position += 1
-          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 && export_item.position != position
-        end
+    def attributes_for_copy
+      attributes.slice('model_class_name', 'description').merge(name: find_unique_name(name))
+    end
 
-        export_items.reset
-        @rexport_fields = nil
-        return true
-      end
-      
-      def attributes_for_copy
-        attributes.slice('model_class_name', 'description').merge(name: find_unique_name(self.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
+    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
-      end
+    def set_position
+      @set_position ||= false
     end
   end
 end