edfize 0.1.0.beta1 → 0.1.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07173882caa9f634f306d9f351e05213db2bd7b4
-  data.tar.gz: 0b78baa7a05690594bcd77afa437cdd864ef3fae
+  metadata.gz: 44aeaf1024f15eadb70e994e4f768d7e23e55073
+  data.tar.gz: a92347e4a34b965c09ba1d751582d0cc0bf56ec4
 SHA512:
-  metadata.gz: a77a87ed38e265fa516302a98643a9f2f1810b1f6b7c46e57bb92372d8fa0936c5a1359a4f7b7ee3bc41985550ee3276d913bf3cbad3d7b6638ca2efee32b3ae
-  data.tar.gz: 154f9505e976ccacbbbfab96d94d2f9d2c29f2b74edbf039a888f430c512bca2feed80658782f6b4c4cdf9373e006c2db713db1b24f251e4011f051867d78947
+  metadata.gz: b809d63028034dc994a9b8dfaeae8cecf37f1195f2a4bef625c3239537ed590dcf96ce0ad80a86b5119748e1db9a2e4c497cfbaf5bdca8f3703b6f007ef40a94
+  data.tar.gz: c6b392c72163d72bf23082699c4d4020bd1e86973f286a33a79eb9070a192d18a7ce86018be7322815a33f339eb8071e33f0bba26abd29297d573b504eca70e8

data/CHANGELOG.md

@@ -1,8 +1,14 @@
 ## 0.1.0
 - Initial EDF class to load headers and signals into Ruby objects
 - `edfize` command has the following actions:
-  - `check`: Validates EDFs in the current directory for errors
-  - `test`: Same as `check`
+  - `test`: Validates EDFs in the current directory for errors
+    - To only show failing tests, add the flag `--failing`
+      - `edfize test --failing`
+    - To suppress descriptive test failures, add the flag `--quiet`
+      - `edfize test --quiet`
+    - Both flags can be used together
+      - `edfize test --failing --quiet`
+  - `check`: Same as `test`
   - `run`: Prints out the headers of all edfs in the current directory
   - `help`: Displays information about `edfize` along with all available commands
   - `version`: Displays the current `edfize` version
@@ -10,3 +16,7 @@
   - Expected Length Check: The expected total size is computed from the (`number
     of data records` * `total samples across all signals`) + `size of header` and
     this is compared to the actual file size.
+  - Reserved Area Checks: The header and the individual header reserved areas are
+    checked to validate that they are blank. Non-blank areas are a sign that the
+    edf header is corrupt and that data from the signal data block have leaked into
+    the header itself.

data/README.md

@@ -24,10 +24,20 @@ Or install it yourself as:
 
 ### Validate EDFs
 
-Use `edfize check` to check that EDFs stored in the current directory have a valid format.
+Use `edfize test` to test that EDFs stored in the current directory have a valid format.
 
     cd <edf-directory>
-    edfize check
+    edfize test
+
+A list of validations performed is:
+
+- **Expected Length Check**: Compares the calculated size of the file based on signal sizes defined in the header with the actual file size. A failure may indicate corruption in the header (if the expected is less than the actual file size), or a partial/truncated file (if the expected is more than the actual file size).
+- **Reserved Area Checks**: Check that reserved areas are blank. Non-blank reserved areas can indicate a sign of header or EDF file corruption.
+
+Flags that can be added to the `test` command include:
+
+- `--failing`: Only display EDFs with failing tests
+- `--quiet`: Suppress detailed failure descriptions that show the expected versus the actual result of the test
 
 ### Print Signal Header information
 
@@ -54,6 +64,119 @@ Use `gem install edfize` to update Edfize to the latest stable
 
 Use `gem install edfize --pre` to update Edfize to the latest prerelease
 
