magic-report 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59c479e22412f34a53caaa404a9febf1186cefe0c0678a9f5c00a4b119f774bf
-  data.tar.gz: a0d46b4b7226ab1b0c74cd5adc6bd385ef54817ba2e6deb5591b27527e36f507
+  metadata.gz: 88305b9a5045e8cd60e96f3ebc8f7991726303f6461cd8de483ccbb483dba5f4
+  data.tar.gz: fb088083b95b0aeff7ca7fd4e92fa567e2685ff566ee8c6459582ed1e1876e6d
 SHA512:
-  metadata.gz: 715c2887cca5db182f97d578140f9bb44204b70881fc81b0c88ca25033ffd0291d515f08e7e1d8f299c3836324940256622dd63f45e0d90578953a3cbd39f1ef
-  data.tar.gz: 549a76ff9458405ae70035692cbc88db8c9708a81bd950bc5370c588f5d91316e3753335b30ff4a35c9d5fd55ee211dab7683290b4af3e772fe6b8f43fc71d9a
+  metadata.gz: fe1a63c8856265ff39b9651474218014a7700da961efb7a5c4adc42106463dd096e30770d520aec072e4df311482c7520c74d141d8448ff8fb948d806e712ad2
+  data.tar.gz: f55df1275d2f7efb325e3329e77b0ccc20eba2a5b682d02f80d156188cbf34740ce7053efe2a96b3c3ced63fcfbe1338adafb33377c3cf68ae851e3d60a17c06

data/lib/magic_report/general_report.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MagicReport
+  class GeneralReport
+    attr_reader :models, :report_klass, :csv, :fill
+
+    def initialize(input, report_klass, options = {})
+      @models = input.is_a?(Enumerable) ? input : [input]
+      @report_klass = report_klass
+      @csv = ::MagicReport::Report::Csv.new(self)
+      @fill = options[:fill] || false
+    end
+
+    def generate
+      models.find_each.with_index do |model, index|
+        report = report_klass.new(model, fill)
+
+        csv.add_headings(report) if index.zero?
+        report.rows.each { |row| csv.add_row(row) }
+      end
+    end
+
+    def as_attachment
+      @as_attachment ||= {
+        mime_type: "text/csv",
+        content: csv.io.read
+      }
+    end
+  end
+end

data/lib/magic_report/report/builder/field.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MagicReport
+  class Report
+    class Builder
+      class Field
+        def self.build(report, name, processor, options)
+          new(report, name, processor, options)
+        end
+
+        attr_reader :report, :name, :processor, :is_primary
+
+        def initialize(report, name, processor, options)
+          @report = report
+          @name = name
+          @processor = processor
+          @is_primary = options.fetch(:primary, false)
+        end
+
+        def process(model)
+          value = extract_value(model)
+
+          if processor.is_a? Proc
+            processor.call(model, value)
+          elsif processor.is_a? Symbol
+            # Refactor
+            report.new(nil).send(processor, model, value)
+          else
+            value
+          end
+        end
+
+        private
+
+        def extract_value(model)
+          model.send(name)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/magic_report/report/builder/has_many.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MagicReport
+  class Report
+    class Builder
+      class HasMany < HasOne
+        def process_rows(model, row, is_fill)
+          extract_relation(model).flat_map.with_index do |rel, idx|
+            # If we're on a first entry, then we should fill first row
+            # Otherwise will be created a new row
+            if idx.zero?
+              options[:class].new(rel, is_fill, row).rows
+            else
+              options[:class].new(rel, is_fill).rows
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/magic_report/report/builder/has_one.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MagicReport
+  class Report
+    class Builder
+      class HasOne
+        def self.build(report, name, options, &extension)
+          new(report, name, options, extension)
+        end
+
+        attr_reader :report, :name, :options, :extension, :prefix
+
+        def initialize(report, name, options, extension)
+          @report = report
+          @name = name
+          @options = options
+          @extension = extension
+          @prefix = I18n.t!("#{report.i18n_scope}.#{report.i18n_key}.#{name}_relation")
+
+          unless options[:class]
+            klass = ::MagicReport::Report.clone
+            klass.define_singleton_method(:name) { "#{report.name}/#{name}" }
+            klass.class_eval(&extension)
+
+            options[:class] = klass
+          end
+        end
+
+        def process(model)
+          relation = extract_relation(model)
+
+          # Refactor here values method call
+          options[:class].new(relation, is_fill).values
+        end
+
+        def process_rows(model, row, is_fill)
+          relation = extract_relation(model)
+
+          # Refactor here values method call
+          options[:class].new(relation, is_fill, row).rows
+        end
+
+        def build_row
+          options[:class].build_row(prefix)
+        end
+
+        private
+
+        def extract_relation(model)
+          model.send(name)
+        end
+      end
+    end
+  end
+end

data/lib/magic_report/report/csv.rb

@@ -8,7 +8,6 @@ module MagicReport
       attr_reader :report, :file, :csv
 
       def initialize(report)
-        @report = report
         @file = Tempfile.new
         @csv = ::CSV.new(@file, write_headers: true)
       end
@@ -16,17 +15,19 @@ module MagicReport
       def generate
         write_headers
 
-        [report.result].flatten.each do |row|
-          value = row.to_h
-
-          if value.is_a?(Array)
-            value.each { |nested_row| csv << nested_row.values }
-          else
-            csv << value.values
-          end
+        report.rows.each do |row|
+          csv << row.to_a
         end
       end
 
+      def add_headings(report)
+        csv << report.headings
+      end
+
+      def add_row(row)
+        csv << row.to_a
+      end
+
       # Don't forget to unlink in production code
       def unlink
         file.close
@@ -38,12 +39,6 @@ module MagicReport
         io.rewind
         io
       end
-
-      private
-
-      def write_headers
-        csv << report.headings
-      end
     end
   end
 end

data/lib/magic_report/report/reflection.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MagicReport
+  class Report
+    module Reflection
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_fields, instance_writer: false, default: {}
+        class_attribute :_has_one, instance_writer: false, default: {}
+        class_attribute :_has_many, instance_writer: false, default: {}
+      end
+
+      class << self
+        def add_field(klass, name, reflection)
+          klass._fields = klass._fields.except(name).merge!(name => reflection)
+        end
+
+        def add_has_one(klass, name, reflection)
+          klass._has_one = klass._has_one.except(name).merge!(name => reflection)
+        end
+
+        def add_has_many(klass, name, reflection)
+          klass._has_many = klass._has_many.except(name).merge!(name => reflection)
+        end
+      end
+    end
+  end
+end

data/lib/magic_report/report/row.rb

@@ -3,61 +3,51 @@
 module MagicReport
   class Report
     class Row
-      attr_accessor :data, :inner_rows, :nested_rows
+      class Column
+        attr_reader :key, :heading, :is_primary, :prefix, :value
+
+        def initialize(key, heading, is_primary, prefix)
+          @key = key
+          @heading = heading
+          @is_primary = is_primary
+          @prefix = prefix
+          @value = nil
+        end
 
-      def initialize
-        @data = {}
-        @inner_rows = {}
-        @nested_rows = {}
-      end
+        def assign_value(value)
+          @value = value
+        end
 
-      def add(field:, value:)
-        data[field] = value
+        def full_heading
+          prefix.present? ? "#{prefix} #{heading}" : heading
+        end
       end
 
-      def add_inner_row(field:, row:)
-        inner_rows[field] = row
-      end
+      attr_reader :columns, :nested_rows
 
-      def add_nested_row(field:, row:)
-        nested_rows[field] ||= []
-        nested_rows[field].push(row)
+      def initialize
+        @columns = []
+        @nested_rows = {}
       end
 
-      def values
-        data.values
+      def add_column_value(key:, value:)
+        @columns.find { |column| column.key == key }.assign_value(value)
       end
 
-      def complex?
-        nested_rows.any?
+      def add_nested_row(key:, row:)
+        nested_rows[key] = row
       end
 
-      def each_nested_row(&block)
-        nested_rows.keys.flat_map do |key|
-          nested_rows[key].map do |nested_row|
-            block.call(nested_row)
-          end
-        end
+      def register_column(key, heading, is_primary, prefix = nil)
+        @columns << Column.new(key, heading, is_primary, prefix)
       end
 
-      def each_inner_row(&block)
-        inner_rows.values.map do |inner_row|
-          block.call(inner_row)
-        end
+      def headings
+        (columns.map(&:full_heading) + nested_rows.values.map(&:headings)).flatten
       end
 
-      def to_h
-        @to_h ||= begin
-          original_hash = inner_rows.any? ? data.merge(each_inner_row { |inner_row| inner_row.to_h }.reduce({}, :merge)) : data
-
-          if complex?
-            each_nested_row do |nested_row|
-              original_hash.merge(nested_row.to_h)
-            end
-          else
-            original_hash
-          end
-        end
+      def to_a
+        (columns.map(&:value) + nested_rows.values.map(&:to_a)).flatten
       end
     end
   end

data/lib/magic_report/report.rb

@@ -2,107 +2,135 @@
 
 module MagicReport
   class Report
-    include ClassHelpers
+    include Reflection
 
-    attr_reader :fields, :has_one, :has_many, :name, :nested_field, :prefix, :result
+    attr_reader :model, :row, :is_fill
 
-    def initialize(fields: nil, has_one: nil, has_many: nil, name: nil, prefix: nil, nested_field: nil)
-      @fields = fields || fields_from_class
-      @has_one = has_one || has_one_from_class
-      @has_many = has_many || has_many_from_class
-      @name = name || name_from_class
-
-      @prefix = prefix
-      @nested_field = nested_field
+    def initialize(model, is_fill = false, row = nil)
+      @model = model
+      @row = row || self.class.build_row
+      @is_fill = is_fill
     end
 
-    def process(input)
-      @result = ::MagicReport::Report::Process.new(self).call(input)
-    end
+    def rows
+      @rows ||= begin
+        rows = []
 
-    def as_csv
-      @as_csv ||= begin
-        csv = ::MagicReport::Report::Csv.new(self)
-        csv.generate
+        _fields.each_value do |field|
+          row.add_column_value(key: field.name, value: field.process(model))
+        end
 
-        csv
-      end
-    end
+        _has_one.each_value do |has_one|
+          simple_row = row.nested_rows[has_one.name]
+
+          has_one.process_rows(model, simple_row, is_fill)
+        end
+
+        rows.push(row)
+
+        _has_many.each_value do |has_many|
+          simple_row = row.nested_rows[has_many.name]
 
-    def as_attachment
-      {
-        mime_type: "text/csv",
-        content: as_csv.io.read
-      }
+          resik = has_many.process_rows(model, simple_row, is_fill)
+
+          resik.map.with_index do |resik_row, index|
+            if index.zero?
+              # rows.push(new_row)
+            else
+              new_row = self.class.build_row
+
+              copy_primary_fields(row, new_row)
+              # TODO: copy ID here
+              # copy_primary_attributes(new_row, row)
+              new_row.nested_rows[has_many.name] = resik_row
+
+              rows.push(new_row)
+            end
+          end
+        end
+
+        rows
+      end
     end
 
     def headings
-      @headings ||= (fields.map { |field| t(field.key) } + has_one.map { |association| association.report.headings } + has_many.map { |association| association.report.headings }).flatten
+      row.headings
     end
 
-    class << self
-      def t(key)
-        ::MagicReport::Utils.t(name: name, key: key)
+    def copy_primary_fields(old_row, new_row)
+      old_row.columns.each do |column|
+        if column.is_primary || is_fill
+          new_row.add_column_value(key: column.key, value: column.value)
+        end
       end
 
-      def fields(*attrs)
-        @fields ||= []
-
-        Types::SymbolArray[attrs].each do |key|
-          @fields << Configuration::Field.new(key: key)
+      if is_fill
+        old_row.nested_rows.each do |key, nested_row|
+          nested_row.columns.each do |column|
+            new_row.nested_rows[key].add_column_value(key: column.key, value: column.value)
+          end
         end
       end
+    end
 
-      def field(*attrs)
-        key, processor = attrs
+    class << self
+      # Default i18n scope for locales
+      #
+      # en:
+      #   magic_report:
+      #
+      def i18n_scope
+        :magic_report
+      end
 
-        @fields ||= []
-        @fields << Configuration::Field.new(key: key, processor: processor)
+      def i18n_key
+        name.underscore.tr("/", ".").to_sym
       end
 
