ruby_tdms 2.0.0

data/lib/ruby_tdms/file.rb

@@ -0,0 +1,13 @@
+require_relative 'streaming'
+
+module RubyTDMS
+	class File < ::File
+		include Streaming
+
+		class << self
+			def parse(filename)
+				Document.new open(filename, 'rb')
+			end
+		end
+	end
+end

data/lib/ruby_tdms/object_parser.rb

@@ -0,0 +1,47 @@
+require_rel 'objects'
+
+module RubyTDMS
+	class ObjectParser
+		class << self
+			# Given a +Segment+, parse the next object. If no objects remain, return nil.
+			def parse_stream(stream, document, segment)
+				path = Path.new raw: stream.read_utf8_string
+				raw_index = stream.read_u32
+
+				if path == '/'
+					# File object
+					Objects::File.new(path, document, segment).tap { |obj| obj.parse_stream stream }
+				else
+					case raw_index
+						when 0xFFFFFFFF
+							# No data stored, indicating a group object
+							Objects::Group.new(path, document, segment).tap { |obj| obj.parse_stream stream }
+						when 0x69120000
+							# "DAQmx Format Changing scaler"
+							# TODO: Implement support for this
+							raise NotImplementedError, 'DAQmx Format Changing scaler support is not implemented'
+						when 0x69130000
+							# "DAQmx Digital Line scaler"
+							# TODO: Implement support for this
+							raise NotImplementedError, 'DAQmx Digital Line scaler support is not implemented'
+						when 0x00000000
+							# Identical to previous segment, so clone the channel object and have it update streaming parameters
+							previous_channel = document.objects.reverse.find { |object| object.path == path }
+							Objects::Channel.new(path, document, segment).tap { |obj|
+								obj.continue_stream stream, raw_index, previous_channel
+								group = document.objects.find { |object| object.is_a? Objects::Group and object.path == Path.new(parts: path.to_a[0..-2]) }
+								group.channels << obj if group
+							}
+						else
+							Objects::Channel.new(path, document, segment).tap { |obj|
+								obj.parse_stream stream, raw_index
+								group = document.objects.find { |object| object.is_a? Objects::Group and object.path == Path.new(parts: path.to_a[0..-2]) }
+								group.channels << obj if group
+							}
+					end
+
+				end
+			end
+		end
+	end
+end

data/lib/ruby_tdms/objects/base.rb

@@ -0,0 +1,47 @@
+module RubyTDMS
+	module Objects
+		# TDMS object base.
+		# All objects hold a collection of Segment references since objects can be striped across segments.
+		class Base
+			attr_reader :path, :properties, :segment, :stream
+
+
+			def initialize(path, document, segment)
+				@path = path
+				@document = document
+				@segment = segment
+				@stream = document.stream
+
+				@properties = []
+			end
+
+
+			def continue_stream(stream, previous_channel)
+				parse_properties stream
+			end
+
+
+			def parse_stream(stream)
+				parse_properties stream
+			end
+
+
+			def as_json
+				{
+					path: path.to_s,
+					properties: properties.reduce({}) { |properties, property| properties[property.name.to_s.to_sym] = property.value; properties }
+				}
+			end
+
+
+			protected
+
+			def parse_properties(stream)
+				@properties_length = stream.read_u32
+				@properties_length.times do
+					@properties << stream.read_property(@segment.big_endian?)
+				end
+			end
+		end
+	end
+end

data/lib/ruby_tdms/objects/channel.rb

