spanbars 0.1.2beta

data/features/support/ref3_out_0.0000005_10.csv

@@ -0,0 +1,47 @@
+simple,1555027810103,0.009,1555028866704,0.0090015,1555028361598,0.0089965,1555028866704,0.0090015,1056,3.65e-05,3.0e-08,3,bottom
+strict,1555028361598,0.0089965,1555028875619,0.0090015,514,2.2e-05,4.0e-08,10,up
+simple,1555028868208,0.009001,1555028875619,0.0090015,1555029270853,0.0089965,1555029270853,0.0089965,402,1.65e-05,4.0e-08,-9,top
+strict,1555028875620,0.0090015,1555029674690,0.0089945,799,4.4e-05,6.0e-08,-13,down
+simple,1555029271053,0.008997,1555030003672,0.009,1555029674690,0.0089945,1555030003672,0.009,732,4.2e-05,6.0e-08,5,bottom
+strict,1555029674691,0.0089945,1555030015594,0.0090005,340,1.6e-05,5.0e-08,11,up
+simple,1555030007679,0.0089995,1555030015594,0.0090005,1555030283081,0.008995,1555030283081,0.008995,275,1.65e-05,6.0e-08,-9,top
+simple,1555030284285,0.0089955,1555030318652,0.008997,1555030344002,0.0089905,1555030344002,0.0089905,59,1.6e-05,2.7e-07,-9,top
+simple,1555030344202,0.008991,1555030399708,0.008994,1555030421650,0.008988,1555030421650,0.008988,77,1.9e-05,2.5e-07,-6,top
+strict,1555030015595,0.0090005,1555030424755,0.008988,409,5.35e-05,1.3e-07,-24,down
+simple,1555030421750,0.0089885,1555030479161,0.0089935,1555030424755,0.008988,1555030479161,0.0089935,57,1.4e-05,2.5e-07,9,bottom
+simple,1555030487477,0.0089925,1555030508723,0.0089955,1555030492488,0.00899,1555030508723,0.0089955,21,1.8e-05,8.6e-07,5,bottom
+strict,1555030424756,0.008988,1555030678129,0.0089965,253,5.25e-05,2.1e-07,16,up
+simple,1555030508824,0.008995,1555030678129,0.0089965,1555030801155,0.008991,1555030801155,0.008991,292,3.4e-05,1.2e-07,-7,top
+simple,1555030801856,0.0089915,1555030913566,0.0089945,1555031382526,0.0089895,1555031382526,0.0089895,580,2.0e-05,3.0e-08,-4,top
+strict,1555030678130,0.0089965,1555031563056,0.0089875,884,4.7e-05,5.0e-08,-17,down
+simple,1555031385132,0.00899,1555032144345,0.008993,1555031563056,0.0089875,1555032144345,0.008993,759,2.9e-05,4.0e-08,5,bottom
+simple,1555032154368,0.0089935,1555034282118,0.0089965,1555032392101,0.008991,1555034282118,0.0089965,2127,4.5e-05,2.0e-08,5,bottom
+strict,1555031563057,0.0089875,1555036341361,0.0089975,4778,0.000101,2.0e-08,19,up
+simple,1555034340129,0.008996,1555036341361,0.0089975,1555039961893,0.008992,1555039961893,0.008992,5621,8.0e-05,1.0e-08,-8,top
+simple,1555039967000,0.0089915,1555043323622,0.008995,1555047080899,0.0089895,1555047080899,0.0089895,7113,8.1e-05,1.0e-08,-4,top
+strict,1555036341362,0.0089975,1555047900711,0.008986,11559,0.0001415,1.0e-08,-22,down
+simple,1555047086109,0.00899,1555049115751,0.008991,1555047900711,0.008986,1555049115751,0.008991,2029,4.1e-05,2.0e-08,2,bottom
+strict,1555047900712,0.008986,1555049115751,0.008991,1215,2.3e-05,2.0e-08,9,up
+simple,1555049144807,0.0089905,1555049285467,0.0089905,1555050220412,0.008985,1555050220412,0.008985,1075,2.45e-05,2.0e-08,-11,down
+simple,1555050221113,0.0089855,1555051580965,0.008988,1555054260302,0.0089825,1555054260302,0.0089825,4039,8.4e-05,2.0e-08,-6,top
+simple,1555054282243,0.008983,1555055459355,0.0089855,1555056264677,0.0089795,1555056264677,0.0089795,1982,4.45e-05,2.0e-08,-7,top
+strict,1555049115752,0.008991,1555058550101,0.0089755,9434,0.0002295,2.0e-08,-31,down
+simple,1555056264776,0.008979,1555060529342,0.008981,1555058550101,0.0089755,1555060529342,0.008981,4264,0.00012,3.0e-08,4,bottom
+strict,1555058550102,0.0089755,1555061122664,0.008985,2572,6.05e-05,2.0e-08,18,up
+simple,1555060537257,0.0089815,1555061122664,0.008985,1555062281053,0.0089795,1555062281053,0.0089795,1743,3.9e-05,2.0e-08,-4,top
+simple,1555062289070,0.00898,1555063319883,0.0089815,1555065802473,0.008976,1555065802473,0.008976,3513,8.6e-05,2.0e-08,-8,top
+simple,1555065836939,0.0089765,1555066423283,0.008979,1555069022947,0.0089735,1555069022947,0.0089735,3186,7.0e-05,2.0e-08,-5,top
+strict,1555061122665,0.008985,1555069050906,0.0089735,7928,0.0001825,2.0e-08,-22,down
+simple,1555069039183,0.008974,1555072066248,0.008979,1555069050906,0.0089735,1555072066248,0.008979,3027,8.4e-05,3.0e-08,9,bottom
+strict,1555069050907,0.0089735,1555072173333,0.008979,3122,8.75e-05,3.0e-08,10,up
+simple,1555072070359,0.0089785,1555072173333,0.008979,1555072345801,0.0089735,1555072345801,0.0089735,275,1.6e-05,6.0e-08,-9,top
+strict,1555072173334,0.008979,1555072989884,0.008973,816,4.0e-05,5.0e-08,-11,down
+simple,1555072349612,0.008974,1555074429826,0.0089785,1555072989884,0.008973,1555074429826,0.0089785,2080,5.15e-05,2.0e-08,9,bottom
+simple,1555074484800,0.008978,1555077606252,0.008981,1555076788548,0.0089755,1555077606252,0.008981,3121,8.0e-05,3.0e-08,5,bottom
+strict,1555072989885,0.008973,1555077646209,0.0089845,4656,0.0001125,2.0e-08,22,up
+simple,1555077609865,0.0089805,1555077646209,0.0089845,1555080336231,0.008979,1555080336231,0.008979,2726,0.0001085,4.0e-08,-3,top
+simple,1555080341046,0.0089795,1555080428210,0.0089805,1555080984657,0.008975,1555080984657,0.008975,643,2.45e-05,4.0e-08,-8,top
+simple,1555080994388,0.0089755,1555082504200,0.008977,1555084253820,0.0089715,1555084253820,0.0089715,3259,0.000118,4.0e-08,-8,top
+simple,1555084253921,0.008971,1555084551227,0.008974,1555095538507,0.0089685,1555095538507,0.0089685,11284,0.0001765,2.0e-08,-4,top
+strict,1555077646210,0.0089845,1555095737956,0.0089655,18091,0.000441,2.0e-08,-37,down
+simple,1555095544426,0.008967,1555098169130,0.008971,1555095737956,0.0089655,1555098169130,0.008971,2624,8.2e-05,3.0e-08,8,bottom

data/lib/spanbar.rb

@@ -0,0 +1,147 @@
+# A model for SpanBars
+class SpanBar
+
+  attr_reader :type, :resources, :open, :high, :low, :close, :highval, :lowval
+
+  # Checks if instance has a type and is not :error
+  def valid? 
+    not (@type.nil? or @type == :error)
+  end
+
+  # Calculates the path of the instance, i.e. sums up all moves, regardless of up or down
+  def path
+    return @path unless @path.nil?
+    prev = @resources[0][:p]
+    @path = 0 
+    1.upto(@resources.size-1) do |i| 
+      @path += (@resources[i][:p] - prev).abs
+      prev  =  @resources[i][:p]
+    end
+    @path
+  end
+
+  # @!visibility private
+  def start; @start  ||= @openval[:t];  end
+  # @!visibility private
+  def end;   @end    ||= @closeval[:t]; end
+
+  # Calculates the momentum, i.e. the speed of move in current instance
+  def momentum
+    @momentum ||= self.path.to_f / @duration
+  end
+
+  # Creates a new instance
+  #
+  # @option b [Array] expects an Array of measures in format [ {t: <timestamp>, p: <value>}, ... ] 
+  # @option ticksize [Float] The ticksize of underlying processor (defaults to 1.0)
+  # @option strict   [Boolean] Whether this is a strict or a simple SpanBar (defaults to :true)
+  def initialize(b, ticksize = 1.0, strict = true)
+    a = b.dup.flatten.compact
+    return if a.nil? or a.empty?
+
+    # Quick helper to calculate the amount of decimals in the ticksize
+    def decimals(a); num = 0; while (a != a.to_i); num += 1; a *= 10; end; num; end
+
+    @ticksize   = ticksize
+    @format     = "%1.#{decimals(@ticksize)}f"
+    @strict     = strict
+    @openval    = a[0]
+    @closeval   = a[-1]
+    @highval    = a.reverse.max_by{|x| x[:p]}
+    @lowval     = a.reverse.min_by{|x| x[:p]}
+    @open       = @openval[:p]
+    @high       = @highval[:p]
+    @low        = @lowval[:p]
+    @close      = @closeval[:p]
+    @duration   = (@closeval[:t] - @openval[:t]) / 1000
+    @resources  = a 
+    @path       = self.path
+    @momentum   = self.momentum.round(8)
+    if @high == @close
+      @type =  @low  == @open ? :up     : :bottom
+    elsif @low == @close
+      @type =  @high == @open ? :down   : :top
+    else
+      @type = :error
+    end
+    raise "Validation error: Type must be :up or :down for #{self.inspect}" if @strict and not [:up,:down].include?(@type)
+  end
+
+  # Method that splits the @resources Array (containing all measures of the bar) at peak
+  #
+  # @option peak (Symbol) Can be either :high or :low
+  def split_for(peak)
+    tmp0 = []
+    case peak
+    when :high
+      tmp0.prepend(@resources.pop) while @resources.last[:p] < @high
+    when :low
+      tmp0.prepend(@resources.pop) while @resources.last[:p] > @low
+    else
+      raise "Unknown peak #{peak} found in :split_for."
+    end
+    return [ @resources, tmp0 ]
+  end
+
+  # For human output, set output
+  def set_intraday
+    @intraday = true
+  end
+
+  # Returns an inspection string
+  def inspect
+    pval = lambda {|val| "#{val[:t]}::#{@format % val[:p]}" }
+    if @strict
+      return "<#SpanBar:0x00#{self.object_id.to_s(16)}, #{@strict ? "strict" : "simple"}, :#{@type
+                           },\tpath: #{"%g" % self.path}, momentum: #{"%g" % self.momentum
+                           }, open: #{pval.(@openval)}, close: #{pval.(@closeval)}>"
+    else
+      return "<#SpanBar:0x00#{self.object_id.to_s(16)}, #{@strict ? "strict" : "simple"}, :#{@type
+                           },\tpath: #{"%g" % self.path}, momentum: #{"%g" % self.momentum
+                           }, open: #{pval.(@openval)}, high: #{pval.(@highval)
+                           }, low: #{ pval.(@lowval)}, close: #{pval.(@closeval)}>"
+    end
+  end
+
+  # Return human readable output of instance
+  def to_human
+    if @intraday 
+      time = lambda{|t| now = (t / 1000) % 86400; "#{"%02d" % (now/3600)}:#{"%02d" % ((now%3600)/60)}:#{"%02d" % (now%60)}" }
+    else
+      time = lambda{|t| Time.at(t/1000).strftime("%Y %b %d %H:%M:%S")}
+    end
+    pval = lambda {|v| "[#{time.(v[:t])}, #{@format % v[:p]}]" }
+    if @strict 
+      return "STRICT, OPEN: #{pval.(@openval)}, CLOSE: #{pval.(@closeval)
+           }, MOM: #{"%g" % (@momentum / @ticksize) },\tDUR: #{@duration
+           },\tEFF: #{((@close - @open) / @ticksize).to_i}, :#{@type.to_s.upcase}"
+    else
+      return "SIMPLE, OPEN: #{pval.(@openval)
+      }, #{ ([:up, :bottom].include? @type) ? "LOW: #{pval.(@lowval)}" : "HIGH #{pval.(@highval)}" 
+      }, CLOSE: #{pval.(@closeval)}, MOM: #{"%g" % (@momentum / @ticksize) 
+      },\tDUR: #{@duration},\tEFF: #{((@close - @open) / @ticksize).to_i}, :#{@type.to_s.upcase}"
+    end
+  end
+
+  # Returns an array containing instance values as needed for CSV output
+  def to_a
+    if @strict
+      return [ "strict", 
+               @openval[:t],  @openval[ :p].round(8),
+               @closeval[:t], @closeval[:p].round(8),
+               @duration, @path.round(8), @momentum.round(8),
+             ((@close - @open) / @ticksize).to_i, 
+             @type ]
+    else 
+      return [ "simple", 
+               @openval[:t],  @openval[ :p].round(8),
+               @highval[:t],  @highval[ :p].round(8),
+               @lowval[:t],   @lowval[  :p].round(8),
+               @closeval[:t], @closeval[:p].round(8),
+               @duration, @path.round(8), @momentum.round(8),
+             ((@close - @open) / @ticksize).to_i,
+             @type ]
+    end 
+  end
+end
+

data/lib/spanbarprocessor.rb

@@ -0,0 +1,196 @@
+require 'slop'
+require 'csv'
+require 'colorize'
+
+
+# SpanBarHelpers includes some little helpers for convenient usage in SpanBarProcessor
+module SpanBarHelpers
+
+  # creates a new upfollowing tick that has a minimum higher value than the preceeding one
+  #
+  # @param a [Float]
+  # @param t [Integer]
+  def tickup(a,t=1)
+    { p: a[:p] + 0.000000001, t: a[:t] + t }
+  end
+
+  # creates a new upfollowing tick that has a minimum lower value than the preceeding one
+  #
+  # @param a [Float]
+  # @param t [Integer]
+  def tickdown(a,t=1)
+    { p: a[:p] - 0.000000001, t: a[:t] + t }
+  end
+end
+
+# The main working class 
+class SpanBarProcessor
+  include SpanBarHelpers
+
+  # Convenient generator for testing purposes
+  #
+  # @!visibility private
+  def self.generate_random
+    p = self.new(5,1)
+    i = 5
+    t = 1
+    s = true
+    while s == true
+      s = p.add(t,i)
+      t += 1 + (Random.rand * 10 ).to_i
+      i += Random.rand > 0.5 ? 1 : -1
+    end
+    s
+  end
+
+  attr_reader :simpleBar, :simpleBars, :spanBars
+
+  # Creates a new instance of SpanBarProcessor
+  #
+  # @param opts [Hash]
+  # @option opts [Integer] :span     The span to filter for (defaults to 10)
+  # @option opts [Float]   :ticksize The ticksize to apply on timeseries (defaults to 1.0)
+  # @option opts [Boolean] :simple   Whether to only create simple bars. (defaults to false)
+  # @option opts [Boolean] :both     Whether to output simple AND strict bars. (defaults to false, overrides :simple)
+
+  def initialize(opts = {})
+    @span = opts[:span].nil? ? 10 : opts[:span] 
+    raise ArgumentError, "Span must by of type Integer and > 1" unless @span.is_a? Integer and @span > 1
+    @ts     = opts[:ticksize].nil? ? 1.0 : opts[:ticksize]
+    raise ArgumentError, "Ticksize must be Numeric, i.e. Integer, Float, ..." unless @ts.is_a? Numeric and @ts > 0
+    @simple = opts[:simple].nil? ? false : opts[:simple] 
+    if opts[:both] == true
+      @simple = false
+      @both   = true
+    else
+      @both   = false
+    end
+    @limit  = @ts * @span
+    @simpleMax, @simpleMin = 0, Float::INFINITY
+    @simpleBar  = []
+    @simpleBars = []
+    @spanBars   = [] 
+    @ticks  = []
+  end
+
+  # Sends a new items of the timeseries
+  #
+  # @option t [Integer] The timestamp (preferrably in JS format, i.e. Milliseconds since 1970-01-01)
+  # @option p [Float]   The value
+  def add(t, p)
+    raise ArgumentError, "SpanBar#add requires either an Integer (Timestamp) or a Time object as first argument" unless [Integer, Time].include?(t.class)
+    raise ArgumentError, "SpanBar#add requires either a Numeric or NilClass as second argument" unless p.is_a? Numeric or p.nil?
+    return nil if p.nil?
+    tick = {t: (t.class == Integer ? t : t.to_i), p: p.to_f}
+    @simpleBar << tick
+    @simpleMax = [tick[:p],@simpleMax].max
+    @simpleMin = [tick[:p],@simpleMin].min
+    if @simpleMax - @simpleMin > @limit
+      simple = SpanBar.new(@simpleBar, @ts, false)
+      unless @simple
+        result = self.create_strict_from(simple)
+      end
+      @simpleBars << simple
+      @simpleMax, @simpleMin = 0, Float::INFINITY
+      @simpleBar = []
+      if @simple 
+        return [ simple ] # we need an Array from caller
+      else
+        begin 
+          result << simple if @both and simple 
+        rescue 
+          return [ simple ] 
+        end
+        return result
+      end
+    end
+    return false
+  end
+
+  # Private method to further process simple bars to strict bars
+  #
+  # @option simple [SpanBar]
+  def create_strict_from(simple)
+    elem0 = @currentBar
+    elem1 = simple
+
+    res   = [ ]
+    if elem0.nil?  # means this is the very first chunk working on
+      case elem1.type
+      when :bottom
+        tmp0, tmp1 = elem1.split_for :low
+        @currentBar = SpanBar.new([tmp0.last, tmp1], @ts)
+      when :top
+        tmp0, tmp1 = elem1.split_for :high
+        @currentBar = SpanBar.new([tmp0.last, tmp1], @ts)
+      when *[:up,:down]
+        @currentBar = elem1
+      else
+        raise "Invalid type for initial simple SpanBar #{elem0}"
+      end
+    else           # otherwise there is already a preceding element
+      case elem0.type
+      when :up
+        case elem1.type
+        when *[:bottom, :up]
+          if elem0.close - elem1.low > @limit
+            res << elem0
+            tmp0, tmp1 = elem1.split_for :low
+            res <<        SpanBar.new([ tickup(elem0.resources.last), tmp0 ], @ts)
+            @currentBar = SpanBar.new([ tickup(tmp0.last),tmp1], @ts)
+          elsif elem0.close - elem1.low <= @limit and elem0.close <= elem1.close
+            @currentBar = SpanBar.new([ elem0.resources, elem1.resources], @ts)
+          else 
+            # silently dropping unneeded fragment
+          end
+        when *[:top, :down]
+          if elem1.high >= elem0.close
+            tmp0, tmp1 = elem1.split_for :high
+            res << SpanBar.new([ elem0.resources, tmp0 ], @ts)
+            @currentBar = SpanBar.new([tickdown(tmp0.last),tmp1], @ts)
+          else
+            res << elem0
+            @currentBar = SpanBar.new([ tickup(elem0.resources.last), elem1.resources], @ts)
+          end
+        else
+          raise "Unknown type for secondary simple SpanBar #{elem1}"
+        end
+      when :down
+        case elem1.type
+        when *[:top, :down]
+          if elem1.high - elem0.close > @limit # only for percentage !?: or elem1.low <= elem0.low
+            res << elem0
+            tmp0, tmp1 = elem1.split_for :high
+            res <<        SpanBar.new([  tickup(elem0.resources.last), tmp0 ], @ts)
+            @currentBar = SpanBar.new([tickdown(tmp0.last),tmp1], @ts)
+          elsif elem1.high - elem0.close <= @limit and elem0.close >= elem1.close
+            @currentBar = SpanBar.new([elem0.resources, elem1.resources], @ts)
+          else
+            # silently dropping unneeded fragment 
+          end
+        when *[:bottom, :up]
+          if elem1.low <= elem0.close
+            tmp0, tmp1 =  elem1.split_for :low
+            res <<        SpanBar.new([ elem0.resources, tmp0 ], @ts)
+            @currentBar = SpanBar.new([tickup(tmp0.last),tmp1],  @ts)
+          else
+            res << elem0
+            @currentBar = SpanBar.new([ tickup(elem0.resources.last), elem1.resources], @ts)
+          end
+        else
+          raise "Unknown or invalid type for secondary simple SpanBar #{elem1}"
+        end
+      else
+        raise "Unknown or invalid type for primary simple SpanBar #{elem0}"
+      end
+    end
+
+    res.each {|x| @spanBars << x }
+    return res.empty? ? false : res
+  end
+
+  #def set_intraday
+  #  @spanBars.each{|bar| bar.set_intraday}
+  #end
+
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: spanbars
+version: !ruby/object:Gem::Version
+  version: 0.1.2beta
+platform: ruby
+authors:
+- Benjamin L. Tischendorf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 'Tiny tool to process input CSV data as timeseries to span bars '
+email: donkeybridge@jtown.eu
+executables:
+- spanbars
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/spanbars
+- features/01_spanbarprocessor_initialization.feature
+- features/02_spanbarprocessor_add.feature
+- features/03_spanbar_initialization.feature
+- features/04_spanbars_commandline.feature
+- features/step_definitions/01_spanbar_processor_initialization_steps.rb
+- features/step_definitions/02_spanbarprocessor_add_steps.rb
+- features/step_definitions/03_spanbar_initialization_steps.rb
+- features/step_definitions/04_spanbars_commandline_steps.rb
+- features/support/env.rb
+- features/support/ref1.csv
+- features/support/ref1_out_0.25_25.csv
+- features/support/ref2.csv
+- features/support/ref2_out_1_25.csv
+- features/support/ref3.csv
+- features/support/ref3_out_0.0000005_10.csv
+- lib/spanbar.rb
+- lib/spanbarprocessor.rb
+homepage: https://github.com/donkeybridge/spanbars
+licenses:
+- BSD-4-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Tiny tool to process input CSV data as timeseries to span bars
+test_files:
+- features/01_spanbarprocessor_initialization.feature
+- features/support/ref3.csv
+- features/support/ref3_out_0.0000005_10.csv
+- features/support/ref1.csv
+- features/support/ref2_out_1_25.csv
+- features/support/env.rb
+- features/support/ref2.csv
+- features/support/ref1_out_0.25_25.csv
+- features/02_spanbarprocessor_add.feature
+- features/04_spanbars_commandline.feature
+- features/step_definitions/01_spanbar_processor_initialization_steps.rb
+- features/step_definitions/02_spanbarprocessor_add_steps.rb
+- features/step_definitions/04_spanbars_commandline_steps.rb
+- features/step_definitions/03_spanbar_initialization_steps.rb
+- features/03_spanbar_initialization.feature