daru 0.1.3.1 → 0.1.4

data/lib/daru/io/io.rb

@@ -4,14 +4,32 @@ module Daru
       def process_row(row,empty)
         row.to_a.map do |c|
           if empty.include?(c)
+            # FIXME: As far as I can guess, it will never work.
+            # It is called only inside `from_plaintext`, and there
+            # data is splitted by `\s+` -- there is no chance that
+            # "empty" (currently just '') will be between data?..
             nil
-          elsif c.is_a?(String) && c.is_number?
-            c =~ /^\d+$/ ? c.to_i : c.tr(',','.').to_f
           else
-            c
+            try_string_to_number(c)
           end
         end
       end
+
+      private
+
+      INT_PATTERN = /^[-+]?\d+$/
+      FLOAT_PATTERN = /^[-+]?\d+[,.]?\d*(e-?\d+)?$/
+
+      def try_string_to_number(s)
+        case s
+        when INT_PATTERN
+          s.to_i
+        when FLOAT_PATTERN
+          s.tr(',', '.').to_f
+        else
+          s
+        end
+      end
     end
   end
 
@@ -27,7 +45,7 @@ module Daru
         worksheet_id = opts[:worksheet_id]
         book         = Spreadsheet.open path
         worksheet    = book.worksheet worksheet_id
-        headers      = worksheet.row(0).recode_repeated.map(&:to_sym)
+        headers      = ArrayHelper.recode_repeated(worksheet.row(0)).map(&:to_sym)
 
         df = Daru::DataFrame.new({})
         headers.each_with_index do |h,i|
@@ -57,46 +75,18 @@ module Daru
 
       # Functions for loading/writing CSV files
       def from_csv path, opts={}
-        opts[:col_sep]           ||= ','
-        opts[:converters]        ||= :numeric
-
-        daru_options = opts.keys.each_with_object({}) do |k, hash|
-          if [:clone, :order, :index, :name].include?(k)
-            hash[k] = opts[k]
-            opts.delete k
-          end
-        end
+        daru_options, opts = from_csv_prepare_opts opts
 
         # Preprocess headers for detecting and correcting repetition in
         # case the :headers option is not specified.
-        if opts[:headers]
-          opts[:header_converters] ||= :symbol
-
-          csv = ::CSV.read(path, 'rb',opts)
-          yield csv if block_given?
-
-          hsh = {}
-          csv.by_col.each do |col_name, values|
-            hsh[col_name] = values
-          end
-        else
-          csv = ::CSV.open(path, 'rb', opts)
-          yield csv if block_given?
-
-          csv_as_arrays = csv.to_a
-          headers       = csv_as_arrays[0].recode_repeated.map
-          csv_as_arrays.delete_at 0
-          csv_as_arrays = csv_as_arrays.transpose
-
-          hsh = {}
-          headers.each_with_index do |h, i|
-            hsh[h] = csv_as_arrays[i]
+        hsh =
+          if opts[:headers]
+            from_csv_hash_with_headers(path, opts)
+          else
+            from_csv_hash(path, opts)
+              .tap { |hash| daru_options[:order] = hash.keys }
           end
 
-          # Order columns as given in CSV
-          daru_options[:order] = headers.to_a
-        end
-
         Daru::DataFrame.new(hsh,daru_options)
       end
 
@@ -154,12 +144,7 @@ module Daru
           fields = fields.map(&:to_sym)
         end
 
-        vectors = Hash[*fields.map { |name|
-          [
-            name,
-            Daru::Vector.new([]).tap { |v| v.rename name }
-          ]
-        }.flatten]
+        vectors = fields.map { |name| [name, Daru::Vector.new([], name: name)] }.to_h
 
         Daru::DataFrame.new(vectors, order: fields).tap do |df|
           relation.pluck(*fields).each do |record|
@@ -200,6 +185,42 @@ module Daru
           false
         end
       end
+
+      private
+
+      DARU_OPT_KEYS = [:clone, :order, :index, :name].freeze
+
+      def from_csv_prepare_opts opts
+        opts[:col_sep]           ||= ','
+        opts[:converters]        ||= :numeric
+
+        daru_options = opts.keys.each_with_object({}) do |k, hash|
+          hash[k] = opts.delete(k) if DARU_OPT_KEYS.include?(k)
+        end
+        [daru_options, opts]
+      end
+
+      def from_csv_hash_with_headers(path, opts)
+        opts[:header_converters] ||= :symbol
+
+        ::CSV
+          .read(path, 'rb',opts)
+          .tap { |c| yield c if block_given? }
+          .by_col.map { |col_name, values| [col_name, values] }.to_h
+      end
+
+      def from_csv_hash(path, opts)
+        csv_as_arrays =
+          ::CSV
+          .open(path, 'rb', opts)
+          .tap { |c| yield c if block_given? }
+          .to_a
+
+        headers       = ArrayHelper.recode_repeated(csv_as_arrays.shift)
+        csv_as_arrays = csv_as_arrays.transpose
+
+        headers.each_with_index.map { |h, i| [h, csv_as_arrays[i]] }.to_h
+      end
     end
   end
 end

data/lib/daru/io/sql_data_source.rb

@@ -1,55 +1,52 @@
 module Daru
   module IO
     class SqlDataSource
-      # Private adapter class for DBI::DatabaseHandle
       # @private
-      class DbiAdapter
-        def initialize(dbh, query)
-          @dbh = dbh
+      class Adapter
+        def initialize(conn, query)
+          @conn = conn
           @query = query
         end
 
-        def each_column_name
-          result.column_names.each do |column_name|
-            yield(column_name.to_sym)
-          end
+        def result_hash
+          column_names
+            .map(&:to_sym)
+            .zip(rows.transpose)
+            .to_h
         end
+      end
+
+      # Private adapter class for DBI::DatabaseHandle
+      # @private
+      class DbiAdapter < Adapter
+        private
 
-        def each_row
-          result.fetch do |row|
-            yield(row.to_a)
-          end
+        def column_names
+          result.column_names
         end
 
-        private
+        def rows
+          result.to_a.map(&:to_a)
+        end
 
         def result
-          @result ||= @dbh.execute(@query)
+          @result ||= @conn.execute(@query)
         end
       end
 
       # Private adapter class for connections of ActiveRecord
       # @private
-      class ActiveRecordConnectionAdapter
-        def initialize(conn, query)
-          @conn = conn
-          @query = query
-        end
+      class ActiveRecordConnectionAdapter < Adapter
+        private
 
-        def each_column_name
-          result.columns.each do |column_name|
-            yield(column_name.to_sym)
-          end
+        def column_names
+          result.columns
         end
 
-        def each_row
-          result.each do |row|
-            yield(row.values)
-          end
+        def rows
+          result.cast_values
         end
 
-        private
-
         def result
           @result ||= @conn.exec_query(@query)
         end
@@ -67,50 +64,24 @@ module Daru
       end
 
       def make_dataframe
-        vectors = {}
-        fields = []
-        @adapter.each_column_name do |column_name|
-          vectors[column_name] = Daru::Vector.new([])
-          vectors[column_name].rename column_name
-          fields.push column_name
-        end
-
-        df = Daru::DataFrame.new(vectors, order: fields)
-        @adapter.each_row do |row|
-          df.add_row(row)
-        end
-
-        df.update
-
-        df
+        Daru::DataFrame.new(@adapter.result_hash).tap(&:update)
       end
 
       private
 
       def init_adapter(db, query)
-        begin
-          query = query.to_str
-        rescue
-          raise ArgumentError, 'query must be a string'
-        end
+        query = String.try_convert(query) or
+          raise ArgumentError, "Query must be a string, #{query.class} received"
 
-        case
-        when check_dbi(db)
+        case db
+        when DBI::DatabaseHandle
           DbiAdapter.new(db, query)
-        when check_active_record_connection(db)
+        when ActiveRecord::ConnectionAdapters::AbstractAdapter
           ActiveRecordConnectionAdapter.new(db, query)
         else
-          raise ArgumentError, 'unknown database type'
+          raise ArgumentError, "Unknown database adapter type #{db.class}"
         end
       end
-
-      def check_dbi(obj)
-        obj.is_a?(DBI::DatabaseHandle)
-      end
-
-      def check_active_record_connection(obj)
-        obj.is_a?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
-      end
     end
   end
 end

data/lib/daru/iruby/helpers.rb

@@ -0,0 +1,38 @@
+module Daru
+  # @private
+  module IRuby
+    module Helpers
+      module_function
+
+      def tuples_with_rowspans(index)
+        index.sparse_tuples.transpose
+             .map { |r| nils_counted(r) }
+             .transpose.map(&:compact)
+      end
+
+      def tuples_with_colspans(index)
+        index.sparse_tuples.transpose
+             .map { |r| nils_counted(r) }
+             .map(&:compact)
+      end
+
+      # It is complicated, but the only algo I could think of.
+      # It does [:a, nil, nil, :b, nil, :c] # =>
+      #         [[:a,3], nil, nil, [:b,2], nil, :c]
+      # Needed by tuples_with_colspans/rowspans, which we need for pretty HTML
+      def nils_counted array
+        grouped = [[array.first]]
+        array[1..-1].each do |val|
+          if val
+            grouped << [val]
+          else
+            grouped.last << val
+          end
+        end
+        grouped.flat_map { |items|
+          [[items.first, items.count], *[nil] * (items.count - 1)]
+        }
+      end
+    end
+  end
+end

data/lib/daru/iruby/templates/dataframe.html.erb

@@ -0,0 +1,52 @@
+<table>
+  <tr>
+    <th colspan='<%= @vectors.size+1 %>'>Daru::DataFrame<%= name ? ": #{name} " : ''%>(<%=nrows%>x<%=ncols%>)</th>
+  </tr>
+
+  <% if @vectors.is_a? MultiIndex %>
+    <% Daru::IRuby::Helpers.tuples_with_colspans(@vectors).each_with_index do |tuple, idx| %>
+      <tr>
+        <% if idx.zero? %>
+          <th rowspan="<%= @vectors.width %>"></th>
+        <% end %>
+        <% tuple.each do |idx, span| %>
+          <th colspan="<%= span %>"><%= idx %></th>
+        <% end %>
+      </tr>
+    <% end %>
+  <% else %>
+    <tr>
+      <th></th>
+      <% @vectors.each do |vector| %>
+        <th><%=vector%></th>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% @index.first(threshold).each_with_index do |index, pos| %>
+    <tr>
+      <td><%= index %></td>
+      <% row.at(pos).each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% if nrows > threshold %>
+    <tr>
+      <% (@vectors.size + 1).times do %>
+        <td>...</td>
+      <% end %>
+    </tr>
+
+    <% last_index = @index.to_a.last
+       last_row = row_at @index.size-1 %>
+
+    <tr>
+      <td><%= last_index %></td>
+        <% last_row.each do |element| %>
+          <td><%= element.to_s %></td>
+        <% end %>
+    </tr>
+  <% end %>
+</table>

data/lib/daru/iruby/templates/dataframe_mi.html.erb

@@ -0,0 +1,58 @@
+<table>
+  <tr>
+    <th colspan='<%= @vectors.size+index.width %>'>Daru::DataFrame<%= name ? ": #{name} " : ''%>(<%=nrows%>x<%=ncols%>)</th>
+  </tr>
+  <% if @vectors.is_a? MultiIndex %>
+    <% Daru::IRuby::Helpers.tuples_with_colspans(@vectors).each_with_index do |tuple, idx| %>
+      <tr>
+        <% if idx.zero? %>
+          <th colspan="<%= index.width %>" rowspan="<%= @vectors.width %>"></th>
+        <% end %>
+        <% tuple.each do |idx, span| %>
+          <th colspan="<%= span %>"><%= idx %></th>
+        <% end %>
+      </tr>
+    <% end %>
+  <% else %>
+    <tr>
+      <th colspan="<%= index.width %>"></th>
+      <% @vectors.each do |vector| %>
+        <th><%=vector%></th>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% Daru::IRuby::Helpers.tuples_with_rowspans(@index).first(threshold).zip(@index.to_a).each do |tuple, index| %>
+    <tr>
+      <% tuple.each do |idx, span| %>
+        <th rowspan="<%= span %>"><%= idx %></th>
+      <% end %>
+      <% row[index].each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% if nrows > threshold %>
+    <tr>
+      <% index.width.times do %>
+        <th>...</th>
+      <% end %>
+      <% @vectors.size.times do %>
+        <td>...</td>
+      <% end %>
+    </tr>
+
+    <% last_index = @index.to_a.last
+       last_row = row[last_index] %>
+
+    <tr>
+      <% last_index.each do |idx| %>
+        <th><%= idx %></td>
+      <% end %>
+      <% last_row.each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+</table>

data/lib/daru/iruby/templates/multi_index.html.erb

@@ -0,0 +1,12 @@
+<table>
+  <tr>
+    <th colspan="<%= width %>">Daru::MultiIndex(<%= size %>x<%= width %>)</th>
+  </tr>
+  <% Daru::IRuby::Helpers.tuples_with_rowspans(self).each do |row| %>
+    <tr>
+      <% row.each do |val, span| %>
+        <th rowspan="<%= span %>"><%= val %></th>
+      <% end %>
+    </tr>
+  <% end %>
+</table>