+### Example of how to Load and Analyze EDFs in a Ruby Script
+
+The following Ruby file demonstrates how to make use of the Edfize gem to load EDF signals into arrays for analysis.
+
+`tutorial_01_load_edf_and_signals.rb`
+```ruby
+# Tutorial 01 - Load EDF and Signals
+#
+#   gem install edfize
+#
+#   ruby tutorial_01_load_edf_and_signals.rb
+#
+# The EDF exists at:
+#
+#    https://sleepdata.org/datasets/shhs/files/edfs/shhs1?f=shhs1-200001.edf
+#
+
+require 'rubygems'
+require 'edfize'
+
+# Loads the file and reads the EDF Header
+edf = Edfize::Edf.new('shhs1-200001.edf')
+
+# Loads the data section of the EDF into Signal objects
+edf.load_signals
+
+# Print out information on the signals
+puts "EDF #{edf.filename} contains the following #{edf.signals.count} signal#{'s' unless edf.signals.count == 1}:\n\n"
+
+edf.signals.each do |signal|
+  puts "Signal"
+  puts "  Label                  : #{signal.label}"
+  puts "  Samples Per Data Record: #{signal.samples_per_data_record}"
+  puts "  First 10 Samples       : #{(signal.samples[0..10] + ['...']).inspect}\n\n"
+end
+```
+
+When run, the code above will output the following:
+
+```console
+EDF shhs1-200001.edf contains the following 14 signals:
+
+Signal
+  Label                  : SaO2
+  Samples Per Data Record: 1
+  First 10 Samples       : [29695, 29695, 29695, 29695, 29695, 29695, 29695, 29695, 28927, 28927, 28927, "..."]
+
+Signal
+  Label                  : H.R.
+  Samples Per Data Record: 1
+  First 10 Samples       : [-12493, -12493, -12493, -12697, -12697, -12697, -13107, -13107, -13107, -13107, -13107, "..."]
+
+Signal
+  Label                  : EEG(sec)
+  Samples Per Data Record: 125
+  First 10 Samples       : [-5, -13, -2, -13, -23, 1, 21, -9, 6, -17, 6, "..."]
+
+Signal
+  Label                  : ECG
+  Samples Per Data Record: 125
+  First 10 Samples       : [3, 7, -10, 0, 5, 4, 0, 3, 11, -12, -3, "..."]
+
+Signal
+  Label                  : EMG
+  Samples Per Data Record: 125
+  First 10 Samples       : [51, 9, -48, 84, 10, -23, 20, -10, 58, 2, 26, "..."]
+
+Signal
+  Label                  : EOG(L)
+  Samples Per Data Record: 50
+  First 10 Samples       : [29, 3, -127, 15, -67, 47, -3, -33, -25, 16, 28, "..."]
+
+Signal
+  Label                  : EOG(R)
+  Samples Per Data Record: 50
+  First 10 Samples       : [12, 25, 127, -106, 59, -3, 9, 7, 20, 7, -7, "..."]
+
+Signal
+  Label                  : EEG
+  Samples Per Data Record: 125
+  First 10 Samples       : [-3, 31, 65, 4, 52, 12, -2, 21, -26, 34, -9, "..."]
+
+Signal
+  Label                  : THOR RES
+  Samples Per Data Record: 10
+  First 10 Samples       : [-27, 17, -25, -57, 18, -24, 6, 32, 38, -21, 41, "..."]
+
+Signal
+  Label                  : ABDO RES
+  Samples Per Data Record: 10
+  First 10 Samples       : [-40, 34, -2, -28, 68, -117, -20, -24, 5, -27, 67, "..."]
+
+Signal
+  Label                  : POSITION
+  Samples Per Data Record: 1
+  First 10 Samples       : [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, "..."]
+
+Signal
+  Label                  : LIGHT
+  Samples Per Data Record: 1
+  First 10 Samples       : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, "..."]
+
+Signal
+  Label                  : NEW AIR
+  Samples Per Data Record: 10
+  First 10 Samples       : [6, 7, 3, 3, 7, 3, 6, 0, 5, 5, 9, "..."]
+
+Signal
+  Label                  : OX stat
+  Samples Per Data Record: 1
+  First 10 Samples       : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, "..."]
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/sleepepi/edfize/fork )

data/lib/edfize/edf.rb

@@ -2,13 +2,28 @@ require 'edfize/signal'
 
 module Edfize
   class Edf
-    attr_reader :signals, :filename
+    attr_reader   :filename
+
+    attr_reader   :reserved               # 44 bytes - ASCII
+    attr_reader   :number_of_data_records #  8 bytes - ASCII
+
+    attr_accessor :signals
+
+    RESERVED_SIZE = 44
+
+
 
     HEADER_OFFSET = 256
+    SIZE_OF_SAMPLE_IN_BYTES = 2
 
     def initialize(filename)
       @filename = filename
       @signals = []
+
+      read_header
+
+      # Other
+      get_number_of_data_records
       signal_labels
       transducer_types
       physical_dimensions
@@ -17,12 +32,12 @@ module Edfize
       digital_minimums
       digital_maximums
       prefilterings
-      samples_in_data_records
+      samples_per_data_records
       reserved_areas
     end
 
-    def size
-      File.size(@filename)
+    def load_signals
+      get_data_records
     end
 
     def size_of_header
@@ -33,55 +48,61 @@ module Edfize
       256 + (ns * 256)
     end
 
-    def total_size
-      IO.binread(@filename).size
+    # Total File Size In Bytes
+    def edf_size
+      File.size(@filename)
     end
 
+    # Data Section Size In Bytes
     def expected_data_size
-      result = 0
-      @signals.each do |signal|
-        result += signal.samples_in_data_record.to_i * 2 # NR * Int(16)
-      end
-      result * number_of_data_records.to_i
+      @signals.collect(&:samples_per_data_record).inject(:+).to_i * @number_of_data_records * SIZE_OF_SAMPLE_IN_BYTES
     end
 
-    def expected_total_size
+    def expected_edf_size
       expected_data_size + size_of_header
-      # (duration_of_a_data_record.to_i * number_of_data_records.to_i * number_of_signals.to_i) * 8
     end
 
     def print_header
-      puts @filename
-      puts "#{size} bytes (Total File Size)"
-      puts "'#{header_version}' (0)"
-      puts "'#{header_local_patient_identification}' (local patient identification)"
-      puts "'#{header_local_recording_identification}' (local recording indentification)"
-      puts "'#{header_start_date_of_recording}' (dd.mm.yy start date of recording)"
-      puts "'#{header_start_time_of_recording}' (hh.mm.ss start time of recording)"
-      # puts "--- RESERVED"
-      puts "'#{number_of_data_records}' (number of data records, -1 if unknown)"
-      puts "'#{duration_of_a_data_record}' seconds (duration of a data record)"
-      puts "'#{number_of_signals}' number of signals (ns) in data record"
+      puts "\nEDF                            : #{@filename}"
+      puts "Total File Size                : #{edf_size} bytes"
+      puts "\nHeader Information"
+      puts "Version                        : #{header_version}"
+      puts "Local Patient Identification   : #{header_local_patient_identification}"
+      puts "Local Recording Identification : #{header_local_recording_identification}"
+      puts "Start Date of Recording        : #{header_start_date_of_recording} (dd.mm.yy)"
+      puts "Start Time of Recording        : #{header_start_time_of_recording} (hh.mm.ss)"
+      puts "Reserved                       : '#{@reserved}'"
+      puts "Number of Data Records         : #{number_of_data_records}"
+      puts "Duration of a Data Record      : #{duration_of_a_data_record.to_i} second#{'s' unless duration_of_a_data_record.to_i == 1}"
+      puts "Number of Signals (NS)         : #{number_of_signals}"
+      puts "\nSignal Information"
       signals.each_with_index do |signal, index|
-        puts "'#{signal.label}' (signal[#{index+1}] label)"
-        puts "'#{signal.physical_dimension}' (signal[#{index+1}] physical_dimension)"
-        puts "'#{signal.transducer_type}' (signal[#{index+1}] transducer_type)"
-        puts "'#{signal.physical_minimum}' (signal[#{index+1}] physical_minimum)"
-        puts "'#{signal.physical_maximum}' (signal[#{index+1}] physical_maximum)"
-        puts "'#{signal.digital_minimum}' (signal[#{index+1}] digital_minimum)"
-        puts "'#{signal.digital_maximum}' (signal[#{index+1}] digital_maximum)"
-        puts "'#{signal.prefiltering}' (signal[#{index+1}] prefiltering)"
-        puts "'#{signal.samples_in_data_record}' (signal[#{index+1}] samples_in_data_record)"
-        puts "'#{signal.reserved_area}' (signal[#{index+1}] reserved_area)"
+        puts "\n  Position                     : #{index + 1}"
+        puts "  Label                        : #{signal.label}"
+        puts "  Physical Dimension           : #{signal.physical_dimension}"
+        puts "  Transducer Type              : #{signal.transducer_type}"
+        puts "  Physical Minimum             : #{signal.physical_minimum}"
+        puts "  Physical Maximum             : #{signal.physical_maximum}"
+        puts "  Digital Minimum              : #{signal.digital_minimum}"
+        puts "  Digital Maximum              : #{signal.digital_maximum}"
+        puts "  Prefiltering                 : #{signal.prefiltering}"
+        puts "  Samples Per Data Record      : #{signal.samples_per_data_record}"
+        puts "  Reserved Area                : '#{signal.reserved_area}'"
       end
-      puts "#{size} bytes (Total File Size)"
-      puts "Size of Header (bytes)          : #{size_of_header}"
-      puts "Size of Data   (bytes)          : #{data_size}"
-      puts "Total Size     (bytes)          : #{total_size}"
+      puts "\nGeneral Information"
+      puts "Size of Header (bytes)         : #{size_of_header}"
+      puts "Size of Data   (bytes)         : #{data_size}"
+      puts "Total Size     (bytes)         : #{edf_size}"
+
+      puts "Expected Size of Header (bytes): #{expected_size_of_header}"
+      puts "Expected Size of Data   (bytes): #{expected_data_size}"
+      puts "Expected Total Size     (bytes): #{expected_edf_size}"
+    end
+
+    protected
 
-      puts "Expected Size of Header (bytes) : #{expected_size_of_header}"
-      puts "Expected Size of Data   (bytes) : #{expected_data_size}"
-      puts "Expected Total Size     (bytes) : #{expected_total_size}"
+    def read_header
+      read_reserved
     end
 
     def header_version
@@ -114,13 +135,13 @@ module Edfize
     end
 
     # 44 ascii : reserved
-    # def reserved
-    #   IO.binread(@filename, 44, 192)
-    # end
+    def read_reserved
+      @reserved = IO.binread(@filename, RESERVED_SIZE, 192)
+    end
 
     # 8 ascii : number of data records (-1 if unknown, obey item 10 of the additional EDF+ specs)
-    def number_of_data_records
-      IO.binread(@filename, 8, 236)
+    def get_number_of_data_records
+      @number_of_data_records = IO.binread(@filename, 8, RESERVED_SIZE + 192).to_i
     end
 
     # 8 ascii : duration of a data record, in seconds
@@ -210,11 +231,12 @@ module Edfize
     end
 
     # ns * 8 ascii : ns * nr of samples in each data record
-    def samples_in_data_records
+    def samples_per_data_records
       offset = HEADER_OFFSET + ns * (16 + 80 + 8 + 8 + 8 + 8 + 8 + 80)
       (0..ns-1).to_a.each do |signal_number|
         @signals[signal_number] ||= Signal.new()
-        @signals[signal_number].samples_in_data_record = IO.binread(@filename, 8, offset+(signal_number*8))
+        @signals[signal_number].samples_per_data_record = IO.binread(@filename, 8, offset+(signal_number*8)).to_i
+        @signals[signal_number].samples = Array.new(@signals[signal_number].samples_per_data_record, 0)
       end
     end
 
@@ -227,28 +249,22 @@ module Edfize
       end
     end
 
-    def get_samples
-      offset = size_of_header
-      current_read_offset = 0
-      (0..ns-1).to_a.each do |signal_number|
-        @signals[signal_number] ||= Signal.new()
-        read_size = @signals[signal_number].samples_in_data_record.to_i * 2 * number_of_data_records.to_i
-        @signals[signal_number].samples = IO.binread(@filename, read_size, size_of_header + current_read_offset).unpack('s*')
-        current_read_offset += read_size
-      end
-    end
 
-    # 2-byte integer
-    # [16Bit]signed short: -32767 to 32767
-    # .unpack('s*')
-    def data_signals
-      data_section = IO.binread(@filename, nil, size_of_header)
-      dataset_section.unpack('s*')
+    #
+    def get_data_records
+      current_read_offset = size_of_header
+      (0..@number_of_data_records-1).to_a.each do |data_record_index|
+        @signals.each do |signal|
+          # 16-bit signed integer size = 2 Bytes = 2 ASCII characters
+          read_size = signal.samples_per_data_record * SIZE_OF_SAMPLE_IN_BYTES
+          signal.samples[data_record_index..data_record_index+signal.samples_per_data_record] = IO.binread(@filename, read_size, current_read_offset).unpack('s*')
+          current_read_offset += read_size
+        end
+      end
     end
 
     def data_size
-      data_section = IO.binread(@filename, nil, size_of_header)
-      data_section.size
+      IO.binread(@filename, nil, size_of_header).size
     end
   end
 end

data/lib/edfize/signal.rb

@@ -1,21 +1,9 @@
 module Edfize
   class Signal
-    attr_accessor :label, :transducer_type, :physical_dimension, :physical_minimum, :physical_maximum,
-                  :digital_minimum, :digital_maximum, :prefiltering, :samples_in_data_record, :reserved_area, :samples
-
-    def initialize
-      @label = ''
-      @physical_dimension = ''
-      @transducer_type = ''
-      @physical_minimum = ''
-      @physical_maximum = ''
-      @digital_minimum = ''
-      @digital_maximum = ''
-      @prefiltering = ''
-      @samples_in_data_record = ''
-      @reserved_area = ''
-      @samples = []
-    end
-
+    attr_accessor :label, :transducer_type, :physical_dimension,
+                  :physical_minimum, :physical_maximum,
+                  :digital_minimum, :digital_maximum,
+                  :prefiltering, :samples_per_data_record,
+                  :reserved_area, :samples
   end
 end

data/lib/edfize/tests/check_length.rb

@@ -1,15 +1,16 @@
 module Edfize
   module Tests
-    # This test checks that the length calculated from the EDF header matches
-    # the total length of the file
-    def self.test_expected_length(edf)
-      passes = (edf.expected_total_size == edf.total_size)
-      puts "  #{passes ? 'PASS' : 'FAIL'}".colorize( passes ? :green : :red ) + " Expected File Size"
-      unless passes or not verbose
-        puts "    Expected : #{edf.expected_total_size} bytes"
-        puts "    Actual   : #{edf.total_size} bytes"
+    module CheckLength
+      # This test checks that the length calculated from the EDF header matches
+      # the total length of the file
+      def test_expected_length(runner)
+        result = Result.new
+        result.passes = (runner.edf.expected_edf_size == runner.edf.edf_size)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Expected File Size"
+        result.expected  = "    Expected : #{runner.edf.expected_edf_size} bytes"
+        result.actual    = "    Actual   : #{runner.edf.edf_size} bytes"
+        result
       end
-      passes
     end
   end
 end

data/lib/edfize/tests/check_reserved_area.rb

@@ -0,0 +1,15 @@
+module Edfize
+  module Tests
+    module CheckReservedArea
+      # This test checks that the reserved area in the header is blank
+      def test_reserved_area_blank(runner)
+        result           = Result.new
+        result.passes    = (runner.edf.reserved == ' ' * Edf::RESERVED_SIZE)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Reserved Area Blank"
+        result.expected  = "    Expected : #{(' ' * Edf::RESERVED_SIZE).inspect}"
+        result.actual    = "    Actual   : #{runner.edf.reserved.to_s.inspect}"
+        result
+      end
+    end
+  end
+end

data/lib/edfize/tests/check_reserved_signal_areas.rb

@@ -0,0 +1,17 @@
+module Edfize
+  module Tests
+    module CheckReservedSignalAreas
+      # This test checks that the reserved areas in the signal headers are blank
+      def test_reserved_signal_areas_blank(runner)
+        reserved_areas = runner.edf.signals.collect(&:reserved_area)
+
+        result = Result.new
+        result.passes = (reserved_areas.reject{|r| r.to_s.strip == ''}.count == 0)
+        result.pass_fail = "  #{result.passes ? 'PASS' : 'FAIL'}".colorize( result.passes ? :green : :red ) + " Signal Reserved Area Blank"
+        result.expected  = "    Expected : #{[''] * runner.edf.signals.count}"
+        result.actual    = "    Actual   : #{reserved_areas}"
+        result
+      end
+    end
+  end
+end

data/lib/edfize/tests/result.rb

@@ -0,0 +1,7 @@
+module Edfize
+  module Tests
+    class Result
+      attr_accessor :passes, :pass_fail, :expected, :actual
+    end
+  end
+end

data/lib/edfize/tests/runner.rb

@@ -0,0 +1,54 @@
+module Edfize
+  module Tests
+    class Runner
+      attr_reader :tests_run, :tests_failed, :edf, :verbose, :show_passing
+
+      TESTS = %w( expected_length reserved_area_blank reserved_signal_areas_blank )
+
+      def initialize(edf, argv)
+        @tests_run = 0
+        @tests_failed = 0
+        @edf = edf
+        @verbose = argv.include?('--quiet') ? false : true
+        @show_passing = argv.include?('--failing') ? false : true
+      end
+
+      def run_tests
+        results = []
+
+        TESTS.each do |test_name|
+          result = Edfize::Tests.send("test_#{test_name}", self)
+          @tests_failed += 1 unless result.passes
+          @tests_run += 1
+          results << result
+        end
+
+        puts "\n#{@edf.filename}" if results.reject{|r| r.passes}.count > 0 or @show_passing
+        results.each do |result|
+          print_result(result)
+        end
+
+        # test_expected_length(edf) ? nil : failure_count += 1
+        # test_count += 1
+
+        # test_reserved_area_blank(edf) ? nil : failure_count += 1
+        # test_count += 1
+
+        # test_reserved_signal_areas_blank(edf) ? nil : failure_count += 1
+        # test_count += 1
+
+        # [test_count, failure_count]
+      end
+
+      def print_result(result)
+        if self.show_passing or !result.passes
+          puts result.pass_fail
+          unless result.passes or not self.verbose
+            puts result.expected
+            puts result.actual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/edfize/tests.rb

@@ -1,21 +1,13 @@
+require 'edfize/tests/result'
+require 'edfize/tests/runner'
 require 'edfize/tests/check_length'
+require 'edfize/tests/check_reserved_area'
+require 'edfize/tests/check_reserved_signal_areas'
 
 module Edfize
   module Tests
-    def self.verbose
-      true
-    end
-
-    def self.run(edf)
-      puts "\n#{edf.filename}"
-
-      failure_count = 0
-      test_count = 0
-
-      test_expected_length(edf) ? nil : failure_count += 1
-      test_count += 1
-
-      [test_count, failure_count]
-    end
+    extend CheckLength
+    extend CheckReservedArea
+    extend CheckReservedSignalAreas
   end
 end

data/lib/edfize/version.rb

@@ -3,7 +3,7 @@ module Edfize
     MAJOR = 0
     MINOR = 1
     TINY = 0
-    BUILD = "beta1"
+    BUILD = "beta2"
 
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end

data/lib/edfize.rb

@@ -10,7 +10,7 @@ module Edfize
     when 'v'
       version
     when 'c', 't'
-      check
+      check(argv[1..-1])
     when 'r'
       print_headers
     else
@@ -31,7 +31,7 @@ module Edfize
     puts "Edfize #{Edfize::VERSION::STRING}"
   end
 
-  def self.check
+  def self.check(argv)
     test_start_time = Time.now
     edf_count = edfs_in_current_directory.count
     test_count = 0
@@ -39,9 +39,10 @@ module Edfize
     puts "Started\n"
     edfs_in_current_directory.each do |edf_file_name|
       edf = Edfize::Edf.new(edf_file_name)
-      tests_run, failures = Edfize::Tests.run(edf)
-      test_count += tests_run
-      failure_count += failures
+      runner = Edfize::Tests::Runner.new(edf, argv)
+      runner.run_tests
+      test_count += runner.tests_run
+      failure_count += runner.tests_failed
     end
     puts "\nFinished in #{Time.now - test_start_time}s"
     puts "#{edf_count} EDF#{'s' unless edf_count == 1}, #{test_count} test#{'s' unless test_count == 1}, " + "#{failure_count} failure#{'s' unless failure_count == 1}".colorize( failure_count == 0 ? :green : :red )
@@ -54,6 +55,7 @@ Usage: edfize COMMAND [ARGS]
 The most common edfize commands are:
   [c]heck           Check EDFs in current directory for errors
   [t]est            Same as [c]heck
+  [r]un             Print EDF headers for current directory
   [h]elp            Show edfize command-line documentation
   [v]ersion         Returns the version of Edfize
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edfize
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta1
+  version: 0.1.0.beta2
 platform: ruby
 authors:
 - Remo Mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-30 00:00:00.000000000 Z
+date: 2014-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -72,6 +72,10 @@ files:
 - lib/edfize/signal.rb
 - lib/edfize/tests.rb
 - lib/edfize/tests/check_length.rb
+- lib/edfize/tests/check_reserved_area.rb
+- lib/edfize/tests/check_reserved_signal_areas.rb
+- lib/edfize/tests/result.rb
+- lib/edfize/tests/runner.rb
 - lib/edfize/version.rb
 homepage: https://github.com/sleepepi/edfize
 licenses: