roo 2.6.0 → 2.8.3

data/lib/roo/excelx/sheet_doc.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'roo/excelx/extractor'
 
@@ -5,7 +7,7 @@ module Roo
   class Excelx
     class SheetDoc < Excelx::Extractor
       extend Forwardable
-      delegate [:styles, :workbook, :shared_strings, :base_date] => :@shared
+      delegate [:workbook] => :@shared
 
       def initialize(path, relationships, shared, options = {})
         super(path)
@@ -19,7 +21,12 @@ module Roo
       end
 
       def hyperlinks(relationships)
-        @hyperlinks ||= extract_hyperlinks(relationships)
+        # If you're sure you're not going to need this hyperlinks you can discard it
+        @hyperlinks ||= if @options[:no_hyperlinks] || !relationships.include_type?("hyperlink")
+          {}
+        else
+          extract_hyperlinks(relationships)
+        end
       end
 
       # Get the dimensions for the sheet.
@@ -39,13 +46,10 @@ module Roo
       def each_cell(row_xml)
         return [] unless row_xml
         row_xml.children.each do |cell_element|
-          # If you're sure you're not going to need this hyperlinks you can discard it
-          hyperlinks = unless @options[:no_hyperlinks]
-                         key = ::Roo::Utils.ref_to_key(cell_element['r'])
-                         hyperlinks(@relationships)[key]
-                       end
+          coordinate = ::Roo::Utils.extract_coordinate(cell_element["r"])
+          hyperlinks = hyperlinks(@relationships)[coordinate]
 
-          yield cell_from_xml(cell_element, hyperlinks)
+          yield cell_from_xml(cell_element, hyperlinks, coordinate)
         end
       end
 
@@ -53,13 +57,13 @@ module Roo
 
       def cell_value_type(type, format)
         case type
-        when 's'.freeze
+        when 's'
           :shared
-        when 'b'.freeze
+        when 'b'
           :boolean
-        when 'str'.freeze
+        when 'str'
           :string
-        when 'inlineStr'.freeze
+        when 'inlineStr'
           :inlinestr
         else
           Excelx::Format.to_type(format)
@@ -74,42 +78,58 @@ module Roo
       #             </c>
       # hyperlink - a String for the hyperlink for the cell or nil when no
       #             hyperlink is present.
+      # coordinate - a Roo::Excelx::Coordinate for the coordinate for the cell
+      #              or nil to extract coordinate from cell_xml.
+      # empty_cell - an Optional Boolean value.
       #
       # Examples
       #
-      #    cells_from_xml(<Nokogiri::XML::Element>, nil)
+      #    cells_from_xml(<Nokogiri::XML::Element>, nil, nil)
       #    # => <Excelx::Cell::String>
       #
       # Returns a type of <Excelx::Cell>.
-      def cell_from_xml(cell_xml, hyperlink)
-        coordinate = extract_coordinate(cell_xml['r'])
-        return Excelx::Cell::Empty.new(coordinate) if cell_xml.children.empty?
+      def cell_from_xml(cell_xml, hyperlink, coordinate, empty_cell=true)
+        coordinate ||= ::Roo::Utils.extract_coordinate(cell_xml["r"])
+        cell_xml_children = cell_xml.children
+        return create_empty_cell(coordinate, empty_cell) if cell_xml_children.empty?
 
         # NOTE: This is error prone, to_i will silently turn a nil into a 0.
         #       This works by coincidence because Format[0] is General.
-        style = cell_xml['s'].to_i
-        format = styles.style_format(style)
-        value_type = cell_value_type(cell_xml['t'], format)
+        style = cell_xml["s"].to_i
         formula = nil
 
-        cell_xml.children.each do |cell|
+        cell_xml_children.each do |cell|
           case cell.name
           when 'is'
-            content_arr = cell.search('t').map(&:content)
-            unless content_arr.empty?
-              return Excelx::Cell.create_cell(:string, content_arr.join(''), formula, style, hyperlink, coordinate)
+            content = +""
+            cell.children.each do |inline_str|
+              if inline_str.name == 't'
+                content << inline_str.content
+              end
+            end
+            unless content.empty?
+              return Excelx::Cell.cell_class(:string).new(content, formula, style, hyperlink, coordinate)
             end
           when 'f'
             formula = cell.content
           when 'v'
-            return create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, coordinate)
+            format = style_format(style)
+            value_type = cell_value_type(cell_xml["t"], format)
+
+            return create_cell_from_value(value_type, cell, formula, format, style, hyperlink, coordinate)
           end
         end
 
-        Excelx::Cell::Empty.new(coordinate)
+        create_empty_cell(coordinate, empty_cell)
+      end
+
+      def create_empty_cell(coordinate, empty_cell)
+        if empty_cell
+          Excelx::Cell::Empty.new(coordinate)
+        end
       end
 
-      def create_cell_from_value(value_type, cell, formula, format, style, hyperlink, base_date, coordinate)
+      def create_cell_from_value(value_type, cell, formula, format, style, hyperlink, coordinate)
         # NOTE: format.to_s can replace excelx_type as an argument for
         #       Cell::Time, Cell::DateTime, Cell::Date or Cell::Number, but
         #       it will break some brittle tests.
@@ -125,11 +145,12 @@ module Roo
         #       3. formula
         case value_type
         when :shared
-          value = shared_strings.use_html?(cell.content.to_i) ? shared_strings.to_html[cell.content.to_i] : shared_strings[cell.content.to_i]
-          Excelx::Cell.create_cell(:string, value, formula, style, hyperlink, coordinate)
+          cell_content = cell.content.to_i
+          value = shared_strings.use_html?(cell_content) ? shared_strings.to_html[cell_content] : shared_strings[cell_content]
+          Excelx::Cell.cell_class(:string).new(value, formula, style, hyperlink, coordinate)
         when :boolean, :string
           value = cell.content
-          Excelx::Cell.create_cell(value_type, value, formula, style, hyperlink, coordinate)
+          Excelx::Cell.cell_class(value_type).new(value, formula, style, hyperlink, coordinate)
         when :time, :datetime
           cell_content = cell.content.to_f
           # NOTE: A date will be a whole number. A time will have be > 1. And
@@ -148,35 +169,35 @@ module Roo
                       else
                         :date
                       end
-          Excelx::Cell.create_cell(cell_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+          base_value = cell_type == :date ? base_date : base_timestamp
+          Excelx::Cell.cell_class(cell_type).new(cell_content, formula, excelx_type, style, hyperlink, base_value, coordinate)
         when :date
-          Excelx::Cell.create_cell(value_type, cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
+          Excelx::Cell.cell_class(:date).new(cell.content, formula, excelx_type, style, hyperlink, base_date, coordinate)
         else
-          Excelx::Cell.create_cell(:number, cell.content, formula, excelx_type, style, hyperlink, coordinate)
+          Excelx::Cell.cell_class(:number).new(cell.content, formula, excelx_type, style, hyperlink, coordinate)
         end
       end
 
-      def extract_coordinate(coordinate)
-        row, column = ::Roo::Utils.split_coordinate(coordinate)
-
-        Excelx::Coordinate.new(row, column)
-      end
-
       def extract_hyperlinks(relationships)
         return {} unless (hyperlinks = doc.xpath('/worksheet/hyperlinks/hyperlink'))
 
-        Hash[hyperlinks.map do |hyperlink|
-          if hyperlink.attribute('id') && (relationship = relationships[hyperlink.attribute('id').text])
-            [::Roo::Utils.ref_to_key(hyperlink.attributes['ref'].to_s), relationship.attribute('Target').text]
+        hyperlinks.each_with_object({}) do |hyperlink, hash|
+          if relationship = relationships[hyperlink['id']]
+            target_link = relationship['Target']
+            target_link += "##{hyperlink['location']}" if hyperlink['location']
+
+            Roo::Utils.coordinates_in_range(hyperlink["ref"].to_s) do |coord|
+              hash[coord] = target_link
+            end
           end
-        end.compact]
+        end
       end
 
       def expand_merged_ranges(cells)
         # Extract merged ranges from xml
         merges = {}
         doc.xpath('/worksheet/mergeCells/mergeCell').each do |mergecell_xml|
-          tl, br = mergecell_xml['ref'].split(/:/).map { |ref| ::Roo::Utils.ref_to_key(ref) }
+          tl, br = mergecell_xml["ref"].split(/:/).map { |ref| ::Roo::Utils.ref_to_key(ref) }
           for row in tl[0]..br[0] do
             for col in tl[1]..br[1] do
               next if row == tl[0] && col == tl[1]
@@ -191,10 +212,14 @@ module Roo
       end
 
       def extract_cells(relationships)
-        extracted_cells = Hash[doc.xpath('/worksheet/sheetData/row/c').map do |cell_xml|
-          key = ::Roo::Utils.ref_to_key(cell_xml['r'])
-          [key, cell_from_xml(cell_xml, hyperlinks(relationships)[key])]
-        end]
+        extracted_cells = {}
+        empty_cell = @options[:empty_cell]
+
+        doc.xpath('/worksheet/sheetData/row/c').each do |cell_xml|
+          coordinate = ::Roo::Utils.extract_coordinate(cell_xml["r"])
+          cell = cell_from_xml(cell_xml, hyperlinks(relationships)[coordinate], coordinate, empty_cell)
+          extracted_cells[coordinate] = cell if cell
+        end
 
         expand_merged_ranges(extracted_cells) if @options[:expand_merged_ranges]
 
@@ -203,9 +228,25 @@ module Roo
 
       def extract_dimensions
         Roo::Utils.each_element(@path, 'dimension') do |dimension|
-          return dimension.attributes['ref'].value
+          return dimension["ref"]
         end
       end
+
+      def style_format(style)
+        @shared.styles.style_format(style)
+      end
+
+      def base_date
+        @shared.base_date
+      end
+
+      def base_timestamp
+        @shared.base_timestamp
+      end
+
+      def shared_strings
+        @shared.shared_strings
+      end
     end
   end
 end

data/lib/roo/excelx/styles.rb

@@ -55,9 +55,9 @@ module Roo
       end
 
       def extract_num_fmts
-        Hash[doc.xpath('//numFmt').map do |num_fmt|
-          [num_fmt['numFmtId'], num_fmt['formatCode']]
-        end]
+        doc.xpath('//numFmt').each_with_object({}) do |num_fmt, hash|
+          hash[num_fmt['numFmtId']] = num_fmt['formatCode']
+        end
       end
     end
   end

data/lib/roo/excelx/workbook.rb

@@ -29,13 +29,17 @@ module Roo
 
       # aka labels
       def defined_names
-        Hash[doc.xpath('//definedName').map do |defined_name|
+        doc.xpath('//definedName').each_with_object({}) do |defined_name, hash|
           # "Sheet1!$C$5"
           sheet, coordinates = defined_name.text.split('!$', 2)
           col, row = coordinates.split('$')
           name = defined_name['name']
-          [name, Label.new(name, sheet, row, col)]
-        end]
+          hash[name] = Label.new(name, sheet, row, col)
+        end
+      end
+
+      def base_timestamp
+        @base_timestamp ||= base_date.to_datetime.to_time.to_i
       end
 
       def base_date

data/lib/roo/excelx.rb

@@ -4,12 +4,11 @@ require 'roo/link'
 require 'roo/tempdir'
 require 'roo/utils'
 require 'forwardable'
+require 'set'
 
 module Roo
   class Excelx < Roo::Base
     extend Roo::Tempdir
-
-    require 'set'
     extend Forwardable
 
     ERROR_VALUES = %w(#N/A #REF! #NAME? #DIV/0! #NULL! #VALUE! #NUM!).to_set
@@ -25,8 +24,9 @@ module Roo
     require 'roo/excelx/sheet_doc'
     require 'roo/excelx/coordinate'
     require 'roo/excelx/format'
+    require 'roo/excelx/images'
 
-    delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files] => :@shared
+    delegate [:styles, :workbook, :shared_strings, :rels_files, :sheet_files, :comments_files, :image_rels, :image_files] => :@shared
     ExceedsMaxError = Class.new(StandardError)
 
     # initialization and opening of a spreadsheet file
@@ -40,14 +40,23 @@ module Roo
       sheet_options = {}
       sheet_options[:expand_merged_ranges] = (options[:expand_merged_ranges] || false)
       sheet_options[:no_hyperlinks] = (options[:no_hyperlinks] || false)
+      sheet_options[:empty_cell] = (options[:empty_cell] || false)
+      shared_options = {}
 
+      shared_options[:disable_html_wrapper] = (options[:disable_html_wrapper] || false)
       unless is_stream?(filename_or_stream)
         file_type_check(filename_or_stream, %w[.xlsx .xlsm], 'an Excel 2007', file_warning, packed)
         basename = find_basename(filename_or_stream)
       end
 
+      # NOTE: Create temp directory and allow Ruby to cleanup the temp directory
+      #       when the object is garbage collected. Initially, the finalizer was
+      #       created in the Roo::Tempdir module, but that led to a segfault
+      #       when testing in Ruby 2.4.0.
       @tmpdir = self.class.make_tempdir(self, basename, options[:tmpdir_root])
-      @shared = Shared.new(@tmpdir)
+      ObjectSpace.define_finalizer(self, self.class.finalize(object_id))
+
+      @shared = Shared.new(@tmpdir, shared_options)
       @filename = local_filename(filename_or_stream, @tmpdir, packed)
       process_zipfile(@filename || filename_or_stream)
 
@@ -57,10 +66,10 @@ module Roo
         end
       end.compact
       @sheets = []
-      @sheets_by_name = Hash[@sheet_names.map.with_index do |sheet_name, n|
-        @sheets[n] = Sheet.new(sheet_name, @shared, n, sheet_options)
-        [sheet_name, @sheets[n]]
-      end]
+      @sheets_by_name = {}
+      @sheet_names.each_with_index do |sheet_name, n|
+        @sheets_by_name[sheet_name] = @sheets[n] = Sheet.new(sheet_name, @shared, n, sheet_options)
+      end
 
       if cell_max
         cell_count = ::Roo::Utils.num_cells_in_range(sheet_for(options.delete(:sheet)).dimensions)
@@ -89,7 +98,12 @@ module Roo
     def sheet_for(sheet)
       sheet ||= default_sheet
       validate_sheet!(sheet)
-      @sheets_by_name[sheet]
+      @sheets_by_name[sheet] || @sheets[sheet]
+    end
+
+    def images(sheet = nil)
+      images_names = sheet_for(sheet).images.map(&:last)
+      images_names.map { |iname| image_files.find { |ifile| ifile[iname] } }
     end
 
     # Returns the content of a spreadsheet-cell.
@@ -218,7 +232,7 @@ module Roo
       sheet = sheet_for(sheet)
       key = normalize(row, col)
       cell = sheet.cells[key]
-      !cell || cell.empty? || (cell.type == :string && cell.value.empty?) ||
+      !cell || cell.empty? ||
         (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
     end
 
@@ -320,7 +334,7 @@ module Roo
 
       wb.extract(path)
       workbook_doc = Roo::Utils.load_xml(path).remove_namespaces!
-      workbook_doc.xpath('//sheet').map { |s| s.attributes['id'].value }
+      workbook_doc.xpath('//sheet').map { |s| s['id'] }
     end
 
     # Internal
@@ -344,17 +358,13 @@ module Roo
 
       wb_rels.extract(path)
       rels_doc = Roo::Utils.load_xml(path).remove_namespaces!
-      worksheet_type = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet'
 
       relationships = rels_doc.xpath('//Relationship').select do |relationship|
-        relationship.attributes['Type'].value == worksheet_type
+        worksheet_types.include? relationship['Type']
       end
 
-      relationships.inject({}) do |hash, relationship|
-        attributes = relationship.attributes
-        id = attributes['Id']
-        hash[id.value] = attributes['Target'].value
-        hash
+      relationships.each_with_object({}) do |relationship, hash|
+        hash[relationship['Id']] = relationship['Target']
       end
     end
 
@@ -371,6 +381,15 @@ module Roo
       end
     end
 
+    def extract_images(entries, tmpdir)
+      img_entries = entries.select { |e| e.name[/media\/image([0-9]+)/] }
+      img_entries.each do |entry|
+        path = "#{@tmpdir}/roo#{entry.name.gsub(/xl\/|\//, "_")}"
+        image_files << path
+        entry.extract(path)
+      end
+    end
+
     # Extracts all needed files from the zip file
     def process_zipfile(zipfilename_or_stream)
       @sheet_files = []
@@ -404,6 +423,7 @@ module Roo
       sheet_ids = extract_worksheet_ids(entries, "#{@tmpdir}/roo_workbook.xml")
       sheets = extract_worksheet_rels(entries, "#{@tmpdir}/roo_workbook.xml.rels")
       extract_sheets_in_order(entries, sheet_ids, sheets, @tmpdir)
+      extract_images(entries, @tmpdir)
 
       entries.each do |entry|
         path =
@@ -430,6 +450,10 @@ module Roo
           #        drawings, etc.
           nr = Regexp.last_match[1].to_i
           rels_files[nr - 1] = "#{@tmpdir}/roo_rels#{nr}"
+        when /drawing([0-9]+).xml.rels$/
+          # Extracting drawing relationships to make images lists for each sheet
+          nr = Regexp.last_match[1].to_i
+          image_rels[nr - 1] = "#{@tmpdir}/roo_image_rels#{nr}"
         end
 
         entry.extract(path) if path
@@ -437,7 +461,14 @@ module Roo
     end
 
     def safe_send(object, method, *args)
-      object.send(method, *args) if object && object.respond_to?(method)
+      object.send(method, *args) if object&.respond_to?(method)
+    end
+
+    def worksheet_types
+      [
+        'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet', # OOXML Transitional
+        'http://purl.oclc.org/ooxml/officeDocument/relationships/worksheet' # OOXML Strict
+      ]
     end
   end
 end

data/lib/roo/formatters/base.rb

@@ -0,0 +1,15 @@
+module Roo
+  module Formatters
+    module Base
+      # converts an integer value to a time string like '02:05:06'
+      def integer_to_timestring(content)
+        h = (content / 3600.0).floor
+        content -= h * 3600
+        m = (content / 60.0).floor
+        content -= m * 60
+        s = content
+        Kernel.format("%02d:%02d:%02d", h, m, s)
+      end
+    end
+  end
+end

data/lib/roo/formatters/csv.rb

@@ -0,0 +1,84 @@
+module Roo
+  module Formatters
+    module CSV
+      def to_csv(filename = nil, separator = ",", sheet = default_sheet)
+        if filename
+          File.open(filename, "w") do |file|
+            write_csv_content(file, sheet, separator)
+          end
+          true
+        else
+          sio = ::StringIO.new
+          write_csv_content(sio, sheet, separator)
+          sio.rewind
+          sio.read
+        end
+      end
+
+      private
+
+      # Write all cells to the csv file. File can be a filename or nil. If the
+      # file argument is nil the output goes to STDOUT
+      def write_csv_content(file = nil, sheet = nil, separator = ",")
+        file ||= STDOUT
+        return unless first_row(sheet) # The sheet is empty
+
+        1.upto(last_row(sheet)) do |row|
+          1.upto(last_column(sheet)) do |col|
+            # TODO: use CSV.generate_line
+            file.print(separator) if col > 1
+            file.print cell_to_csv(row, col, sheet)
+          end
+          file.print("\n")
+        end
+      end
+
+      # The content of a cell in the csv output
+      def cell_to_csv(row, col, sheet)
+        return "" if empty?(row, col, sheet)
+
+        onecell = cell(row, col, sheet)
+
+        case celltype(row, col, sheet)
+        when :string
+          %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+        when :boolean
+          # TODO: this only works for excelx
+          onecell = self.sheet_for(sheet).cells[[row, col]].formatted_value
+          %("#{onecell.gsub('"', '""').downcase}")
+        when :float, :percentage
+          if onecell == onecell.to_i
+            onecell.to_i.to_s
+          else
+            onecell.to_s
+          end
+        when :formula
+          case onecell
+          when String
+            %("#{onecell.gsub('"', '""')}") unless onecell.empty?
+          when Integer
+            onecell.to_s
+          when Float
+            if onecell == onecell.to_i
+              onecell.to_i.to_s
+            else
+              onecell.to_s
+            end
+          when Date, DateTime, TrueClass, FalseClass
+            onecell.to_s
+          else
+            fail "unhandled onecell-class #{onecell.class}"
+          end
+        when :date, :datetime
+          onecell.to_s
+        when :time
+          integer_to_timestring(onecell)
+        when :link
+          %("#{onecell.url.gsub('"', '""')}")
+        else
+          fail "unhandled celltype #{celltype(row, col, sheet)}"
+        end || ""
+      end
+    end
+  end
+end

data/lib/roo/formatters/matrix.rb

@@ -0,0 +1,23 @@
+module Roo
+  module Formatters
+    module Matrix
+      # returns a matrix object from the whole sheet or a rectangular area of a sheet
+      def to_matrix(from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
+        require 'matrix'
+
+        return ::Matrix.empty unless first_row
+
+        from_row ||= first_row(sheet)
+        to_row ||= last_row(sheet)
+        from_column ||= first_column(sheet)
+        to_column ||= last_column(sheet)
+
+        ::Matrix.rows(from_row.upto(to_row).map do |row|
+          from_column.upto(to_column).map do |col|
+            cell(row, col, sheet)
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/roo/formatters/xml.rb

@@ -0,0 +1,31 @@
+# returns an XML representation of all sheets of a spreadsheet file
+module Roo
+  module Formatters
+    module XML
+      def to_xml
+        Nokogiri::XML::Builder.new do |xml|
+          xml.spreadsheet do
+            sheets.each do |sheet|
+              self.default_sheet = sheet
+              xml.sheet(name: sheet) do |x|
+                if first_row && last_row && first_column && last_column
+                  # sonst gibt es Fehler bei leeren Blaettern
+                  first_row.upto(last_row) do |row|
+                    first_column.upto(last_column) do |col|
+                      next if empty?(row, col)
+
+                      x.cell(cell(row, col),
+                      row: row,
+                      column: col,
+                      type: celltype(row, col))
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end.to_xml
+      end
+    end
+  end
+end

data/lib/roo/formatters/yaml.rb

@@ -0,0 +1,40 @@
+module Roo
+  module Formatters
+    module YAML
+      # returns a rectangular area (default: all cells) as yaml-output
+      # you can add additional attributes with the prefix parameter like:
+      # oo.to_yaml({"file"=>"flightdata_2007-06-26", "sheet" => "1"})
+      def to_yaml(prefix = {}, from_row = nil, from_column = nil, to_row = nil, to_column = nil, sheet = default_sheet)
+        # return an empty string if there is no first_row, i.e. the sheet is empty
+        return "" unless first_row
+
+        from_row ||= first_row(sheet)
+        to_row ||= last_row(sheet)
+        from_column ||= first_column(sheet)
+        to_column ||= last_column(sheet)
+
+        result = "--- \n"
+        from_row.upto(to_row) do |row|
+          from_column.upto(to_column) do |col|
+            next if empty?(row, col, sheet)
+
+            result << "cell_#{row}_#{col}: \n"
+            prefix.each do|k, v|
+              result << "  #{k}: #{v} \n"
+            end
+            result << "  row: #{row} \n"
+            result << "  col: #{col} \n"
+            result << "  celltype: #{celltype(row, col, sheet)} \n"
+            value = cell(row, col, sheet)
+            if celltype(row, col, sheet) == :time
+              value = integer_to_timestring(value)
+            end
+            result << "  value: #{value} \n"
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/roo/helpers/default_attr_reader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Roo
+  module Helpers
+    module DefaultAttrReader
+      def attr_reader_with_default(attr_hash)
+        attr_hash.each do |attr_name, default_value|
+          instance_variable = :"@#{attr_name}"
+          define_method attr_name do
+            if instance_variable_defined? instance_variable
+              instance_variable_get instance_variable
+            else
+              default_value
+            end
+          end
+        end
+      end
+    end
+  end
+end