noventius 1.0.0

data/lib/nuntius/post_processors/date_ranges.rb

@@ -0,0 +1,120 @@
+module Nuntius
+
+  module PostProcessors
+
+    class DateRanges
+
+      DATE_STEPS = %i(day month)
+      STEPS = %i(day month hour dow moy)
+
+      def initialize(column_index_or_name, step, time_zone = 'America/Montevideo')
+        fail ArgumentError, "Step not supported [#{step}]." unless STEPS.include?(step.to_sym)
+
+        @column_index_or_name = column_index_or_name
+        @step = step.to_sym
+        @time_zone = time_zone
+      end
+
+      def process(report, rows)
+        return [] if rows.empty?
+
+        rows_by_date = group_rows_by_date(report, rows)
+
+        start_date = rows_by_date.keys.min
+        end_date = rows_by_date.keys.max
+
+        empty_row = build_empty_row(report)
+
+        build_range(start_date, end_date).map do |value|
+          rows_by_date.fetch(value, [value].concat(empty_row))
+        end
+      end
+
+      private
+
+      def group_rows_by_date(report, rows)
+        column_index = get_column_index(report, rows.first.is_a?(Hash))
+
+        rows.inject({}) do |result, row|
+          row[column_index] = parse_date_column(row[column_index])
+          result.merge(row[column_index].to_i => row)
+        end
+      end
+
+      def parse_date_column(value)
+        if DATE_STEPS.include?(@step)
+          Time.parse(value).in_time_zone(@time_zone)
+        else
+          value.to_i
+        end
+      end
+
+      def get_column_index(report, hash_rows)
+        if hash_rows
+          @column_index_or_name.to_s
+        elsif @column_index_or_name.is_a?(Integer)
+          @column_index_or_name
+        else
+          report.column_index(@column_index_or_name)
+        end
+      end
+
+      def build_empty_row(report)
+        columns_count = report.columns.size
+        [''] * (columns_count - 1)
+      end
+
+      def build_range(start_value, end_value)
+        case @step
+        when :day
+          (DayRange.new(start_value)..DayRange.new(end_value)).map(&:date)
+        when :month
+          (MonthRange.new(start_value)..MonthRange.new(end_value)).map(&:date)
+        else
+          start_value..end_value
+        end
+      end
+
+      class BaseRange
+
+        include Comparable
+
+        attr_reader :date
+
+        def initialize(date)
+          @date = date
+        end
+
+        def succ
+          self.class.new(@date + @step)
+        end
+
+        def <=>(other)
+          @date <=> other.date
+        end
+
+      end
+
+      class DayRange < BaseRange
+
+        def initialize(date)
+          super
+          @step = 1.day
+        end
+
+      end
+
+      class MonthRange < BaseRange
+
+        def initialize(date)
+          super
+          @step = 1.month
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl/columns.rb

@@ -0,0 +1,132 @@
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      module Columns
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        module ClassMethods
+
+          def columns
+            @columns ||= []
+          end
+
+          def columns_names
+            @columns_names ||= []
+          end
+
+          def column(name, type, options = {})
+            validate_name_not_taken!(name)
+
+            Column.new(name, type, options).tap do |column|
+              columns_names << column.name
+              columns << column
+            end
+          end
+
+          def columns_group(name, children, options = {})
+            validate_name_not_taken!(name)
+
+            ColumnsGroup.new(name, children, options).tap do |columns_group|
+              columns_names << columns_group.name
+              children.map { |child| columns.delete(child) }
+
+              columns << columns_group
+            end
+          end
+
+          def dynamic_columns(method_name)
+            columns << -> { send(method_name) }
+          end
+
+          private
+
+          def validate_name_not_taken!(name)
+            fail "Column name: #{name} is taken" if columns_names.include?(name.to_sym)
+          end
+
+        end
+
+        module InstanceMethods
+
+          def columns
+            return @columns if @columns
+
+            build_columns
+
+            @columns
+          end
+
+          def columns_without_groups
+            return @columns_without_groups if @columns_without_groups
+
+            build_columns
+
+            @columns_without_groups
+          end
+
+          def columns_names
+            @columns_names ||= self.class.columns_names.dup
+          end
+
+          def column(name, type, options = {})
+            validate_name_not_taken!(name)
+
+            Column.new(name, type, options).tap do |column|
+              columns_names << column.name
+            end
+          end
+
+          def column_group(name, children, options = {})
+            validate_name_not_taken!(name)
+
+            ColumnsGroup.new(name, children, options).tap do |columns_group|
+              columns_names << columns_group.name
+            end
+          end
+
+          def column_index(name)
+            columns_without_groups.find_index { |column| column.name == name }
+          end
+
+          private
+
+          def validate_name_not_taken!(name)
+            fail "Column name: #{name} is taken" if columns_names.include?(name.to_sym)
+          end
+
+          def build_columns
+            @columns = self.class.columns.map do |column|
+              column = instance_exec(&column) if column.is_a?(Proc)
+
+              column
+            end.flatten
+
+            @columns_without_groups = build_columns_without_groups(@columns)
+          end
+
+          def build_columns_without_groups(columns)
+            columns.map do |column|
+              if column.is_a?(Nuntius::Column)
+                column
+              else
+                build_columns_without_groups(column.columns)
+              end
+            end.flatten
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl/filters.rb

@@ -0,0 +1,50 @@
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      module Filters
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        module ClassMethods
+
+          def filters
+            (@filters ||= []).sort_by! { |f| f.options[:priority] }
+          end
+
+          def filter(name, type, args = {})
+            filters << Filter.new(name, type, args)
+            define_filter_accessors(name, type)
+          end
+
+          protected
+
+          def define_filter_accessors(name, _type)
+            define_method(name) { filter_params[name] }
+            define_method("#{name}=") { |value| filter_params[name] = value }
+          end
+
+        end
+
+        module InstanceMethods
+
+          attr_reader :filter_params
+
+          def filters
+            self.class.filters.deep_dup
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl/nested.rb

@@ -0,0 +1,66 @@
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      module Nested
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        module ClassMethods
+
+          attr_reader :nested_options
+          attr_reader :nested_report_class
+
+          def nest_report(klass, options = {})
+            @nested_report_class = klass
+            @nested_options = options
+          end
+
+          def includes_nested?
+            @nested_report_class != nil
+          end
+
+        end
+
+        module InstanceMethods
+
+          def nested_options
+            self.class.nested_options
+          end
+
+          def enable_nested?
+            return @enable_nested unless @enable_nested.nil?
+
+            return false unless self.class.includes_nested?
+
+            @enable_nested = nested_options.fetch(:if, true)
+            @enable_nested = public_send(@enable_nested) if @enable_nested.is_a?(Symbol)
+            @enable_nested = instance_exec(&@enable_nested) if @enable_nested.is_a?(Proc)
+
+            @enable_nested
+          end
+
+          def build_nested_report(row)
+            row ||= []
+
+            nested_filters = nested_options[:filters] || filter_params
+            nested_filters = public_send(nested_filters, row) if nested_filters.is_a?(Symbol)
+            nested_filters = instance_exec(row, &nested_filters) if nested_filters.is_a?(Proc)
+
+            self.class.nested_report_class.new(nested_filters)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl/post_processors.rb

@@ -0,0 +1,40 @@
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      module PostProcessors
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        module ClassMethods
+
+          def post_processors
+            @post_processors ||= []
+          end
+
+          def post_processor(post_processor, options = {})
+            post_processors << [post_processor, options]
+          end
+
+        end
+
+        module InstanceMethods
+
+          def post_processors
+            self.class.post_processors
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl/validations.rb

@@ -0,0 +1,40 @@
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      module Validations
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+
+        module ClassMethods
+
+          def validations
+            @validations ||= []
+          end
+
+          def validate(name, rules: {}, messages: {})
+            validations << Validation.new(name, rules, messages)
+          end
+
+        end
+
+        module InstanceMethods
+
+          def validations
+            self.class.validations.deep_dup
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/dsl.rb

@@ -0,0 +1,42 @@
+require_relative 'dsl/filters'
+require_relative 'dsl/columns'
+require_relative 'dsl/nested'
+require_relative 'dsl/post_processors'
+require_relative 'dsl/validations'
+
+module Nuntius
+
+  class Report
+
+    module Dsl
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+
+        include Filters::ClassMethods
+        include Columns::ClassMethods
+        include Nested::ClassMethods
+        include PostProcessors::ClassMethods
+        include Validations::ClassMethods
+
+      end
+
+      module InstanceMethods
+
+        include Filters::InstanceMethods
+        include Columns::InstanceMethods
+        include Nested::InstanceMethods
+        include PostProcessors::InstanceMethods
+        include Validations::InstanceMethods
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report/interpolator.rb

@@ -0,0 +1,75 @@
+module Nuntius
+
+  class Report
+
+    module Interpolator
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+
+      end
+
+      module InstanceMethods
+
+        UNESCAPED_REGEX = /(<%\w+%>)+/
+        UNESCAPED_VARIABLE_REGEX = /(?:<%)(\w+)(?:%>)/
+
+        ESCAPED_REGEX = /({\w+})+/
+        ESCAPED_VARIABLE_REGEX = /(?:{)(\w+)(?:})/
+
+        # Interpolate the given text in the context of `self`
+        #
+        # Interpolated variables will try to call a method on `self` for obtaining the value.
+        #
+        # Two syntax are supported at the moment.
+        #
+        # Let's say we have a method called foo that return String 'bar'
+        #
+        # {foo} => 'bar'
+        # <%foo%> => bar
+        #
+        # @param [String] text The text to interpolate
+        # @return [String] The interpolated text
+        def interpolate(text)
+          return unless text
+
+          # Interpolate escaped variables
+          text.scan(ESCAPED_REGEX).flatten.each do |var|
+            var_name = var.match(ESCAPED_VARIABLE_REGEX)[1]
+            value = send(var_name.to_sym)
+
+            text.gsub!(var, escape(value))
+          end
+
+          # Interpolate unescaped variables
+          text.scan(UNESCAPED_REGEX).flatten.each do |var|
+            var_name = var.match(UNESCAPED_VARIABLE_REGEX)[1]
+            value = send(var_name.to_sym)
+
+            text.gsub!(var, value)
+          end
+
+          text
+        end
+
+        protected
+
+        def escape(value)
+          if value.respond_to?(:map)
+            "(#{value.map { |v| escape(v) }.join(', ')})"
+          else
+            ActiveRecord::Base.connection.quote(value)
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/report.rb

@@ -0,0 +1,81 @@
+require_relative 'report/dsl'
+require_relative 'report/interpolator'
+require_relative 'serializers/csv'
+
+module Nuntius
+
+  class Report
+
+    include Dsl
+    include Interpolator
+
+    class << self
+
+      attr_reader :tab_title
+
+      def title(title)
+        @tab_title = title
+      end
+
+    end
+
+    def initialize(filter_params = {})
+      @filter_params = filter_params
+    end
+
+    def self.all
+      Dir.glob(File.expand_path('app/reports/*.rb', Rails.root)).map do |file|
+        file[%r{app\/reports\/(.*)\.rb}, 1].classify.constantize
+      end
+    end
+
+    def result
+      @result ||= ActiveRecord::Base.connection.exec_query(interpolate(sql))
+    end
+
+    def columns
+      columns = super
+
+      columns = result.columns.map { |column| Column.new(column, :string) } unless columns.any?
+
+      columns
+    end
+
+    def rows # rubocop:disable Rails/Delegate
+      result.rows
+    end
+
+    def processed_rows
+      post_processors.inject(rows) do |rows, (post_processor, options)|
+        execute = options.fetch(:if, true)
+        execute = instance_exec(&execute) if execute.is_a?(Proc)
+        execute = public_send(execute) if execute.is_a?(Symbol)
+
+        return rows unless execute
+
+        if post_processor.is_a?(Proc)
+          instance_exec(rows, &post_processor)
+        elsif post_processor.is_a?(Symbol)
+          public_send(post_processor, rows)
+        else
+          post_processor.process(self, rows)
+        end
+      end
+    end
+
+    def to(format)
+      case format
+      when :csv
+        Serializers::Csv.new(self).generate
+      else
+        fail NotImplementedError, "No serializer found for: #{format}"
+      end
+    end
+
+    def sql
+      fail NotImplementedError, "Abstract method #{__method__}"
+    end
+
+  end
+
+end

data/lib/nuntius/serializers/csv.rb

@@ -0,0 +1,54 @@
+require 'csv'
+
+module Nuntius
+
+  module Serializers
+
+    class Csv
+
+      def initialize(report)
+        @report = report
+      end
+
+      def generate
+        CSV.generate(force_quotes: true) do |csv|
+          csv << headers
+          rows.each { |row| csv << row }
+        end
+      end
+
+      private
+
+      def headers
+        @report.columns.map do |column|
+          column_with_prefix(column)
+        end.flatten
+      end
+
+      def column_with_prefix(column, prefixes = [])
+        if column.is_a?(Nuntius::Column)
+          [*prefixes, column.label].join(' ')
+        else
+          column.columns.map do |local_column|
+            column_with_prefix(local_column, prefixes + [column.label])
+          end.flatten
+        end
+      end
+
+      def rows
+        @report.rows.map do |row|
+          row(row)
+        end
+      end
+
+      def row(row)
+        row.map do |cell|
+          cell
+        end
+      end
+
+    end
+
+  end
+
+end