cosmos 3.9.2 → 4.0.0

data/install/tools/mac/CmdSequence.app/Contents/MacOS/main.sh

@@ -0,0 +1,10 @@
+#!/bin/bash -l
+TOOLNAME=CmdSequence
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+rm $DIR/$TOOLNAME
+if hash rbenv 2>/dev/null; then
+  ln -s `rbenv which ruby` $DIR/$TOOLNAME
+else
+  ln -s `which ruby` $DIR/$TOOLNAME
+fi
+exec $DIR/$TOOLNAME $DIR/$TOOLNAME.rb "$@" &

data/install/tools/mac/CmdSequence.app/Contents/MacOS/tool_launch.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: ascii-8bit
+
+# Copyright 2015 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+def tool_launch
+  begin
+    require 'bundler/setup'
+    require 'cosmos'
+    yield
+  rescue Exception => error
+    popup_error = error; popup_error = $cosmos_fatal_exception if defined? $cosmos_fatal_exception
+    begin
+      raise error if STDIN.isatty # Have a console
+      raise error unless defined? $cosmos_fatal_exception or (error.class != SystemExit and error.class != Interrupt)
+      case RUBY_PLATFORM
+      when /mingw32/
+        require 'fiddle'
+        Fiddle::Function.new(Fiddle.dlopen('user32')['MessageBox'], [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG], Fiddle::TYPE_LONG).call(0, "#{popup_error.class}:#{popup_error.message}\n\n#{popup_error.backtrace.join("\n")}\n\nNote: Ctrl-C will copy this information to the clipboard.", "Error Starting COSMOS Tool", 0x50030)
+      when /darwin/
+        system("osascript -e 'display notification \"#{popup_error.class}:#{popup_error.message}:#{popup_error.backtrace[0].tr("'\"`<>", '')}\" with title \"Error Starting COSMOS Tool\"'")
+      else
+        message = "#{popup_error.class}:#{popup_error.message}\\n\\n#{popup_error.backtrace.join("\\n").tr("'\"`<>", '')}"
+        command = "zenity --info --text=\"#{message}\" --title=\"Error Starting COSMOS Tool\""
+        success = system(command)
+        system("notify-send \"Error Starting COSMOS Tool\" \"#{message}\"") unless success
+      end
+    ensure
+      raise error
+    end
+  end
+end

data/lib/cosmos.rb

@@ -34,7 +34,7 @@ if Kernel.is_windows?
 else
   ENV['PATH'] = File.join(File.dirname(__FILE__), '../bin') + ':' + ENV['PATH']
 end
-require 'cosmos/ext/platform'
+require 'cosmos/ext/platform' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
 
 # Remove warning about dl deprecation in Ruby 2.0 and 2.1
 saved_verbose = $VERBOSE; $VERBOSE = nil

data/lib/cosmos/config/config_parser.rb

@@ -8,12 +8,11 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'cosmos/ext/config_parser'
+require 'cosmos/ext/config_parser' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
 require 'tempfile'
 require 'erb'
 
 module Cosmos
-
   # Reads COSMOS style configuration data which consists of keywords followed
   # by 0 or more comma delimited parameters. Parameters with spaces must be
   # enclosed in quotes. Quotes should also be used to indicate a parameter is a
@@ -131,7 +130,7 @@ module Cosmos
     end
 
     # @param url [String] The url to link to in error messages
-    def initialize(url = "https://github.com/BallAerospace/COSMOS/wiki/Configuration-Guide")
+    def initialize(url = "http://cosmosrb.com/docs/home")
       @url = url
     end
 
@@ -180,21 +179,16 @@ module Cosmos
                    remove_quotes = true,
                    &block)
       @filename = filename
-      file = nil
-      unparsed_data = nil
-      begin
-        # Create a temp file where we can write the ERB parsed output
-        file = Tempfile.new("parsed_#{File.basename(filename)}")
-        unparsed_data = File.read(@filename)
-        file.write(ERB.new(unparsed_data).result(binding))
-        file.rewind
 
-        size = file.stat.size.to_f
+      # Create a temp file where we write the ERB parsed output
+      file = create_parsed_output_file(filename)
+      size = file.stat.size.to_f
 
-        # Callbacks for beginning of parsing
-        @@message_callback.call("Parsing #{size} bytes of #{filename}") if @@message_callback
-        @@progress_callback.call(0.0) if @@progress_callback
+      # Callbacks for beginning of parsing
+      @@message_callback.call("Parsing #{size} bytes of #{filename}") if @@message_callback
+      @@progress_callback.call(0.0) if @@progress_callback
 
+      begin
         # Loop through each line of the data
         parse_loop(file,
                    yield_non_keyword_lines,
@@ -202,13 +196,8 @@ module Cosmos
                    size,
                    PARSING_REGEX,
                    &block)
-      rescue Exception => e
-        debug_file = create_debug_output_file(filename, file, unparsed_data, e)
-        if debug_file
-          raise e, "#{e}\nDebug output in #{debug_file}", e.backtrace
-        else
-          raise e
-        end
+      rescue Exception => e # Catch EVERYTHING so we can re-raise with additional info
+        raise e, "#{e}\n\nParsed output in #{file.path}", e.backtrace
       ensure
         file.close unless file.closed?
       end
@@ -225,7 +214,7 @@ module Cosmos
       # for a backwards range
       (1..min_num_params).each do |index|
         # If the parameter is nil (0 based) then we have a problem
-        if @parameters[index-1].nil?
+        if @parameters[index - 1].nil?
           raise Error.new(self, "Not enough parameters for #{@keyword}.", usage, @url)
         end
       end
@@ -329,7 +318,7 @@ module Cosmos
         when 'MIN_FLOAT64'
           return -Float::MAX
         when 'MAX_FLOAT64'
-           return Float::MAX
+          return Float::MAX
         when 'MIN_FLOAT32'
           return -3.402823e38
         when 'MAX_FLOAT32'
@@ -347,30 +336,31 @@ module Cosmos
 
     protected
 
-    # Writes the parsed results for debugging if we had an error parsing
-    def create_debug_output_file(filename, file, unparsed_data, exception)
+    # Writes the ERB parsed results
+    def create_parsed_output_file(filename)
       begin
-        debug_file = nil
-        tmp_folder = File.join(Cosmos::USERPATH, 'outputs', 'tmp')
-        tmp_folder = Cosmos::USERPATH unless File.exist?(tmp_folder)
-        debug_file = File.join(tmp_folder, "parser_error_#{File.basename(filename)}")
-        File.open(debug_file, 'w') do |save_file|
-          save_file.puts exception.formatted
-          save_file.puts "\nParsed Data (will only be present if parse ran successfully):"
-          save_file.puts
-          if file
-            file.rewind
-            save_file.puts file.read
-          end
-          save_file.puts "\nUnparsed Data:"
-          save_file.puts
-          save_file.puts unparsed_data if unparsed_data
-        end
-      rescue Exception
-        # Oh well - we tried
-        debug_file = nil
+        output = ERB.new(File.read(filename)).result(binding)
+      rescue => e
+        # The first line of the backtrace indicates the line where the ERB
+        # parse failed. Grab the line number for the error message.
+        match = /:(.*):/.match(e.backtrace[0])
+        line_number = match.captures[0] if match
+        raise e, "ERB error at #{filename}:#{line_number}\n#{e}", e.backtrace
+      end
+      # Make a copy of the filename since we're calling slice! which modifies
+      # it directly. Downcase to avoid filesytem case issues.
+      copy = filename.downcase.dup
+      if copy.include?(Cosmos::USERPATH.downcase)
+        copy.slice!(Cosmos::USERPATH.downcase) # Remove the USERPATH
+      elsif copy.include?(':') # Check for Windows drive letter
+        copy = copy.split(':')[1]
       end
-      debug_file
+      parsed_filename = File.join(Cosmos::USERPATH, 'outputs', 'tmp', copy)
+      FileUtils.mkdir_p(File.dirname(parsed_filename)) # Create the path
+      file = File.open(parsed_filename, 'w+')
+      file.puts output
+      file.rewind # Rewind so the file is ready to read
+      file
     end
 
     def self.calculate_range_value(type, data_type, bit_size)
@@ -379,9 +369,9 @@ module Cosmos
       case data_type
       when :INT
         if type == 'MIN'
-          value = -2**(bit_size-1)
+          value = -2**(bit_size - 1)
         else # 'MAX'
-          value = 2**(bit_size-1) - 1
+          value = 2**(bit_size - 1) - 1
         end
       when :UINT
         # Default is 0 for 'MIN'
@@ -405,16 +395,114 @@ module Cosmos
       value
     end
 
-    # Iterates over each line of the io object and yields the keyword and
-    # parameters
-    #~ def parse_loop(
-      #~ io,
-      #~ yield_non_keyword_lines,
-      #~ remove_quotes,
-      #~ size,
-      #~ rx,
-      #~ &block)
+    if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_EXT']
+      # Iterates over each line of the io object and yields the keyword and parameters
+      def parse_loop(io, yield_non_keyword_lines, remove_quotes, size, rx)
+        line_continuation = false
+
+        @line_number = 0
+        @keyword = nil
+        @parameters = []
+        @line = nil
+
+        while true
+          @line_number += 1
 
-  end # class ConfigParser
+          if @@progress_callback && ((@line_number % 10) == 0)
+            @@progress_callback.call(io.pos / size) if size > 0.0
+          end
+
+          begin
+            line = io.readline
+          rescue Exception
+            break
+          end
+
+          line.strip!
+          data = line.scan(rx)
+          first_item = data[0].to_s
+
+          if line_continuation
+            @line << line
+            # Carry over keyword and parameters
+          else
+            @line = line
+            if (first_item.length == 0) || (first_item[0] == '#')
+              @keyword = nil
+            else
+              @keyword = first_item.upcase
+            end
+            @parameters = []
+          end
+
+          # Ignore comments and blank lines
+          if @keyword.nil?
+            if (yield_non_keyword_lines) && (!line_continuation)
+              yield(@keyword, @parameters)
+            end
+            next
+          end
+
+          if line_continuation
+            if remove_quotes
+              @parameters << first_item.remove_quotes
+            else
+              @parameters << first_item
+            end
+            line_continuation = false
+          end
+
+          length = data.length
+          if (length > 1)
+            (1..(length - 1)).each do |index|
+              string = data[index]
+
+              # Don't process trailing comments such as:
+              # KEYWORD PARAM #This is a comment
+              # But still process Ruby string interpolations such as:
+              # KEYWORD PARAM #{var}
+              if (string.length > 0) && (string[0] == '#')
+                if !((string.length > 1) && (string[1] == '{'))
+                  break
+                end
+              end
+
+              # If the string is simply '&' and its the last string then its a line continuation so break the loop
+              if (string.length == 1) && (string[0] == '&') && (index == (length - 1))
+                line_continuation = true
+                next
+              end
+
+              line_continuation = false
+              if remove_quotes
+                @parameters << string.remove_quotes
+              else
+                @parameters << string
+              end
+            end
+          end
+
+          # If we detected a line continuation while going through all the
+          # strings on the line then we strip off the continuation character and
+          # return to the top of the loop to continue processing the line.
+          if line_continuation
+            # Strip the continuation character
+            if @line.length >= 1
+              @line = @line[0..-2]
+            else
+              @line = ""
+            end
+            next
+          end
+
+          yield(@keyword, @parameters)
+        end
+
+        @@progress_callback.call(1.0) if @@progress_callback
+
+        return nil
+      end
+    end
 
-end # module Cosmos
+  end
+end

data/lib/cosmos/config/meta_config_parser.rb

@@ -0,0 +1,57 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'erb'
+require 'psych'
+require 'tempfile'
+
+class Array
+  def to_meta_config_yaml(indentation = 0)
+    Psych.dump(self).split("\n")[1..-1].join("\n#{' '*indentation}")
+  end
+end
+class Hash
+  def to_meta_config_yaml(indentation = 0)
+    Psych.dump(self).split("\n")[1..-1].join("\n#{' '*indentation}")
+  end
+end
+
+module Cosmos
+  # Reads YAML formatted files describing a configuration file
+  class MetaConfigParser
+    def self.load(filename)
+      data = nil
+      if File.exist?(filename)
+        path = filename
+      else
+        path = Cosmos.data_path("config/#{filename}")
+      end
+      tf = Tempfile.new("temp.yaml")
+      output = ERB.new(File.read(path)).result(binding)
+      tf.write(output)
+      tf.close
+      begin
+        data = Psych.load_file(tf.path)
+      rescue => error
+        error_file = "ERROR_#{filename}"
+        File.open(error_file, 'w') { |file| file.puts output }
+        raise error.exception("#{error.message}\n\nParsed output written to #{File.expand_path(error_file)}\n")
+      end
+      tf.unlink
+      data
+    end
+
+    def self.dump(object, filename)
+      File.open(filename, 'w') do |file|
+        file.write Psych.dump(object)
+      end
+    end
+  end
+end

data/lib/cosmos/conversions/polynomial_conversion.rb

@@ -9,7 +9,7 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'cosmos/conversions/conversion'
-require 'cosmos/ext/polynomial_conversion'
+require 'cosmos/ext/polynomial_conversion' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
 
 module Cosmos
 
@@ -33,9 +33,25 @@ module Cosmos
       @converted_bit_size = 64
     end
 
-    # @param (see Conversion#call)
-    # @return [Float] The value with the polynomial applied
-    # def call(value, myself, buffer)
+    if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_EXT']
+      # @param (see Conversion#call)
+      # @return [Float] The value with the polynomial applied
+      def call(value, myself, buffer)
+        value = value.to_f
+
+        # Handle C0
+        result = @coeffs[0]
+
+        # Handle Coefficients raised to a power
+        raised_to_power = 1.0
+        @coeffs[1..-1].each do |coeff|
+          raised_to_power *= value
+          result += (coeff * raised_to_power)
+        end
+
+        return result
+      end
+    end
 
     # @return [String] Class followed by the list of coefficients
     def to_s

data/lib/cosmos/conversions/unix_time_conversion.rb

@@ -31,18 +31,18 @@ module Cosmos
     # @return [Float] Packet time in seconds since UNIX epoch
     def call(value, packet, buffer)
       if @microseconds_item_name
-        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), packet.read(@microseconds_item_name, :RAW, buffer))
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), packet.read(@microseconds_item_name, :RAW, buffer)).sys
       else
-        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), 0)
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), 0).sys
       end
     end
 
     # @return [String] The name of the class followed by the time conversion
     def to_s
       if @microseconds_item_name
-        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), packet.read('#{@microseconds_item_name}', :RAW, buffer))"
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), packet.read('#{@microseconds_item_name}', :RAW, buffer)).sys"
       else
-        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), 0)"
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), 0).sys"
       end
     end