mesa_script 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5625fddbfb3e4c4f87d42ddc201c5adb6b45a75
-  data.tar.gz: 8b5e505dd02e1d65d84bd0bea5aaeef49076105b
+  metadata.gz: 61f0c3a50b013b45d21a7cb35923258fa442e28e
+  data.tar.gz: ae3672c28b5ac2b79e20251457a841455f363951
 SHA512:
-  metadata.gz: b6659a3b7d8b6cc11a59778c5fea9932ecead35b1a1ff2d8b14416e118414a1ebd306d36bd934fd15cd85aed75de65c6440439f65c7dd7ef393e4d10b5036d40
-  data.tar.gz: 1d365d16c557a9f06b055d643dc56f5ffe3f29de9487a444da6691a9a041180fb7a9586241cda93c37fed8a1fa93320ee2f8aa13aed2565cd283e25fb73f2682
+  metadata.gz: 9fc6a8d0051a2095e5e9cbc53d255d91d48b508c26702175ad3afd3fc7341787a8503ea2c261323d5465b387e2ef025e508269391bc5f6f4d508b661b39ac5f5
+  data.tar.gz: 329a2b712e47b20cd553869daa01b2548ac1bb900b229d3961627828de0c420438db5f735f40f6f0b7b5ceb9a1bfae62c2e48a3be63ef9e1528955c1621f728b

data/lib/mesa_script.rb

@@ -1,50 +1,187 @@
 InlistItem = Struct.new(:name, :type, :value, :namelist, :order, :is_arr,
                         :num_indices, :flagged)
+def namelist_sym(namelist)
+  namelist.to_s.downcase.to_sym
+end
 
 class Inlist
-
   # Get access to current MESA version.
   def self.version
-    v_num = IO.read(File.join(ENV['MESA_DIR'], 'data', 'version_number')).to_i
-    return v_num
+    IO.read(File.join(ENV['MESA_DIR'], 'data', 'version_number')).to_i
   end
 
   # Determine proper file suffix for fortran source
   def self.f_end
     if Inlist.version >= 7380
-      "f90"
+      'f90'
     else
-      "f"
+      'f'
     end
   end
 
+  # these hold the names of the namelists as well as the locations of the
+  # fortran files that define their controls as well as the defaults files
+  # that define their default values and order in formatted inlists
+  @namelists = []
+  @source_files = Hash.new([])
+  @defaults_files = {}
 
+  # this holds the "guts"; control names, types, defaults, and orders
   @inlist_data = {}
-  # Different namelists can be added or subtracted if MESA should change or
-  # proprietary inlists are required. Later hashes should be edited in a
-  # similar way to get the desired behavior for additional namelists.
 
-  #################### ADD NEW NAMELISTS HERE ####################
-  @namelists = %w{ star_job controls pgstar }
-  ################## POINT TO .INC FILES HERE ####################
-  @nt_files = {
-                'star_job' => %w{star_job_controls.inc},
-                'controls' => %w{star_controls.inc},
-                'pgstar'   => %w{pgstar_controls.inc}
-              }
-  @nt_files['controls'] << "ctrls_io.#{f_end}"
-  # User can specify a custom name for a namelist defaults file. The default
-  # is simply the namelist name followed by '.defaults'
+  # used to turn on a namelist; need to provide namelist name as well as
+  # locations for source file (usually a .inc or .f90 file that defines
+  # allowable controls) and a defaults file (usually a .defaults file that
+  # lists all controls and their default values). Shorthand versions for
+  # the three common star namelists and the one common binary namelist are
+  # defined below for convenience
+  def self.config_namelist(namelist: nil, source_files: nil,
+                           defaults_file: nil, verbose: true)
+    new_namelist = namelist_sym(namelist)
+    add_namelist(new_namelist)
+    set_source_files(new_namelist, source_files)
+    set_defaults_file(new_namelist, defaults_file)
+    return unless verbose
+    puts 'Added the following namelist data:'
+    puts "  namelist: #{new_namelist}"
+    puts "    source: #{@source_files[new_namelist].join(', ')}"
+    puts "  defaults: #{@defaults_files[namelist_sym(namelist)]}"
+    puts "Did not load data yet, though.\n\n"
+  end
+
+  def self.add_namelist(new_namelist)
+    if new_namelist.nil? || new_namelist.empty?
+      raise(NamelistError.new, 'Must provide a namelist name.')
+    end
+    return if @namelists.include? namelist_sym(new_namelist)
+    @namelists << namelist_sym(new_namelist)
+  end
+
+  def self.set_source_files(namelist, new_sources)
+    # set source files. There may be more than one, so we ALWAYS make it an
+    # array. Flatten magic allows for users to supply an array or a scalar
+    # (single string)
+    if new_sources.nil? || new_sources.empty?
+      raise NamelistError.new,
+            "Must provide a source file for namelist #{namelist}. For " \
+            'example, $MESA_DIR/star/private/star_job_controls.inc for ' \
+            'star_job.'
+    end
+    source_to_add = if new_sources.respond_to?(:map)
+                      new_sources.map(&:to_s)
+                    else
+                      new_sources.to_s
+                    end
+    @source_files[namelist_sym(namelist)] = [source_to_add].flatten
+  end
+
+  def self.set_defaults_file(namelist, new_defaults_file)
+    # set defaults file. This is limited to being scalar string for now.
+    return unless new_defaults_file
+    @defaults_files[namelist_sym(namelist)] = new_defaults_file.to_s
+  end
+
+  # Delete all namelists and associated data.
+  def self.delete_all_namelists
+    namelists.each { |namelist| remove_namelist(namelist) }
+    @have_data = false
+  end
+
+  # delete namelist and associated data
+  def self.delete_namelist(namelist)
+    to_delete = namelist_sym(namelist)
+    found_something = namelists.delete(to_delete)
+    found_something = delete_files(to_delete) || found_something
+    # this also undefines methods
+    found_something = delete_data(to_delete) || found_something
+    unless found_something
+      puts "WARNING: Attempting to delete namelist #{namelist} data, but it " \
+           "wasn't present in existing Inlist data. Nothing happened."
+    end
+    namelist
+  end
+
+  # just remove associated source and defaults files; don't touch underlying
+  # data or methods (if any exist yet)
+  def self.delete_files(namelist)
+    found_something = false
+    [source_files, defaults_files].each do |files|
+      found_something ||= files.delete(namelist_sym(namelist))
+    end
+    found_something
+  end
+
+  # see if data has been loaded, and if it has, delete all the methods
+  # associated with it and then wipe the data, too.
+  def self.delete_data(namelist)
+    to_delete = namelist_sym(namelist)
+    return false unless inlist_data.include? namelist_sym(to_delete)
+    delete_methods(to_delete)
+    inlist_data.delete(to_delete)
+  end
+
+  # just delete the methods. This will throw errors if they don't exist
+  def self.delete_methods(namelist)
+    @inlist_data[namelist_sym(namelist)].each { |datum| delete_method(datum) }
+  end
 
