tabulo 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8546e761344f764d8d14a7cbfc8fd9d84912da5
-  data.tar.gz: 6371e46be06a8891f4a80306a434b16f33c6aa44
+  metadata.gz: 84dadcb8679194ba436e2e213defc55800771628
+  data.tar.gz: aa8d2182569ba3a439bce0b82ef8ceeeb36a4b81
 SHA512:
-  metadata.gz: 4a0a18378e96fa1d64019f2d4179fad9829e7ce65dfc60390eab46c7674c97bb655eeec144ebf72b93c5aed064183155811dad5ac74e4cb093e4628d33dbc3ac
-  data.tar.gz: d4426bf5cb78e655ba8cc60b71f577cb9a47f7e7408879fb9fe51136b409e5f8b04e42d4bea44ac2342cac36b8d9ed9d7126fab383e96dd112dc4b3656ae09de
+  metadata.gz: 91d583322688d1db9f7c0dd21111f40d039da50fc767c78eecda2d640b75e42bae6478bc73a88b2c0810e1ce20fe35b61c7ad550a00b5c8a261fb2bf9e7c4b34
+  data.tar.gz: e0cee253d0513f05158b84bacd7c3e40ad0c546e5765b28c726ecab9936d7c67fa5893d032925bb43c28a96bc2002533c218105bf1ac0fdf43de07559b1106ad

data/CHANGELOG.md

@@ -1,16 +1,21 @@
 # Changelog
 
-## v0.5.1
+### v0.6.0
 
-* Fix Rubydocs Markdown parsing.
+* Correctly handle newlines in cell content.
+* Use keyword arguments instead of option hashes.
+* Write remaining pending specs.
 
-## v0.5.0
+### v0.5.1
+
+* Unsuccessful attempt to fix broken appearance of http://www.rubydoc.info/gems/tabulo/0.5.1
+
+### v0.5.0
 
 * Add Table#shrinkwrap! method to automate column widths so they "just fit".
 * Improve documentation.
-* Minor tidy-ups.
 
-## v0.4.2
+### v0.4.2
 
 * Improve README.
 * Fix error when printing a Table, or a Row thereof, when the Table doesn't
@@ -18,44 +23,43 @@
 * Remove unused development dependency on yard-tomdoc.
 * Write more specs.
 
-## v0.4.1
+### v0.4.1
 
 * Update README to reflect default column width of 12.
 
-## v0.4.0
+### v0.4.0
 
 * Increase default column width from 8 to 12
 * Allow default column width to be configured when initializing a Table
 * Minor code tidy-ups, including removal of undocumented ability for
   Table#add_column to accept a Column instance directly.
 
-## v0.3.1
+### v0.3.1
 
 * Fix width and other options ignored by Table#add_column.
 
-## v0.3.0
+### v0.3.0
 
 * Rename Table#header_row to Table#formatted_header
 * Improve documentation, and use Yardoc instead of Tomdoc
 * Remove Tabulo::Column from the publicly documented API.
 
-## v0.2.2
+### v0.2.2
 
 * Write documentation
-* Create a TODO file
 
-## v0.2.1
+### v0.2.1
 
 * Code tidy-ups
 * Tidy-ups and improvements to README, including adding badges for test coverage etc..
 
-## v0.2.0
+### v0.2.0
 
 * Allow columns to be initialized with `columns` option in `Table` initializer
 * Removed redundant `truncate` option.
 * Rename `wrap_cells_to` to `wrap_body_cells_to`.
 * Improve README.
 
-## v0.1.0
+### v0.1.0
 
 Initial release.

data/README.md

@@ -4,6 +4,7 @@
 [![Build Status][BS img]][Build Status]
 [![Dependency Status][DS img]][Dependency Status]
 [![Coverage Status][CS img]][Coverage Status]
+[![Code Climate][CC img]][Code Climate]
 
 ## Overview
 
@@ -26,28 +27,30 @@ end
 |      5000000 |     10000000 |
 ```
 
-Tabulo is flexible:
+## Features
 
-* Fix individual column widths, then either [wrap](#width-wrapping-truncation) or
-  [truncate](#width-wrapping-truncation) the overflow as you prefer.
+* [Fix](#fixed-column-widths) individual column widths, then either [wrap](#overflow-handling) or
+  [truncate](#overflow-handling) the overflow as you prefer.
 * Alternatively, [shrinkwrap](#shrinkwrap) the table so that each column is just wide enough for
   its contents.
 * You can cap total table width when shrinkwrapping, to [stop it overflowing your terminal](#max-table-width)
   horizontally and becoming an unreadable mess.
 * Cell content alignment is [configurable](#cell-alignment), but with useful defaults, with numbers
   aligned right and strings left.
-* Headers can be [repeated](#repeating-headers) as desired.
+* Headers are [repeatable](#repeating-headers)
+* Newlines within cell content are correctly handled.
 * A `Tabulo::Table` is an `Enumerable`, so you can [step through it](#enumerator) one row at a time,
   without having to wait for the entire underlying collection to load.
-* Each `Tabulo::Row` is also an `Enumerable`.
+* Each `Tabulo::Row` is also an `Enumerable`:
 
-```ruby
-table.each do |row|
-  row.each do |cell|
-    # cell => 1, 2 ... 2, 4 ... etc.
-  end
-end
-```
+>
+  ```ruby
+    table.each do |row|
+      row.each do |cell|
+        # cell => 1, 2 ... 2, 4 ... etc.
+      end
+    end
+  ```
 
 ## Installation
 
@@ -139,9 +142,11 @@ the `align_header` or `align_body` options of `add_column`, e.g.:
 table.add_column("Doubled", align_header: :left, align_body: :left) { |n| n * 2 }
 ```
 
-<a name="width-wrapping-truncation"></a>
 ### Column width, wrapping and truncation
 
+<a name="fixed-column-widths"></a>
+#### Configuring fixed widths
+
 By default, column width is fixed at 12 characters, plus 1 character of padding on either side.
 This can be adjusted on a column-by-column basis using the `width` option of `add_column`:
 
@@ -180,7 +185,7 @@ table = Tabulo::Table.new([1, 2], columns: %i(itself even?), column_width: 6)
 Widths set for individual columns always override the default column width for the table.
 
 <a name="shrinkwrap"></a>
-### Automating column widths
+#### Automating column widths
 
 Instead of setting column widths "manually", you can tell the table to sort out the widths
 itself, so that each column is just wide enough for its header and contents (plus a character
@@ -222,7 +227,7 @@ puts Tabulo::Table.new([1, 2], columns: %i(itself even?)).shrinkwrap!(max_table_
 |     2 |  true |
 ```
 
-If the table cannot be fit within `max_column_width`, column widths are reduced as required, with
+If the table cannot be fit within `max_table_width`, column widths are reduced as required, with
 wrapping or truncation then occuring as necessary (see [Overflow handling](#overflow-handling)).
 Under the hood, a character of width is deducted column by column&mdash;the widest column being
 targetted each time&mdash;until the table will fit. This is very useful when you want to ensure the
@@ -233,7 +238,7 @@ the maximum cell width needs to be calculated for each column. You may not want
 if the collection is very large.
 
 <a name="overflow-handling"></a>
-### Overflow handling
+#### Overflow handling
 
 By default, if cell contents exceed their column width, they are wrapped for as many rows as
 required:
@@ -394,8 +399,10 @@ License](http://opensource.org/licenses/MIT).
 [Build Status]: https://travis-ci.org/matt-harvey/tabulo
 [Dependency Status]: https://gemnasium.com/matt-harvey/tabulo
 [Coverage Status]: https://coveralls.io/r/matt-harvey/tabulo
+[Code Climate]: https://codeclimate.com/github/matt-harvey/tabulo
 
 [GV img]: https://img.shields.io/gem/v/tabulo.svg
 [BS img]: https://img.shields.io/travis/matt-harvey/tabulo.svg
 [DS img]: https://img.shields.io/gemnasium/matt-harvey/tabulo.svg
 [CS img]: https://img.shields.io/coveralls/matt-harvey/tabulo.svg
+[CC img]: https://img.shields.io/codeclimate/github/matt-harvey/tabulo.svg

data/TODO.md

@@ -1,9 +1,3 @@
 # TODO
 
-* Consider incorporating a linter / static analysis tool into the build.
-* Raise an ArgumentError for disallowed arguments and options (this is
-  a library!)
-* Column#initialize should have the same signature as Table#add_column.
-* Handle multiline cell content (i.e. when the calculated cell value
-  itself contains a newline).
-* Pending specs.
+* Fix broken appearance of http://www.rubydoc.info/gems/tabulo/<version> .

data/lib/tabulo/column.rb

@@ -7,31 +7,34 @@ module Tabulo
     attr_reader :header, :label
 
     # @!visibility private
-    def initialize(options)
-      @label, @header = options[:label], options[:header]
-      @align_header = options[:align_header] || :center
-      @align_body = options[:align_body]  || nil
-      @extractor = options[:extractor] || @label.to_proc
-      @formatter = options[:formatter] || :to_s.to_proc
-      @width = options[:width]
+    def initialize(label:, header:, width:, align_header:, align_body:,
+      formatter:, extractor:)
+
+      @label = label
+      @header = header
+      @width = width
+      @align_header = align_header
+      @align_body = align_body
+      @formatter = formatter
+      @extractor = extractor
     end
 
     # @!visibility private
-    def header_cell
-      align_cell_content(@header, @align_header)
+    def header_subcells
+      infilled_subcells(@header, @align_header)
     end
 
     # @!visibility private
     def horizontal_rule
-      Table::HORIZONTAL_RULE_CHARACTER * @width
+      Table::HORIZONTAL_RULE_CHARACTER * width
     end
 
     # @!visibility private
-    def body_cell(source)
+    def body_subcells(source)
       cell_datum = body_cell_value(source)
       formatted_content = @formatter.call(cell_datum)
       real_alignment = (@align_body || infer_alignment(cell_datum))
-      align_cell_content(formatted_content, real_alignment)
+      infilled_subcells(formatted_content, real_alignment)
     end
 
     # @!visibility private
@@ -46,6 +49,16 @@ module Tabulo
 
     private
 
+    # @!visibility private
+    def infilled_subcells(str, real_alignment)
+      str.split($/, -1).flat_map do |substr|
+        num_subsubcells = [1, (substr.length.to_f / width).ceil].max
+        (0...num_subsubcells).map do |i|
+          align_cell_content(substr.slice(i * width, width), real_alignment)
+        end
+      end
+    end
+
     # @!visibility private
     def align_cell_content(content, real_alignment)
       padding = [@width - content.length, 0].max

data/lib/tabulo/row.rb

@@ -4,10 +4,10 @@ module Tabulo
     include Enumerable
 
     # @!visibility private
-    def initialize(table, source, options = { with_header: true })
+    def initialize(table, source, with_header: true)
       @table = table
       @source = source
-      @with_header = options[:with_header]
+      @with_header = with_header
     end
 
     # Calls the given block once for each cell in the {Row}, passing that cell as parameter.

data/lib/tabulo/table.rb

@@ -15,73 +15,67 @@ module Tabulo
     attr_reader :columns
 
     # @param [Enumerable] sources the underlying Enumerable from which the table will derive its data
-    # @param [Hash] options
-    # @option options [Array[Symbol]] :columns ([]) Specifies the initial columns.
+    # @param [Array[Symbol]] columns Specifies the initial columns.
     #   Each element of the Array  will be used to create a column whose content is
     #   created by calling the corresponding method on each element of sources. Note
     #   the {#add_column} method is a much more flexible way to set up columns on the table.
-    # @option options [Fixnum, nil] :column_width (nil) The default column width for columns in this
+    # @param [Fixnum, nil] column_width The default column width for columns in this
     #   table, not excluding padding. If nil, then DEFAULT_COLUMN_WIDTH will be used.
-    # @option options [:start, nil, Fixnum] :header_frequency (:start) Controls the display of column headers.
+    # @param [:start, nil, Fixnum] header_frequency Controls the display of column headers.
     #   If passed <tt>:start</tt>, headers will be shown at the top of the table only. If passed <tt>nil</tt>,
     #   headers will not be shown. If passed a Fixnum N (> 0), headers will be shown at the top of the table,
     #   then repeated every N rows.
-    # @option options [nil, Fixnum] :wrap_header_cells_to (nil) Controls wrapping behaviour for header
+    # @param [nil, Fixnum] wrap_header_cells_to Controls wrapping behaviour for header
     #   cells if the content thereof is longer than the column's fixed width. If passed <tt>nil</tt> (default),
     #   content will be wrapped for as many rows as required to accommodate it. If passed a Fixnum N (> 0),
     #   content will be wrapped up to N rows and then truncated thereafter.
-    # @option options [nil, Fixnum] :wrap_body_cells_to (nil) Controls wrapping behaviour for table cells (excluding
+    # @param [nil, Fixnum] wrap_body_cells_to Controls wrapping behaviour for table cells (excluding
     #   headers), if their content is longer than the column's fixed width. If passed <tt>nil</tt>, content will
     #   be wrapped for as many rows as required to accommodate it. If passed a Fixnum N (> 0), content will be
     #   wrapped up to N rows and then truncated thereafter.
     #
     # @return [Table] a new Table
-    def initialize(sources, options = { })
-      opts = {
-        columns: [],
-        column_width: DEFAULT_COLUMN_WIDTH,
-        header_frequency: :start,
+    def initialize(sources, columns: [], column_width: nil, header_frequency: :start,
+      wrap_header_cells_to: nil, wrap_body_cells_to: nil)
 
-        # nil to wrap to no max, 1 to wrap to 1 row then truncate, etc..
-        wrap_header_cells_to: nil,
-        wrap_body_cells_to: nil
+      @sources = sources
+      @header_frequency = header_frequency
+      @wrap_header_cells_to = wrap_header_cells_to
+      @wrap_body_cells_to = wrap_body_cells_to
 
-      }.merge(options)
+      @default_column_width = (column_width || DEFAULT_COLUMN_WIDTH)
 
-      @header_frequency = opts[:header_frequency]
-      @wrap_header_cells_to = opts[:wrap_header_cells_to]
-      @wrap_body_cells_to = opts[:wrap_body_cells_to]
-      @sources = sources
       @joiner = "|"
       @truncation_indicator = "~"
       @padding_character = " "
-      @default_column_width = opts[:column_width] || DEFAULT_COLUMN_WIDTH
-      @columns = opts[:columns].map { |item| make_column(item) }
+
+      @columns = []
+      columns.each { |item| add_column(item) }
+
       yield self if block_given?
     end
 
     # Adds a column to the Table.
     #
     # @param [Symbol, String] label A unique identifier for this column, which by default will
-    #   also be used as the column header text (see also the header option). If the
+    #   also be used as the column header text (see also the header param). If the
     #   extractor argument is not also provided, then the label argument should correspond to
     #   a method to be called on each item in the table sources to provide the content
     #   for this column.
     #
-    # @param [Hash] options
-    # @option options [String] :header Text to be displayed in the column header. By default the column
-    #   label will also be used as its header text.
-    # @option options [:left, :center, :right] :align_header (:center) Specifies how the header text
+    # @param [nil, #to_s] header (nil) Text to be displayed in the column header. If passed nil,
+    #   the column's label will also be used as its header text.
+    # @param [:left, :center, :right] align_header (:center) Specifies how the header text
     #   should be aligned.
-    # @option options [:left, :center, :right, nil] :align_body (nil) Specifies how the cell body contents
+    # @param [:left, :center, :right, nil] align_body (nil) Specifies how the cell body contents
     #   should be aligned. Possible If <tt>nil</tt> is passed, then the alignment is determined
     #   by the type of the cell value, with numbers aligned right, booleans center-aligned, and
     #   other values left-aligned. Note header text alignment is configured separately using the
-    #   :align_header option.
-    # @option options [Fixnum] :width (nil) Specifies the width of the column, excluding padding. If
-    #   nil, then the column will take the width provided by the `column_width` option
+    #   :align_header param.
+    # @param [Fixnum] width (nil) Specifies the width of the column, excluding padding. If
+    #   nil, then the column will take the width provided by the `column_width` param
     #   with which the Table was initialized.
-    # @option options [#to_proc] :formatter (:to_s.to_proc) A lambda or other callable object that
+    # @param [#to_proc] formatter (:to_s.to_proc) A lambda or other callable object that
     #   will be passed the calculated value of each cell to determine how it should be displayed. This
     #   is distinct from the extractor (see below). For example, if the extractor for this column
     #   generates a Date, then the formatter might format that Date in a particular way.
@@ -92,8 +86,18 @@ module Tabulo
     #   column. If this is not provided, then the column label will be treated as a method to be
     #   called on each source item to determine each cell's value.
     #
-    def add_column(label, options = { }, &extractor)
-      @columns << make_column(label, options.merge(extractor: extractor))
+    def add_column(label, header: nil, align_header: :center, align_body: nil,
+      width: nil, formatter: :to_s.to_proc, &extractor)
+
+      @columns << Column.new(
+        label: label.to_sym,
+        header: (header || label).to_s,
+        align_header: align_header,
+        align_body: align_body,
+        width: (width || @default_column_width),
+        formatter: formatter,
+        extractor: (extractor || label.to_proc)
+      )
     end
 
     # @return [String] a graphical "ASCII" representation of the Table, suitable for
@@ -132,7 +136,7 @@ module Tabulo
 
     # @return [String] an "ASCII" graphical representation of the Table column headers.
     def formatted_header
-      format_row(true, &:header_cell)
+      format_row(@wrap_header_cells_to, &:header_subcells)
     end
 
     # @return [String] an "ASCII" graphical representation of a horizontal
@@ -145,7 +149,8 @@ module Tabulo
     #   end
     #
     def horizontal_rule
-      format_row(false, HORIZONTAL_RULE_CHARACTER, CORNER_CHARACTER, &:horizontal_rule)
+      inner = @columns.map { |column| surround(column.horizontal_rule, HORIZONTAL_RULE_CHARACTER) }
+      surround_join(inner, CORNER_CHARACTER)
     end
 
     # Reset all the column widths so that each column is *just* wide enough to accommodate
@@ -157,23 +162,28 @@ module Tabulo
     # be traversed and all the column extractors and formatters to be applied in order
     # to calculate the required widths.
     #
-    # @param [Hash] options
-    # @option options [String] :max_table_width (nil) If provided, stops the total table
+    # @param [nil, Numeric] max_table_width (nil) If provided, stops the total table
     #   width (including padding and borders) from expanding beyond this number of characters.
     #   Width is deducted from columns if required to achieve this, with one character progressively
     #   deducted from the width of the widest column until the target is reached. When the
     #   table is printed, wrapping or truncation will then occur in these columns as required
-    #   (depending on how they were configured).
+    #   (depending on how they were configured). Note that regardless of the value passed to
+    #   max_table_width, the table will always be left wide enough to accommodate at least
+    #   1 character's width of content, 1 character of left padding and 1 character of right padding
+    #   in each column, together with border characters (1 on each side of the table and 1 between
+    #   adjacent columns). I.e. there is a certain width below width the Table will refuse to
+    #   shrink itself.
     #
     # @return [Table] the Table itself
-    def shrinkwrap!(options = { })
+    def shrinkwrap!(max_table_width: nil)
       return self if columns.none?
-      max_table_width = options[:max_table_width]
 
       header_widths = columns.map { |c| c.header.length }
 
       column_widths = @sources.inject(header_widths) do |widths, source|
-        columns.map { |c| c.formatted_cell_content(source).length }.zip(widths).map(&:max)
+        columns.map do |c|
+          c.formatted_cell_content(source).split($/, -1).map(&:length).max || 1
+        end.zip(widths).map(&:max)
       end
 
       columns.zip(column_widths).each do |column, width|
@@ -188,7 +198,6 @@ module Tabulo
 
         # Ensure max table width is at least wide enough to accommodate table borders and padding
         # and one character of content.
-        # TODO Document this behaviour.
         min_table_width = total_padding + total_borders + columns.count
         max_table_width = min_table_width if min_table_width > max_table_width
 
@@ -207,9 +216,9 @@ module Tabulo
     end
 
     # @!visibility private
-    def formatted_body_row(source, options = { with_header: false })
-      inner = format_row { |column| column.body_cell(source) }
-      if options[:with_header]
+    def formatted_body_row(source, with_header: false)
+      inner = format_row(@wrap_body_cells_to) { |column| column.body_subcells(source) }
+      if with_header
         join_lines([horizontal_rule, formatted_header, horizontal_rule, inner])
       else
         inner
@@ -219,56 +228,70 @@ module Tabulo
     private
 
     # @!visibility private
-    def body_row(source, options = { with_header: false })
-      Row.new(self, source, options)
+    def body_row(source, with_header: false)
+      Row.new(self, source, with_header: with_header)
     end
 
     # @!visibility private
-    def format_row(header = false, padder = @padding_character, joiner = @joiner)
-      # TODO Tidy this up -- or at least comment it.
+    #
+    # Yields each column to passed block, then wraps and joins the results to form
+    # a formatted row.
+    def format_row(wrap_cells_to)
+
+      # Create an array of "cell stacks", each of which is an array of strings that
+      # will be stacked on top of each other to form a wrapped cell.
       cell_stacks = @columns.map do |column|
-        raw = yield column
-        wrap = (header ? @wrap_header_cells_to : @wrap_body_cells_to)
         column_width = column.width
-        cell_body_length = (wrap ? column_width * wrap : raw.length)
-        truncated = (cell_body_length < raw.length)
-        cell_body = raw[0...cell_body_length]
-        num_subcells = (cell_body_length.to_f / column_width).ceil
-        (0...num_subcells).map do |i|
-          s = cell_body.slice(i * column_width, column_width)
-          right_padder = ((truncated && i == num_subcells - 1) ? @truncation_indicator : padder)
-          "#{padder}#{s}#{padder * (column_width - s.length)}#{right_padder}"
+
+        # Get the raw, non-wrapped, non-truncated content of the cell.
+        raw_subcells = yield column
+
+        truncated = (wrap_cells_to && (raw_subcells.size > wrap_cells_to))
+        subcells = (wrap_cells_to ? raw_subcells[0...wrap_cells_to] : raw_subcells)
+
+        subcells.map.with_index do |subcell, i|
+          lpad = @padding_character
+          rpad = (truncated && (i == subcells.size - 1) ? @truncation_indicator : @padding_character)
+          "#{lpad}#{subcell}#{rpad}"
         end
       end
 
-      subrows = (0...cell_stacks.map(&:size).max || 1).map do |subrow_index|
+      max_cell_stack_height = cell_stacks.map(&:size).max || 1
+
+      # A subrow is a string representing a single horizontal slice of this row that's
+      # strictly one character high.
+      subrows = (0...max_cell_stack_height).map do |subrow_index|
         cell_stacks.map.with_index do |cell_stack, column_index|
           if subrow_index < cell_stack.size
+            # This cell stack is at least as "deep" as the subrow we're on. So just
+            # grab the subcell for this subrow from this cell stack.
             cell_stack[subrow_index]
           else
-            "#{padder}#{' ' * @columns[column_index].width}#{padder}"
+            # This cell stack is not "deep" enough. So we make an empty subcell to
+            # add to this subrow for this column
+            surround(' ' * @columns[column_index].width, @padding_character)
           end
         end
       end
 
-      join_lines(subrows.map { |subrow| "#{joiner}#{subrow.join(joiner)}#{joiner}" })
+      # Join each subrow with border characters, then join these with newlines, to form
+      # the wrapped, formatted row as a single string.
+      join_lines(subrows.map { |subrow| surround_join(subrow, @joiner) })
     end
 
     # @!visibility private
-    def join_lines(lines)
-      lines.join($/)  # join strings with cross-platform newline
+    def surround(str, ch0)
+      "#{ch0}#{str}#{ch0}"
+    end
+
+    # @!visibility private
+    def surround_join(arr, ch)
+      surround(arr.join(ch), ch)
     end
 
     # @!visibility private
-    def make_column(item, options = { })
-      Column.new({
-        label: item.to_sym,
-        header: item.to_s,
-        align_header: :center,
-        width: @default_column_width,
-        formatter: :to_s.to_proc
-
-      }.merge(options))
+    def join_lines(lines)
+      lines.join($/)  # join strings with cross-platform newline
     end
   end
 end

data/lib/tabulo/version.rb

@@ -1,3 +1,3 @@
 module Tabulo
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tabulo
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Matthew Harvey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-28 00:00:00.000000000 Z
+date: 2017-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler