rspreadsheet 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a45451dc3599fbe6519acf7c0d27bb277743a782
-  data.tar.gz: 25b449a6d2efd44fcbf5396275bd0ebb22dbc85f
+  metadata.gz: ece0fff71891eecf4cbdf45b2c0d305b63a47e37
+  data.tar.gz: c8429a173fbe6f67d3c870b6cd9220d0a1960ca3
 SHA512:
-  metadata.gz: b6ed38a381b781d6b543285a783fc54346a70f61d6c99c4e1c7e18ea5e1ab3674ec0fc27cc8af647298fcbc5cc2bc66c58dda0af127967eec2db9647894e46d7
-  data.tar.gz: 341cce44687eeb226acc0b27df38b00951d5d2067a28898962cf9aaee4216d1a5318cb3b54784a8661a4083b5f9ec8d9660701c1656a96666a9fc42cf14a793a
+  metadata.gz: 84f8ec487137af55e90ec4227e2828248b60b7e943e49cf261e4538971b25e4b9363f325bcb60ddfd9e98790c07ccb3d9c0bd97570dc168ac312cd559b452748
+  data.tar.gz: 40f34733025850b05f84bd768232bef7f39035733d5973a63d4c24d938e14d9b4021a7a38c7341eab1064535068481e3eaa392b25adec1a3800c19e061cea78c

data/.directory

@@ -0,0 +1,4 @@
+[Dolphin]
+Timestamp=2014,11,19,5,36,18
+Version=3
+ViewMode=1

data/.gitignore

@@ -23,6 +23,8 @@ build/
 /rdoc/
 .~lock*
 .*kate-swp
+.*kate-swp.bak
+.directory
 
 ## Environment normalisation:
 /.bundle/

data/.kateproject

@@ -0,0 +1,4 @@
+{
+  "name": "RSpreadSheet"
+, "files": [ { "git": 1 } ]
+}

data/DEVEL_BLOG.md

