Refactor apply_method in GroupBy (#488)

* Renames class method in Daru::Core::GroupBy for clarity

* Adds deprecation code for renamed method

* Updates Daru::Core::GroupBy to use aggregate in apply_method

This also fixes issues with Daru::Core::GroupBy#std: when a group
  had only one value, the std was not NaN (which was wrong)

Author: paisible-wanderer

lib/daru/core/group_by.rb

@@ -2,21 +2,25 @@ module Daru
   module Core
     class GroupBy
       class << self
+        extend Gem::Deprecate
+
         # @private
-        def get_positions_group_map_on(indexes_with_positions, sort: false)
-          group_map = {}
+        def group_by_index_to_positions(indexes_with_positions, sort: false)
+          index_to_positions = {}
 
           indexes_with_positions.each do |idx, position|
-            (group_map[idx] ||= []) << position
+            (index_to_positions[idx] ||= []) << position
           end
 
           if sort # TODO: maybe add a more "stable" sorting option?
-            sorted_keys = group_map.keys.sort(&Daru::Core::GroupBy::TUPLE_SORTER)
-            group_map = sorted_keys.map { |k| [k, group_map[k]] }.to_h
+            sorted_keys = index_to_positions.keys.sort(&Daru::Core::GroupBy::TUPLE_SORTER)
+            index_to_positions = sorted_keys.map { |k| [k, index_to_positions[k]] }.to_h
           end
 
-          group_map
+          index_to_positions
         end
+        alias get_positions_group_map_on group_by_index_to_positions
+        deprecate :get_positions_group_map_on, :group_by_index_to_positions, 2019, 10
 
         # @private
         def get_positions_group_for_aggregation(multi_index, level=-1)
@@ -25,14 +29,14 @@ def get_positions_group_for_aggregation(multi_index, level=-1)
           new_index = multi_index.dup
           new_index.remove_layer(level) # TODO: recheck code of Daru::MultiIndex#remove_layer
 
-          get_positions_group_map_on(new_index.each_with_index)
+          group_by_index_to_positions(new_index.each_with_index)
         end
 
         # @private
         def get_positions_group_map_for_df(df, group_by_keys, sort: true)
           indexes_with_positions = df[*group_by_keys].to_df.each_row.map(&:to_a).each_with_index
 
-          get_positions_group_map_on(indexes_with_positions, sort: sort)
+          group_by_index_to_positions(indexes_with_positions, sort: sort)
         end
 
         # @private
@@ -57,6 +61,9 @@ def df_from_group_map(df, group_map, remaining_vectors, from_position: true)
         end
       end
 
+      # The group_by was done over the vectors in group_vectors; the remaining vectors are the non_group_vectors
+      attr_reader :group_vectors, :non_group_vectors
+
       # lazy accessor/attr_reader for the attribute groups
       def groups
         @groups ||= GroupBy.group_map_from_positions_to_indexes(@groups_by_pos, @context.index)
@@ -93,7 +100,7 @@ def initialize context, names
         @group_vectors     = names
         @non_group_vectors = context.vectors.to_a - names
 
-        @context = context # TODO: maybe rename in @original_df or @grouped_db
+        @context = context # TODO: maybe rename in @original_df
 
         # FIXME: It feels like we don't want to sort here. Ruby's #group_by
         # never sorts:
@@ -362,21 +369,15 @@ def select_groups_from method, quantity
         Daru::DataFrame.rows(rows, order: @context.vectors, index: indexes)
       end
 
-      def apply_method method_type, method
-        order = @non_group_vectors.select do |ngvec|
-          method_type == :numeric && @context[ngvec].type == :numeric
-        end
+      def select_numeric_non_group_vectors
+        @non_group_vectors.select { |ngvec| @context[ngvec].type == :numeric }
+      end
 
-        rows = groups_by_idx.map do |_group, indexes|
-          order.map do |ngvector|
-            slice = @context[ngvector][*indexes]
-            slice.is_a?(Daru::Vector) ? slice.send(method) : slice
-          end
-        end
+      def apply_method method_type, method
+        raise 'To implement' if method_type != :numeric
+        aggregation_options = select_numeric_non_group_vectors.map { |k| [k, method] }.to_h
 
-        index = get_grouped_index
-        order = Daru::Index.new(order)
-        Daru::DataFrame.new(rows.transpose, index: index, order: order)
+        aggregate(aggregation_options)
       end
 
       def get_grouped_index(index_tuples=nil)