simple_drilldown 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24272122319881a4c28db29d1b986ebd2f49d0ed50d642648fe5e5795c4f04b4
-  data.tar.gz: c5ec174af7dcb4d1ca5dfabfa0abc27b8999177d2f6580be2f65f874825bfcf0
+  metadata.gz: 203d9f2001a9677cd008ef0e7f9a10755420c1a06269d3fe2e37cb7467d35dcc
+  data.tar.gz: 18bbbd147c2f78ae45674054c6f5af919f49e792da115971ba145693f2528f67
 SHA512:
-  metadata.gz: 6310bab272395d0b003616e99e9467c81f31148a6410e83e124770589ef6e9e81de2b60ca8aa84b31eadfc1fb62bfbe81a7e377187a2d0479d0c6e3c819cdbe1
-  data.tar.gz: ba2943b101e839e0793c51c4d80e94e27952476993c70b6eeaaa1a3a953336da0115890262f2a135ca49669a6298b8bf777bc5d60ba304616ca3c61041c504a4
+  metadata.gz: 81dc94488937c04c7563cbc6560fed331cb8bd92a57751fc2df36372c87fe6e25d206d4a983f34d7f3473786bdb78e452a4058f453cf1fa48ec51b94d2efb3d3
+  data.tar.gz: f3fcaed4cadf14219ed36cc683e8ad04fc16c27b80c1b5112fb133cfb8a2060d81b8210953b656c848da2fa63c4989c75f3e02cbd91d2c940e476148d92fb2fb

data/lib/generators/drilldown_controller/drilldown_controller_generator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class DrilldownControllerGenerator < Rails::Generators::NamedBase
   source_root File.expand_path('templates', __dir__)
 
   def copy_drilldown_controller_file
-    template "drilldown_controller.rb.erb", "app/controllers/#{file_name}_drilldown_controller.rb"
+    template 'drilldown_controller.rb.erb', "app/controllers/#{file_name}_drilldown_controller.rb"
     route "resources(:#{singular_name}_drilldown, only: :index){collection{get :excel_export;get :html_export}}"
   end
 end

data/lib/simple_drilldown/drilldown_controller.rb

@@ -47,26 +47,52 @@ module SimpleDrilldown
         @@fields[name] = options
       end
 
-      def dimension(name, select_expression = name.to_s, options = {})
-        includes = options.delete(:includes)
+      def summary_fields(*summary_fields)
+        @@summary_fields = summary_fields
+      end
+
+      def dimension(name, select_expression = name, options = {})
         interval = options.delete(:interval)
-        label_method = options.delete(:label_method) || ->(f) { f.to_s }
+        label_method = options.delete(:label_method)
         legal_values = options.delete(:legal_values) || legal_values_for(name)
         reverse = options.delete(:reverse)
+        row_class = options.delete(:row_class)
+        if select_expression.is_a?(Array)
+          queries = select_expression
+        else
+          includes = options.delete(:includes)
+          conditions = options.delete(:where)
+          queries = [{
+            select: select_expression,
+            includes: includes,
+            where: conditions
+          }]
+        end
+        raise "Unexpected options: #{options.inspect}" if options.present?
 
-        raise "Unknown options: #{options.keys.inspect}" unless options.empty?
+        queries.each do |query_opts|
+          raise "Unknown options: #{query_opts.keys.inspect}" unless (query_opts.keys - %i[select includes where]).empty?
+        end
 
         @@dimension_defs ||= Concurrent::Hash.new
 
         @@dimension_defs[name.to_s] = {
-            select_expression: select_expression,
-            pretty_name: I18n.t(name),
-            url_param_name: name.to_s,
-            legal_values: legal_values,
-            label_method: label_method,
-            reverse: reverse,
-            includes: includes,
-            interval: interval
+          includes: queries.inject([]) do |a, e|
+            i = e[:includes]
+            next a unless i
+            next a if a.include?(i)
+
+            a + [i]
+          end,
+          interval: interval,
+          label_method: label_method,
+          legal_values: legal_values,
+          pretty_name: I18n.t(name),
+          queries: queries,
+          reverse: reverse,
+          select_expression: queries.size > 1 ? "COALESCE(#{queries.map { |q| q[:select] }.join(',')})" : queries[0][:select],
+          row_class: row_class,
+          url_param_name: name.to_s
         }
       end
 
@@ -74,29 +100,38 @@ module SimpleDrilldown
         lambda do |search|
           my_filter = search.filter.dup
           my_filter.delete(field.to_s) unless preserve_filter
-          conditions, t, includes = make_conditions(my_filter)
-          dimension = @@dimension_defs[field.to_s]
-          if dimension[:includes]
-            if dimension[:includes].is_a?(Array)
-              includes += dimension[:includes]
-            else
-              includes << dimension[:includes]
+          filter_conditions, _t, includes = make_conditions(my_filter)
+          dimension_def = @@dimension_defs[field.to_s]
+          result_sets = dimension_def[:queries].map do |query|
+            if query[:includes]
+              if query[:includes].is_a?(Array)
+                includes += query[:includes]
+              else
+                includes << query[:includes]
+              end
+              includes.uniq!
             end
-            includes.uniq!
-          end
-          rows = @@target_class.unscoped.where(@@base_condition)
-              .select("#{dimension[:select_expression]} AS value")
-              .where(conditions)
-              .joins(make_join([], @@target_class.name.underscore.to_sym, includes))
-              .order('value')
-              .group('value').all.to_a
-          search.filter[field.to_s]&.each do |selected_value|
-            unless rows.find { |r| dimension[:label_method].call(r[:value]) == selected_value }
+            rows = @@target_class.unscoped.where(@@base_condition)
+                                 .select("#{query[:select]} AS value")
+                                 .where(filter_conditions)
+                                 .where(query[:where])
+                                 .joins(make_join([], @@target_class.name.underscore.to_sym, includes))
+                                 .order('value')
+                                 .group(:value)
+                                 .to_a
+            filter_fields = search.filter[field.to_s]
+            filter_fields&.each do |selected_value|
+              next if rows.find { |r| r[:value].to_s == selected_value }
+
+              # FIXME(uwe):  Convert the selected value to same data type as legal values
               rows << { value: selected_value }
+              # EMXIF
             end
+            rows.map { |r| [dimension_def[:label_method]&.call(r[:value]) || r[:value], r[:value]] }
           end
-          values = rows.map { |r| [dimension[:label_method]&.call(r[:value]) || r[:value], r[:value]] }.sort_by { |a| a[0].upcase }
-          values.reverse! if dimension[:reverse]
+          values = result_sets.inject(&:+).uniq
+          values.sort! if dimension_def[:queries].size > 1
+          values.reverse! if dimension_def[:reverse]
           values
         end
       end
@@ -115,22 +150,24 @@ module SimpleDrilldown
             values = [*values]
             if dimension_def[:interval]
               values *= 2 if values.size == 1
-              if values.size != 2
-                raise "Need 2 values for interval filter: #{values.inspect}"
-              end
+              raise "Need 2 values for interval filter: #{values.inspect}" if values.size != 2
 
-              if !values[0].blank? && !values[1].blank?
+              if values[0].present? && values[1].present?
                 condition_strings << "#{dimension_def[:select_expression]} BETWEEN ? AND ?"
                 condition_values += values
-                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "from #{values[0]} to #{values[1]}"}"
-              elsif !values[0].blank?
+                filter_texts << <<~TEXT
+                  #{dimension_def[:pretty_name]} #{dimension_def[:label_method]&.call(values) || "from #{values[0]} to #{values[1]}"}
+                TEXT
+              elsif values[0].present?
                 condition_strings << "#{dimension_def[:select_expression]} >= ?"
-                condition_values < values[0]
-                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "from #{values[0]}"}"
-              elsif !values[1].blank?
+                condition_values << values[0]
+                filter_texts <<
+                  "#{dimension_def[:pretty_name]} #{dimension_def[:label_method]&.call(values) || "from #{values[0]}"}"
+              elsif values[1].present?
                 condition_strings << "#{dimension_def[:select_expression]} <= ?"
-                condition_values < values[1]
-                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "to #{values[1]}"}"
+                condition_values << values[1]
+                filter_texts <<
+                  "#{dimension_def[:pretty_name]} #{dimension_def[:label_method]&.call(values) || "to #{values[1]}"}"
               end
               includes << dimension_def[:includes] if dimension_def[:includes]
             else
@@ -140,7 +177,8 @@ module SimpleDrilldown
                 else
                   condition_values << value
                 end
-                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(value) : value}"
+                filter_texts <<
+                  "#{dimension_def[:pretty_name]} #{dimension_def[:label_method]&.call(value) || value}"
                 includes << dimension_def[:includes] if dimension_def[:includes]
                 "(#{dimension_def[:select_expression]}) = ?"
               end.join(' OR ')
@@ -148,11 +186,12 @@ module SimpleDrilldown
           end
           filter_text = filter_texts.join(' and ')
           conditions = [condition_strings.map { |c| "(#{c})" }.join(' AND '), *condition_values]
-          includes.uniq!
+          includes.keep_if(&:present?).uniq!
         else
           filter_text = nil
           conditions = nil
         end
+        conditions = nil if conditions == ['']
         [conditions, filter_text, includes]
       end
 
@@ -161,7 +200,7 @@ module SimpleDrilldown
         when Array
           include.map { |i| make_join(joins, model, i) }.join(' ')
         when Hash
-          sql = ''
+          sql = +''
           include.each do |parent, child|
             sql << make_join(joins, model, parent) + ' '
             ass = model.to_s.camelize.constantize.reflect_on_association parent
@@ -171,6 +210,7 @@ module SimpleDrilldown
         when Symbol
           return '' if joins.include?(include)
 
+          joins = joins.dup
           joins << include
           ass = model_class.reflect_on_association include
           raise "Unknown association: #{model} => #{include}" unless ass
@@ -183,17 +223,20 @@ module SimpleDrilldown
             "LEFT JOIN #{include_table} #{include_alias} ON #{include_alias}.id = #{model_table}.#{include}_id"
           when :has_one, :has_many
             fk_col = ass.options[:foreign_key] || "#{model}_id"
-            sql = "LEFT JOIN #{include_table} #{include_alias} ON #{include_alias}.#{fk_col} = #{model_table}.id"
-            if (ass_order = ass.options[:order].try(:to_s))
-              ass_order.sub!(/ DESC\s*$/i, '')
+            sql = +"LEFT JOIN #{include_table} #{include_alias} ON #{include_alias}.#{fk_col} = #{model_table}.id"
+            sql << " AND #{include_alias}.deleted_at IS NULL" if ass.klass.paranoid?
+            if ass.scope && (ass_order = ScopeHolder.new(ass.scope).to_s)
+              ass_order = ass_order.sub(/ DESC\s*$/i, '')
               ass_order_prefixed = ass_order.dup
               ActiveRecord::Base.connection.columns(include_table).map(&:name).each do |cname|
                 ass_order_prefixed.gsub!(/\b#{cname}\b/, "#{include_alias}.#{cname}")
               end
-              sql << " AND  #{ass_order_prefixed} = (SELECT MIN(#{ass_order}) FROM #{include_table} t2 WHERE t2.#{fk_col} = #{model_table}.id #{
-              if ass.klass.paranoid?
-                'AND t2.deleted_at IS NULL'
-              end})"
+              paranoid_clause = 'AND t2.deleted_at IS NULL' if ass.klass.paranoid?
+              # FIXME(uwe):  Should we add "where" from the ScopeHolder here as well?  Ref: DrilldownChanges#changes_for
+              min_query = <<~SQL
+                SELECT MIN(#{ass_order}) FROM #{include_table} t2 WHERE t2.#{fk_col} = #{model_table}.id #{paranoid_clause}
+              SQL
+              sql << " AND  #{ass_order_prefixed} = (#{min_query})"
             end
             sql
           else
@@ -225,13 +268,16 @@ module SimpleDrilldown
       @list_includes = @@list_includes
       @list_order = @@list_order
       @dimension_defs = @@dimension_defs
-      @summary_fields = []
+      @@summary_fields = [] unless defined?(@@summary_fields)
+      @summary_fields = @@summary_fields
+
+      @history_fields = @fields.select { |_k, v| v[:list_change_times] }.map { |k, _v| k.to_s }
     end
 
     # ?dimension[0]=supplier&dimension[1]=transaction_type&
     # filter[year]=2009&filter[supplier][0]=Shell&filter[supplier][1]=Statoil
     def index(do_render = true)
-      @search = Search.new(params[:search]&.to_unsafe_h, @default_fields, @default_select_value)
+      @search = new_search_object
 
       @transaction_fields = (@search.fields + (@fields.keys.map(&:to_s) - @search.fields))
       @transaction_fields_map = @fields
@@ -240,11 +286,9 @@ module SimpleDrilldown
       includes = @base_includes.dup
 
       @dimensions = []
-      select << ", 'All' as value0"
+      select << ", 'All'::text as value0"
       @dimensions += @search.dimensions.map do |dn|
-        if @dimension_defs[dn].nil?
-          raise "Unknown distribution field: #{@search.dimensions.inspect}"
-        end
+        raise "Unknown distribution field: #{dn.inspect}" if @dimension_defs[dn].nil?
 
         @dimension_defs[dn]
       end
@@ -255,42 +299,108 @@ module SimpleDrilldown
 
       conditions, @filter_text, filter_includes = self.class.make_conditions(@search.filter)
       includes += filter_includes
-      includes.uniq!
+      includes.keep_if(&:present?).uniq!
       if @search.order_by_value && @dimensions.size <= 1
-        order = 'count DESC'
+        order = case @search.select_value
+                when DrilldownSearch::SelectValue::VOLUME
+                  'volume DESC'
+                when DrilldownSearch::SelectValue::VOLUME_COMPENSATED
+                  'volume_compensated DESC'
+                when DrilldownSearch::SelectValue::COUNT
+                  'count DESC'
+                else
+                  'count DESC'
+                end
       else
-        order = @dimensions.map { |d| d[:select_expression] }.join(', ')
+        order = (1..@dimensions.size).map { |i| "value#{i}" }.join(',')
         order = nil if order.empty?
       end
-      group = (@base_group + @dimensions.map { |d| d[:select_expression] }).join(', ')
+      group = (@base_group + (1..@dimensions.size).map { |i| "value#{i}" }).join(',')
       group = nil if group.empty?
 
+      joins = self.class.make_join([], @target_class.name.underscore.to_sym, includes)
       rows = @target_class.unscoped.where(@base_condition).select(select).where(conditions)
-                          .joins(self.class.make_join([], @target_class.name.underscore.to_sym, includes))
+                          .joins(joins)
                           .group(group)
-                          .order(order).all.to_a
+                          .order(order).to_a
 
       if rows.empty?
         @result = { value: 'All', count: 0, row_count: 0, nodes: 0, rows: [] }
+        @summary_fields.each { |f| @result[f] = 0 }
       else
         if do_render && @search.list && rows.inject(0) { |sum, r| sum + r[:count].to_i } > LIST_LIMIT
           @search.list = false
-          flash[:notice] = "More than #{LIST_LIMIT} records.  List disabled."
+          flash.now[:notice] = "More than #{LIST_LIMIT} records.  List disabled."
         end
         @result = result_from_rows(rows, 0, 0, ['All'])
       end
 
       remove_duplicates(@result) unless @base_group.empty?
 
-      @remaining_dimensions = @dimension_defs.dup.delete_if do |dim_name, _dimension|
-        (@search.filter[dim_name] && @search.filter[dim_name].size == 1) ||
-          (@dimensions.any? { |d| d[:url_param_name] == dim_name })
+      @remaining_dimensions = @dimension_defs.dup
+      @remaining_dimensions.each_key do |dim_name|
+        if (@search.filter[dim_name] && @search.filter[dim_name].size == 1) ||
+           (@dimensions.any? { |d| d[:url_param_name] == dim_name })
+          @remaining_dimensions.delete(dim_name)
+        end
       end
 
       populate_list(conditions, includes, @result, []) if @search.list
       render template: '/drilldown/index' if do_render
     end
 
+    def choices
+      @search = new_search_object
+      dimension_name = params[:dimension_name]
+      dimension = @dimension_defs[dimension_name]
+      selected = @search.filter[dimension_name] || []
+      raise "Unknown dimension #{dimension_name.inspect}: #{@dimension_defs.keys.inspect}" unless dimension
+
+      choices = [[t(:all), nil]] +
+                (dimension[:legal_values]&.call(@search)&.map { |o| o.is_a?(Array) ? o[0..1].map(&:to_s) : o.to_s } || [])
+      choices_html = choices.map do |c|
+        %(<option value="#{c[1]}"#{' SELECTED' if selected.include?(c[1])}>#{c[0]}</option>)
+      end.join("\n")
+      render html: choices_html.html_safe
+    end
+
+    def html_export
+      index(false)
+      render template: '/drilldown/html_export', layout: 'print'
+    end
+
+    def excel_export
+      index(false)
+      headers['Content-Type'] = 'application/vnd.ms-excel'
+      headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
+      headers['Cache-Control'] = ''
+      render template: '/drilldown/excel_export', layout: false
+    end
+
+    def excel_export_transactions
+      params[:search][:list] = '1'
+      index(false)
+      @transactions = get_transactions(@result)
+      headers['Content-Type'] = 'application/vnd.ms-excel'
+      headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
+      render template: '/drilldown/excel_export_transactions', layout: false
+    end
+
+    def xml_export
+      params[:search][:list] = '1'
+      index(false)
+      @transactions = get_transactions(@result)
+      headers['Content-Type'] = 'text/xml'
+      headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
+      render template: '/drilldown/xml_export', layout: false
+    end
+
+    private
+
+    def new_search_object
+      SimpleDrilldown::Search.new(params[:search].to_unsafe_h, @default_fields, @default_select_value)
+    end
+
     def remove_duplicates(result)
       rows = result[:rows]
       return 0 unless rows
@@ -301,6 +411,9 @@ module SimpleDrilldown
         if prev_row
           if prev_row[:value] == r[:value]
             prev_row[:count] += r[:count]
+            @summary_fields.each do |f|
+              prev_row[f] += r[f]
+            end
             prev_row[:row_count] = [prev_row[:row_count], r[:row_count]].max
             prev_row[:nodes] = [prev_row[:nodes], r[:nodes]].max
             prev_row[:rows] += r[:rows] if prev_row[:rows] || r[:rows]
@@ -322,7 +435,8 @@ module SimpleDrilldown
 
     # Empty summary rows are needed to plot zero points in the charts
     def add_zero_results(result_rows, dimension)
-      legal_values = self.class.legal_values_for(@dimensions[dimension][:url_param_name], true).call(@search).map { |lv| lv[1] }
+      legal_values =
+        self.class.legal_values_for(@dimensions[dimension][:url_param_name], true).call(@search).map { |lv| lv[1] }
       legal_values.reverse! if @dimensions[dimension][:reverse]
       current_values = result_rows.map { |r| r[:value] }.compact
       empty_values = legal_values - current_values
@@ -335,9 +449,8 @@ module SimpleDrilldown
             row_count: 0,
             nodes: 0
           }
-          if dimension < @dimensions.size - 1
-            sub_result[:rows] = add_zero_results([], dimension + 1)
-          end
+          @summary_fields.each { |f| sub_result[f] = 0 }
+          sub_result[:rows] = add_zero_results([], dimension + 1) if dimension < @dimensions.size - 1
           result_rows << sub_result
         end
         result_rows = result_rows.sort_by { |r| legal_values.index(r[:value]) }
@@ -353,12 +466,14 @@ module SimpleDrilldown
       return nil if values != previous_values
 
       if dimension == @dimensions.size
-        return {
+        result = {
           value: values[-1],
           count: row[:count].to_i,
           row_count: 1,
           nodes: @search.list ? 2 : 1
         }
+        @summary_fields.each { |f| result[f] = row[f].to_i }
+        return result
       end
 
       result_rows = []
@@ -373,61 +488,84 @@ module SimpleDrilldown
 
       result_rows = add_zero_results(result_rows, dimension)
 
-      {
+      result = {
         value: values[-1],
         count: result_rows.inject(0) { |t, r| t + r[:count].to_i },
         row_count: result_rows.inject(0) { |t, r| t + r[:row_count] },
         nodes: result_rows.inject(0) { |t, r| t + r[:nodes] } + 1,
         rows: result_rows
       }
+      @summary_fields.each { |f| result[f] = result_rows.inject(0) { |t, r| t + r[f] } }
+      result
     end
 
-    def html_export
-      index(false)
-      render template: '/drilldown/html_export', layout: '../drilldown/print'
-    end
-
-    def excel_export
-      index(false)
-      headers['Content-Type'] = 'application/vnd.ms-excel'
-      headers['Content-Disposition'] = 'attachment; filename="elections.xls"'
-      headers['Cache-Control'] = ''
-      render template: '/drilldown/excel_export', layout: false
-    end
-
-    private
-
     def populate_list(conditions, includes, result, values)
       if result[:rows]
         result[:rows].each do |r|
           populate_list(conditions, includes, r, values + [r[:value]])
         end
       else
-        options = { include: includes + @list_includes, order: @list_order }
+        list_includes = includes + @list_includes
         @search.fields.each do |field|
           field_def = @transaction_fields_map[field.to_sym]
           raise "Field definition missing for: #{field.inspect}" unless field_def
 
           field_includes = field_def[:include]
           if field_includes
-            options[:include] += field_includes.is_a?(Array) ? field_includes : [field_includes]
+            list_includes += field_includes.is_a?(Array) ? field_includes : [field_includes]
           end
         end
-        options[:include].uniq!
-
-        joins = self.class.make_join([], @target_class.name.underscore.to_sym, options.delete(:include))
-        result[:transactions] = @target_class.unscoped.joins(joins).where(@base_condition).where(list_conditions(conditions, values)).includes(options[:include]).order(options[:order]).all
+        list_includes.uniq!
+        if @search.list_change_times
+          @history_fields.each do |f|
+            list_includes << { assignment: { order: :"#{f}_changes" } } if @search.fields.include? f
+          end
+        end
+        joins = self.class.make_join([], @target_class.name.underscore.to_sym, list_includes)
+        list_conditions = list_conditions(conditions, values)
+        base_query = @target_class.unscoped.where(@base_condition).joins(joins).order(@list_order)
+        base_query = base_query.where(list_conditions) if list_conditions
+        result[:transactions] = base_query.to_a
       end
     end
 
     def list_conditions(conditions, values)
+      conditions ||= ['']
+
       list_conditions_string = conditions[0].dup
       @dimensions.each do |d|
-        list_conditions_string << "#{unless list_conditions_string.empty?
-                                       ' AND '
-                                     end}#{d[:select_expression]} = ?"
+        list_conditions_string << "#{' AND ' unless list_conditions_string.empty?}#{d[:select_expression]} = ?"
       end
       [list_conditions_string, *(conditions[1..-1] + values)]
     end
+
+    def get_transactions(tree)
+      return tree[:transactions] if tree[:transactions]
+
+      tree[:rows].map { |r| get_transactions(r) }.flatten
+    end
+
+    class ScopeHolder
+      def initialize(scope)
+        instance_eval(&scope)
+      end
+
+      def order(order)
+        @order = order
+        self
+      end
+
+      def where(*_conditions)
+        self
+      end
+
+      def to_s
+        if @order.is_a?(Hash)
+          @order.map { |field, direction| "#{field} #{direction}" }.join(', ')
+        else
+          @order.to_s
+        end
+      end
+    end
   end
 end

data/lib/simple_drilldown/drilldown_helper.rb

@@ -9,7 +9,7 @@ module SimpleDrilldown
 
     def caption
       result = @search.title ? @search.title : "#{@target_class} #{t(@search.select_value.downcase)}" +
-          ((@dimensions && @dimensions.any?) ? ' by ' + @dimensions.map { |d| d[:pretty_name] }.join(' and ') : '')
+        ((@dimensions && @dimensions.any?) ? ' by ' + @dimensions.map { |d| d[:pretty_name] }.join(' and ') : '')
       result.gsub('$date', [*@search.filter[:calendar_date]].uniq.join(' - '))
     end
 

data/lib/simple_drilldown/engine.rb

@@ -4,8 +4,8 @@ module SimpleDrilldown
   class Engine < ::Rails::Engine
     isolate_namespace SimpleDrilldown
 
-    initializer "simple_drilldown.assets.precompile" do |app|
-      app.config.assets.precompile += %w( chartkick.js )
+    initializer 'simple_drilldown.assets.precompile' do |app|
+      app.config.assets.precompile += %w[chartkick.js]
     end
   end
 end

data/lib/simple_drilldown/search.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model/naming'
 
 module SimpleDrilldown
@@ -14,6 +16,7 @@ module SimpleDrilldown
     module SelectValue
       COUNT = 'COUNT'
       VOLUME = 'VOLUME'
+      VOLUME_COMPENSATED = 'VOLUME_COMPENSATED'
     end
 
     attr_reader :dimensions
@@ -22,14 +25,22 @@ module SimpleDrilldown
     attr_reader :filter
     attr_accessor :list
     attr_accessor :percent
-    attr_reader :last_change_time
+    attr_reader :list_change_times
     attr_reader :order_by_value
     attr_reader :select_value
     attr_reader :title
     attr_reader :default_fields
 
-    def initialize(attributes_or_search, default_fields = nil, default_select_value = nil)
-      if attributes_or_search.is_a? Search
+    def self.validators_on(_attribute)
+      []
+    end
+
+    def self.human_attribute_name(attribute)
+      attribute
+    end
+
+    def initialize(attributes_or_search, default_fields = nil, default_select_value = SelectValue::COUNT)
+      if attributes_or_search.is_a? self.class
         s = attributes_or_search
         @dimensions = s.dimensions.dup
         @display_type = s.display_type.dup
@@ -37,7 +48,7 @@ module SimpleDrilldown
         @filter = s.filter.dup
         @list = s.list
         @percent = s.percent
-        @last_change_time = s.last_change_time
+        @list_change_times = s.list_change_times
         @order_by_value = s.order_by_value
         @select_value = s.select_value.dup
         @title = s.title
@@ -45,45 +56,48 @@ module SimpleDrilldown
       else
         attributes = attributes_or_search
         @default_fields = default_fields
+        @default_select_value = default_select_value
         @dimensions = attributes && attributes[:dimensions] || []
-        @dimensions.delete_if { |d| d.empty? }
+        @dimensions.delete_if(&:empty?)
         @filter = attributes && attributes[:filter] ? attributes[:filter] : {}
-        @filter.each { |k, v| v.delete('') }
-        @filter.delete_if { |k, v| v.empty? }
-        @display_type = attributes && attributes[:display_type] ? attributes[:display_type] : DisplayType::NONE
-        if @dimensions.size >= 2 && @display_type == DisplayType::PIE
-          @display_type = DisplayType::BAR
+        @filter.keys.dup.each { |k| @filter[k] = [*@filter[k]] }
+        @filter.each do |_k, v|
+          v.delete('')
+          v.delete('Select Some Options')
         end
+        @filter.delete_if { |_k, v| v.empty? }
+        @display_type = attributes && attributes[:display_type] ? attributes[:display_type] : DisplayType::NONE
+        @display_type = DisplayType::BAR if @dimensions.size >= 2 && @display_type == DisplayType::PIE
 
         @order_by_value = attributes && (attributes[:order_by_value] == '1')
-        @select_value = attributes && attributes[:select_value] && attributes[:select_value].size > 0 ? attributes[:select_value] : SelectValue::COUNT
-        @list = attributes && attributes[:list] && attributes[:list] == '1' || false
+        @select_value = attributes&.dig(:select_value).present? ? attributes[:select_value] : @default_select_value
+        @list = attributes&.[](:list) == '1'
         @percent = attributes&.[](:percent) == '1'
-        @last_change_time = attributes && attributes[:last_change_time] && attributes[:last_change_time] == '1' || false
-        if (attributes && attributes[:fields])
-          if attributes[:fields].is_a?(Array)
-            @fields = attributes[:fields]
-          else
-            @fields = attributes[:fields].select { |k, v| v == '1' }.map { |k, v| k }
-          end
-        else
-          @fields = @default_fields
-        end
-        @title = attributes[:title] if attributes && attributes[:title] && attributes[:title].size > 0
+        @list_change_times = attributes&.[](:list_change_times) == '1'
+        @fields = if attributes && attributes[:fields]
+                    if attributes[:fields].is_a?(Array)
+                      attributes[:fields]
+                    else
+                      attributes[:fields].to_h.select { |_k, v| v == '1' }.map { |k, _v| k }
+                    end
+                  else
+                    @default_fields
+                  end
+        @title = attributes[:title] if attributes&.dig(:title).present?
       end
     end
 
     def url_options
       o = {
-          :search => {
-              :title => title,
-              :list => list ? '1' : '0',
-              :last_change_time => last_change_time ? '1' : '0',
-              :filter => filter,
+          search: {
+              title: title,
+              list: list ? '1' : '0',
               percent: percent ? '1' : '0',
-              :dimensions => dimensions,
-              :display_type => display_type,
-          }
+              list_change_times: list_change_times ? '1' : '0',
+              filter: filter,
+              dimensions: dimensions,
+              display_type: display_type,
+          },
       }
       o[:search][:fields] = fields unless fields == @default_fields
       o
@@ -95,8 +109,9 @@ module SimpleDrilldown
     end
 
     def drill_down(dimensions, *values)
-      raise "Too many values" if values.size > self.dimensions.size
-      s = Search.new(self)
+      raise 'Too many values' if values.size > self.dimensions.size
+
+      s = self.class.new(self)
       values.each_with_index { |v, i| s.filter[dimensions[i][:url_param_name]] = [v] }
       values.size.times { s.dimensions.shift }
       s

data/lib/simple_drilldown/version.rb

@@ -1,3 +1,3 @@
 module SimpleDrilldown
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_drilldown
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Uwe Kubosch
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2020-03-16 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: chartkick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -30,20 +44,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '7'
-- !ruby/object:Gem::Dependency
-  name: chartkick
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement