rspreadsheet 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 152586e2f35f91ad2793d61bdd9b1d2f3d497f2a
-  data.tar.gz: 891cd0526d5c16c065bbced2da5dab48586d50a2
+  metadata.gz: c147702da70bb4a26183164ed522e854d65ffb60
+  data.tar.gz: 7bac02b0ac665aebb70232c06d02e07a487a3f61
 SHA512:
-  metadata.gz: 82757075eefa5c3d7fbe287237aff3deca67242d893b6cc64211f51c10d4053d8f739515ec9df89ee7d1eb9761fe96126c9ce270fe7d74276563e1ce1cf7475f
-  data.tar.gz: ce78296bd79b804f132fd7d9bf2358cb27fba64a0711e0b126512dcf3b7ea5730cc2fd7f21bef1f9cc3459451a92c81985daac7c6833f4194d7a167557900ffe
+  metadata.gz: 27c8e0ca9ea36ee65a8316a42ba2f993b10c4282ffe1447b3be4e2db4123a682e00c4a161b32f97cd2aa39d4e04402b521404950f8b29afdb9d456d22d63892e
+  data.tar.gz: fc92b43e46ba1157b294810dfecd524eba13e95c773357a9d65590a866b315200fc9fd616c5dcbc7bdfb9f5d73d50a667eababff5af7135f3e3f74ae83519e30

data/.gitignore

@@ -22,6 +22,7 @@ build/
 /doc/
 /rdoc/
 .~lock*
+.*kate-swp
 
 ## Environment normalisation:
 /.bundle/
@@ -31,8 +32,8 @@ build/
 # intended to run in multiple environments; otherwise, check them in:
 
 Gemfile.lock
-# .ruby-version
-# .ruby-gemset
+.ruby-version
+.ruby-gemset
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc

data/DEVEL_BLOG.md

@@ -2,6 +2,7 @@ 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.
   * 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.
@@ -9,12 +10,17 @@ See [GUIDE.md](GUIDE.md#conventions) for syntax conventions.
   * Allow any of these:
     * ``book['Spring 2014']`` as alternative to ``book.worksheets('Spring 2014')`` ?
     * ``sheet.cells.F13`` as alternative to ``sheet.cells[14,5]`` ?
- 
+
+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.
+
+    
 ## Developing this gem
 
 ### Automated testing
 
-  * ``guard`` will get tested any changes as soon as they are summitted
+  * ``budele exec guard`` will get tested any changes as soon as they are summitted
   * ``rake spec`` runs all test manually
 
 ### Automated utilities
@@ -37,3 +43,7 @@ alternative way using ``gem`` command
     gem push rspreadsheet-x.y.z.gem
 
 
+### Naming conventions
+
+  * create_xxx - creates object and inserts it where necessary
+  * prepare_xxx - create object, but does not insert it anywhere

data/GUIDE.md

@@ -13,13 +13,13 @@ p sheet[1,1].class           # => String
 p sheet[1,1]                 # => "My top 5"
 
 # These are all the same values - alternative syntax
+p sheet.rows(1).cells(0).value   
+p sheet.cells(1,1).value
 p sheet.A1
 p sheet[1,1]
-p sheet.cells(0,0).value
-p sheet.rows(0).cells(0).value   
 
 # How to inspect/manipulate the Cell object
-sheet.cells(1,1)            # => Rspreadsheet::Cell
+sheet.cells(1,1)                 # => Rspreadsheet::Cell
 sheet.cells(1,1).format
 sheet.cells(1,1).format.size = 15
 sheet.cells(1,1).format.weight = bold

data/Guardfile

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

data/investigate.rb

@@ -0,0 +1,19 @@
+require 'xml'
+
+ns = XML::Namespace.new(XML::Node.new('xxx'), 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+
+d = XML::Document.new
+nr = XML::Node.new('root', 'text')
+d.root = nr
+n2 = XML::Node.new('element', 'content')
+nr << n2
+puts d.to_s
+
+n2.namespaces.namespace = ns
+nr.namespaces.namespace = ns
+puts d.to_s
+
+n2.namespaces.namespace = ns
+puts d.to_s
+

data/lib/class_extensions.rb

@@ -1,36 +1,48 @@
 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 }
     return result
   end
   # if node2 contains at least all that I do
-  def simpifation_of?(node2)
-    return false if (self.name != node2.name)
+  def simplification_of?(node2)
+    first_diff(node2).nil?
+  end
+  # return first difference where self has something more than node2 does
+  def first_diff(node2)
+    where = self.path.split('/').last
+    
+    return "#{where}> Equivalent node does not exist: #{self.name} != NOTHING" if node2.nil?
+    return "#{where}> Names are different: #{self.name} != #{node2.name}" if (self.name != node2.name)
     self.attributes.each do |attr|
-      return false unless node2.attributes[attr.name] == attr.value
+      return "#{where}> Attribute #{attr} have diffent values: #{attr.value} != #{node2.attributes[attr.name]}" unless node2.attributes[attr.name] == attr.value
     end
     
     elems1 = self.elements
     elems2 = node2.elements
-    return false if (elems1.length != elems2.length) 
+#     return "#{where}> elements have different number of subelements #{elems1.length} !=  #{elems2.length}" if (elems1.length != elems2.length) 
     elems1.length.times do |i|
-      unless 
-        case elems1[i].node_type_name
-          when 'text' 
-            (elems1[i].to_s == elems2[i].to_s) 
-          when 'element' 
-            elems1[i].simpifation_of?(elems2[i])
-          else true 
-        end
-      then 
-        return false 
+      if (elems1[i].node_type_name == 'text') && ((elems1[i].to_s != elems2[i].to_s) )
+        return  "#{where}> #{i+1}th text subelements are different: #{elems1[i].to_s} != #{elems2[i].to_s}"
+      elsif (elems1[i].node_type_name == 'element') && (!elems1[i].simplification_of?(elems2[i]))
+        return "#{where}/[#{i+1}]#{elems1[i].first_diff(elems2[i])}"
       end
     end
        
-    return true
+    return nil
+  end
+  def equals?(node2)  #TODO redefine == with this
+    self.simplification_of?(node2) and node2.simplification_of?(self)
   end
-  def equals?(node2)
-    simpifation_of?(node2) and node2.simpifation_of?(self)
+  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,54 +1,166 @@
 require 'andand'
 
 module Rspreadsheet
+
 class Cell
-  attr_reader :value,:col,:row, :source_node
-  def initialize(arow,acol,source_node=nil)
-    @col = acol
-    @row = arow
-    @source_node = source_node
-    unless @source_node.nil?
-      @type = @source_node.attributes['value-type'].to_s
-      if (@source_node.children.size == 0) and (not @source_node.attributes?)
-        @value = nil
-      else
-        # here you also ned to read style not only value
-        @value = case @type
-          when 'float'
-            @source_node.attributes['value'].to_f
-          when 'string'
-            @source_node.elements.first.andand.content.to_s
-          when 'date'
-            Date.strptime(@source_node.attributes['date-value'].to_s, '%Y-%m-%d')
-          when 'percentage'  
-            @source_node.attributes['value'].to_f
-          else
-            if @source_node.children.size == 0
-              nil
-            else
-              nil
-#               raise "Unknown type from #{@source_node.to_s} / children size=#{@source_node.children.size.to_s} / type=#{@type}"
-            end
-        end
-      end
+  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,asource_node=nil)
+    raise "First parameter should be Row object not #{aparent_row.class}" unless aparent_row.kind_of?(Rspreadsheet::Row)
+    @mode = :regular
+    @parent_row = aparent_row
+    if asource_node.nil?
+      asource_node = Cell.empty_cell_node
     end
+    @xmlnode = asource_node
+    @col = coli
   end
-  def to_s
-    value
+  def ns_table; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('table') end
+  def ns_office; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('office') end
+  def ns_text; @parent_row.xmlnode.doc.root.namespaces.find_by_prefix('text') end
+  def to_s; value end
+  def xml; self.source_node.to_s; end
+  def value_xml; self.source_node.children.first.children.first.to_s; end
+  def coordinates; [row,col]; end
+  def row; @parent_row.row; end
+  def value
+    gt = guess_cell_type
+    if (@mode == :regular) or (@mode == @repeated)
+      case 
+        when gt == nil then nil
+        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
+      end
+    elsif @mode == :outbound # needs to check whether it is still unbound
+      if parent_row.still_out_of_used_range?
+        nil
+      else
+        parent_row.normalize.cells(@col).value
+      end  
+    else
+      raise "Unknown cell mode #{@mode}"
+    end
   end
   def value=(avalue)
-    @value=avalue
-    self
+    if @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
+    elsif (@mode == :repeated) or (@mode == :outbound ) # Cell did not exist individually yet, detach row and create editable cell
+      row = @parent_row.detach
+      row.cells(@col).value = avalue
+    else
+      raise "Unknown cell mode #{@mode}"
+    end
   end
-  def xml
-    self.source_node.to_s
+  def remove_all_value_attributes_and_content(node)
+    if att = Tools.get_ns_attribute(@xmlnode, 'office','value') then att.remove! end
+    if att = Tools.get_ns_attribute(@xmlnode, 'office','date-value') then att.remove! end
+    @xmlnode.content=''
   end
-  def value_xml
-#     self.source_node.children.first.to_s
-    self.source_node.children.first.children.first.to_s
+  def set_type_attribute(typestring)
+    Tools.set_ns_attribute(@xmlnode,'office','value-type',typestring)
   end
-  def coordinates
-    [row,col]
+  
+  # based on @xmlnode and optionally value which is about to be assigned, guesses which type the result should be
+  def guess_cell_type(avalue=nil)
+    # try guessing by value
+    valueguess = case avalue
+      when Numeric then Float
+      when Date then Date
+      when String,nil then nil
+      else nil
+    end
+    result = valueguess
+    
+    if valueguess.nil? # valueguess is most important
+      # if not succesfull then try guessing by type
+      type = @xmlnode.attributes['value-type'].to_s
+      typeguess = case type
+        when 'float' then Float
+        when 'string' then String
+        when 'date' then Date
+        when 'percentage' then 'percentage'
+        else 
+          if @xmlnode.children.size == 0
+            nil
+          else 
+            raise "Unknown type from #{@xmlnode.to_s} / children size=#{@xmlnode.children.size.to_s} / type=#{type}"
+          end
+      end
+      
+      result =
+      if !typeguess.nil? # if not certain by value, but have a typeguess
+        if !avalue.nil?  # with value we may try converting
+          if (typeguess(avalue) rescue false) # if convertible then it is typeguess
+            typeguess
+          elsif (String(avalue) rescue false) # otherwise try string
+            String
+          else # if not convertible to anyhing concious then nil
+            nil 
+          end
+        else             # without value we just beleive typeguess
+          typeguess
+        end
+      else # it not have a typeguess
+        if (String(avalue) rescue false) # convertible to String
+          String
+        else
+          nil
+        end
+      end
+    end
+    result
+  end
+  def inspect
+    "#<Cell:[#{row},#{col}]=#{value}(#{guess_cell_type.to_s})"
   end
 end
+
 end
+
+# ## initialize cells
+#   @cells = Hash.new do |hash, coords|
+#     # we create empty cell and place it to hash, we do not have to check whether there is a cell in XML already, because it would be in hash as well
+#     hash[coords]=Cell.new(coords[0],coords[1])
+#     # TODO: create XML empty node here or upon save?
+#   end
+#   rowi = 1
+#   unless @xmlnode.nil?
+#     @xmlnode.elements.select{ |node| node.name == 'table-row'}.each do |row_source_node|
+#       coli = 1
+#       row_source_node.elements.select{ |node| node.name == 'table-cell'}.each do |cell_source_node|
+#         initialize_cell(rowi,coli,cell_source_node)
+#         coli += 1
+#       end
+#       rowi += 1
+#     end
+#   end
+
+