framecurve 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+gem "term-ansicolor"
+group :development do
+  gem "jeweler", "~> 1.6.4"
+  gem "rake"
+  gem "cli_test"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Julik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,27 @@
+= framecurve
+
+framecurve (http://framecurve.org) file handling gem for Ruby.
+
+It currently includes only one binary, framecurve_validator, that will validate framecurve files passed in the arguments and report
+any errors found in the files to STDERR.
+
+    $framecurve_validator somefile.framecurve.txt another.framecurve.txt
+    
+For the rest this gem includes a handful of classes for manipulating framecurves and is intended as a library for when you want to do something
+with framecurves from within Ruby. This will also power the online framecurve validation service once it's online.
+
+== Contributing to framecurve
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Julik. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'jeweler'
+require './lib/framecurve'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.version = Framecurve::VERSION
+  gem.name = "framecurve"
+  gem.homepage = "http://github.com/guerilla-di/framecurve"
+  gem.license = "MIT"
+  gem.summary = %Q{ Handles Framecurve files }
+  gem.description = %Q{ Parser, validation and interpolation}
+  gem.email = "me@julik.nl"
+  gem.authors = ["Julik"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/framecurve_validator

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + "/../lib/framecurve"
+require 'term/ansicolor'
+
+class Color
+  extend Term::ANSIColor
+end
+
+raise "Pass at least one path to a framecurve file as a argument" if ARGV.empty?
+
+def print_list(destination, of)
+  of.each do | elem |
+    destination.puts "    * %s" % elem
+  end
+end
+
+ARGV.each do | arg |
+  validator = Framecurve::Validator.new
+  validator.parse_and_validate(arg)
+  
+  unless validator.any_errors? || validator.any_warnings?
+    puts Color.green { "Framecurve file %s TOTALLY OK! Good job!" % arg }
+  else
+    $stderr.puts Color.bold{ arg }
+    if validator.any_errors?
+      $stderr.puts Color.red{ Color.bold { "    The file had the following ERRORS flagged:" % arg }}
+      print_list($stderr, validator.errors)
+    end
+    
+    if validator.any_warnings?
+      $stderr.puts Color.orange{ Color.bold { "    The file was sort of OK but did cause the following warnings:" % arg }}
+      print_list($stderr, validator.warnings)
+    end
+    exit 10
+  end 
+end

data/framecurve.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "framecurve"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Julik"]
+  s.date = "2011-12-30"
+  s.description = " Parser, validation and interpolation"
+  s.email = "me@julik.nl"
+  s.executables = ["framecurve_validator"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "bin/framecurve_validator",
+    "framecurve.gemspec",
+    "lib/framecurve.rb",
+    "lib/framecurve/comment.rb",
+    "lib/framecurve/curve.rb",
+    "lib/framecurve/parser.rb",
+    "lib/framecurve/serializer.rb",
+    "lib/framecurve/tuple.rb",
+    "lib/framecurve/validator.rb",
+    "test/helper.rb",
+    "test/test_framecurve_comment.rb",
+    "test/test_framecurve_curve.rb",
+    "test/test_framecurve_parser.rb",
+    "test/test_framecurve_serializer.rb",
+    "test/test_framecurve_tuple.rb",
+    "test/test_framecurve_validator.rb",
+    "test/test_framecurve_validator_binary.rb"
+  ]
+  s.homepage = "http://github.com/guerilla-di/framecurve"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "Handles Framecurve files"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<term-ansicolor>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<cli_test>, [">= 0"])
+    else
+      s.add_dependency(%q<term-ansicolor>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<cli_test>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<term-ansicolor>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<cli_test>, [">= 0"])
+  end
+end
+

data/lib/framecurve.rb

@@ -0,0 +1,11 @@
+module Framecurve
+  VERSION = "1.0.0"
+  
+  # Is raised when a malformed framecurve bit has occurred in the system
+  class Malformed < RuntimeError
+  end
+end
+
+%w( tuple comment curve parser validator serializer ).each do | f |
+  require File.join(File.dirname(__FILE__), "framecurve", f)
+end

data/lib/framecurve/comment.rb

@@ -0,0 +1,14 @@
+# Represents a framecurve comment
+class Framecurve::Comment < Struct.new(:text)
+  def tuple?
+    false
+  end
+  
+  def comment?
+    true
+  end
+  
+  def to_s
+    ['#', text.to_s.gsub(/\r\n?/, '')].join(' ')
+  end
+end

data/lib/framecurve/curve.rb

@@ -0,0 +1,108 @@
+# Represents a curve file with comments and frame correlation records
+class Framecurve::Curve
+  include Enumerable
+  
+  # If this curve has been generated or parsed from a file, the parser 
+  # will preserve the filename here
+  attr_accessor :filename
+  
+  def initialize(*elements)
+    @elements = elements.flatten
+  end
+  
+  # Iterates over all the tuples in the curve
+  def each_tuple
+    @elements.each do | e |
+      yield(e) if e.tuple?
+    end
+  end
+  
+  # Return the tuples in this curve
+  def only_tuples
+    @elements.select{|e| e.tuple? }
+  end
+  
+  # Iterates over all the elements in the curve
+  def each
+    @elements.each(&Proc.new)
+  end
+  
+  # Iterates over all the comments in the curve
+  def each_comment
+    @elements.each do | e |
+      yield(e) if e.comment?
+    end
+  end
+  
+  # Adds a comment line
+  def comment!(text)
+    @elements.push(Framecurve::Comment.new(text.strip))
+  end
+  
+  # Adds a tuple
+  def tuple!(at, value)
+    t = Framecurve::Tuple.new(at.to_i, value.to_f)
+    # Validate for sequencing
+    if any_tuples?
+      last_frame = only_tuples[-1].at
+      if t.at <= last_frame
+        raise Framecurve::Malformed, "Cannot add a frame that comes before or at the same frame as the previous one (%d after %d)" % [t.at, last_frame]
+      end
+    end
+    
+    @elements.push(t)
+  end
+  
+  # Returns the number of lines in this curve file
+  def length
+    @elements.length
+  end
+  
+  # Tells whether the curve contains any elements
+  def empty?
+    @elements.empty?
+  end
+  
+  # Get a record by offset (line number 0-based)
+  def [](at)
+    @elements[at]
+  end
+  
+  # Tells whether the curve has any tuples at all
+  def any_tuples?
+    @elements.any? {|e| e.tuple? }
+  end
+  
+  # Returns a new curve with the same data with all the intermediate frames interpolated properly
+  # and all the comments except for the preamble removed
+  def to_materialized_curve
+    c = self.class.new
+    c.comment! "http://framecurve.org/specification-v1"
+    c.comment! "at_frame\tuse_frame_of_source"
+    each_defined_tuple {|t|  c.tuple!(t.at, t.value) }
+    return c
+  end
+  
+  # Yields each tuple that is defined by this framecurve in succession.
+  # For example, if the curve contains tuples at (1, 123.45) and (10, 167.89)
+  # this method will yield 10 times for each defined integer frame value
+  def each_defined_tuple
+    tuples = select{|e| e.tuple? }
+    tuples.each_with_index do | tuple, idx |
+      next_tuple = tuples[idx + 1]
+      if next_tuple.nil?
+        yield(tuple)
+      else # Apply linear interpolation
+        dt = next_tuple.at - tuple.at
+        if dt > 1
+          dy = next_tuple.value - tuple.value
+          delta = dy / dt
+          dt.times do | increment |
+            value_inc = delta * increment
+            yield(Framecurve::Tuple.new(tuple.at + increment, tuple.value + value_inc))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/framecurve/parser.rb

@@ -0,0 +1,49 @@
+# Parses the data in the passed file/IO into a Curve object
+class Framecurve::Parser
+  COMMENT = /^#(.+)$/
+  CORRELATION_RECORD = /^([-]?\d+)\t([-]?(\d+(\.\d*)?)|\.\d+)([eE][+-]?[0-9]+)?$/
+  
+  # Parse from file path or IO. If the passed object is an IO it will be read from.
+  # If the passed object is a string it will be interpreted as a path and the file at that path
+  # will be parsed instead
+  def parse(path_or_io)
+    # If the first argument is a path parse from the opened file, 
+    # and record the filename in the curve as well
+    unless path_or_io.respond_to?(:read)
+       curve = File.open(path_or_io, "r", &method(:parse))
+       curve.filename = File.basename(path_or_io)
+       return curve
+    end
+    
+    @line_counter = 0 # IO#lineno is not exactly super-reliable
+    elements = []
+    until path_or_io.eof?
+      str = path_or_io.gets("\n")
+      @line_counter += 1
+      
+      str = str.strip
+      item = if str =~ COMMENT
+        extract_comment(str)
+      elsif str =~ CORRELATION_RECORD
+        extract_tuple(str)
+      else
+        raise Framecurve::Malformed, "Malformed line #{str.inspect} at offset #{path_or_io.pos}, line #{@line_counter}"
+      end
+      elements.push(item)
+    end
+    
+    return Framecurve::Curve.new(elements)
+  end
+  
+  private
+  def extract_comment(line)
+    comment_txt = line.scan(COMMENT).flatten[0].strip
+    Framecurve::Comment.new(comment_txt)
+  end
+  
+  def extract_tuple(line)
+    slots = line.scan(CORRELATION_RECORD).flatten
+    Framecurve::Tuple.new(slots[0].to_i, slots[1].to_f)
+  end
+  
+end

data/lib/framecurve/serializer.rb

@@ -0,0 +1,13 @@
+# Writes out a Curve object to the passed IO
+class Framecurve::Serializer
+  # Serialize the passed curve into io. Will use the materialized curve version.
+  # Will write the file with CRLF linebreaks instead of LF
+  def serialize(io, curve)
+    io.write("# http://framecurve.org/specification-v1\n")
+    io.write("# at_frame\tuse_frame_of_source\n")
+    curve.to_materialized_curve.each_tuple do | t |
+      io.write(t)
+      io.write("\r\n")
+    end
+  end
+end

data/lib/framecurve/tuple.rb

@@ -0,0 +1,20 @@
+# Represents one Framecurve frame correlation record
+class Framecurve::Tuple < Struct.new(:at, :value)
+  include Comparable
+  
+  def tuple?
+    true
+  end
+  
+  def comment?
+    false
+  end
+  
+  def to_s
+    "%d\t%.5f" % [at, value]
+  end
+  
+  def <=>(another)
+    to_s <=> another.to_s
+  end
+end

data/lib/framecurve/validator.rb

@@ -0,0 +1,94 @@
+# Validates a Curve object for well-formedness and completeness.
+#   v = Validator.new
+#   v.parse(io_handle)
+#   v.errors => []
+#   v.warnings => ["Do not put cusswords in your framecurves"]
+class Framecurve::Validator
+  attr_reader :warnings, :errors
+  
+  def initialize
+    @warnings, @errors = [], []
+  end
+  
+  def any_errors?
+    @errors.any?
+  end
+  
+  def any_warnings?
+    @warnings.any?
+  end
+  
+  # Parse and validate a file (API similar to Parser#parse)
+  def parse_and_validate(path_or_io)
+    begin
+      validate(Framecurve::Parser.new.parse(path_or_io))
+    rescue Framecurve::Malformed => e
+      @errors.push(e.message)
+    end
+  end
+  
+  # Validate a passed Curve object
+  def validate(curve)
+    initialize # reset
+    methods_matching(/^(verify|recommend)/).each do | method_name |
+      method(method_name).call(curve)
+    end
+  end
+  
+  private
+  
+  def methods_matching(pattern)
+    private_methods.select { |m|  m.to_s =~ pattern }
+  end
+  
+  def verify_at_least_one_line(curve)
+    @errors.push("The framecurve did not contain any lines at all") if curve.empty?
+  end
+  
+  def verify_at_least_one_tuple(curve)
+    first_tuple = curve.find{|e| e.tuple? }
+    @errors.push("The framecurve did not contain any frame correlation records") unless first_tuple
+  end
+  
+  def verify_proper_sequencing(curve)
+    tuples = curve.select{|e| e.tuple? }
+    frame_numbers = tuples.map{|t| t.at }
+    proper_sequence = frame_numbers.sort
+    
+    unless frame_numbers == proper_sequence
+      @errors.push("The frame sequencing is out of order " + 
+      "(expected #{proper_sequence.inspect} but got #{frame_numbers.inspect})." +
+      " The framecurve spec mandates that frames are recorded sequentially") 
+    end
+  end
+  
+  def verify_file_naming(curve)
+    return unless curve.respond_to?(:filename) && curve.filename
+    unless curve.filename =~ /\.framecurve\.txt$/
+      @errors.push("The framecurve file has to have the .framecurve.txt double extension, but had %s" % File.extname(curve.filename).inspect)
+    end
+  end
+  
+  def verify_no_duplicate_records(curve)
+    detected_dupes = []
+    curve.each do | t |
+      next unless t.tuple?
+      next if detected_dupes.include?(t.at)
+      elements = curve.select{|e| e.tuple? && e.at == t.at }
+      if elements.length > 1
+        detected_dupes.push(t.at)
+        @errors.push("The framecurve contains the same frame (%d) twice or more (%d times)" % [t.at, elements.length])
+      end
+    end
+  end
+  
+  def recommend_proper_preamble(curve)
+    first_comments = curve.map do | e |
+      break unless e.comment?
+      e
+    end
+  end
+  
+  def recommend_proper_column_headers(curve)
+  end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+require 'stringio'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'framecurve'
+require 'cli_test'

data/test/test_framecurve_comment.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestFramecurveComment < Test::Unit::TestCase
+  def test_not_tuple
+    assert Framecurve::Comment.new.comment?
+    assert !Framecurve::Comment.new.tuple?
+  end
+  
+  def test_initialization
+    c = Framecurve::Comment.new("Very interesting \r\n comment")
+    assert_equal "Very interesting \r\n comment", c.text
+    assert_equal "# Very interesting  comment", c.to_s
+  end
+  
+  def test_initialization_with_nil_produces_usable_to_s
+    c = Framecurve::Comment.new(nil)
+    assert_equal "# ", c.to_s
+  end
+end

data/test/test_framecurve_curve.rb

@@ -0,0 +1,107 @@
+require 'helper'
+
+class TestFramecurveCurve < Test::Unit::TestCase
+  def test_init_with_empty_array
+    c = Framecurve::Curve.new([])
+    assert c.empty?
+    assert !c.any?
+  end
+  
+  def test_init_with_no_arguments
+    c = Framecurve::Curve.new
+    assert c.empty?
+    assert !c.any?
+  end
+  
+  def test_init_with_one_tuple
+    c = Framecurve::Curve.new( Framecurve::Tuple.new(10, 123))
+    assert !c.empty?
+    assert_equal 1, c.length
+    items = c.to_a
+    assert_equal [Framecurve::Tuple.new(10, 123)], c.to_a
+  end
+  
+  def test_each_tuple
+    c = Framecurve::Curve.new( Framecurve::Comment.new("Welcome"), Framecurve::Tuple.new(10, 123))
+    assert !c.empty?
+    assert_equal 2, c.length
+    tuples = []
+    c.each_tuple(&tuples.method(:push))
+    assert_equal [Framecurve::Tuple.new(10, 123)], tuples
+  end
+  
+  def test_only_tuples
+    c = Framecurve::Curve.new( Framecurve::Comment.new("Welcome"), Framecurve::Tuple.new(10, 123))
+    assert !c.empty?
+    tuples = c.only_tuples
+    assert_equal [Framecurve::Tuple.new(10, 123)], tuples
+  end
+  
+  def test_each_comment
+    c = Framecurve::Curve.new( Framecurve::Comment.new("Welcome"), Framecurve::Tuple.new(10, 123))
+    assert !c.empty?
+    comments = []
+    c.each_comment(&comments.method(:push))
+    assert_equal [Framecurve::Comment.new("Welcome")], comments
+  end
+  
+  def test_subscript
+    c = Framecurve::Curve.new( Framecurve::Comment.new("Welcome"), Framecurve::Tuple.new(10, 123))
+    assert_equal Framecurve::Comment.new("Welcome"), c[0]
+    assert_equal Framecurve::Tuple.new(10, 123), c[1]
+  end
+  
+  def test_comment!
+    c = Framecurve::Curve.new
+    c.comment!("Also")
+    assert !c.empty?
+    assert_equal Framecurve::Comment.new("Also"), c[0]
+  end
+  
+  def test_tuple!
+    c = Framecurve::Curve.new
+    c.tuple!(10, 123.45)
+    assert !c.empty?
+    assert_equal Framecurve::Tuple.new(10, 123.45), c[0]
+  end
+  
+  def test_raises_malformed_with_tuple_at_duplicate_frame
+    c = Framecurve::Curve.new
+    c.tuple!(10, 123.45)
+    assert_raise(Framecurve::Malformed) do
+      c.tuple!(10, 456.45)
+    end
+  end
+  
+  def test_filaneme_accessor
+    c = Framecurve::Curve.new
+    assert_nil c.filename
+    c.filename = "foo.framecurve.txt"
+    assert_equal "foo.framecurve.txt", c.filename
+  end
+  
+  def test_teach_defined_tuple
+    c = Framecurve::Curve.new(Framecurve::Tuple.new(1, 123.45), Framecurve::Tuple.new(10, 567.89))
+    concrete = []
+    c.each_defined_tuple(&concrete.method(:push))
+    ref = [
+      Framecurve::Tuple.new(1, 123.450000),
+      Framecurve::Tuple.new(2, 172.83222222222224),
+      Framecurve::Tuple.new(3, 222.21444444444444),
+      Framecurve::Tuple.new(4, 271.5966666666667),
+      Framecurve::Tuple.new(5, 320.9788888888889),
+      Framecurve::Tuple.new(6, 370.36111111111114),
+      Framecurve::Tuple.new(7, 419.74333333333334),
+      Framecurve::Tuple.new(8, 469.12555555555554),
+      Framecurve::Tuple.new(9, 518.5077777777778),
+      Framecurve::Tuple.new(10, 567.89),
+    ]
+    assert_equal ref, concrete
+  end
+  
+  def test_materialized_curve
+    c = Framecurve::Curve.new(Framecurve::Tuple.new(1, 123.45), Framecurve::Tuple.new(10, 567.89))
+    materialized = c.to_materialized_curve
+    assert_equal 12, materialized.length
+  end
+end

data/test/test_framecurve_parser.rb

@@ -0,0 +1,57 @@
+require 'helper'
+
+class TestFramecurveParser < Test::Unit::TestCase
+  def test_parser
+    data = ["# Framecurve data", "10\t1293.12", "#Some useful info", "10\t145"].join("\r\n")
+    p = Framecurve::Parser.new
+    elements = p.parse(StringIO.new(data))
+    assert_kind_of Framecurve::Curve, elements
+    
+    assert_equal 4, elements.length
+    
+    assert_kind_of Framecurve::Comment, elements[0]
+    assert_kind_of Framecurve::Tuple, elements[1]
+    assert_kind_of Framecurve::Comment, elements[2]
+    assert_kind_of Framecurve::Tuple, elements[3]
+    
+    assert_equal "Framecurve data", elements[0].text
+    assert_equal Framecurve::Tuple.new(10, 1293.12), elements[1]
+    assert_equal "Some useful info", elements[2].text
+  end
+  
+  def test_parse_with_neg_source_frame
+    data = "10\t-1293.12"
+    elements = Framecurve::Parser.new.parse(StringIO.new(data))
+    assert_kind_of Framecurve::Curve, elements
+    
+    assert_equal 1, elements.length
+    assert_kind_of Framecurve::Tuple, elements[0]
+    assert_equal Framecurve::Tuple.new(10, -1293.12), elements[0]
+  end
+  
+  def test_parse_with_neg_dest_frame
+    data = "-123\t-1293.12"
+    elements = Framecurve::Parser.new.parse(StringIO.new(data))
+    assert_kind_of Framecurve::Curve, elements
+    
+    assert_equal 1, elements.length
+    assert_kind_of Framecurve::Tuple, elements[0]
+    assert_equal Framecurve::Tuple.new(-123, -1293.12), elements[0]
+  end
+  
+  def test_should_try_to_open_file_at_path_if_string_passed_to_parse
+    v = Framecurve::Parser.new
+    assert !File.exist?("/tmp/some_file.framecurve.txt")
+    assert_raise(Errno::ENOENT) do
+      v.parse("/tmp/some_file.framecurve.txt")
+    end
+  end
+  
+  def test_parser_fails_on_malformed_lines
+    data = "Sachlich gesehen\nbambam"
+    assert_raise(Framecurve::Malformed) do
+      Framecurve::Parser.new.parse(StringIO.new(data))
+    end
+  end
+  
+end

data/test/test_framecurve_serializer.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class TestFramecurveSerializer < Test::Unit::TestCase
+  def test_output
+    f = Framecurve::Curve.new(Framecurve::Tuple.new(10, 123))
+    s = StringIO.new
+    Framecurve::Serializer.new.serialize(s, f)
+    assert_equal "# http://framecurve.org/specification-v1\n# at_frame\tuse_frame_of_source\n10\t123.00000\r\n", s.string
+  end
+  
+  def test_materializes_frames
+    f = Framecurve::Curve.new(Framecurve::Tuple.new(10, 123), Framecurve::Tuple.new(12, 456))
+    s = StringIO.new
+    Framecurve::Serializer.new.serialize(s, f)
+    assert_equal "# http://framecurve.org/specification-v1\n# at_frame\tuse_frame_of_source\n10\t123.00000\r\n11\t289.00000\r\n12\t456.00000\r\n", s.string
+  end
+end

data/test/test_framecurve_tuple.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+class TestFramecurveTuple < Test::Unit::TestCase
+  def test_initialization
+    t = Framecurve::Tuple.new(123, 645.1458)
+    assert_equal 123, t.at
+    assert_equal 645.1458, t.value
+    assert_equal "123\t645.14580", t.to_s
+  end
+  
+  def test_not_comment
+    assert !Framecurve::Tuple.new.comment?
+    assert Framecurve::Tuple.new.tuple?
+  end
+  
+  def test_vlidates_equality_to_5_decimal_places
+    t = Framecurve::Tuple.new(1, 1234.567890)
+    t2 = Framecurve::Tuple.new(1, 1234.567891)
+    t3 = Framecurve::Tuple.new(1, 1234.567884)
+    
+    assert_equal t, t2
+    assert_not_equal t, t3
+  end
+end

data/test/test_framecurve_validator.rb

@@ -0,0 +1,78 @@
+require 'helper'
+
+class TestFramecurveValidator < Test::Unit::TestCase
+  
+  def test_should_error_out_with_malformed_input_to_parse_and_validate
+    v = Framecurve::Validator.new
+    io = StringIO.new("foobar")
+    v.parse_and_validate(io)
+    assert v.any_errors?
+    assert_equal ["Malformed line \"foobar\" at offset 6, line 1"], v.errors
+  end
+  
+  def test_should_not_error_out_with_good_input_to_parse_and_validate
+    v = Framecurve::Validator.new
+    io = StringIO.new("# Nice framecurve\r\n1\t146.0")
+    v.parse_and_validate(io)
+    assert !v.any_errors?
+  end
+  
+  def test_should_try_to_open_file_at_path_if_string_passed_to_parse_and_validate
+    v = Framecurve::Validator.new
+    assert_raise(Errno::ENOENT) do
+      v.parse_and_validate("/tmp/some_file.framecurve.txt")
+    end
+  end
+  
+  def test_should_record_filename_error_with_improper_extension
+    File.open("wrong.extension", "wb"){|f| f.write("# This might have been\r\n1\t123.45") }
+    begin
+      v = Framecurve::Validator.new
+      v.parse_and_validate("wrong.extension")
+      assert v.any_errors?
+      assert_equal ["The framecurve file has to have the .framecurve.txt double extension, but had \".extension\""], v.errors
+    ensure
+      File.unlink("wrong.extension")
+    end
+  end
+  
+  def test_should_init_with_empty_errors_and_warnings
+    v = Framecurve::Validator.new
+    assert !v.any_errors?
+    assert !v.any_warnings?
+    assert_equal [], v.errors
+    assert_equal [], v.warnings
+  end
+  
+  def test_should_error_out_with_empty
+    v = Framecurve::Validator.new
+    v.validate([])
+    assert v.any_errors?
+    assert_equal ["The framecurve did not contain any lines at all",
+     "The framecurve did not contain any frame correlation records"], v.errors
+  end
+  
+  def test_should_error_out_without_actual_tuples
+    c = Framecurve::Curve.new( Framecurve::Comment.new("Only text") )
+    v = Framecurve::Validator.new
+    v.validate(c)
+    assert v.any_errors?
+    assert_equal ["The framecurve did not contain any frame correlation records"], v.errors
+  end
+  
+  def test_should_error_out_with_dupe_frames
+    c = Framecurve::Curve.new( Framecurve::Tuple.new(10, 123.4), Framecurve::Tuple.new(10, 123.4) )
+    v = Framecurve::Validator.new
+    v.validate(c)
+    assert v.any_errors?
+    assert_equal ["The framecurve contains the same frame (10) twice or more (2 times)"], v.errors
+  end
+  
+  def test_should_error_out_with_improper_sequencing
+    c = Framecurve::Curve.new( Framecurve::Tuple.new(10, 123.4), Framecurve::Tuple.new(1, 123.4) )
+    v = Framecurve::Validator.new
+    v.validate(c)
+    assert v.any_errors?
+    assert_equal ["The frame sequencing is out of order (expected [1, 10] but got [10, 1]). The framecurve spec mandates that frames are recorded sequentially"], v.errors
+  end
+end

data/test/test_framecurve_validator_binary.rb

@@ -0,0 +1,51 @@
+require 'helper'
+require "fileutils"
+
+class TestFramecurveValidatorBinary < Test::Unit::TestCase
+  BINARY = File.expand_path(File.dirname(__FILE__) + "/../bin/framecurve_validator")
+  GOOD_FC_PATH = "simple.framecurve.txt"
+  BAD_FC_PATH = "crap"
+  
+  # Run the binary under test with passed options, and return [exit_code, stdout_content, stderr_content]
+  def cli(commandline_arguments)
+    CLITest.new(BINARY).run(commandline_arguments)
+  end
+  
+  def setup
+    File.open(GOOD_FC_PATH, "wb") do | f |
+      c = Framecurve::Curve.new(Framecurve::Tuple.new(10, 123.45))
+      Framecurve::Serializer.new.serialize(f, c)
+    end
+    
+    File.open(BAD_FC_PATH, "wb") do | f |
+      f.write("This is gibberish")
+    end
+  end
+  
+  def teardown
+    File.unlink(GOOD_FC_PATH) if File.exist?(GOOD_FC_PATH)
+    File.unlink(BAD_FC_PATH) if File.exist?(BAD_FC_PATH)
+    File.unlink(GOOD_FC_PATH + ".tmp") if File.exist?(GOOD_FC_PATH + ".tmp")
+  end
+  
+  def test_cli_with_valid_file
+    s, o, e = cli(File.expand_path(GOOD_FC_PATH))
+    assert_equal 0, s
+    assert o.include?("OK!")
+    assert_equal '', e
+  end
+  
+  def test_cli_with_bad_file
+    s, o, e = cli(File.expand_path(BAD_FC_PATH))
+    assert_equal 10, s, "The exit status on fail should not be 0"
+    assert e.include?("ERRORS")
+  end
+  
+  def test_cli_with_bad_filename_extension
+    FileUtils.cp(GOOD_FC_PATH, GOOD_FC_PATH + ".tmp")
+    s, o, e = cli(File.expand_path(GOOD_FC_PATH + ".tmp"))
+    assert_equal 10, s, "The exit status on fail should not be 0"
+    assert e.include?("but had \".tmp\"")
+  end
+  
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: framecurve
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Julik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: &10799030 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *10799030
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &10798700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *10798700
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &10798440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10798440
+- !ruby/object:Gem::Dependency
+  name: cli_test
+  requirement: &10798170 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10798170
+description: ! ' Parser, validation and interpolation'
+email: me@julik.nl
+executables:
+- framecurve_validator
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- bin/framecurve_validator
+- framecurve.gemspec
+- lib/framecurve.rb
+- lib/framecurve/comment.rb
+- lib/framecurve/curve.rb
+- lib/framecurve/parser.rb
+- lib/framecurve/serializer.rb
+- lib/framecurve/tuple.rb
+- lib/framecurve/validator.rb
+- test/helper.rb
+- test/test_framecurve_comment.rb
+- test/test_framecurve_curve.rb
+- test/test_framecurve_parser.rb
+- test/test_framecurve_serializer.rb
+- test/test_framecurve_tuple.rb
+- test/test_framecurve_validator.rb
+- test/test_framecurve_validator_binary.rb
+homepage: http://github.com/guerilla-di/framecurve
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Handles Framecurve files
+test_files: []