carray-netcdf 2.0.0 → 2.1.0

data/lib/carray/netcdf/group.rb

@@ -14,6 +14,9 @@ module CA
     class Group
 
       include CA::NetCDF
+      # The low-level calls are this class's helpers, not its interface.
+      private :nc_get_var, :nc_get_vara, :nc_get_vars, :nc_get_varm,
+              :nc_put_var, :nc_put_vara, :nc_put_vars, :nc_put_varm
 
       # @param ncid [Integer] group id
       # @param file [File] root file (for codec + mode + close)
@@ -28,6 +31,22 @@ module CA
         load_metadata
       end
 
+      # Read this group's dimensions, variables, subgroups and attributes
+      # again from the file. They are read once, when the file is opened,
+      # and kept up to date by this API's own `def_*` calls; a change made
+      # through the low-level API (`nc_put_att`, `nc_rename_var`,
+      # `nc_def_var` on `ncid`) is seen only after a reload. Var, Dim and
+      # Group objects taken before it describe the old state; take new
+      # ones after it.
+      # @return [self]
+      def reload
+        @file.ensure_open
+        @dims, @vars, @groups = {}, {}, {}
+        @atts_cache = nil
+        load_metadata
+        self
+      end
+
       # @!attribute [r] ncid
       #   @return [Integer]
       # @!attribute [r] file
@@ -36,13 +55,13 @@ module CA
       #   @return [Group, nil]
       attr_reader :ncid, :file, :parent
 
-      # @return [String] `""` for the root group, `"myGroup"` for a named
+      # @return [String] `"/"` for the root group, `"myGroup"` for a named
       #   group
-      def name = nc_inq_grpname(@ncid)
+      def name = (@file.ensure_open; nc_inq_grpname(@ncid))
 
       # @return [String] `"/"` for root, `"/model/ocean"` for a nested
       #   group
-      def path = nc_inq_grpname_full(@ncid)
+      def path = (@file.ensure_open; nc_inq_grpname_full(@ncid))
 
       # @return [Boolean]
       def root? = @parent.nil?
@@ -50,11 +69,12 @@ module CA
       # @!group Introspection (this group only)
 
       # @return [Hash{String => Dim}]
-      def dims       = @dims
+      # (a frozen copy: the group's own table is changed only by def_*)
+      def dims       = @dims.dup.freeze
       # @return [Hash{String => Var}]
-      def vars       = @vars
+      def vars       = @vars.dup.freeze
       # @return [Hash{String => Group}]
-      def groups     = @groups
+      def groups     = @groups.dup.freeze
       # @param name [#to_s]
       # @return [Dim, nil]
       def dim(name)  = @dims[name.to_s]
@@ -74,10 +94,11 @@ module CA
       # Group-scoped global attributes (each group has its own set in
       # netcdf-4). Cached; invalidated by our own {#def_att}. Other paths
       # that mutate attributes (`rename_att` / `del_att` / a direct
-      # `nc_put_att`) aren't exposed by layer 2, so we don't have to watch
+      # `nc_put_att`) aren't exposed by the high-level API, so we don't have to watch
       # for them.
       # @return [Hash{String => Object}] frozen
       def atts
+        @file.ensure_open
         @atts_cache ||= read_group_attributes
       end
 
@@ -129,8 +150,8 @@ module CA
         n   = name.to_s
         len = length == :unlimited ? NC_UNLIMITED : Integer(length)
         @file.ensure_define_mode
-        @dims[n] = Dim.new(self, nc_def_dim(@ncid, n, len),
-                           unlimited: length == :unlimited)
+        register_dim(Dim.new(self, nc_def_dim(@ncid, n, len),
+                            unlimited: length == :unlimited))
       end
 
       # NetCDF-4 per-variable storage / filter options that {#def_var}
@@ -138,9 +159,16 @@ module CA
       # variable attribute). See {#apply_var_options} for accepted values.
       # @return [Array<Symbol>]
       VAR_OPTION_KEYS = %i[
-        chunks deflate shuffle fletcher32 endian no_fill
+        chunks deflate shuffle zstandard bzip2 szip blosc fletcher32 endian no_fill
       ].freeze
 
+      # The compressors among {VAR_OPTION_KEYS}, and with shuffle, the
+      # options {#def_var} takes from one source as a whole.
+      # @api private
+      COMPRESSION_KEYS  = %i[deflate zstandard bzip2 szip blosc].freeze
+      # @api private
+      COMPRESSION_GROUP = (COMPRESSION_KEYS + %i[shuffle]).freeze
+
       # Define a variable in this group.
       #
       # @example Positional
@@ -165,7 +193,10 @@ module CA
       # Kwargs are variable attributes, plus the reserved storage / filter
       # options (see {VAR_OPTION_KEYS}). Overriding attributes merge into
       # the template's; a kwarg keyed the same as a template attribute
-      # wins.
+      # wins. Between two NetCDF-4 files the template's storage settings
+      # ({Var#storage_options}) are copied too, under any given here and
+      # over the file-wide defaults; its chunk sizes are copied only when
+      # the new variable's dimensions have the template's lengths.
       #
       # @param name [#to_s] variable name
       # @param type [Symbol, String, Integer, nil] on-disk type; required
@@ -179,6 +210,13 @@ module CA
       def def_var(name, type = nil, dims = nil, template: nil, **atts)
         n = name.to_s
 
+        # Split the reserved storage / filter kwargs off first, before a
+        # template's attributes are merged in under String keys.
+        given_opts = {}
+        VAR_OPTION_KEYS.each do |k|
+          given_opts[k] = atts.delete(k) if atts.key?(k)
+        end
+
         # Accept `dims:` as a keyword too — a natural spelling when template:
         # is in use and the positional slot would otherwise force `nil` fillers.
         if atts.key?(:dims)
@@ -204,11 +242,14 @@ module CA
                   raise ArgumentError,
                         "def_var template: expected Var / Group / File, got #{template.class}"
                 end
+          template_storage = (src.file.netcdf4? && @file.netcdf4?) ? src.storage_options : {}
           type ||= src.nc_type
           dims ||= src.dims.map(&:name)
-          # template.atts (String keys, frozen) merged under any explicit
-          # atts (Symbol / String keys).  Explicit wins on collision.
-          atts = src.atts.merge(atts.transform_keys(&:to_s))
+          # The template's attributes are copied as stored, keeping their
+          # types (below); the explicit ones (Symbol / String keys) replace
+          # any of the same name and are written by value.
+          atts = atts.transform_keys(&:to_s)
+          copied_atts = src.atts.keys - atts.keys
         end
 
         raise ArgumentError,
@@ -217,28 +258,119 @@ module CA
 
         # Accept a name (String / Symbol) or a Dim object.  Names are resolved
         # by walking up the group tree for netcdf-4 dim inheritance.
-        dimids = Array(dims).map { |d| d.is_a?(Dim) ? d.to_i : resolve_dim(d.to_s).to_i }
-        # Split reserved storage/filter kwargs off before treating the rest
-        # as variable attributes.  Per-var kwargs win over the file-wide
-        # defaults (nil / false / 0 are all "explicit"; they override).
+        # A Dim is taken as it is only when it belongs to this file and is in
+        # scope here; one from another file or a sibling group is looked up
+        # by its name, since its id means something else here.
+        dim_objects = Array(dims).map do |d|
+          if d.is_a?(Dim) && d.group.file.equal?(@file) && dim_by_id(d.to_i)
+            d
+          else
+            resolve_dim(d.is_a?(Dim) ? d.name : d.to_s)
+          end
+        end
+        dimids      = dim_objects.map(&:to_i)
+        # The template's chunk sizes fit only its own shape: keep them when
+        # every dimension has the template's length (or is unlimited in
+        # both), and leave chunking to libnetcdf otherwise.
+        if template_storage&.key?(:chunks) && ! same_extent?(src.dims, dim_objects)
+          template_storage.delete(:chunks)
+        end
+        # Per-var kwargs win over the template's storage, which wins over
+        # the file-wide defaults (nil / false / 0 are all "explicit"; they
+        # override). Compression is taken whole from the first of these
+        # that names any compressor, so `zstandard: 3` over a deflated
+        # template replaces deflate rather than stacking on it.
+        template_storage ||= {}
         file_defaults = @file.var_defaults
+        chosen = [given_opts, template_storage, file_defaults].find do |o|
+          COMPRESSION_KEYS.any? { |k| o.key?(k) }
+        end
+        unless chosen.nil? || chosen.equal?(template_storage)
+          template_storage = template_storage.reject { |k, _| COMPRESSION_GROUP.include?(k) }
+        end
+        unless chosen.nil? || chosen.equal?(file_defaults)
+          file_defaults = file_defaults.reject { |k, _| COMPRESSION_GROUP.include?(k) }
+        end
         opts = {}
         VAR_OPTION_KEYS.each do |k|
-          if atts.key?(k)
-            opts[k] = atts.delete(k)
+          if given_opts.key?(k)
+            opts[k] = given_opts[k]
+          elsif template_storage.key?(k)
+            opts[k] = template_storage[k]
           elsif file_defaults.key?(k)
             opts[k] = file_defaults[k]
           end
         end
         @file.ensure_define_mode
-        nct    = nc_type_for(type)
-        varid  = nc_def_var(@ncid, n, nct, dimids)
-        apply_var_options(varid, opts) unless opts.empty?
-        # A CArray value keeps its own on-disk type (so a schema loader's
-        # `_FillValue: {short: -32768}` on a float variable stays short);
-        # a packed-space attribute takes the variable's type (CF §2.5.1).
-        atts.each { |k, v| put_var_att(@ncid, varid, k.to_s, v, nct) }
-        @vars[n] = Var.new(self, varid)
+        nct = nc_type_for(type)
+        # NetCDF has no way to remove a variable, so what can be checked
+        # here is checked before nc_def_var defines it.
+        check_var_options(opts)
+        atts.each { |k, v| attribute_values(k.to_s, v) if v.is_a?(CArray) }
+        # A NaN fill (xarray writes one on every float variable) has no
+        # value in an integer type the template's type is overridden with.
+        if copied_atts && nct != src.nc_type && Var::INTEGER_TYPES.include?(NC_TO_CA[nct])
+          (copied_atts & PACKED_SPACE_ATTS).each do |k|
+            next unless Array(src.atts[k]).any? { |x| x.is_a?(Float) && !x.finite? }
+            raise ArgumentError,
+                  "the template's #{k} is #{src.atts[k].inspect}, which an integer type " \
+                  "cannot hold; give #{k}: for the new type"
+          end
+        end
+        varid = nc_def_var(@ncid, n, nct, dimids)
+        begin
+          apply_var_options(varid, opts) unless opts.empty?
+          # A packed-space attribute takes the variable's type (CF §2.5.1),
+          # a CArray value included; another CArray keeps its own type.
+          unsigned = unsigned_flag?(atts["_Unsigned"] || atts[:_Unsigned] || (copied_atts && src.atts["_Unsigned"]))
+          atts.each { |k, v| put_var_att(@ncid, varid, k.to_s, v, nct, unsigned: unsigned) }
+          copied_atts&.each do |k|
+            # A packed-space attribute follows the variable when its type
+            # was overridden; anything else keeps the template's type.
+            if PACKED_SPACE_ATTS.include?(k) && nct != src.nc_type
+              put_var_att(@ncid, varid, k, src.atts[k], nct, unsigned: unsigned)
+            else
+              copy_att_from(src.group, src.varid, k, varid)
+            end
+          end
+        ensure
+          # Registered even when a later step failed, so that the object
+          # model matches the file (the block form's abort rolls it back).
+          @vars[n] = Var.new(self, varid)
+        end
+        @vars[n]
+      end
+
+      # Raise on storage options that would fail only after the variable
+      # is defined: a value of the wrong form, or a NetCDF-4 option on a
+      # classic file.
+      # @api private
+      private def check_var_options(opts)
+        c = opts[:chunks]
+        unless c.nil? || c.is_a?(Array) || %i[contiguous compact].include?(c)
+          raise ArgumentError, "chunks: expected Array / :contiguous / :compact, got #{c.inspect}"
+        end
+        e = opts[:endian]
+        unless e.nil? || %i[native little big].include?(e)
+          raise ArgumentError, "endian: expected :native / :little / :big, got #{e.inspect}"
+        end
+        szip_arguments(opts[:szip])   if opts[:szip]
+        blosc_arguments(opts[:blosc]) if opts[:blosc]
+        return if @file.netcdf4?
+        netcdf4_only = []
+        netcdf4_only << :chunks     if c
+        netcdf4_only << :deflate    if opts[:deflate].to_i.positive?
+        netcdf4_only << :shuffle    if opts[:shuffle]
+        netcdf4_only << :zstandard  if opts[:zstandard] && opts[:zstandard].to_i != 0
+        netcdf4_only << :bzip2      if opts[:bzip2].to_i.positive?
+        netcdf4_only << :szip       if opts[:szip]
+        netcdf4_only << :blosc      if opts[:blosc]
+        netcdf4_only << :fletcher32 if opts[:fletcher32]
+        netcdf4_only << :endian     if e
+        return if netcdf4_only.empty?
+        raise ArgumentError,
+              "#{netcdf4_only.map { |k| "#{k}:" }.join(', ')} need a NetCDF-4 file " \
+              "(create it with netcdf4: true)"
       end
 
       # Apply NetCDF-4 storage / filter options on a freshly defined
@@ -248,12 +380,21 @@ module CA
       #   chunks: :contiguous      # NC_CONTIGUOUS
       #   chunks: :compact         # NC_COMPACT (small vars only)
       #   deflate: 4               # compression level 1..9 (0 / nil = off)
-      #   shuffle: true            # shuffle filter, usually paired with deflate
+      #   shuffle: true            # shuffle filter, usually paired with a compressor
+      #   zstandard: 3             # zstandard level (0 / nil = off; libnetcdf >= 4.9)
+      #   bzip2: 9                 # bzip2 level 1..9 (0 / nil = off; libnetcdf >= 4.9)
+      #   szip: { coding: :nn, pixels_per_block: 32 }   # coding :nn / :ec
+      #   blosc: { compressor: :lz4, level: 5, blocksize: 0, shuffle: :byte }
+      #                            # libnetcdf >= 4.9; compressor :lz / :lz4 /
+      #                            # :lz4hc / :snappy / :zlib / :zstd,
+      #                            # shuffle :none / :byte / :bit
       #   fletcher32: true         # per-chunk fletcher32 checksum
       #   endian: :little / :big / :native
       #   no_fill: true            # disable pre-fill (perf)
       #
-      # These all require NetCDF-4; libnetcdf raises on a NetCDF-3 file
+      # These all require NetCDF-4, except `no_fill:` and an off
+      # `deflate:` (0 / nil, without `shuffle:`), which is a new variable's
+      # default and so is not sent; libnetcdf raises on a NetCDF-3 file
       # and the raise propagates.
       # @api private
       private def apply_var_options(varid, opts)
@@ -266,13 +407,33 @@ module CA
           end
         end
         if opts.key?(:deflate) || opts.key?(:shuffle)
+          # The netcdf gem reads these flags as Ruby truth values, so they
+          # go as true / false (a 0 would read as true).
           level   = (opts[:deflate] || 0).to_i
-          on      = level.positive? ? 1 : 0
-          shuffle = opts[:shuffle] ? 1 : 0
-          nc_def_var_deflate(@ncid, varid, shuffle, on, level)
+          on      = level.positive?
+          shuffle = opts[:shuffle] ? true : false
+          if on || shuffle
+            nc_def_var_deflate(@ncid, varid, shuffle, on, level)
+          end
+        end
+        # The other compressors, after shuffle so that it runs first. A
+        # filter libnetcdf lacks raises NC_ENOFILTER from the netcdf gem.
+        # zstandard also takes negative ("fast") levels; only 0 / nil / false
+        # is off, and libnetcdf checks the range.
+        if (level = opts[:zstandard]) && level.to_i != 0
+          nc_def_var_zstandard(@ncid, varid, level.to_i)
+        end
+        if opts[:bzip2].to_i.positive?
+          nc_def_var_bzip2(@ncid, varid, opts[:bzip2].to_i)
+        end
+        if (s = opts[:szip])
+          nc_def_var_szip(@ncid, varid, *szip_arguments(s))
+        end
+        if (b = opts[:blosc])
+          nc_def_var_blosc(@ncid, varid, *blosc_arguments(b))
         end
         if opts[:fletcher32]
-          nc_def_var_fletcher32(@ncid, varid, 1)
+          nc_def_var_fletcher32(@ncid, varid, true)
         end
         if (e = opts[:endian])
           endian = case e
@@ -284,8 +445,81 @@ module CA
           nc_def_var_endian(@ncid, varid, endian)
         end
         if opts.key?(:no_fill)
-          nc_def_var_fill(@ncid, varid, opts[:no_fill] ? 1 : 0, nil)
+          nc_def_var_fill(@ncid, varid, opts[:no_fill] ? true : false, nil)
+        end
+      end
+
+      SZIP_CODINGS = { nn: :NC_SZIP_NN, ec: :NC_SZIP_EC }.freeze
+      BLOSC_COMPRESSORS = {
+        lz: :BLOSC_LZ, lz4: :BLOSC_LZ4, lz4hc: :BLOSC_LZ4HC,
+        snappy: :BLOSC_SNAPPY, zlib: :BLOSC_ZLIB, zstd: :BLOSC_ZSTD,
+      }.freeze
+      BLOSC_SHUFFLES = { none: :BLOSC_NOSHUFFLE, byte: :BLOSC_SHUFFLE, bit: :BLOSC_BITSHUFFLE }.freeze
+      private_constant :SZIP_CODINGS, :BLOSC_COMPRESSORS, :BLOSC_SHUFFLES
+
+      # Whether two lists of Dims have the same extent: the same number,
+      # and each pair unlimited in both or of the same length.
+      # @api private
+      private def same_extent?(dims, others)
+        return false unless dims.size == others.size
+        dims.zip(others).all? do |a, b|
+          if a.unlimited? || b.unlimited?
+            a.unlimited? == b.unlimited?
+          else
+            a.length == b.length
+          end
+        end
+      end
+
+      # `szip: { coding:, pixels_per_block: }` as the arguments of
+      # `nc_def_var_szip`.
+      # @api private
+      private def szip_arguments(opt)
+        unless opt.is_a?(Hash)
+          raise ArgumentError, "szip: expected a Hash, got #{opt.inspect}"
+        end
+        coding = SZIP_CODINGS[opt.fetch(:coding, :nn)] or
+          raise ArgumentError, "szip: coding: expected :nn / :ec, got #{opt[:coding].inspect}"
+        [::NetCDF.const_get(coding), Integer(opt.fetch(:pixels_per_block, 32))]
+      end
+
+      # `blosc: { compressor:, level:, blocksize:, shuffle: }` as the
+      # arguments of `nc_def_var_blosc`.
+      # @api private
+      private def blosc_arguments(opt)
+        unless opt.is_a?(Hash)
+          raise ArgumentError, "blosc: expected a Hash, got #{opt.inspect}"
+        end
+        compressor = BLOSC_COMPRESSORS[opt.fetch(:compressor, :lz4)] or
+          raise ArgumentError, "blosc: compressor: expected one of #{BLOSC_COMPRESSORS.keys.inspect}, got #{opt[:compressor].inspect}"
+        shuffle = BLOSC_SHUFFLES[opt.fetch(:shuffle, :byte)] or
+          raise ArgumentError, "blosc: shuffle: expected :none / :byte / :bit, got #{opt[:shuffle].inspect}"
+        [::NetCDF.const_get(compressor), Integer(opt.fetch(:level, 5)),
+         Integer(opt.fetch(:blocksize, 0)), ::NetCDF.const_get(shuffle)]
+      end
+
+      # Copy attribute `name` of `src_varid` (or `NC_GLOBAL`) in `src_group`
+      # onto `varid` here, keeping its type. When libnetcdf cannot (an
+      # `NC_STRING` attribute into a classic file), it is written by value.
+      # @api private
+      private def copy_att_from(src_group, src_varid, name, varid = NC_GLOBAL)
+        @file.ensure_define_mode
+        begin
+          nc_copy_att(src_group.ncid, src_varid, name, @ncid, varid)
+        rescue ::NetCDF::Error
+          value = nc_get_att(src_group.ncid, src_varid, name)
+          if value.is_a?(Array) && value.all?(String)
+            raise ArgumentError,
+                  "attribute #{name.inspect} holds several strings (NC_STRING), " \
+                  "which a classic-format file cannot store; give it a value of your own"
+          end
+          if varid == NC_GLOBAL
+            nc_put_att(@ncid, NC_GLOBAL, name, value)
+          else
+            put_var_att(@ncid, varid, name, value, nc_inq_vartype(@ncid, varid))
+          end
         end
+        @atts_cache = nil if varid == NC_GLOBAL
       end
 
       # Define a group-level (global) attribute. A CArray value keeps its
@@ -296,7 +530,7 @@ module CA
       def def_att(name, value)
         @file.ensure_define_mode
         if value.is_a?(CArray)
-          put_att_typed(@ncid, NC_GLOBAL, name.to_s, value.to_a, TYPE_TO_NC[value.data_type])
+          put_att_typed(@ncid, NC_GLOBAL, name.to_s, attribute_values(name.to_s, value), TYPE_TO_NC[value.data_type])
         else
           nc_put_att(@ncid, NC_GLOBAL, name.to_s, value)
         end
@@ -338,7 +572,7 @@ module CA
       #   copy_var("lat", from: src, units: "deg")  # override / add attributes
       #
       # The data copy is bit-identical: raw on-disk values are read via
-      # {Var#raw} (no codec) and written via layer 1 (no codec). Users who
+      # {Var#raw} (no codec) and written via the low-level API (no codec). Users who
       # need a codec-mediated copy should call `def_var(template:)` and
       # write `dst[name] = src[name].to_ca` themselves.
       #
@@ -358,7 +592,17 @@ module CA
         dst = @vars[dst_name]
         ensure_data_mode
         # Bit-identical raw copy (skip both source's decode and dst's encode).
-        if src.scalar?
+        if src.nc_type == NC_STRING
+          # Strings have no CArray type; the netcdf gem moves them as Ruby
+          # Strings, nested by shape.
+          strings = ::NetCDF.nc_get_var(src.group.ncid, src.varid)
+          shape   = src.shape
+          if shape.empty?
+            ::NetCDF.nc_put_var(@ncid, dst.varid, strings)
+          elsif shape.inject(1, :*) > 0
+            ::NetCDF.nc_put_vara(@ncid, dst.varid, shape.map { 0 }, shape, Array(strings).flatten)
+          end
+        elsif src.scalar?
           buf = CArray.new(src.data_type, [1])
           buf[0] = src.raw
           nc_put_var(@ncid, dst.varid, buf)
@@ -393,13 +637,17 @@ module CA
       def ensure_define_mode = @file.ensure_define_mode
       # @return [void]
       def ensure_data_mode   = @file.ensure_data_mode
+      # Run a block in define or data mode ({File#__transaction__}).
       # @api private
       def __transaction__(**opts, &block) = @file.__transaction__(**opts, &block)
 
       # @!endgroup
 
       # @return [String]
-      def inspect = "#<#{self.class} #{path.inspect} vars=#{@vars.keys} groups=#{@groups.keys}>"
+      def inspect
+        return "#<#{self.class} (closed)>" if @file.closed?
+        "#<#{self.class} #{path.inspect} vars=#{@vars.keys} groups=#{@groups.keys}>"
+      end
 
       # Resolve a dimension name by walking up the group tree — netcdf-4
       # dimension inheritance.
@@ -423,15 +671,23 @@ module CA
       # @return [Dim, nil]
       # @api private
       def dim_by_id(dimid)
+        # Dim ids are unique in a file; the file keeps them in one table,
+        # and the dim is found here when it is in this group's scope.
+        d = @file.dim_index[dimid] or return nil
         g = self
         while g
-          d = g.dims.each_value.find { |x| x.to_i == dimid }
-          return d if d
+          return d if g.equal?(d.group)
           g = g.parent
         end
         nil
       end
 
+      # @api private
+      private def register_dim(dim)
+        @file.dim_index[dim.to_i] = dim
+        @dims[dim.name] = dim
+      end
+
       # ---- template / copy source resolution -----------------------------
       # Common: accept the object directly (Dim / Var) or a name + `from:`
       # group; raise cleanly on the invalid combinations.
@@ -469,6 +725,7 @@ module CA
       # Resolve a "/absolute" or "relative/nested" path down to a Var.
       # @api private
       private def resolve_path(str)
+        raise KeyError, "path #{str.inspect} names no variable (it ends in /)" if str.end_with?("/")
         parts = str.split("/").reject(&:empty?)
         raise KeyError, "empty path" if parts.empty?
         leaf = parts.pop
@@ -495,7 +752,7 @@ module CA
         # fallback path is needed; a real error should propagate rather than
         # be silently swallowed (any rescue here used to also catch
         # permission errors and pretend "netcdf-3 layout" — misleading).
-        nc_inq_dimids(@ncid, false).each { |d| dm = Dim.new(self, d); @dims[dm.name] = dm }
+        nc_inq_dimids(@ncid, false).each { |d| register_dim(Dim.new(self, d)) }
         nc_inq_varids(@ncid).each        { |v| vr = Var.new(self, v); @vars[vr.name] = vr }
         nc_inq_grps(@ncid).each do |gid|
           g = Group.new(gid, @file, self)
@@ -508,7 +765,8 @@ module CA
         atts = {}
         nc_inq_natts(@ncid).times do |i|
           name = nc_inq_attname(@ncid, NC_GLOBAL, i)
-          atts[name] = nc_get_att(@ncid, NC_GLOBAL, name)
+          value = readable_att(@ncid, NC_GLOBAL, name, path)
+          atts[name] = deep_freeze(value) unless value.equal?(UNREADABLE_ATT)
         end
         atts.freeze
       end