easy_exports 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a9e4470d18b361781bf745a2ca0dc563b82ccf603b456a55ad75a96113d3975c
+  data.tar.gz: 2576218f1f50c7743f1ef0a9cbada4e4ebe452f20dfb12dec4613aedcb0f23d4
+SHA512:
+  metadata.gz: 401cf20c2ee26d378b6f31d02acb64e34bf49761c417f65e0954d9132f45855feb8fcc13be73948cbdbb5e1b941df1e30363a23828ed14bdec8601e1a13c4309
+  data.tar.gz: 2c5e04b944b9551843802c46ce131f5d0c7ff0e732d1db1f3fc07ef93a9e2227b67771e3a287da54b123d8b4e254e20206e41b9f8a70728cf79f4a3d287fb835

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Dapilah Sydney
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# EasyExports
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "easy_exports"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install easy_exports
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'bundler/gem_tasks'

data/lib/easy_exports/exclude_associations_configurations.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExcludeAssociationsConfigurations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      private
+
+      # associations to exclude methods
+      def associations_to_exclude(associations = [])
+        validate_associations_to_exclude_argument(associations)
+
+        associations.map! do |association|
+          association_name = association.to_s.downcase
+
+          association_name.tap do |name|
+            if association_from_self_with_association(name).blank?
+              raise ArgumentError,
+                    "associations_to_exclude array argument '#{name}' is not an association for #{underscored_self_name} model"
+            end
+          end
+        end
+
+        associations_to_exclude_store.merge!(
+          underscored_self_name => associations
+        )
+      end
+
+      def validate_associations_to_exclude_argument(argument)
+        raise 'Argument for associations_to_exclude has to be an array' unless argument.is_a? Array
+
+        return if argument.all? { |element| [String, Symbol].include? element.class }
+
+        raise 'Argument array for associations_to_exclude has to be either string or Symbol'
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExcludeAssociationsConfigurations

data/lib/easy_exports/exclude_exportable_attributes_configurations.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExcludeExportableAttributesConfigurations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      private
+
+      def exclude_exportable_attributes(association_attributes = {})
+        validate_exclude_exportable_attributes_argument(association_attributes)
+        association_attributes.transform_values! { |values| values.map(&:to_s) }
+
+        validate_association_attributes(association_attributes, 'exclude_exportable_attributes')
+
+        excluded_exportable_attributes_store.merge!(
+          underscored_self_name => association_attributes.stringify_keys
+        )
+      end
+
+      def validate_association_attributes(association_attributes, method = '')
+        association_attributes.each do |association_name, attributes|
+          association = association_from_self_with_association(association_name)
+
+          if association.blank?
+            next if association_name.to_s.downcase == 'all'
+
+            raise ArgumentError,
+                  "#{method} argument key '#{association_name}' is not an association for #{underscored_self_name} model"
+          end
+
+          invalid_attributes = attributes - association.class_name.constantize.attribute_names
+          next if invalid_attributes.empty?
+
+          raise ArgumentError, "#{method} #{invalid_attributes.join(', ')} not defined for #{association.name}"
+        end
+      end
+
+      def validate_exclude_exportable_attributes_argument(argument, method_name = 'exclude_exportable_attributes')
+        raise 'Argument for exclude_exportable_attributes has to be a hash' unless argument.is_a? Hash
+
+        argument.to_a.each do |arg|
+          case arg
+          in [*, [*]] if arg[1].all? { |element| [String, Symbol].include? element.class }
+            next
+          else
+            raise ArgumentError, "Invalid Arguments pattern for #{method_name}"
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExcludeExportableAttributesConfigurations

data/lib/easy_exports/export.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module EasyExports
+  class Export
+    attr_reader :data, :csv_string
+
+    def initialize(exported_data, exported_data_csv_string)
+      @data = exported_data
+      @csv_string = exported_data_csv_string
+    end
+  end
+end

data/lib/easy_exports/exportable_association_aliases_configurations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExportableAssociationAliasesConfigurations
+    extend ActiveSupport::Concern
+
+    class_methods do
+      private
+
+      def exportable_association_aliases(aliases = {})
+        validate_exportable_association_aliases_argument(aliases)
+
+        aliases.transform_values!(&:to_s)
+        aliases.stringify_keys!
+
+        aliases.each do |association_name, _alias_name|
+          next if association_from_self_with_association(association_name).present?
+
+          error_message = <<~MESSAGE
+            exportable_association_aliases argument '#{association_name}' is not an association for #{underscored_self_name} model
+          MESSAGE
+
+          raise ArgumentError, error_message
+        end
+
+        associations_aliases_store.merge!(underscored_self_name => aliases.stringify_keys)
+      end
+
+      def validate_exportable_association_aliases_argument(argument)
+        raise 'Argument for exportable_associations_aliases has to be a hash' unless argument.is_a? Hash
+
+        argument.to_a.each do |arg|
+          case arg
+          in [*, String | Symbol]
+            next
+          else
+            raise 'Invalid Arguments pattern for exportable_associations_aliases'
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExportableAssociationAliasesConfigurations

data/lib/easy_exports/exportable_attribute_resolvers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExportableAttributeResolvers
+    extend ActiveSupport::Concern
+
+    class_methods do
+      private
+
+      def resolve_excluded_exportable_attributes(association_name)
+        exclude_exportable_attributes_for_self = excluded_exportable_attributes_store[underscored_self_name]
+
+        return [] if exclude_exportable_attributes_for_self.blank?
+
+        exclude_exportable_attributes_for_self.with_indifferent_access.slice(
+          association_name,
+          'all'
+        ).values.compact.flatten.uniq
+      end
+
+      def resolve_attributes_for_association(association)
+        association_attributes = association.class_name.constantize.attribute_names
+        association_attributes - resolve_excluded_exportable_attributes(association.name.to_s.downcase)
+      end
+
+      def resolve_associations_names_aliases(association_name)
+        association_aliases_for_self = associations_aliases_store[underscored_self_name]
+        return association_name if association_aliases_for_self.blank?
+
+        association_aliases_for_self[association_name] || association_name
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExportableAttributeResolvers

data/lib/easy_exports/exportable_attributes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExportableAttributes
+    extend ActiveSupport::Concern
+
+    class_methods do
+      cattr_accessor :excluded_exportable_attributes_store, default: {}, instance_writer: false
+      cattr_accessor :associations_aliases_store, default: {}, instance_writer: false
+      cattr_accessor :associations_to_exclude_store, default: {}, instance_writer: false
+
+      def exportable_attributes
+        self_with_associations.each_with_object({}) do |association, attributes|
+          association_name = association.name.to_s.downcase
+          next if associations_to_exclude_store[underscored_self_name]&.include? association_name
+
+          association_attributes = resolve_attributes_for_association(association)
+
+          association_name = resolve_associations_names_aliases(association_name)
+          attributes[humanize_model_name(association_name)] = humanize_attribute_names(association_attributes)
+        end
+      end
+
+      private
+
+      def self_with_associations
+        mock_self_as_reflection = OpenStruct.new(class_name: name, name: underscored_self_name)
+        reflect_on_all_associations.unshift(mock_self_as_reflection)
+      end
+
+      def association_from_self_with_association(association_name)
+        self_with_associations.find { |association| association.name.to_s.downcase == association_name.to_s.downcase }
+      end
+
+      def underscored_self_name
+        name.underscore.downcase
+      end
+
+      def humanize_model_name(model_name)
+        model_name.underscore.humanize(keep_id_suffix: true)
+      end
+
+      def humanize_attribute_names(attributes)
+        attributes.map { |attribute| attribute.humanize(keep_id_suffix: true).downcase }
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExportableAttributes

data/lib/easy_exports/exports_generable.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module EasyExports
+  module ExportsGenerable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def generate_exports(fields_to_export = {}, ids = [])
+        validate_exclude_exportable_attributes_argument(fields_to_export, 'generate_exports')
+
+        selected_exportable_attributes = revert_transformed_names(fields_to_export)
+        export_row_template = generate_export_row_template(selected_exportable_attributes)
+
+        selected_attributes = revert_exportable_attributes_aliases(selected_exportable_attributes)
+        records = fetch_records(ids, selected_attributes)
+
+        exported_data = records.each_with_object([]) do |record, hash_to_export|
+          hash_to_export << value_from_selected_attributes(selected_attributes, record, export_row_template)
+        end.flatten
+
+        csv_string = write_exported_data_to_csv(exported_data, export_row_template)
+
+        EasyExports::Export.new(exported_data, csv_string)
+      end
+
+      def write_exported_data_to_csv(exported_data, export_row_template)
+        CSV.generate(headers: true) do |csv|
+          csv << export_row_template.keys
+
+          exported_data.each do |data|
+            csv << data.values
+          end
+        end
+      end
+
+      def generate_export_row_template(selected_attributes)
+        selected_attributes.each_with_object({}) do |(association_name, attributes), export_row|
+          attributes.each do |attribute|
+            export_row.merge!("#{association_name}_#{attribute}" => nil)
+          end
+        end
+      end
+
+      def fetch_records(ids, selected_attributes)
+        validate_association_attributes(selected_attributes, 'to_exported_data')
+
+        records_with_preloaded_associations(ids, selected_attributes)
+      end
+
+      def association_attributes(association_name)
+        association_name = if association_name == underscored_self_name
+                             association_name.classify
+                           else
+                             reflect_on_all_associations.find do |association|
+                               association.name.to_s == association_name
+                             end&.class_name
+                           end
+
+        association_name.constantize.attribute_names
+      end
+
+      def records_with_preloaded_associations(ids, selected_attributes)
+        records = ids.blank? ? all : where(id: ids)
+
+        associations_to_preload = selected_attributes.keys
+        associations_to_preload.delete(underscored_self_name)
+
+        ActiveRecord::Associations::Preloader.new(
+          records: records,
+          associations: associations_to_preload
+        ).call
+
+        records
+      end
+
+      def value_from_selected_attributes(selected_attributes, record, export_row_template)
+        selected_attributes.each_with_object([export_row_template]) do |(association_name, attributes), export_rows|
+          objects = objects_for_attribute(association_name, record)
+
+          attributes.each do |attribute|
+            attribute_values = resolve_attributes(attribute, objects)
+
+            attribute_values.each_with_index do |value, index|
+              export_column = export_rows[index] || export_row_template
+
+              export_rows[index] = export_column.merge(export_header(association_name, attribute) => value)
+            end
+          end
+        end
+      end
+
+      def export_header(association_name, attribute)
+        association_alias = associations_aliases_store[underscored_self_name]
+        association_alias = association_alias.blank? ? nil : association_alias[association_name]
+
+        "#{association_alias || association_name}_#{attribute}"
+      end
+
+      def resolve_attributes(attribute, objects)
+        objects.empty? ? [nil] : objects.map { |object| parse_attribute_value(object.send(attribute)) }.flatten
+      end
+
+      def parse_attribute_value(value)
+        value_class = value.class
+
+        if value_class.eql?(ActiveSupport::TimeWithZone)
+          DateTime.parse(value.to_s).strftime('%Y-%m-%d %H:%M:%S')
+        elsif !value_class.eql?(String)
+          value
+        else
+          value.start_with?('0') ? "'#{value}" : value
+        end
+      end
+
+      def objects_for_attribute(association_name, record)
+        object = association_name == underscored_self_name ? record : record.send(association_name)
+        object.respond_to?(:each) ? object : [object].compact
+      end
+
+      def revert_exportable_attributes_aliases(attributes_with_aliases)
+        attributes_with_aliases.transform_keys { |key| reversed_associations_name_aliases[key] || key }
+      end
+
+      def reversed_associations_name_aliases
+        associations_aliases = associations_aliases_store[underscored_self_name]
+        return {} if associations_aliases.blank?
+
+        associations_aliases_store[underscored_self_name].with_indifferent_access.to_a.map(&:reverse).to_h
+      end
+
+      def revert_transformed_names(fields)
+        fields.transform_keys! { |key| key.parameterize(separator: '_') }
+
+        fields.transform_values do |value|
+          value.map { |v| v.parameterize(separator: '_') }.uniq
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include EasyExports::ExportsGenerable

data/lib/easy_exports/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EasyExports
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/easy_exports/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EasyExports
+  VERSION = '0.1.0'
+end

data/lib/easy_exports.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'easy_exports/version'
+require 'easy_exports/railtie'
+require 'easy_exports/exportable_attributes'
+require 'easy_exports/exportable_attribute_resolvers'
+require 'easy_exports/exclude_associations_configurations'
+require 'easy_exports/exclude_exportable_attributes_configurations'
+require 'easy_exports/exportable_association_aliases_configurations'
+require 'easy_exports/exports_generable'
+require 'easy_exports/export'
+
+module EasyExports
+  # Your code goes here...
+end

data/lib/tasks/easy_exports_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :easy_exports do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: easy_exports
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dapilah Sydney
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.56'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.56'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+description: Simplify the way you fetch model data, making coding smoother and data
+  exporting handling a breeze
+email:
+- dapilah.sydney@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/easy_exports.rb
+- lib/easy_exports/exclude_associations_configurations.rb
+- lib/easy_exports/exclude_exportable_attributes_configurations.rb
+- lib/easy_exports/export.rb
+- lib/easy_exports/exportable_association_aliases_configurations.rb
+- lib/easy_exports/exportable_attribute_resolvers.rb
+- lib/easy_exports/exportable_attributes.rb
+- lib/easy_exports/exports_generable.rb
+- lib/easy_exports/railtie.rb
+- lib/easy_exports/version.rb
+- lib/tasks/easy_exports_tasks.rake
+homepage: https://github.com/SydDaps/easy_exports
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/SydDaps/easy_exports
+  source_code_uri: https://github.com/SydDaps/easy_exports
+  changelog_uri: https://rubygems.org/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Streamline data retrieval from Rails models
+test_files: []