bmg 0.18.0 → 0.18.5

data/lib/bmg/summarizer/avg.rb

@@ -16,13 +16,13 @@ module Bmg
       end
 
       # Collects one more value + the sum of all
-      def _happens(memo, val) 
+      def _happens(memo, val)
         [memo.first + val, memo.last + 1]
       end
 
       # Finalizes the computation.
-      def finalize(memo) 
-        memo.first / memo.last 
+      def finalize(memo)
+        memo.first / memo.last
       end
 
     end # class Avg

data/lib/bmg/summarizer/by_proc.rb

@@ -0,0 +1,41 @@
+module Bmg
+  class Summarizer
+    #
+    # Generic summarizer that takes a Proc àla each_with_object.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.by_proc{|t,memo| ... }.summarize(...)
+    #
+    class ByProc < Summarizer
+
+      def initialize(least, by_proc)
+        @least = least
+        @by_proc = by_proc
+      end
+
+      # Returns [] as least value.
+      def least
+        @least
+      end
+
+      # Adds val to the memo array
+      def happens(memo, val)
+        @by_proc.call(val, memo)
+      end
+
+      def finalize(memo)
+        memo
+      end
+
+    end # class ByProc
+
+    # Factors a distinct summarizer
+    def self.by_proc(least = nil, proc = nil, &bl)
+      least, proc = nil, least if least.is_a?(Proc)
+      ByProc.new(least, proc || bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/distinct.rb

@@ -0,0 +1,36 @@
+module Bmg
+  class Summarizer
+    #
+    # Collect the distinct values as an array.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.distinct(:qty).summarize(...)
+    #
+    class Distinct < Summarizer
+
+      # Returns [] as least value.
+      def least()
+        {}
+      end
+
+      # Adds val to the memo array
+      def _happens(memo, val)
+        memo[val] = true
+        memo
+      end
+
+      def finalize(memo)
+        memo.keys
+      end
+
+    end # class Distinct
+
+    # Factors a distinct summarizer
+    def self.distinct(*args, &bl)
+      Distinct.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/multiple.rb

@@ -0,0 +1,46 @@
+module Bmg
+  class Summarizer
+    #
+    # A summarizer that collects multiple summarization as a wrapped
+    # tuple.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.multiple(x: ..., y: ...).summarize(...)
+    #
+    class Multiple < Summarizer
+
+      def initialize(defs)
+        @summarization = Summarizer.summarization(defs)
+      end
+
+      # Returns [] as least value.
+      def least()
+        @summarization.each_pair.each_with_object({}){|(k,v),memo|
+          memo[k] = v.least
+        }
+      end
+
+      # Adds val to the memo array
+      def happens(memo, val)
+        @summarization.each_pair.each_with_object({}){|(k,v),memo2|
+          memo2[k] = v.happens(memo[k], val)
+        }
+      end
+
+      def finalize(memo)
+        @summarization.each_pair.each_with_object({}){|(k,v),memo2|
+          memo2[k] = v.finalize(memo[k])
+        }
+      end
+
+    end # class Multiple
+
+    # Factors a distinct summarizer
+    def self.multiple(defs)
+      Multiple.new(defs)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/percentile.rb

@@ -0,0 +1,79 @@
+module Bmg
+  class Summarizer
+    #
+    # Percentile summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.percentile(:qty, 50).summarize(...)
+    #
+    class Percentile < Summarizer
+
+      DEFAULT_OPTIONS = {
+        :variant => :continuous
+      }
+
+      def initialize(*args, &bl)
+        @nth = args.find{|a| a.is_a?(Integer) } || 50
+        functor = args.find{|a| a.is_a?(Symbol) } || bl
+        options = args.select{|a| a.is_a?(Hash) }.inject(DEFAULT_OPTIONS){|memo,opts|
+          memo.merge(opts)
+        }.dup
+        super(functor, options)
+      end
+
+      # Returns [] as least value.
+      def least()
+        []
+      end
+
+      # Collects the value
+      def _happens(memo, val)
+        memo << val
+      end
+
+      # Finalizes the computation.
+      def finalize(memo)
+        return nil if memo.empty?
+        index = memo.size.to_f * (@nth.to_f / 100.0)
+        floor, ceil = index.floor, index.ceil
+        ceil +=1 if floor == ceil
+        below = [floor - 1, 0].max
+        above = [[ceil - 1, memo.size - 1].min, 0].max
+        sorted = memo.sort
+        if options[:variant] == :continuous
+          (sorted[above] + sorted[below]) / 2.0
+        else
+          sorted[below]
+        end
+      end
+
+    end # class Avg
+
+    def self.percentile(*args, &bl)
+      Percentile.new(*args, &bl)
+    end
+
+    def self.percentile_cont(*args, &bl)
+      Percentile.new(*(args + [{:variant => :continuous}]), &bl)
+    end
+
+    def self.percentile_disc(*args, &bl)
+      Percentile.new(*(args + [{:variant => :discrete}]), &bl)
+    end
+
+    def self.median(*args, &bl)
+      Percentile.new(*(args + [50]), &bl)
+    end
+
+    def self.median_cont(*args, &bl)
+      Percentile.new(*(args + [50, {:variant => :continuous}]), &bl)
+    end
+
+    def self.median_disc(*args, &bl)
+      Percentile.new(*(args + [50, {:variant => :discrete}]), &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/summarizer/value_by.rb

@@ -0,0 +1,62 @@
+module Bmg
+  class Summarizer
+    #
+    # ValueBy summarizer.
+    #
+    # Example:
+    #
+    #   # direct ruby usage
+    #   Bmg::Summarizer.value_by(:qty, :by => :serie).summarize(...)
+    #
+    class ValueBy < Summarizer
+
+      DEFAULT_OPTIONS = {
+        :symbolize => false
+      }
+
+      # Returns {} as least value.
+      def least
+        {}
+      end
+
+      # Collects the value
+      def happens(memo, tuple)
+        by = tuple[options[:by]]
+        by = by.to_sym if by && options[:symbolize]
+        misuse!(tuple, memo) if memo.has_key?(by)
+        memo.tap{|m|
+          m[by] = extract_value(tuple)
+        }
+      end
+
+      # Finalizes the computation.
+      def finalize(memo)
+        default_tuple.merge(memo)
+      end
+
+    private
+
+      def default_tuple
+        (options[:series] || []).each_with_object({}){|s,ss|
+          s_def = options[:default]
+          s_def = s_def.to_sym if s_def && options[:symbolize]
+          ss[s] = s_def
+        }
+      end
+
+      def misuse!(tuple, memo)
+        msg = "Summarizer.value_by: summarization key + the serie must form be a candidate key"
+        msg += "\n"
+        msg += "  Tuple: #{tuple.inspect}"
+        msg += "  Memo:  #{memo.inspect}"
+        raise MisuseError, msg
+      end
+
+    end # class ValueBy
+
+    def self.value_by(*args, &bl)
+      ValueBy.new(*args, &bl)
+    end
+
+  end # class Summarizer
+end # module Bmg

data/lib/bmg/support.rb

@@ -1,4 +1,5 @@
 require_relative 'support/tuple_algebra'
 require_relative 'support/tuple_transformer'
 require_relative 'support/keys'
+require_relative 'support/ordering'
 require_relative 'support/output_preferences'

data/lib/bmg/support/ordering.rb

@@ -0,0 +1,20 @@
+module Bmg
+  class Ordering
+
+    def initialize(attrs)
+      @attrs = attrs
+    end
+    attr_reader :attrs
+
+    def comparator
+      ->(t1, t2) {
+        attrs.each do |(attr,direction)|
+          c = t1[attr] <=> t2[attr]
+          return (direction == :desc ? -c : c) unless c==0
+        end
+        0
+      }
+    end
+
+  end # class Ordering
+end # module Bmg

data/lib/bmg/support/tuple_transformer.rb

@@ -32,7 +32,16 @@ module Bmg
           }
         when Hash
           with.each_with_object(tuple.dup){|(k,v),dup|
-            dup[k] = transform_attr(dup[k], v)
+            case k
+            when Symbol
+              dup[k] = transform_attr(dup[k], v)
+            when Class
+              dup.keys.each do |attrname|
+                dup[attrname] = transform_attr(dup[attrname], v) if dup[attrname].is_a?(k)
+              end
+            else
+              raise ArgumentError, "Unexpected transformation `#{with.inspect}`"
+            end
           }
         when Array
           with.inject(tuple){|dup,on|

data/lib/bmg/version.rb

@@ -2,7 +2,7 @@ module Bmg
   module Version
     MAJOR = 0
     MINOR = 18
-    TINY  = 0
+    TINY  = 5
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/lib/bmg/writer.rb

@@ -1 +1,17 @@
+module Bmg
+  module Writer
+
+  protected
+
+    def infer_headers(from)
+      attrlist = if from.is_a?(Type) && from.knows_attrlist?
+        from.to_attrlist
+      elsif from.is_a?(Hash)
+        from.keys
+      end
+      attrlist ? output_preferences.order_attrlist(attrlist) : nil
+    end
+
+  end # module Writer
+end # module Bmg
 require_relative 'writer/csv'

data/lib/bmg/writer/csv.rb

@@ -19,24 +19,14 @@ module Bmg
         relation.each do |tuple|
           if csv.nil?
             headers = infer_headers(tuple) if headers.nil?
-            csv = CSV.new(string_or_io, csv_options.merge(headers: headers))
+            csv_opts = csv_options.merge(headers: headers)
+            csv = CSV.new(string_or_io, **csv_opts)
           end
           csv << headers.map{|h| tuple[h] }
         end
         to_s ? string_or_io.string : string_or_io
       end
 
-    private
-
-      def infer_headers(from)
-        attrlist = if from.is_a?(Type) && from.knows_attrlist?
-          from.to_attrlist
-        elsif from.is_a?(Hash)
-          from.keys
-        end
-        attrlist ? output_preferences.order_attrlist(attrlist) : nil
-      end
-
     end # class Csv
   end # module Writer
 end # module Bmg

data/lib/bmg/writer/xlsx.rb

@@ -0,0 +1,68 @@
+module Bmg
+  module Writer
+    class Xlsx
+      include Writer
+
+      DEFAULT_OPTIONS = {
+      }
+
+      def initialize(csv_options, output_preferences = nil)
+        @csv_options = DEFAULT_OPTIONS.merge(csv_options)
+        @output_preferences = OutputPreferences.dress(output_preferences)
+      end
+      attr_reader :csv_options, :output_preferences
+
+      def call(relation, path)
+        require 'write_xlsx'
+        dup._call(relation, path)
+      end
+
+    protected
+      attr_reader :workbook, :worksheet
+
+      def _call(relation, path)
+        @workbook = WriteXLSX.new(path)
+        @worksheet = workbook.add_worksheet
+
+        headers = infer_headers(relation.type)
+        relation.each_with_index do |tuple,i|
+          headers = infer_headers(tuple) if headers.nil?
+          headers.each_with_index do |h,i|
+            worksheet.write_string(0, i, h)
+          end if i == 0
+          headers.each_with_index do |h,j|
+            meth, *args = write_pair(tuple[h])
+            worksheet.send(meth, 1+i, j, *args)
+          end
+        end
+
+        workbook.close
+        path
+      end
+
+      def write_pair(value)
+        case value
+        when Numeric
+          [:write_number, value]
+        when Date
+          [:write_date_time, value, date_format]
+        else
+          [:write_string, value.to_s]
+        end
+      end
+
+      def date_format
+        @date_format ||= workbook.add_format(:num_format => 'yyyy-mm-dd')
+      end
+
+    end # class Xlsx
+  end # module Writer
+  module Relation
+
+    def to_xlsx(options = {}, path = nil, preferences = nil)
+      options, path = {}, options unless options.is_a?(Hash)
+      Writer::Xlsx.new(options, preferences).call(self, path)
+    end
+
+  end # module Relation
+end # module Bmg