@@ -0,0 +1,105 @@
+require_relative '../data_types'
+require_relative '../channel_enumerator'
+require_relative '../string_channel_enumerator'
+
+module RubyTDMS
+	module Objects
+		class Channel < Base
+			attr_reader :chunk_offsets, :chunk_value_count, :data_length, :data_type, :data_type_id, :dimensions, :chunk_length, :raw_data_offset, :value_count, :value_offset
+
+
+			def initialize(path, document, segment)
+				super
+				@chunk_offsets = []
+				@value_count = 0
+			end
+
+
+			def name
+				path.to_a.last
+			end
+
+
+			def as_json
+				super.merge({
+					name: name,
+					data_type: data_type.name.split('::').last,
+					dimensions: dimensions,
+					values: values.to_a
+				})
+			end
+
+
+			# Get all data from the stream to configure ourself with data type, number of values, etc.
+			def parse_stream(stream, raw_index)
+				@data_type_id = stream.read_u32
+				@dimensions = stream.read_u32
+				@chunk_value_count = stream.read_u64
+
+				@data_type = DataTypes.find_by_id @data_type_id
+				# Get the data length for variable length types (when DataTypes::LENGTH_IN_BYTES is nil)
+				@data_length = @data_type::LENGTH_IN_BYTES || stream.read_u64
+
+				# Chunk length is the same as data length for variable length types
+				@chunk_length = @data_type::LENGTH_IN_BYTES.nil? ? @data_length : @data_length * @dimensions * @chunk_value_count # Size of the data for this channel in a given chunk.
+
+				super stream
+			end
+
+
+			# When a channel is continued in a new segment, this method is called rather than #parse_stream
+			def continue_stream(stream, raw_index, previous_channel)
+				@chunk_value_count = previous_channel.chunk_value_count
+				@data_length = previous_channel.data_length
+				@data_type = previous_channel.data_type
+				@data_type_id = previous_channel.data_type_id
+				@dimensions = previous_channel.dimensions
+
+				@chunk_length = @data_length * @dimensions * @chunk_value_count # Size of the data for this channel in a given chunk.
+
+				super stream, previous_channel
+			end
+
+
+			# After all channels in a segment have been read, we have to determine our raw data starting offset and
+			# the offsets for all individual values, based on the number of chunks in the segment as well as whether
+			# the segment is interleaved.
+			def calculate_offsets
+				previous_channel = nil
+				channels = @segment.raw_channels
+				me = channels.index self
+				previous_channel = channels[me - 1] if me and me > 0
+
+				if @segment.interleaved_data?
+					@value_offset = @segment.raw_channels.map(&:data_length).reduce :+
+				else
+					@value_offset = @data_length
+				end
+
+				@raw_data_offset = @segment.raw_data_offset
+				if previous_channel
+					@raw_data_offset = previous_channel.raw_data_offset
+					@raw_data_offset += @segment.interleaved_data? ? previous_channel.data_length : previous_channel.chunk_length
+				end
+
+				@segment.chunk_count.times do
+					@chunk_offsets << @raw_data_offset + @chunk_offsets.length * @chunk_length
+				end
+				@value_count = @chunk_value_count * @segment.chunk_count
+			end
+
+
+			def values
+				@values ||= begin
+					klass = if @data_type::LENGTH_IN_BYTES.nil?
+						StringChannelEnumerator
+					else
+						ChannelEnumerator
+					end
+
+					klass.new self
+				end
+			end
+		end
+	end
+end

data/lib/ruby_tdms/objects/file.rb

@@ -0,0 +1,11 @@
+require_relative 'base'
+
+module RubyTDMS
+	module Objects
+		class File < Base
+			def as_json
+				super.reject { |key, value| key == :path }
+			end
+		end
+	end
+end

data/lib/ruby_tdms/objects/group.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+
+module RubyTDMS
+	module Objects
+		class Group < Base
+			attr_reader :channels
+
+
+			def initialize(*args)
+				super
+				@channels = []
+			end
+
+
+			def as_json
+				super.merge({
+					channel_count: @channels.length
+				})
+			end
+		end
+	end
+end

data/lib/ruby_tdms/path.rb

@@ -0,0 +1,97 @@
+module RubyTDMS
+	class Path
+		PATH_MATCHER = /(?:(?<!\\))\//
+		RAW_MATCHER = /(?:^|(?<='))\/(?:(?=')|$)/
+
+		# Can initialize with parts, path, or raw. Elements can contain / only in raw or parts forms.
+		def initialize(options = {})
+			raise ArgumentError, 'Initialize with at most one of +parts+, +path+, or +raw+.' if options.length > 1
+			@parts = options[:parts] || []
+			self.path = options[:path] if options.has_key? :path
+			self.raw = options[:raw] if options.has_key? :raw
+		end
+
+
+		def dump
+			to_s
+		end
+
+
+		def hash
+			to_s.hash
+		end
+
+
+		def inspect
+			"#<#{self.class.name}:#{self.object_id} path=#{path.inspect}>"
+		end
+
+
+		def load(string)
+			self.path = string
+		end
+
+
+		def path
+			'/' + @parts.map { |part| part.gsub('/', '\/') }.join('/')
+		end
+
+
+		def path=(value)
+			@parts = value._?('').split(PATH_MATCHER).reject { |x| x.length == 0 }.map { |part| decode_part part }
+		end
+
+
+		def raw
+			'/' + @parts.map { |part| encode_part part }.join('/')
+		end
+
+
+		def raw=(value)
+			@parts = value._?('').split(RAW_MATCHER).reject { |x| x.length == 0 }.map { |part| decode_raw_part part }
+		end
+
+
+		def to_a
+			@parts
+		end
+
+
+		def to_s
+			path
+		end
+
+
+		def ==(other)
+			if other.is_a? String
+				self.to_s == other
+			elsif other.is_a? self.class
+				self.dump == other.dump
+			else
+				super
+			end
+		end
+
+
+		alias eql? ==
+
+
+		protected
+
+		def decode_part(part)
+			part.gsub(/\\\//, '/')
+		end
+
+
+		def decode_raw_part(part)
+			part.gsub(/(^'|'$)/, '').gsub(/''/, "'")
+		end
+
+
+		# Pure part representation -> raw encoded representation
+		# "my / part's / awesomeness" -> "'my / part''s / awesomeness'"
+		def encode_part(part)
+			"'#{part.gsub(/'/, "''")}'"
+		end
+	end
+end

data/lib/ruby_tdms/property.rb

@@ -0,0 +1,16 @@
+module RubyTDMS
+	class Property
+		attr_accessor :name
+		attr_accessor :data # TDMS::DataTypes::Base
+
+		def initialize(name = nil, data = nil)
+			@name = name
+			@data = data
+		end
+
+
+		def value
+			data.value
+		end
+	end
+end

data/lib/ruby_tdms/segment.rb

@@ -0,0 +1,107 @@
+require_relative 'object_parser'
+
+module RubyTDMS
+	# Implements the TDMS segment, including a Segment factory and stream parser.
+	# TODO: Refactor the parser out? Too much coupling between Segment and Document!
+	class Segment
+		FLAG_META_DATA = 1 << 1
+		FLAG_RAW_DATA = 1 << 3
+		FLAG_DAQMX_RAW_DATA = 1 << 7
+		FLAG_INTERLEAVED_DATA = 1 << 5
+		FLAG_BIG_ENDIAN = 1 << 6
+		FLAG_NEW_OBJECT_LIST = 1 << 2
+
+		attr_reader :document
+		attr_reader :objects, :tag, :version, :length, :meta_data_length, :meta_data_offset, :raw_data_offset, :chunk_count
+
+
+		def initialize(document)
+			@document = document
+			@objects = []
+		end
+
+
+		class << self
+			def parse_stream(stream, document)
+				new(document).tap do |new|
+					new.parse_lead_in stream
+					document.segments << new # TODO: smelly
+					new.parse_meta_data stream if new.meta_data?
+				end
+			end
+		end
+
+
+		def raw_channels
+			objects.select { |object| object.is_a? Objects::Channel }
+		end
+
+
+		# Checks if the segment flags have +flag+ set.
+		# @param flag [Fixnum] The flag mask to check, like FLAG_META_DATA or FLAG_RAW_DATA.
+		# @return [Boolean] Whether the segment has the flag in question set.
+		def flag?(flag)
+			!!(@flags & flag == flag)
+		end
+
+
+		def meta_data?
+			flag? FLAG_META_DATA
+		end
+
+
+		def raw_data?
+			flag? FLAG_RAW_DATA
+		end
+
+
+		def daqmx_data?
+			flag? FLAG_DAQMX_RAW_DATA
+		end
+
+
+		def interleaved_data?
+			flag? FLAG_INTERLEAVED_DATA
+		end
+
+
+		def big_endian?
+			flag? FLAG_BIG_ENDIAN
+		end
+
+
+		def new_object_list?
+			flag? FLAG_NEW_OBJECT_LIST
+		end
+
+
+		# protected
+
+		def parse_lead_in(stream)
+			@tag = stream.read 4
+			@flags = stream.read_u32
+			@version = stream.read_u32
+			@length = stream.read_u64 # Overall length of segment minus length of lead-in, aka "Next segment offset" in NI docs.
+			@meta_data_length = stream.read_u64 # Overall length of meta information, aka "Raw data offset" in NI docs.
+
+			@meta_data_offset = @meta_data_length > 0 ? stream.pos : nil
+			@raw_data_offset = stream.pos + @meta_data_length # Stream offset at which raw data for this segment begins.
+			@raw_data_length = @length == -1 ? stream.length - @raw_data_offset : @length - @meta_data_length # Number of bytes raw data occupies. NI docs say @length == -1 means the entire file, after lead-in and header, is raw data.
+		end
+
+
+		def parse_meta_data(stream)
+			@number_of_objects = stream.read_u32
+
+			@number_of_objects.times do
+				object = ObjectParser.parse_stream stream, document, self
+				@objects << object
+			end
+
+
+			@chunk_length = raw_channels.map(&:chunk_length).reduce(:+) # Length of an individual data chunk (summation of each object's raw data length)
+			@chunk_count = @raw_data_length / @chunk_length
+			raw_channels.each { |object| object.calculate_offsets }
+		end
+	end
+end