@@ -2,27 +2,33 @@ See [GUIDE.md](GUIDE.md#conventions) for syntax conventions.
 
 ## Ideas/wishlist
 
-  * What should be returned when asking for row/cell outside used range? Currently it creates new row/cell on fly, but maybe it should only return nil, so the user needs to insert apropriate rows/cells himself before using them. However it spoils little bit syntax like spreadsheet.rows(5).cells(3) because if rows returns nil, that would fail and ugly constructs like spreadsheet.andand.rows(5).andand.cells(3) would be needed. The only way this could be acoided is by using something like "UncreatedRow" object. This concern falls to category "clash of worlds" like the indexing issue (0 vs 1 based) and many others.
+  * What should be returned when asking for row/cell outside used range? Currently it creates new row/cell on fly, but maybe it should only return nil, so the user needs to insert apropriate rows/cells himself before using them. However it spoils little bit syntax like spreadsheet.rows(5).cells(3) because if rows returns nil, that would fail and ugly constructs like spreadsheet.andand.rows(5).andand.cells(3) would be needed. The only way this could be acoided is by using something like "UncreatedRow" object. This concern falls to category "clash of worlds" like the indexing issue (0 vs 1 based) and many others. - now it returns "UncreatedRow/Cell" which is detached upon value assignement.
   * In future inntroduce syntax like ``sheet.range('C3:E4')`` for mass operations. Also maybe ``sheet.cells('C3')`` or ``sheet.cells(3, 'C')`` etc.
   * Trying to make row Enumerable - perhaps skipping empty or undefined cells.
   * Accessors for nonempty/defined cells.
   * Maybe insted two syntaxes for accessing cell, we make both of them do the same and return Proxy object which would act either as value or cell.
   * Allow any of these:
     * ``book['Spring 2014']`` as alternative to ``book.worksheets('Spring 2014')`` ?
-    * ``sheet.cells.F13`` as alternative to ``sheet.cells[14,5]`` ?
-  * We may have problem with the @parent_row concept in cells. If cell has repeated row as parent and it is detached in some other code, the cell never finds out that its parent_row was changed. A cure to this might be, when there are no "unatacched" cells, and when all cells belong to some row. This way if row detaches it can let know to all its cells.
+    * ``sheet.cells('F13')`` as alternative to ``sheet.cells(14,5)`` ?
   * Document that there is a little distinction betwean RSpreadsheet and RSpreadsheet::Workbook. The former delegates everythink to the other.
+  * allow `book.worskheets.first` syntax
+  * allow `sheet.cells.sum { |cell| cell.value }
+  * allow `sheet.rows(1).cells.each {}  iterate through nonempty cells ??? or all of them until last used
+  * `sheet.rows(1).cells` returns list of cells objects and `sheet.rows(1).cellvalues` return array of values with nils when empty
+  * implement to_csv
+  * longterm plan - go through other used libraries and try to find out whose syntax could be adopted, so this library is drop in replacement (possibly with some config options) for them
 
 Guiding ideas
   * xml document is always synchronized with the data. So the save is trivial.
   * no duplication of data. Objects like RowArray should containg minimum information. This one exists solely to speed up cell search. Taken to extream it is questionable, whether we need such objects at all, it might be possible to always work with xml directly.
-
+  * all cells and rows only server as proxy. they hold index and worksheet pointer and everytime read or write is done, the xml is newly searched. until there is a xmlnode caching we have no problem
+  * all cells returned for particular coordinates are **always the same object**. This way we have no problem to synchronize changes.
     
 ## Developing this gem
 
 ### Automated testing
 
-  * ``budele exec guard`` will get tested any changes as soon as they are summitted
+  * ``bundle exec guard`` will get tested any changes as soon as they are summitted
   * ``rake spec`` runs all test manually
 
 ### Automated utilities

data/GUIDE.md

@@ -46,8 +46,8 @@ book.save
 
 ```
 ## Conventions
-  * all coordinates and arrays are 1-based (spreadsheet world is 1-based, ruby is 0-based do I had to make a decision. I intend to make an global option for this, but in early stage I need to keep things simple. 
+  * **all indexes are 1-based**. This applies to rows, cells cordinates, and all array like structures like list od  worksheets etc. Spreadsheet world is 1-based, ruby is 0-based do I had to make a decision. I intend to make an global option for this, but in early stage I need to keep things simple. 
   * with numeric coordinates row always comes before col as in  (row,col)
   * with alphanumerical col always comes before row as in F12
-  * Shorter syntax worksheet[x,y] returns value, longer syntax worksheet.cells(x,y) return cell objects. This allows to work conviniently with values using short syntax and access the cell object if needed (for formatting for example).
+  * Shorter syntax worksheet[x,y] returns value, longer syntax worksheet.cells(x,y) return cell objects. This allows to work conviniently with values using short syntax and access the cell object if needed (to access formatting for example).
 

data/Guardfile

@@ -1,6 +1,6 @@
 guard 'rspec' do
-  # watch /lib/ files
-  watch(%r{^lib/(.+).rb$}) do |m|
+  # watch /lib/rspreadsheet/ files
+  watch(%r{^lib/rspreadsheet/(.+).rb$}) do |m|
     "spec/#{m[1]}_spec.rb"
   end
 

data/README.md

@@ -1,6 +1,6 @@
 # rspreadsheet
 
-[![Build Status](https://travis-ci.org/HazyResearch/deepdive.svg?branch=master)](https://travis-ci.org/HazyResearch/deepdive) [![Coverage Status](https://coveralls.io/repos/gorn/rspreadsheet/badge.png)](https://coveralls.io/r/gorn/rspreadsheet)
+[![Build Status](https://api.travis-ci.org/gorn/rspreadsheet.svg?branch=master)](https://travis-ci.org/gorn/rspreadsheet) [![Coverage Status](https://coveralls.io/repos/gorn/rspreadsheet/badge.png)](https://coveralls.io/r/gorn/rspreadsheet)
 
 Manipulating spreadsheets with Ruby. Read, modify, write or create new OpenDocument Spreadsheet files from ruby code.
 
@@ -8,30 +8,46 @@ Manipulating spreadsheets with Ruby. Read, modify, write or create new OpenDocum
 
 If you need any help or find a bug please [submit an issue](https://github.com/gorn/rspreadsheet/issues) here. I appreciate any feedback and even if you can not help with code, it is interesting for me to hear from you. Different people have different needs and I want to hear about them. If you are a programmer and you have any ideas, wishes, etc you are welcomed to fork the repository and submit a pull request preferably including a failing test.
 
-**Beware: this gem is still in alpha stage (however I use it and it works for what I need).** Currently I am experimenting with syntax to get the feeling what could be the best.
+Alhought this gem is still in alpha stage I use in my project it and it works fine. Currently I am experimenting with syntax to get stabilized. **Any suggestions regarding the syntax is very welcomed**
  
 ## Examples of usage
   
 ```ruby
 require 'rspreadsheet'
+book = Rspreadsheet.open('spreadsheet.ods')
+sheet = book.worksheets[1]
 
-book = Rspreadsheet.open('./icecream_list.ods')
-sheet = book.worksheets 'Icecream list'
-total = 0
 
-(3..20).each do |row|
-  puts 'Icecream name: ' + sheet[row,2]
-  puts 'Icecream ingredients: ' + sheet[row,3]
-  puts "I ate this " + sheet[row,4] + ' times'
-  total += sheet[row,4]
-end
+# get value of a cell B5 (there are more ways to do this)
+sheet.B5                       # => 'cell value'
+sheet[5,2]                     # => 'cell value'
+sheet.rows(5).cells(2).value   # => 'cell value'
+
+# set value of a cell B5
+sheet.F5 = 'text'
+sheet[5,2] = 7
+sheet.cells(5,2).value = 1.78
+
+# working with cell format
+sheet.cells(5,2).format.bold = true
+sheet.cells(5,2).format.background = '#FF0000'
 
-sheet[21,3] = 'Total:'
-sheet[21,4] = total
+# calculating sum of cells in row
+sheet.rows(5).cellvalues.sum
+sheet.rows(5).cells.sum{ |cell| cell.value }
 
-sheet.rows[21].format.bold = true
+# iterating over list of people and displaying the data
+
+total = 0
+sheet.rows.each do |row|
+  puts "Sponsor #{row[1]} with email #{row(2)} has donated #{row(3)} USD."
+  total += row[3]
+end
+puts "Totally fundraised #{total} USD"
 
+# saving file
 book.save
+book.save('different_filename.ods')
 
 ```
 
@@ -68,6 +84,7 @@ This project arised from the necessity. Alhought it is not true that there are n
   * [rods](http://www.drbreinlinger.de/ruby/rods/) - this is pretty ok, but it has terrible syntax. I first thought of writing wrapper around it, but it turned to be not so easy. Also last commit is 2 years old.
   * [rubiod](https://github.com/netoctone/rubiod) - this one is quite ok, the syntax is definitely better that in rods, but it seems also very abandoned. It does not support formats. This is a closest match.
   * [spreadsheet](https://github.com/zdavatz/spreadsheet) - this does not work with OpenDocument and even with Excel has issues in modyfying document. However since it is supposedly used, and has quite good syntax it might be inspirative. I also find the way this gem handles lazy writing of new rows to Spreadsheet object flawed, as well as strange accesibility of rows array object, which if assigned breaks consistency of sheet.
+  * [roo](https://github.com/roo-rb/roo) can only read spreadsheets and not modify and write them back.
 
 One of the main ideas is that the manipulation with OpenDOcument files should be forward compatible and as much current data preserving as possible. The parts of the file which are not needed for the change should not be changed. This is different to some of the mentioned gems, which generate the document from scratch, therefore any advanced features present in the original file which are not directly supported are lost.
 

data/lib/class_extensions.rb

@@ -1,10 +1,4 @@
 class LibXML::XML::Node
-  def new_with_ns(namespace,name)
-    ns = self.namespaces.find_by_prefix('table') || LibXML::XML::Namespace.new(self, 'table', 'urn:oasis:names:tc:opendocument:xmlns:table:1.0')
-    self.namespaces.namespace = ns
-    self
-    LibXML::XML::Node.new('table-row')
-  end
   def elements
     result = []
     each_element { |e| result << e }
@@ -40,9 +34,4 @@ class LibXML::XML::Node
   def equals?(node2)  #TODO redefine == with this
     self.simplification_of?(node2) and node2.simplification_of?(self)
   end
-  def add_table_namesepace
-    ns = self.namespaces.find_by_prefix('table') || LibXML::XML::Namespace.new(self, 'table', 'urn:oasis:names:tc:opendocument:xmlns:table:1.0')
-    self.namespaces.namespace = ns
-    self
-  end
 end

data/lib/rspreadsheet/cell.rb

@@ -1,28 +1,38 @@
 require 'andand'
+require 'rspreadsheet/xml_tied'
 
 module Rspreadsheet
-
-class RowOrNode
-  def mode
-   case
-     when xmlnode.nil? then :outbound
-     when repeated>1  then :repeated
-     else :regular
-   end
-  end
-end
-
-class Cell < RowOrNode
-  attr_accessor :worksheet, :rowi, :coli
+  
+class Cell < XMLTiedItem
+  attr_accessor :worksheet, :coli, :rowi
+  def xml_repeated_attribute;  'number-columns-repeated' end
+  def xml_items_node_name; 'table-cell' end
+  def xml_options; {:xml_items_node_name => xml_items_node_name, :xml_repeated_attribute => xml_repeated_attribute} end
+  def parent; row end
+  def index; @coli end
+  def set_index(value); @coli=value end
+  def set_rowi(arowi); @rowi = arowi end # this should ONLY be used by parent row
   def initialize(aworksheet,arowi,acoli)
+    raise "First parameter should be Worksheet object not #{aworksheet.class}" unless aworksheet.kind_of?(Rspreadsheet::Worksheet)
     @worksheet = aworksheet
     @rowi = arowi
     @coli = acoli
   end
   def row; @worksheet.rows(rowi) end
   def coordinates; [rowi,coli] end
-
-  def xmlnode; @worksheet.cellxmlnode(@rowi,@coli) end
+  def to_s; value.to_s end
+  def valuexml; self.valuexmlnode.andand.inner_xml end
+  def valuexmlnode; self.xmlnode.children.first end
+  # use this to find node in cell xml. ex. xmlfind('.//text:a') finds all link nodes
+  def valuexmlfindall(path)
+    valuexmlnode.nil? ? [] : valuexmlnode.find(path)
+  end
+  def valuexmlfindfirst(path)
+    valuexmlfindall(path).first
+  end
+  def inspect
+    "#<Rspreadsheet::Cell:Cell\n row:#{rowi}, col:#{coli} address:#{address}\n type: #{guess_cell_type.to_s}, value:#{value}\n mode: #{mode}\n>"
+  end
   def value
     gt = guess_cell_type
     if (self.mode == :regular) or (self.mode == :repeated)
@@ -31,7 +41,7 @@ class Cell < RowOrNode
         when gt == Float then xmlnode.attributes['value'].to_f
         when gt == String then xmlnode.elements.first.andand.content.to_s
         when gt == Date then Date.strptime(xmlnode.attributes['date-value'].to_s, '%Y-%m-%d')
-        when gt == 'percentage' then xmlnode.attributes['value'].to_f
+        when gt == :percentage then xmlnode.attributes['value'].to_f
       end
     elsif self.mode == :outbound
       nil
@@ -39,7 +49,59 @@ class Cell < RowOrNode
       raise "Unknown cell mode #{self.mode}"
     end
   end
-  def repeated; (Tools.get_ns_attribute_value(xmlnode, 'table', 'number-columns-repeated') || 1 ).to_i end
+  def value=(avalue)
+    detach_if_needed
+    if self.mode == :regular
+      gt = guess_cell_type(avalue)
+      case
+        when gt == nil then raise 'This value type is not storable to cell'
+        when gt == Float 
+          set_type_attribute('float')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','value', avalue.to_s) 
+          xmlnode << Tools.create_ns_node('text','p', avalue.to_f.to_s)
+        when gt == String then
+          set_type_attribute('string')
+          remove_all_value_attributes_and_content(xmlnode)
+          xmlnode << Tools.create_ns_node('text','p', avalue.to_s)
+        when gt == Date then 
+          set_type_attribute('date')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','date-value', avalue.strftime('%Y-%m-%d'))
+          xmlnode << Tools.create_ns_node('text','p', avalue.strftime('%Y-%m-%d')) 
+        when gt == :percentage
+          set_type_attribute('percentage')
+          remove_all_value_attributes_and_content(xmlnode)
+          Tools.set_ns_attribute(xmlnode,'office','value', '%0.2d%' % avalue.to_f) 
+          xmlnode << Tools.create_ns_node('text','p', (avalue.to_f*100).round.to_s+'%')
+      end
+    else
+      raise "Unknown cell mode #{self.mode}"
+    end
+  end
+  def set_type_attribute(typestring)
+    Tools.set_ns_attribute(xmlnode,'office','value-type',typestring)
+  end
+  def remove_all_value_attributes_and_content(node)
+    if att = Tools.get_ns_attribute(node, 'office','value') then att.remove! end
+    if att = Tools.get_ns_attribute(node, 'office','date-value') then att.remove! end
+    node.content=''
+  end
+  def relative(rowdiff,coldiff)
+    @worksheet.cells(self.rowi+rowdiff, self.coli+coldiff)
+  end
+  def type
+    gct = guess_cell_type
+    case 
+      when gct == Float  then :float
+      when gct == String then :string
+      when gct == Date   then :date
+      when gct == :percentage then :percentage
+      when gct == :unassigned then :unassigned
+      when gct == nil then :unknown
+      else :unknown
+    end
+  end
   def guess_cell_type(avalue=nil)
     # try guessing by value
     valueguess = case avalue
@@ -88,114 +150,49 @@ class Cell < RowOrNode
           nil
         end
       end
+    elsif valueguess == Float and xmlnode.andand.attributes['value-type'] == 'percentage'
+      result = :percentage
     end
     result
   end
-  def detach_if_needed
-    if (self.mode == :repeated) or (self.mode == :outbound ) # Cell did not exist individually yet, detach row and create editable cell
-      @worksheet.detach_cell_in_xml(rowi,coli)
-    end
- end
-  def value=(avalue)
-    detach_if_needed
-    if self.mode == :regular
-      gt = guess_cell_type(avalue)
-      case
-        when gt == nil then raise 'This value type is not storable to cell'
-        when gt == Float 
-          set_type_attribute('float')
-          remove_all_value_attributes_and_content(xmlnode)
-          Tools.set_ns_attribute(xmlnode,'office','value', avalue.to_s) 
-          xmlnode << LibXML::XML::Node.new('p', avalue.to_f.to_s, ns_text)
-        when gt == String then
-          set_type_attribute('string')
-          remove_all_value_attributes_and_content(xmlnode)
-          xmlnode << LibXML::XML::Node.new('p', avalue.to_s, ns_text)
-        when gt == Date then 
-          set_type_attribute('date')
-          remove_all_value_attributes_and_content(xmlnode)
-          Tools.set_ns_attribute(xmlnode,'office','date-value', avalue.strftime('%Y-%m-%d'))
-          xmlnode << LibXML::XML::Node.new('p', avalue.strftime('%Y-%m-%d'), ns_text) 
-        when gt == 'percentage'
-          set_type_attribute('float')
-          remove_all_value_attributes_and_content(xmlnode)
-          Tools.set_ns_attribute(xmlnode,'office','value', avalue.to_f.to_s) 
-          xmlnode << LibXML::XML::Node.new('p', (avalue.to_f*100).round.to_s+'%', ns_text)
-      end
-    else
-      raise "Unknown cell mode #{self.mode}"
-    end
+  def format
+    @format ||= CellFormat.new(self)
   end
-  def set_type_attribute(typestring)
-    Tools.set_ns_attribute(xmlnode,'office','value-type',typestring)
+  def address
+    Tools.convert_cell_coordinates_to_address(coordinates)
   end
-  def remove_all_value_attributes_and_content(node)
-    if att = Tools.get_ns_attribute(node, 'office','value') then att.remove! end
-    if att = Tools.get_ns_attribute(node, 'office','date-value') then att.remove! end
-    node.content=''
+
+end
+
+# proxy object to allow cell.format syntax. Also handles all logic for formats.
+class CellFormat
+  attr_reader :bold
+  def initialize(cell)
+    @bold = false
+    @cell = cell
   end
-  def ns_table; xmlnode.doc.root.namespaces.find_by_prefix('table') end
-  def ns_office; xmlnode.doc.root.namespaces.find_by_prefix('office') end
-  def ns_text; xmlnode.doc.root.namespaces.find_by_prefix('text') end
-  def relative(rowdiff,coldiff)
-    @worksheet.cells(self.rowi+rowdiff, self.coli+coldiff)
+  def cellnode; @cell.xmlnode end
+  def bold=(value)
+    Rspreadsheet::Tools.set_ns_attribute(cellnode,'table','style-name','ce99')
   end
-  def is_repeated?; mode == :repeated end
-  def type
-    gct = guess_cell_type
-    case 
-      when gct == Float  then :float
-      when gct == String then :string
-      when gct == Date   then :date
-      when gct == :percentage then :percentage
-      when gct == :unassigned then :unassigned
-      when gct == nil then :unknown
-      else :unknown
-    end
+  def bold; Tools.get_ns_attribute_value(text_style_node,'fo','font-weight') == 'bold' end
+  def italic; Tools.get_ns_attribute_value(text_style_node,'fo','font-style') == 'italic' end
+  def color; Tools.get_ns_attribute_value(text_style_node,'fo','color') end
+  def font_size; Tools.get_ns_attribute_value(text_style_node,'fo','font-size') end
+  def background_color; Tools.get_ns_attribute_value(cell_style_node,'fo','background-color') end
+ 
+  def unused_cell_style_name
+    last = cellnode.doc.root.find('./office:automatic-styles/style:style').
+      collect {|node| node['name']}.
+      collect{ |name| /^ce(\d*)$/.match(name); $1.andand.to_i}.
+      compact.max
+    "ce#{last+1}"
   end
+  def style_name; Tools.get_ns_attribute_value(cellnode,'table','style-name') end
+  def style_node; cellnode.doc.root.find("./office:automatic-styles/style:style[@style:name=\"#{style_name}\"]").first end
+  def text_style_node; cellnode.doc.root.find("./office:automatic-styles/style:style[@style:name=\"#{style_name}\"]/style:text-properties").first end
+  def cell_style_node; cellnode.doc.root.find("./office:automatic-styles/style:style[@style:name=\"#{style_name}\"]/style:table-cell-properties").first end
 end
-  
-  
-# class Cell
-#   attr_reader :col, :xmlnode
-#   attr_reader  :parent_row  # for debug only
-#   attr_accessor :mode
-#   def self.empty_cell_node
-#     LibXML::XML::Node.new('table-cell',nil, Tools.get_namespace('table'))
-#   end
-#   def initialize(aparent_row,coli,axmlnode=nil)
-#     raise "First parameter should be Row object not #{aparent_row.class}" unless aparent_row.kind_of?(Rspreadsheet::Row)
-#     @parent_row = aparent_row
-#     if axmlnode.nil?
-#       axmlnode = Cell.empty_cell_node
-#     end
-#     @xmlnode = axmlnode
-#     @col = coli
-#     # set @mode
-#     @mode = case
-#       when !@parent_row.used_col_range.include?(coli) then :outbound
-#       when Tools.get_ns_attribute_value(@xmlnode, 'table', 'number-columns-repeated').to_i>1  then :repeated
-#       else:regular
-#     end
-#   end
-#   def to_s; value end
-#   def cell_xml; self.xmlnode.to_s end
-#   def xml; self.xmlnode.children.first.andand.inner_xml end
-#   def address; Rspreadsheet::Tools.c2a(row,col) end
-#   def row; @parent_row.row end
-#   def worksheet; @parent_row.worksheet end
-#   # use this to find node in cell xml. ex. xmlfind('.//text:a') finds all link nodes
-#   def xmlfindall(path)
-#     xmlnode.find(path)
-#   end
-#   def xmlfindfirst(path)
-#     xmlfindall(path).first
-#   end
-#   # based on @xmlnode and optionally value which is about to be assigned, guesses which type the result should be
-#   def inspect
-#     "#<Rspreadsheet::Cell:Cell\n row:#{row}, col:#{col} address:#{address}\n type: #{guess_cell_type.to_s}, value:#{value}\n mode: #{mode}\n>"
-#   end
-# end
 
 end
 
@@ -210,3 +207,8 @@ end
 
 
 
+
+
+
+
+