-      def has_one(attribute, opts = {}, &block)
-        @has_one ||= []
+      def field(*args)
+        options = args.extract_options!
+        name, processor = args
 
-        coerced_attribute = Types::Coercible::Symbol[attribute]
+        reflection = Builder::Field.build(self, name, processor, options)
 
-        klass = ::MagicReport::Utils.derive_class(opts, &block)
+        Reflection.add_field(self, name, reflection)
+      end
 
-        opts[:name] = ::MagicReport::Utils.underscore(opts[:name].to_s) if opts[:name]
+      def fields(*names)
+        names.each { |name| field(name) }
+      end
 
-        if (prefix = opts[:prefix])
-          opts[:prefix] = new(name: ::MagicReport::Utils.underscore(name.to_s)).instance_exec(&prefix)
-        end
+      def has_one(name, **options, &extension)
+        reflection = Builder::HasOne.build(self, name, options, &extension)
 
-        @has_one << Configuration::HasOne.new(klass: klass, opts: opts, key: coerced_attribute)
+        Reflection.add_has_one(self, name, reflection)
       end
 
-      def has_many(attribute, opts = {}, &block)
-        @has_many ||= []
+      def has_many(name, **options, &extension)
+        reflection = Builder::HasMany.build(self, name, options, &extension)
 
-        coerced_attribute = Types::Coercible::Symbol[attribute]
-
-        klass = ::MagicReport::Utils.derive_class(opts, &block)
+        Reflection.add_has_many(self, name, reflection)
+      end
 
-        opts[:name] = ::MagicReport::Utils.underscore(opts[:name].to_s) if opts[:name]
+      # Building empty row for current report
+      # This row doesn't include outer reports
+      def build_row(prefix = nil)
+        row = ::MagicReport::Report::Row.new
 
-        if (prefix = opts[:prefix])
-          opts[:prefix] = new(name: ::MagicReport::Utils.underscore(name.to_s)).instance_exec(&prefix)
+        _fields.each_value do |field|
+          row.register_column(field.name, I18n.t!("#{i18n_scope}.#{i18n_key}.#{field.name}".tr("/", ".")), field.is_primary, prefix)
         end
 
-        @has_many << Configuration::HasMany.new(klass: klass, opts: opts, key: coerced_attribute)
-      end
-    end
-
-    def resolve_path(key)
-      nested_field ? "#{nested_field}.#{key}".to_sym : key
-    end
-
-    private
+        _has_one.each_value do |has_one|
+          row.add_nested_row(key: has_one.name, row: has_one.build_row)
+        end
 
-    def t(key)
-      translated = ::MagicReport::Utils.t(name: name, key: key)
+        _has_many.each_value do |has_many|
+          row.add_nested_row(key: has_many.name, row: has_many.build_row)
+        end
 
-      prefix ? "#{prefix} #{translated}" : translated
+        row
+      end
     end
   end
 end

data/lib/magic_report/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MagicReport
-  VERSION = "0.6.0"
+  VERSION = "0.7.1"
 end

data/lib/magic_report.rb

@@ -3,6 +3,11 @@
 require "dry-types"
 require "i18n"
 
+require "active_support"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/array/extract_options"
+require "active_support/inflector"
+
 require "magic_report/version"
 
 module MagicReport
@@ -14,12 +19,13 @@ module MagicReport
     SymbolArray = Array.of(Types::Coercible::Symbol)
   end
 
-  require "magic_report/utils"
+  require "magic_report/report/builder/field"
+  require "magic_report/report/builder/has_one"
+  require "magic_report/report/builder/has_many"
 
-  require "magic_report/report/class_helpers"
-  require "magic_report/report/configuration"
-  require "magic_report/report/process"
+  require "magic_report/report/reflection"
   require "magic_report/report/row"
   require "magic_report/report/csv"
   require "magic_report/report"
+  require "magic_report/general_report"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magic-report
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Dan Pankratev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-12 00:00:00.000000000 Z
+date: 2025-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-types
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -46,13 +60,14 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/magic_report.rb
+- lib/magic_report/general_report.rb
 - lib/magic_report/report.rb
-- lib/magic_report/report/class_helpers.rb
-- lib/magic_report/report/configuration.rb
+- lib/magic_report/report/builder/field.rb
+- lib/magic_report/report/builder/has_many.rb
+- lib/magic_report/report/builder/has_one.rb
 - lib/magic_report/report/csv.rb