-  ################ POINT TO .DEFAULTS FILES HERE #################
-  @d_files = {}
+  # short hand for adding star_job namelist using sensible defaults as of 10108
+  def self.add_star_job_defaults(verbose: false)
+    config_namelist(
+      namelist: :star_job,
+      source_files: File.join(ENV['MESA_DIR'], 'star', 'private',
+                              'star_job_controls.inc'),
+      defaults_file: File.join(ENV['MESA_DIR'], 'star', 'defaults',
+                               'star_job.defaults'),
+      verbose: verbose
+    )
+  end
 
-  # User can add new paths to namelist default files through this hash
+  # short hand for adding controls namelist using sensible defaults as of 10108
+  def self.add_controls_defaults(verbose: false)
+    config_namelist(
+      namelist: :controls,
+      source_files: [File.join(ENV['MESA_DIR'], 'star', 'private',
+                               'star_controls.inc'),
+                     File.join(ENV['MESA_DIR'], 'star', 'private',
+                               "ctrls_io.#{f_end}")],
+      defaults_file: File.join(ENV['MESA_DIR'], 'star', 'defaults',
+                               'controls.defaults'),
+      verbose: verbose
+    )
+  end
 
-  ############ GIVE PATHS TO .INC AND .DEF FILES HERE ###########
-  @nt_paths = Hash.new(ENV['MESA_DIR'] + '/star/private/')
-  @d_paths = Hash.new(ENV['MESA_DIR'] + '/star/defaults/')
+  # short hand for adding pgstar namelist using sensible defaults as of 10108
+  def self.add_pgstar_defaults(verbose: false)
+    config_namelist(
+      namelist: :pgstar,
+      source_files: File.join(ENV['MESA_DIR'], 'star', 'private',
+                              'pgstar_controls.inc'),
+      defaults_file: File.join(ENV['MESA_DIR'], 'star', 'defaults',
+                               'pgstar.defaults'),
+      verbose: verbose
+    )
+  end
 
+  # short hand for adding binary_defaults namelist using sensible defaults as
+  # of 10108
+  def self.add_binary_defaults
+    config_namelist(
+      namelists: :binary_controls,
+      source_files: File.join(ENV['MESA_DIR'], 'binary', 'public',
+                              'binary_controls.inc'),
+      defaults_file: File.join(ENV['MESA_DIR'], 'binary', 'defaults',
+                               'binary_controls.defaults')
+    )
+  end
+
+  # quickly add all three major namelists for star module (star_job, controls,
+  # and pgstar)
+  def self.add_star_defaults
+    add_star_job_defaults
+    add_controls_defaults
+    add_pgstar_defaults
+  end
 
 ############### NO MORE [SIMPLE] USER-CUSTOMIZABLE FEATURES BELOW ##############
 
@@ -57,34 +194,44 @@ class Inlist
   # Establish class instance variables
   class << self
     attr_accessor :have_data
-    attr_accessor :namelists, :nt_paths, :d_paths, :inlist_data, :d_files,
-                  :nt_files
+    attr_accessor :namelists, :source_files, :defaults_files, :inlist_data
   end
 
   # Generate methods for the Inlist class that set various namelist parameters.
-  def self.get_data
+  def self.get_data(use_star_as_fallback: true)
+    # might need to add star data; preserves expected behavior (minus binary)
+    Inlist.add_star_defaults if use_star_as_fallback && Inlist.namelists.empty?
     Inlist.namelists.each do |namelist|
-      @inlist_data[namelist] = Inlist.get_namelist_data(namelist,
-        Inlist.nt_files[namelist], Inlist.d_files[namelist])
+      @inlist_data[namelist] = Inlist.get_namelist_data(namelist)
     end
     # create methods (interface) for each data category
     @inlist_data.each_value do |namelist_data|
-      namelist_data.each do |datum|
-        if datum.is_arr
-          Inlist.make_parentheses_method(datum)
-        else
-          Inlist.make_regular_method(datum)
-        end
-      end
+      namelist_data.each { |datum| Inlist.make_method(datum) }
     end
     # don't do this nonsense again unles specifically told to do so
     Inlist.have_data = true
   end
 
+  def self.make_method(datum)
+    if datum.is_arr
+      Inlist.make_parentheses_method(datum)
+    else
+      Inlist.make_regular_method(datum)
+    end
+  end
+
+  def self.delete_method(datum)
+    if datum.is_arr
+      Inlist.delete_parentheses_method(datum)
+    else
+      Inlist.delete_regular_method(datum)
+    end
+  end
+
   # Three ways to access array categories. All methods will cause the
   # data category to be staged into your inlist, even if you do not change it
   # Basically, if it appears in your mesascript, it will definitely appear
-  # in your inlist. A command can be unflagged by calling 
+  # in your inlist. A command can be unflagged by calling
   # `unflag_command('COMMAND_NAME')` where COMMAND_NAME is the case-sensitive
   # name of the command to be unflagged.
   #
@@ -104,19 +251,19 @@ class Inlist
   #        xa_lower_limit_species(1, 'h1')    # flags and sets value 1
   #        xa_lower_limit_species 1, 'h1'     # same
   #
-  # For multi-dimensional arrays, things are even more vaired. You can treat 
+  # For multi-dimensional arrays, things are even more vaired. You can treat
   # them like 1-dimensional arrays with the "index" just being an array of
   # indices, for instance:
-  # 
+  #
   #        text_summary1_name[[1,2]] = 'star_mass' # flags ALL values and sets
   #        text_summary1_name([1,2], 'star_mass')  # text_summary1_name(1,2)
   #        text_summary1_name [1,2], 'star_mass    # to 'star_mass'
   #
-  #        text_summary1_name [1,2]                # flags ALL values and 
-  #        text_summary1_name([1,2])               # returns 
+  #        text_summary1_name [1,2]                # flags ALL values and
+  #        text_summary1_name([1,2])               # returns
   #                                                # text_sumarry_name(1,2)
-  # 
-  #        text_summary_name()                     # flags ALL values and 
+  #
+  #        text_summary_name()                     # flags ALL values and
   #        text_summary_name                       # returns entire hash for
   #                                                # text_summary_name
   #
@@ -126,64 +273,127 @@ class Inlist
   #
   #        text_summary1_name(1, 2, 'star_mass')
   #        text_summary1_name 1, 2, 'star_mass'    # same as above (first 3)
-  #        
+  #
   #        text_summary1_name
-  
+
   def self.make_parentheses_method(datum)
-    name = datum.name
+    method_name = datum.name
     num_indices = datum.num_indices
-    define_method(name + '[]=') do|arg1, arg2|
+
+    # assignment array form
+    define_method(method_name + '[]=') do |arg1, arg2|
       if num_indices > 1
-        raise "First argument of #{name}[]= (part in brackets) must be an array with #{num_indices} indices since #{name} is a multi-dimensional array." unless (arg1.is_a?(Array) and arg1.length == num_indices)
+        unless arg1.is_a?(Array) && arg1.length == num_indices
+          raise "First argument of #{method_name}[]= (part in brackets) must "\
+                "be an array with #{num_indices} indices since #{method_name}"\
+                ' is a multi-dimensional array.'
+        end
       end
-      self.flag_command(name)
-      self.data_hash[name].value[arg1] = arg2
+      flag_command(method_name)
+      data_hash[method_name].value[arg1] = arg2
     end
-    define_method(name + '[]') do |arg|
+
+    # de-referencing array form
+    define_method(method_name + '[]') do |arg|
       if num_indices > 1
-        raise "Argument of #{name}[] (part in brackets) must be an array with #{num_indices} indices since #{name} is a multi-dimensional array." unless (arg.is_a?(Array) and arg.length == num_indices)
+        unless arg.is_a?(Array) && arg.length == num_indices
+          raise "Argument of #{method_name}[] (part in brackets) must be an " \
+                "array with #{num_indices} indices since #{method_name} is a "\
+                'multi-dimensional array.'
+        end
       end
-      self.flag_command(name)
-      self.data_hash[name].value[arg]
+      flag_command(method_name)
+      data_hash[method_name].value[arg]
     end
-    define_method(name) do |*args|
-      self.flag_command(name)
+
+    # imperative multi-purpose form
+    define_method(method_name) do |*args|
+      flag_command(method_name)
       case args.length
-      when 0 then self.data_hash[name].value
+      # just retrieve whole value (de-reference)
+      when 0 then data_hash[method_name].value
+      # just retrieve part of value (de-reference)
       when 1
         if num_indices > 1
-          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments." unless (args[0].is_a?(Array) and args[0].length == num_indices)
+          unless args[0].is_a?(Array) && args[0].length == num_indices
+            raise "First argument of #{method_name} must be an array with " \
+                  "#{num_indices} indices since #{method_name} is a " \
+                  'multi-dimensional array OR must provide all indices as ' \
+                  'separate arguments.'
+          end
         end
-        self.data_hash[name].value[args[0]]  
+        data_hash[method_name].value[args[0]]
+      # might be trying to access or a multi-d array OR assign to an array.
       when 2
-        if num_indices == 1 and (not args[0].is_a?(Array))
-          self.data_hash[name].value[args[0]] = args[1]
-        elsif num_indices == 2 and (not args[0].is_a?(Array)) and args[1].is_a?(Fixnum)
-          self.data_hash[name].value[args]
+        # 1-D array with scalar value; simple assignement
+        if num_indices == 1 && !args[0].is_a?(Array)
+          data_hash[method_name].value[args[0]] = args[1]
+        # 2-D array, de-reference single value (NOT AN ASSIGNMENT!)
+        elsif num_indices == 2 && !args[0].is_a?(Array) &&
+              args[1].is_a?(Integer)
+          data_hash[method_name].value[args]
+        # Multi-d array with first argument being an array, second a value to
+        # assign; simple assignment
         elsif num_indices > 1
-          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments." unless (args[0].is_a?(Array) and args[0].length == num_indices)
-          self.data_hash[name].value[args[0]] = args[1]
+          unless args[0].is_a?(Array) && args[0].length == num_indices
+            raise "First argument of #{method_name} must be an array with " \
+                  "#{num_indices} indices since #{method_name} is a " \
+                  'multi-dimensional array OR must provide all indices as ' \
+                  'separate arguments.'
+          end
+          data_hash[method_name].value[args[0]] = args[1]
+        # Can't parse... throw hands up.
         else
-          raise "First argument of #{name} must be an array with #{num_indices} indices since #{name} is a multi-dimensional array OR must provide all indices as separate arguments. The optional final argument is what the #{name} would be set to. Omission of this argument will simply flag #{name} to appear in the inlist."   
-        end 
-      when num_indices
-        self.data_hash[name].value[args]
+          raise "First argument of #{method_name} must be an array with "\
+                "#{num_indices} indices since #{method_name} is a "\
+                'multi-dimensional array OR must provide all indices as '\
+                'separate arguments. The optional final argument is what the '\
+                "#{method_name} would be set to. Omission of this argument "\
+                "will simply flag #{method_name} to appear in the inlist."
+        end
+      # one more argument than number of indices; first n are location to be
+      # assigned, last one is value to be assigned
       when num_indices + 1
-        raise "Bad arguments for #{name}. Either provide an array of #{num_indices} indices for the first argument or provide each index in succession, optionally specifying the desired value for the last argument." if args[0].is_a?(Array)
-        self.data_hash[name].value[args[0..-2]] = args[-1]
+        if args[0].is_a?(Array)
+          raise "Bad arguments for #{method_name}. Either provide an array " \
+                "of #{num_indices} indices for the first argument or provide "\
+                'each index in succession, optionally specifying the desired '\
+                'value for the last argument.'
+        end
+        data_hash[method_name].value[args[0..-2]] = args[-1]
+      # same number of arguments as indices; assume we are de-referencing a
+      # value
+      when num_indices then data_hash[method_name].value[args]
+      # give up... who knows what the user is doing?!
       else
-        raise "Wrong number of arguments for #{name}. Can provide zero arguments (just flag command), one argument (array of indices for multi-d array or one index for 1-d array), two arguments (array of indices/single index for multi-/1-d array and a new value for the value), #{num_indices} arguments where the elements themselves are the right indices (returns the specified element of the array), or #{num_indices + 1} arguments to set the specific value and return it."
-      end      
+        raise "Wrong number of arguments for #{method_name}. Can provide " \
+              'zero arguments (just flag command), one argument (array of ' \
+              'indices for multi-d array or one index for 1-d array), two ' \
+              'arguments (array of indices/single index for multi-/1-d array '\
+              'and a new value for the value), #{num_indices} arguments ' \
+              'where the elements themselves are the right indices (returns ' \
+              "the specified element of the array), or #{num_indices + 1} " \
+              'arguments to set the specific value and return it.'
+      end
     end
-    alias_method name.downcase.to_sym, name.to_sym
-    alias_method (name.downcase + '[]').to_sym, (name + '[]').to_sym
-    alias_method (name.downcase + '[]=').to_sym, (name + '[]=').to_sym
+    alias_method method_name.downcase.to_sym, method_name.to_sym
+    alias_method((method_name.downcase + '[]').to_sym,
+                 (method_name + '[]').to_sym)
+    alias_method((method_name.downcase + '[]=').to_sym,
+                 (method_name + '[]=').to_sym)
+  end
+
+  def self.delete_parentheses_method(datum)
+    base_name = datum.name
+    method_names = [base_name, base_name + '[]', base_name + '[]=']
+    alias_names = method_names.map(&:downcase)
+    [method_names, alias_names].flatten.uniq.each { |meth| remove_method(meth) }
   end
 
   # Two ways to access/change scalars. All methods will cause the data category
   # to be staged into your inlist, even if you do not change the value.
   # Basically, if it appears in your mesascript, it will definitely appear in
-  # your inlist. 
+  # your inlist.
   #
   # 1. Change value, like
   #        initial_mass(1.0)
@@ -200,23 +410,30 @@ class Inlist
   #    traditional for ruby (why do you want empty parentheses anyway?). Returns
   #    current value.
   #
-  # A command can be unflagged by calling `unflag_command('COMMAND_NAME')` 
+  # A command can be unflagged by calling `unflag_command('COMMAND_NAME')`
   # where COMMAND_NAME is the case-sensitive name of the command to be
   # unflagged.
 
   def self.make_regular_method(datum)
-    name = datum.name
-    define_method(name) do |*args|
-      self.flag_command(name)
-      return self.data_hash[name].value if args.empty?
-      self.data_hash[name].value = args[0]
+    method_name = datum.name
+    define_method(method_name) do |*args|
+      self.flag_command(method_name)
+      return self.data_hash[method_name].value if args.empty?
+      self.data_hash[method_name].value = args[0]
     end
-    aliases = [(name + '=').to_sym,
-               (name.downcase + '=').to_sym,
-               name.downcase.to_sym]
-    aliases.each { |ali| alias_method ali, name.to_sym }
+    aliases = [(method_name + '=').to_sym,
+               (method_name.downcase + '=').to_sym,
+               method_name.downcase.to_sym]
+    aliases.each { |ali| alias_method ali, method_name.to_sym }
   end
 
+  def self.delete_regular_method(datum)
+    method_name = datum.name
+    aliases = [method_name + '=',
+               method_name.downcase + '=',
+               method_name.downcase]
+    [method_name, aliases].flatten.uniq.each { |meth| remove_method meth }
+  end
 
   # Ensure provided value's data type matches expected data type. Then convert
   # to string for printing to an inlist. If value is a string, change nothing
@@ -225,39 +442,49 @@ class Inlist
   def self.parse_input(name, value, type)
     if value.class == String
       if type == :string
-        value = "'#{value}'" unless value[0] == "'" and value[-1] == "'"
+        value = "'#{value}'" unless value[0] == "'" && value[-1] == "'"
       end
-      return value
+      value
     elsif type == :bool
       unless [TrueClass, FalseClass].include?(value.class)
-        raise "Invalid value for namelist item #{name}: #{value}. Use " +
-        "'.true.', '.false.', or a Ruby boolean (true/false)."
+        raise "Invalid value for namelist item #{name}: #{value}. Use " \
+              "'.true.', '.false.', or a Ruby boolean (true/false)."
       end
       if value == true
-        return '.true.'
+        '.true.'
       elsif value == false
-        return '.false.'
+        '.false.'
       else
         raise "Error converting value #{value} of #{name} to a boolean."
       end
     elsif type == :int
-      raise "Invalid value for namelist item #{name}: #{value}. Must provide"+
-      " an int or float." unless value.is_a?(Integer) or value.is_a?(Float)
+      unless value.is_a?(Integer) || value.is_a?(Float)
+        raise "Invalid value for namelist item #{name}: #{value}. Must " \
+              'provide an int or float.'
+      end
       if value.is_a?(Float)
-        puts "WARNING: Expected integer for #{name} but got #{value}. Value" + 
-             " will be converted to an integer."
+        puts "WARNING: Expected integer for #{name} but got #{value}. Value" \
+             ' will be converted to an integer.'
       end
-      return value.to_i.to_s
+      value.to_i.to_s
     elsif type == :float
-      raise "Invalid value for namelist item #{name}: #{value}. Must provide " +
-      "an int or float." unless value.is_a?(Integer) or value.is_a?(Float)
-      return sprintf("%g", value).sub('e', 'd')
+      unless value.is_a?(Integer) || value.is_a?(Float)
+        raise "Invalid value for namelist item #{name}: #{value}. Must "\
+              'provide an int or float.'
+      end
+      res = format('%g', value).sub('e', 'd')
+      res += 'd0' unless res.include?('d')
+      res
     elsif type == :type
-      puts "WARNING: 'type' values are currently unsupported (regarding #{name}) because your humble author has no idea what they look like in an inlist. You should tell him what to do at wmwolf@physics.ucsb.edu. Your input, #{value}, has been passed through to your inlist verbatim."
-      return value.to_s
+      puts "WARNING: 'type' values are currently unsupported " \
+           "(regarding #{name}) because your humble author has no idea what " \
+           'they look like in an inlist. You should tell him what to do at ' \
+           "wmwolf@asu.edu. Your input, #{value}, has been passed through to "\
+           'your inlist verbatim.'
+      value.to_s
     else
-      raise "Error parsing value for namelist item #{name}: #{value}. Expected "
-            "type was #{type}."
+      raise "Error parsing value for namelist item #{name}: #{value}. " \
+            "Expected type was #{type}."
     end
   end
 
@@ -268,7 +495,7 @@ class Inlist
   # clean up and re-order your inlist, but all comments will be lost. All other
   # information SHOULD remain intact.
   def self.inlist_to_mesascript(inlist_file, script_file, dbg = false)
-    Inlist.get_data unless Inlist.have_data       # ensure we have inlist data
+    Inlist.get_data unless Inlist.have_data # ensure we have inlist data
     inlist_contents = File.readlines(inlist_file)
 
     # make namelist separators comments
@@ -301,7 +528,7 @@ class Inlist
         command =~ /(\s*$)/                       # save buffer space
         buffer_space = Regexp.last_match(1)
         command.strip!                            # remove white space
-        name, value = command.split('=').map { |datum| datum.strip }
+        name, value = command.split('=').map(&:strip)
         if dbg
           puts "name: #{name}"
           puts "value: #{value}"
@@ -309,28 +536,28 @@ class Inlist
         if name =~ /\((\d+)\)/                    # fix 1D array assignments
           name.sub!('(', '[')
           name.sub!(')', ']')
-          name = name + ' ='
+          name += ' ='
         elsif name =~ /\((\s*\d+\s*,\s*)+\d\s*\)/ # fix multi-D arrays
           # arrays become hashes in MesaScript, so rather than having multiple
           # indices, the key becomes the array of indices themselves, hence
           # the double braces replacing single parentheses
-          name.sub!('(', '[[')          
+          name.sub!('(', '[[')
           name.sub!(')', ']]')
-          name = name + ' ='
+          name += ' ='
         end
         name.downcase!
-        if value =~ /'.*'/ or value =~ /".*"/
-          result = name + ' ' + value             # leave strings alone
-        elsif %w[.true. .false.].include?(value.downcase)
-          result = name + ' ' + value.downcase.gsub('.', '') # fix booleans
-        elsif value =~ /\d+\.?\d*([eEdD]\d+)?/
-          result = name + ' ' + value.downcase.sub('d', 'e') # fix floats
-        else
-          result = name + ' ' + value             # leave everything else alone
-        end
+        results = if value =~ /'.*'/ || value =~ /".*"/
+                    name + ' ' + value # leave strings alone
+                  elsif %w[.true. .false.].include?(value.downcase)
+                    name + ' ' + value.downcase.delete('.') # fix booleans
+                  elsif value =~ /\d+\.?\d*([eEdD]\d+)?/
+                    name + ' ' + value.downcase.sub('d', 'e') # fix floats
+                  else
+                    name + ' ' + value # leave everything else alone
+                  end
         result = leading_space + result + buffer_space + comment
         if dbg
-          puts "parsed to:"
+          puts 'parsed to:'
           puts result
           puts ''
         end
@@ -342,11 +569,10 @@ class Inlist
       f.puts ''
       f.puts "Inlist.make_inlist('#{File.basename(inlist_file)}') do"
       new_contents.each { |line| f.puts '  ' + line }
-      f.puts "end"
+      f.puts 'end'
     end
   end
 
-
   # Create an Inlist object, execute block of commands that presumably populate
   # the inlist, then write the inlist to a file with the given name. This is
   # the money routine with user-supplied commands in the instance_eval block.
@@ -370,29 +596,21 @@ class Inlist
   # belongs to, and its relative ordering in that namelist. Bogus defaults are
   # assigned according to the object's type, and the ordering is unknown.
 
-  def self.get_namelist_data(namelist, nt_filename = nil, d_filename = nil)
-    temp_data = Inlist.get_names_and_types(namelist, nt_filename)
-    Inlist.get_defaults(temp_data, namelist, d_filename)
+  def self.get_namelist_data(namelist)
+    temp_data = Inlist.get_names_and_types(namelist)
+    Inlist.get_defaults(temp_data, namelist)
   end
 
-  def self.get_names_and_types(namelist, nt_filenames = nil)
-    nt_filenames ||= Inlist.nt_files[namelist]
-    unless nt_filenames.respond_to?(:each)
-      nt_filenames = [nt_filenames]
-    end
-    nt_full_paths = nt_filenames.map { |file| Inlist.nt_paths[namelist] + file }
-
+  def self.get_names_and_types(namelist)
     namelist_data = []
 
-    nt_full_paths.each do |nt_full_path|
-      unless File.exists?(nt_full_path)
-        raise "Couldn't find file #{nt_full_path}"
-      end
-      contents = File.readlines(nt_full_path)
+    source_files[namelist].each do |source_file|
+      raise "Couldn't find file #{source_file}" unless File.exist?(source_file)
+      contents = File.readlines(source_file)
 
       # Throw out comments and blank lines, ensure remaining lines are a proper
       # Fortran assignment, then remove leading and trailing white space
-      contents.reject! { |line| is_comment?(line) or is_blank?(line) }
+      contents.reject! { |line| is_comment?(line) || is_blank?(line) }
       contents.map! do |line|
         my_line = line.dup
         my_line = my_line[0...my_line.index('!')] if has_comment?(my_line)
@@ -405,24 +623,24 @@ class Inlist
         full_lines << Inlist.full_line(contents, i)
       end
       pairs = full_lines.map do |line|
-        line.split('::').map { |datum| datum.strip}
+        line.split('::').map(&:strip)
       end
       pairs.each do |pair|
         type = case pair[0]
-        when /logical/ then :bool
-        when /character/ then :string
-        when /real/ then :float
-        when /integer/ then :int
-        when /type/ then :type
-        else
-          raise "Couldn't determine type of entry #{pair[0]} in " +
-                "#{nt_full_path}."
-        end
+               when /logical/ then :bool
+               when /character/ then :string
+               when /real/ then :float
+               when /integer/ then :int
+               when /type/ then :type
+               else
+                 raise "Couldn't determine type of entry #{pair[0]} in " \
+                       "#{source_file}."
+               end
         name_chars = pair[1].split('')
         names = []
         paren_level = 0
         name_chars.each do |char|
-          if paren_level > 0 and char == ','
+          if paren_level > 0 && char == ','
             names << '!'
             next
           elsif char == '('
@@ -432,7 +650,7 @@ class Inlist
           end
           names << char
         end
-        names = names.join.split(',').map { |name| name.strip }
+        names = names.join.split(',').map(&:strip)
         names.each do |name|
           is_arr = false
           num_indices = 0
@@ -442,10 +660,9 @@ class Inlist
             name.sub!(/\(.*\)/, '')
           elsif pair[0] =~ /dimension\((.*)\)/i
             is_arr = true
-            num_indices = $1.count(',') + 1
+            num_indices = Regexp.last_match[1].count(',') + 1
           end
-          type_default = {:bool => false, :string => '', :float => 0.0,
-                          :int => 0}
+          type_default = { bool: false, string: '', float: 0.0, int: 0 }
           dft = is_arr ? Hash.new(type_default[type]) : type_default[type]
           namelist_data << InlistItem.new(name, type, dft, namelist, -1, is_arr,
                                           num_indices)
@@ -459,64 +676,85 @@ class Inlist
   # Inlist.get_names_and_types and assigns defaults and orders to each item.
   # Looks for this information in the specified defaults filename.
 
-  def self.get_defaults(temp_data, namelist, d_filename = nil, whine = false)
-    d_filename ||= namelist + '.defaults'
-    d_full_path = Inlist.d_paths[namelist] + d_filename
-    raise "Couldn't find file #{d_filename}" unless File.exists?(d_full_path)
-    contents = File.readlines(d_full_path)
-    contents.reject! { |line| is_comment?(line) or is_blank?(line) }
+  def self.get_defaults(temp_data, namelist, whine = false)
+    defaults_file = defaults_files[namelist]
+    unless File.exist?(defaults_file)
+      raise "Couldn't find file #{defaults_file}"
+    end
+    contents = File.readlines(defaults_file)
+    # throw out comments and blank lines
+    contents.reject! { |line| is_comment?(line) || is_blank?(line) }
+    # remaining lines should only be assignments. Only use the part of the line
+    # up to the comment character, then strip all whitespace
     contents.map! do |line|
       my_line = line.dup
-      if has_comment?(line)
-        my_line = my_line[0...my_line.index('!')]
+      my_line = my_line[0...my_line.index('!')] if has_comment?(line)
+      unless my_line =~ /=/
+        raise "Equal sign missing in line:\n\t #{my_line}\n in file " \
+              "#{full_path}."
       end
-      raise "Equal sign missing in line:\n\t #{my_line}\n in file " +
-        "#{full_path}." unless my_line =~ /=/
       my_line.strip!
     end
-    pairs = contents.map {|line| line.split('=').map {|datum| datum.strip}}
-    n_d_hash = {}
-    n_o_hash = {}
+    # divide lines into two element arrays: name and value
+    pairs = contents.map { |line| line.split('=').map(&:strip) }
+    n_d_hash = {} # maps names to default values
+    n_o_hash = {} # maps names to default order in inlist
     pairs.each_with_index do |pair, i|
       name = pair[0]
       default = pair[1]
+      # look for parentheses in name, indicating an array
       if name =~ /\(.*\)/
+        # make selector be the stuff in the parentheses
         selector = name[/\(.*\)/][1..-2]
+        # make name just be the part without parentheses
         name.sub!(/\(.*\)/, '')
+        # colon indicates mass assignment
         if selector.include?(':')
           default = Hash.new(default)
-        elsif selector.count(',') == 0
-          default = {selector.to_i => default}
+        # lack of a comma indicates dimension = 1
+        elsif selector.count(',').zero?
+          default = { selector.to_i => default }
+        # at least one comma, so dimension > 1
         else
+          # reformat the selector (now a key in the default hash) to an
+          # array of integers
           selector = selector.split(',').map { |index| index.strip.to_i }
-          default = default = {selector => default}
+          default = { selector => default }
         end
       end
+      # if the default value is a hash, we probably don't have every possible
+      # value, so just merge scraped values with the automatically chosen
+      # defaults
       if n_d_hash[name].is_a?(Hash)
         n_d_hash[name].merge!(default)
+      # scalar values get a simple assignment
       else
         n_d_hash[name] = default
       end
+      # order is just the same as the order it appeared in its defaults file
       n_o_hash[name] ||= i
     end
     temp_data.each do |datum|
-      unless n_d_hash.keys.include?(datum.name)
-        puts "WARNING: no default found for control #{datum.name}. Using standard defaults." if whine
+      unless n_d_hash.key?(datum.name)
+        if whine
+          puts "WARNING: no default found for control #{datum.name}. Using " \
+               'standard defaults.'
+        end
       end
       default = n_d_hash[datum.name]
-      if default.is_a?(Hash) and datum.value.is_a?(Hash)
-        datum.value = datum.value.merge(default)
-      else
-        datum.value = default || datum.value
-      end
+      datum.value = if default.is_a?(Hash) && datum.value.is_a?(Hash)
+                      datum.value.merge(default)
+                    else
+                      default || datum.value
+                    end
       datum.order = n_o_hash[datum.name] || datum.order
     end
     temp_data
   end
 
-  def self.full_line(lines, i)
-    return lines[i] unless lines[i][-1] == '&'
-    [lines[i].sub('&', ''), full_line(lines, i+1)].join(' ')
+  def self.full_line(lines, indx)
+    return lines[indx] unless lines[indx][-1] == '&'
+    [lines[indx].sub('&', ''), full_line(lines, indx + 1)].join(' ')
   end
 
   def self.is_comment?(line)
@@ -538,14 +776,15 @@ class Inlist
 
   attr_accessor :data_hash
   attr_reader :names
-  def initialize
-    Inlist.get_data unless Inlist.have_data?
+  def initialize(use_star_as_fallback: true)
+    unless Inlist.have_data?
+      Inlist.get_data(use_star_as_fallback: use_star_as_fallback)
+    end
     @data = Inlist.inlist_data
     @data_hash = {}
     @data.each_value do |namelist_data|
       namelist_data.each do |datum|
         @data_hash[datum.name] = datum.dup
-
       end
     end
     @names = @data_hash.keys
@@ -570,7 +809,7 @@ class Inlist
   def flag_command(name)
     @data_hash[name].flagged = true
   end
-  
+
   def unflag_command(name)
     @data_hash[name].flagged = false
   end
@@ -580,21 +819,22 @@ class Inlist
     if datum.is_arr
       lines = @data_hash[name].value.keys.map do |key|
         prefix = "  #{datum.name}("
-        suffix = ") = " + 
-        Inlist.parse_input(datum.name, datum.value[key], datum.type) + "\n"
-        if key.respond_to?(:inject)
-          indices = key[1..-1].inject(key[0].to_s) do |res, elt| 
-            "#{res}, #{elt}"
-          end
-        else
-          indices = key.to_s
-        end
+        suffix = ') = ' +
+                 Inlist.parse_input(datum.name, datum.value[key], datum.type) +
+                 "\n"
+        indices = if key.respond_to?(:inject)
+                    key[1..-1].inject(key[0].to_s) do |res, elt| 
+                      "#{res}, #{elt}"
+                    end
+                  else
+                    key.to_s
+                  end
         prefix + indices + suffix
       end
       lines = lines.join
       @to_write[datum.namelist][datum.order] = lines
     else
-      @to_write[datum.namelist][datum.order] =  "  " + datum.name + ' = ' +
+      @to_write[datum.namelist][datum.order] = '  ' + datum.name + ' = ' +
                 Inlist.parse_input(datum.name, datum.value, datum.type) + "\n"
     end
   end
@@ -615,13 +855,13 @@ class Inlist
     # blank lines between disparate data
     namelists.each do |namelist|
       @to_write[namelist].each_index do |i|
-        next if (i == 0 or i == @to_write[namelist].size - 1)
+        next if [0, @to_write[namelist].size - 1].include? i
         this_line = @to_write[namelist][i]
-        prev_line = @to_write[namelist][i-1]
-      
+        prev_line = @to_write[namelist][i - 1]
+
         this_line = '' if this_line.nil?
         prev_line = '' if prev_line.nil?
-        if this_line.empty? and not(prev_line.empty? or prev_line == "\n")
+        if this_line.empty? && !(prev_line.empty? || prev_line == "\n")
           @to_write[namelist][i] = "\n"
         end
       end
@@ -634,10 +874,11 @@ class Inlist
     result = ''
     namelists.each do |namelist|
       result += "\n&#{namelist}\n"
-      result += @to_write[namelist].join("")
+      result += @to_write[namelist].join('')
       result += "\n/ ! end of #{namelist} namelist\n"
     end
     result.sub("\n\n\n", "\n\n")
   end
-
 end
+
+class NamelistError < Exception; end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: mesa_script
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - William Wolf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2018-05-14 00:00:00.000000000 Z
 dependencies: []
 description: MesaScript - a DSL for making dynamic inlists for the MESA stellar evolution
   code.
-email: wmwolf@physics.ucsb.edu
+email: wmwolf@asu.edu
 executables:
 - inlist2mesascript
 extensions: []
@@ -25,13 +25,7 @@ homepage: https://wmwolf.github.io
 licenses:
 - MIT
 metadata: {}
-post_install_message: |2
-    Thanks for installing MesaScript!
-
-    To learn more about how to use MesaScript and to keep up to date with its
-    features, check out the README at the project homepage:
-
-    https://github.com/wmwolf/MesaScript
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -47,12 +41,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: MesaScript is a domain specific language (DSL) that allows the user to write
   inlists for MESA that include variables, loops, conditionals, etc. For more detailed
-  instructions, see the readme on the github page at   https://github.com/wmwolf/MesaScript  This
+  instructions, see the readme on the github page at  https://github.com/wmwolf/MesaScript  This
   software requires a relatively modern installation of MESA (version > 5596). It
   has been tested on Ruby versions > 1.9, but there is no guarantee it will work on
   older (or newer!) versions. Any bugs or requests should be sent to the author, Bill