spreet 0.0.2 → 0.0.3

data/README.rdoc

@@ -1,3 +1,49 @@
 = Spreet
 
-Universal handler for spr[eadsh]eets.
+Universal handler for spr[eadsh]eets.
+
+== Why ?
+This gems is a handler for spreadsheets. With its independent API, it is possible to create, update files in some formats. Today the list is not very long:
+
+* CSV: UTF-8 with commas (Read & Write)
+* CSV for Excel: CP1252 with semicolons (Read & Write)
+* ODS: Open Document Format (Read & Write with restrictions)
+
+== Installation
+
+  gem install spreet
+
+== How to use it
+
+  # Create a new document
+  doc = Spreet::Document.new
+  sheet = doc.sheets.add "My Sheet"
+
+  # Coordinates can be called with spreadsheet style...
+  sheet["A1"] = "Last name"
+  # ...or more classic style...
+  sheet[1,0] = "First name"
+  # ...or if necessary as a Hash
+  sheet[:x=>2, :y=>0] = "Born on"
+
+  sheet.next_row
+  for person in People.all
+    sheet.row person.last_name, person.first_name, person.born_on
+  end
+
+  # Write it as a classic CSV
+  sheet.write("people-1.csv")
+  # Write it as a CSV for Excel
+  sheet.write("people-2.csv", :format=>:xcsv) # CSV for Excel
+  # or write it as an Open Document Spreadsheet
+  sheet.write("people-3.ods")
+  
+== To do soon
+
+* Add style management for cells
+* Add Header/Footer
+* HTML Writer
+* PDF Writer like OpenOffice/LibreOffice would make it
+
+== Travis
+{<img src="https://secure.travis-ci.org/burisu/spreet.png"/>}[http://travis-ci.org/burisu/spreet]

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/big_array.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+# Class to manage big hash with lot of pairs
+class BigArray
+
+  def initialize(klass_name=nil, partition=8, levels=4)
+    @partition = partition.to_i
+    raise ArgumentError.new("Partition must be an integer > 0") unless @partition > 0
+    @levels = levels.to_i
+    raise ArgumentError.new("Levels must be an integer > 0") unless @levels > 0
+    klass_name ||= "#{self.class.name}#{@partition}_#{@levels}"
+    @base_class = "Hash"
+    code  = ""
+    code << "class #{klass_name}\n"
+    code << "  def initialize()\n"
+    code << "    @root = #{@base_class}.new\n"
+    code << "  end\n\n"
+
+    code << "  def [](index)\n"
+    code << dive do |pointer|
+      "return nil"
+    end.strip.gsub(/^/, '    ')+"\n"
+    code << "    return cursor[#{index_at_level(@levels)}]\n"
+    code << "  end\n\n"
+
+    code << "  def []=(index, value)\n"
+    # code << "    index, value = args[0], args[1]\n"
+    code << dive do |pointer|
+      "#{pointer} = #{@base_class}.new"
+    end.strip.gsub(/^/, '    ')+"\n"
+    code << "    return cursor[#{index_at_level(@levels)}] = value\n"
+    code << "  end\n\n"
+
+    code << "  def delete(index)\n"
+    # code << "    index, value = args[0], args[1]\n"
+    code << dive do |pointer|
+      "return nil"
+    end.strip.gsub(/^/, '    ')+"\n"
+    code << "    return cursor.delete(#{index_at_level(@levels)})\n"
+    code << "  end\n\n"
+
+    code << "  def each(&block)\n"
+    code << browse do
+      "yield(index, value)"
+    end.strip.gsub(/^/, '    ')+"\n"
+    code << "  end\n\n"
+
+    code << "  def to_hash\n"
+    code << "    hash = {}\n"
+    code << browse do
+      "hash[index] = value"
+    end.strip.gsub(/^/, '    ')+"\n"
+    code << "    return hash\n"
+    code << "  end\n\n"
+
+    code << "end\n"
+    # raise code
+    eval(code)
+    return self.class.const_get(klass_name)
+  end
+
+  private
+
+  def dive(&block)
+    code = ""
+    for level in 1..(@levels-1)
+      pointer = "#{level == 1 ? '@root' : 'cursor'}[#{index_at_level(level)}]"
+      code << "unless #{pointer}.is_a?(#{@base_class})\n"
+      code << yield(pointer).to_s.strip.gsub(/^/, '  ')+"\n"
+      code << "end\n"
+      code << "cursor = #{pointer}\n"
+    end
+    return code
+  end
+
+  def browse(level = 1, &block)
+    code = ""
+    value = (level == @levels ? 'value' : "h#{level}")
+    code << "for l#{level}, #{value} in #{level == 1 ? '@root' : 'h'+(level-1).to_s}\n"
+    if level > 1
+      i = (level == @levels ? "index" : "i#{level}")
+      code << "  #{i} = ("+(level>2 ? "i" : "l")+"#{level-1} << #{@partition})|l#{level}\n"
+    end
+    if level == @levels
+      code << yield.to_s.strip.gsub(/^/, '  ')+"\n"
+    else
+      code << browse(level + 1, &block).to_s.strip.gsub(/^/, '  ')+"\n"
+    end
+    code << "end\n"
+    return code
+  end
+
+  def index_at_level(level, variable="index")
+    v = variable
+    v = "(#{v} >> #{(@levels-level)*@partition})" if level < @levels
+    return "#{v}&#{2**@partition-1}"
+  end
+
+
+end

data/lib/duration.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+# Class to manage durations (or intervals in SQL vocabulary)
+class Duration
+  # 365.25 * 86_400 == 31_557_600
+  SECONDS_IN_YEAR = 31_557_600 # 31_556_926 => 31_556_928
+  SECONDS_IN_MONTH = SECONDS_IN_YEAR / 12
+  
+  FIELDS = [:years, :months, :days, :hours, :minutes, :seconds]
+  attr_accessor *FIELDS
+  attr_reader :sign
+  
+  def initialize(*args)
+    @years, @months, @days, @hours, @minutes, @seconds = 0, 0, 0, 0, 0, 0
+    @sign = 1
+    if args.size == 1 and args[0].is_a? String
+      self.parse(args[0])
+    else
+      @years   = (args.shift || 0).to_i
+      @months  = (args.shift || 0).to_i
+      @days    = (args.shift || 0).to_i
+      @hours   = (args.shift || 0).to_i
+      @minutes = (args.shift || 0).to_i
+      @seconds = (args.shift || 0).to_i      
+    end
+  end
+
+  def parse(string)
+    unless string.match(/^\-?P(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+(\.\d+)?S)?)?$/)
+      raise ArgumentError.new("Malformed string")
+    end
+    strings = string.split('T')
+    strings[0].gsub(/\d+[YMD]/) do |token|
+      code, count = token.to_s[-1..-1], token.to_s[0..-2].to_i
+      if code == "Y"
+        @years = count
+      elsif code == "M"
+        @months = count
+      elsif code == "D"
+        @days = count
+      end
+      token
+    end
+    strings[1].to_s.gsub(/(\d+[HM]|\d+(\.\d+)?S)/) do |token|
+      code, count = token.to_s[-1..-1], token.to_s[0..-2]
+      if code == "H"
+        @hours = count.to_i
+      elsif code == "M"
+        @minutes = count.to_i
+      elsif code == "S"
+        @seconds = count.to_f
+      end
+      token
+    end
+    self.sign = (string.match(/^\-/) ? -1 : 1)
+    return self
+  end
+
+  def sign=(val)
+    @sign = (val >= 0 ? 1 : -1)
+  end
+
+  def to_s(compression = :normal)
+    if compression == :maximum
+      return (@sign > 0  ? "" : "-")+"P#{@years.to_s+'Y' if @years > 0}#{@months.to_s+'M' if @months > 0}#{@days.to_s+'D' if @days > 0}"+((@hours.zero? and @minutes.zero? and @seconds.zero?) ? '' : "T#{(@hours.to_s+'H') if @hours > 0}#{(@minutes.to_s+'M') if @minutes > 0}#{((@seconds.floor != @seconds ? @seconds.to_s : @seconds.to_i.to_s)+'S') if @seconds > 0}")
+    elsif compression == :minimum
+      return (@sign > 0  ? "" : "-")+"P"+@years.to_s+"Y"+@months.to_s+"M"+@days.to_s+"DT"+@hours.to_s+"H"+@minutes.to_s+"M"+@seconds.to_s+"S"
+    else
+      return (@sign > 0  ? "" : "-")+"P"+((@years.zero? and @months.zero? and @days.zero?) ? '' : @years.to_s+"Y"+@months.to_s+"M"+@days.to_s+"D")+((@hours.zero? and @minutes.zero? and @seconds.zero?) ? '' : "T"+@hours.to_s+"H"+@minutes.to_s+"M"+(@seconds.round != @seconds ? @seconds.to_s : @seconds.to_i.to_s)+"S")
+    end
+  end
+
+  # Export all values to hash 
+  def to_hash
+    {:years=>@years, :months=>@months, :days=>@days, :hours=>@hours, :minutes=>@minutes, :seconds=>@seconds, :sign=>@sign}
+  end
+
+  # Computes a duration in seconds based on theoric and statistic values
+  # Because the relation between some of date parts isn't fixed (such as the number of days in a month), 
+  # the order relationship between durations is only partial, and the result of a comparison 
+  # between two durations may be undetermined.
+  def to_f
+    count = @seconds
+    count += 60 * @minutes
+    # 60 * 60 = 3_600
+    count += 3_600 * @hours
+    # 60 * 60 * 24 = 86_400
+    count += 86_400 * @days
+    # 365.25/12 * 86_400 == 31_557_600/12 == 2_629_800
+    count += SECONDS_IN_MONTH * @months
+    # 365.25 * 86_400 == 31_557_600
+    count += SECONDS_IN_YEAR * @years
+    return @sign * count
+  end
+
+  def to_i
+    self.to_f.to_i
+  end
+
+  # Normalize seconds, minutes, hours and month with their fixed relations
+  def normalize!(normalize_method = :right)
+    if normalize_method == :seconds
+      count = self.to_f
+      @years = (count / SECONDS_IN_YEAR).floor
+      count -= @years * SECONDS_IN_YEAR
+      @months = (count / SECONDS_IN_MONTH).floor
+      count -= @months * SECONDS_IN_MONTH
+      @days = (count / 86_400).floor
+      count -= @days * 86_400
+      @hours = (count / 3_600).floor
+      count -= @hours * 3_600
+      @minutes = (count / 60).floor
+      count -= @minutes * 60
+      @seconds = count
+    else
+      if @seconds >= 60
+        minutes = (@seconds / 60).floor
+        @seconds -= minutes * 60
+        @minutes += minutes
+      end
+      if @minutes >= 60
+        hours = (@minutes / 60).floor
+        @minutes -= hours * 60
+        @hours += hours
+      end
+      if @hours >= 24
+        days = (@hours / 24).floor
+        @hours -= days * 24
+        @days += days
+      end
+      # No way to convert correctly days in month 
+      if @months >= 12
+        years = (@months / 12).floor
+        @months -= years * 12
+        @years += years
+      end
+    end
+    return self
+  end
+
+  def normalize(normalize_method = :right)
+    self.dup.normalize!(normalize_method)
+  end
+
+end

data/lib/spreet.rb

@@ -1,11 +1,19 @@
 # encoding: utf-8
 require 'pathname'
+require 'duration'
+require 'money'
+require 'time'
+require 'big_array'
+require 'spreet/coordinates'
+
+# Create class for  arrays
+BigArray.new("Cells", 10, 3)
 
 module Spreet
 
   module VERSION
     version = nil
-    File.open("VERSION") {|f| version = f.read.split('.')}
+    File.open(File.join(File.dirname(__FILE__), "..", "VERSION")) {|f| version = f.read.split('.')}
     MAJOR = version[0].to_i.freeze
     MINOR = version[1].to_i.freeze
     TINY  = version[2].to_i.freeze
@@ -15,83 +23,42 @@ module Spreet
   end
 
 
-  class Coordinates
-    # Limit coordinates x and y in 0..65535 but coordinates are in one integer of 32 bits
-    CPU_SEMI_WIDTH = 16 # ((RUBY_PLATFORM.match(/^[^\-]*[^\-0-9]64/) ? 64 : 32) / 2).freeze
-    Y_FILTER = ((1 << CPU_SEMI_WIDTH) - 1).freeze
-
-    BASE_26_BEF = "0123456789abcdefghijklmnop"
-    BASE_26_AFT = "abcdefghijklmnopqrstuvwxyz"
-
-    attr_accessor :x, :y
-    def initialize(*args)
-      value = (args.size == 1 ? args[0] : args)
-      @x, @y = 0, 0
-      if value.is_a? String
-        if value.downcase.match(/^[a-z]+[0-9]+$/)
-          value = value.downcase.split(/([A-Z]+|[0-9]+)/).delete_if{|x| x.size.zero?}
-          @x, @y = value[0].tr(BASE_26_AFT, BASE_26_BEF).to_i(26), value[1].to_i(10)-1
-        elsif value.downcase.match(/^[0-9]+[^0-9]+[0-9]+$/)
-          value = value.downcase.split(/[^0-9]+/)
-          @x, @y = value[0].to_i(10), value[1].to_i(10)
-        end
-      elsif value.is_a? Integer
-        @x, @y = (value >> CPU_SEMI_WIDTH), value & Y_FILTER
-      elsif value.is_a? Coordinates
-        @x, @y = value.x, value.y
-      elsif value.is_a? Array
-        @x, @y = value[0].to_i, value[1].to_i
-      elsif value.is_a? Hash
-        @x, @y = value[:x] || value[:column] || 0, value[:y] || value[:row] || 0
-      end
-    end
-
-    def to_s
-      @x.to_s(26).tr(BASE_26_BEF, BASE_26_AFT).upcase+(@y+1).to_s(10)
-    end
-
-    def to_a
-      [@x, @y]
-    end
-
-    def to_hash
-      {:x=>@x, :y=>@y}
-    end
-    
-    def to_i
-      (@x << CPU_SEMI_WIDTH) + @y
-    end
-
-    def ==(other_coordinate)
-      other_coordinate.x == self.x and other_coordinate.y == self.y
-    end
-
-    def <=>(other_coordinate)
-      self.to_i <=> other_coordinate.to_i
-    end
-  end
-
   # Represents a cell in a sheet
   class Cell
     attr_reader :text, :value, :type, :sheet, :coordinates
+    attr_accessor :annotation
 
     def initialize(sheet, *args)
       @sheet = sheet
       @coordinates = Coordinates.new(*args)
       self.value = nil
       @empty = true
+      @covered = false # determine_covered
+      @annotation = nil
     end
 
     def value=(val)
-      @value = val
-      @type = determine_type
-      @text = val.to_s
-      @empty = false
+      if val.is_a?(Cell)
+        @value = val.value
+        @type = val.type
+        self.text = val.text
+        @empty = val.empty?
+        @annotation = val.annotation
+      else
+        @value = val
+        @type = determine_type
+        self.text = val
+        @empty = false
+      end
     end
 
     def empty?
       @empty
     end
+    
+    def covered?
+      @covered
+    end
 
     def clear!
       self.value = nil
@@ -106,29 +73,35 @@ module Spreet
       self.coordinates <=> other_cell.coordinates
     end
 
+    def text=(val)
+      @text = val.to_s
+    end
+
+    def inspect
+      "<#{self.coordinates}: #{self.text.inspect}#{'('+self.value.inspect+')' if self.text != self.value}>"
+    end
+
     private
+
     
     def determine_type
-      if value.is_a? Date
+      if value.is_a? Date or value.is_a? DateTime
         :date
-      elsif value.is_a? Integer
-        :integer
-      elsif value.is_a? Numeric
-        :decimal
-      elsif value.is_a? DateTime
-        :datetime
+      elsif value.is_a? Numeric # or percentage
+        :float
+      elsif value.is_a? Money
+        :currency
+      elsif value.is_a? Duration
+        :time
       elsif value.is_a?(TrueClass) or value.is_a?(FalseClass)
         :boolean
-      elsif value.nil?
-        :null
-      else
+      else # if value.is_a?(String)
         :string
       end
     end
 
   end
 
-
   class Sheet
     attr_reader :document, :name, :columns
     attr_accessor :current_row
@@ -138,7 +111,8 @@ module Spreet
       self.name = name
       raise ArgumentError.new("Must be a Document") unless document.is_a? Document
       @current_row = 0
-      @cells = {}
+      @cells = {} # BigArray::Cells.new
+      @bound = compute_bound
     end
 
     def name=(value)
@@ -152,11 +126,6 @@ module Spreet
       @name = value
     end
 
-    def cells
-      @cells.delete_if{|k,v| v.empty?}
-      @cells.values
-    end
-
     def next_row(increment = 1)
       @current_row += increment
     end
@@ -175,7 +144,7 @@ module Spreet
       value = args.delete_at(-1)
       cell = self[*args]
       cell.value = value
-      @bound = compute_bound
+      @updated = true
     end
 
     def row(*args)
@@ -188,13 +157,17 @@ module Spreet
       next_row
     end
 
+    def rows(index)
+      row = []
+      for i in 0..bound.x
+        row[i] = self[i, index]
+      end
+      return row
+    end
+
     def each_row(&block)
       for j in 0..bound.y
-        row = []
-        for i in 0..bound.x
-          row[i] = self[i, j]
-        end
-        yield row
+        yield rows(j)
       end
     end
 
@@ -204,13 +177,17 @@ module Spreet
     end
     
     def bound
-      @bound
+      if @updated
+        compute_bound
+      else
+        @bound
+      end
     end
 
     def remove!(coordinates)
       raise ArgumentError.new("Must be a Coordinates") unless document.is_a?(Coordinates)
       @cells.delete(coordinates.to_i)
-      @bound = compute_bound
+      @updated = true
     end
 
     # Moves the sheet to an other position in the list of sheets
@@ -231,14 +208,17 @@ module Spreet
     private
 
     def compute_bound
-      bound = Coordinates.new
-      for id, cell in @cells
+      bound = Coordinates.new(0,0)
+      for index, cell in @cells
+      # for cell in @cells.compact
         unless cell.empty?
           bound.x = cell.coordinates.x if cell.coordinates.x > bound.x
-          bound.y = cell.coordinates.y if cell.coordinates.x > bound.y
+          bound.y = cell.coordinates.y if cell.coordinates.y > bound.y
         end
       end
-      return bound
+      @updated = false
+      @bound = bound
+      return @bound
     end
 
   end
@@ -280,11 +260,14 @@ module Spreet
     end
 
     def remove(sheet)
-      @array.delete(sheet)
+      @array.delete_at(index(sheet))
     end
 
     def move(sheet, shift=0)
-      move_at(sheet, index(sheet) + shift)
+      position = index(sheet) + shift
+      position = 0 if position < 0
+      position = self.count-1 if position >= self.count
+      move_at(sheet, position)
     end
 
     def move_at(sheet, position=-1)
@@ -310,17 +293,6 @@ module Spreet
     def initialize(option={})
       @sheets = Sheets.new(self)
     end
-    
-    def to_term
-      text = "Spreet (#{@sheets.count}):\n"
-      for sheet in @sheets
-        text << " - #{sheet.name}:\n"
-        for cell in sheet.cells.sort
-          text << "   - #{cell.coordinates.to_s}: #{cell.text.inspect}\n"
-        end
-      end
-      return text
-    end
 
     def write(file, options={})
       handler = self.class.extract_handler(file, options.delete(:format))