-- lib/magic_report/report/process.rb
+- lib/magic_report/report/reflection.rb
 - lib/magic_report/report/row.rb
-- lib/magic_report/utils.rb
 - lib/magic_report/version.rb
 homepage: https://github.com/thefaded/magic-report
 licenses:
@@ -73,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: An easy way to export data to CSV

data/lib/magic_report/report/class_helpers.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module MagicReport
-  class Report
-    module ClassHelpers
-      def name_from_class
-        ::MagicReport::Utils.underscore(self.class.name)
-      end
-
-      def fields_from_class
-        self.class.instance_variable_get(:@fields) || []
-      end
-
-      def has_one_from_class
-        self.class.instance_variable_get(:@has_one) || []
-      end
-
-      def has_many_from_class
-        self.class.instance_variable_get(:@has_many) || []
-      end
-    end
-  end
-end

data/lib/magic_report/report/configuration.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module MagicReport
-  class Report
-    module Configuration
-      class Field
-        attr_reader :key, :processor
-
-        def initialize(key:, processor: nil)
-          @key = key
-          @processor = processor
-        end
-
-        def process(entity)
-          processor ? processor.call(entity) : entity.send(key)
-        end
-      end
-
-      class HasOne
-        attr_reader :klass, :opts, :prefix, :key
-
-        def initialize(klass:, opts:, key:)
-          @klass = klass
-          @prefix = opts[:prefix]
-          @key = key
-          @opts = opts
-        end
-
-        def process_entity(entity)
-          report.process(entity)
-        end
-
-        def report
-          @report ||= init_report
-        end
-
-        private
-
-        # { class: Exports::Supplier, prefix: lambda }
-
-        def init_report
-          klass.new(report_params)
-        end
-
-        def report_opts
-          opts
-        end
-
-        def report_params
-          opts.reject { |k, v| %i[class].include? k }.merge(nested_field: key)
-        end
-      end
-
-      class HasMany < HasOne; end
-    end
-  end
-end

data/lib/magic_report/report/process.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module MagicReport
-  class Report
-    class Process
-      attr_reader :report
-
-      def initialize(report)
-        @report = report
-      end
-
-      def call(input)
-        if input.is_a? Enumerable
-          input.map do |entity|
-            process_entity(entity)
-          end
-        else
-          process_entity(input)
-        end
-      end
-
-      private
-
-      def process_entity(entity)
-        row = Row.new
-
-        process_fields(entity, row)
-        process_has_one(entity, row)
-        process_has_many(entity, row)
-
-        row
-      end
-
-      def process_fields(entity, row)
-        report.fields.each do |field|
-          row.add(field: report.resolve_path(field.key), value: field.process(entity))
-        end
-      end
-
-      def process_has_one(entity, row)
-        report.has_one.each do |association|
-          inner_row = association.process_entity(entity.send(association.key))
-
-          row.add_inner_row(field: report.resolve_path(association.key), row: inner_row)
-        end
-      end
-
-      def process_has_many(entity, row)
-        report.has_many.each do |association|
-          entity.send(association.key).each do |entity|
-            nested_row = association.process_entity(entity)
-
-            row.add_nested_row(field: report.resolve_path(association.key), row: nested_row)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/magic_report/utils.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module MagicReport
-  module Utils
-    def underscore(klass)
-      return "ded" unless klass
-
-      klass.gsub(/::/, "/")
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .tr("-", "_")
-        .tr("/", ".")
-        .downcase
-    end
-
-    def derive_class(opts, &block)
-      if block
-        raise "name option must be provided" unless opts[:name]
-
-        cloned_klass = ::MagicReport::Report.clone
-        cloned_klass.define_singleton_method(:name) { opts[:name] }
-        cloned_klass.class_eval(&block)
-        cloned_klass
-      else
-        opts[:class]
-      end
-    end
-
-    # @param name is the report name
-    # @key is a field
-    def t(name:, key:)
-      I18n.translate!("magic_report.#{name}.#{key}")
-    end
-
-    module_function :underscore
-    module_function :derive_class
-    module_function :t
-  end
-end