rubyXL-git-ref-6002046 2.0.0

data/lib/rubyXL/generic_storage.rb

@@ -0,0 +1,40 @@
+module RubyXL
+  class GenericStorage < Hash
+    attr_reader :local_dir_path
+
+    def initialize(local_dir_path)
+      @local_dir_path = local_dir_path
+      @mode = 'r'
+      super
+    end
+
+    def binary
+      @mode = 'rb'
+      self
+    end
+
+    def load_dir(root_dir)
+      dirpath = File.join(root_dir, @local_dir_path)
+      if File.directory?(dirpath) then
+        (Dir.new(dirpath).entries - ['.', '..', '.DS_Store', '_rels']).each { |filename|
+          self[filename] = File.open(File.join(dirpath, filename), @mode).read
+        }
+      end
+
+      self
+    end
+
+    def load_file(root_dir, filename)
+      filepath = File.join(root_dir, @local_dir_path, filename)
+      self[filename] = File.open(filepath, @mode).read if File.readable?(filepath)
+      self
+    end
+
+    def add_to_zip(zipfile)
+      each_pair { |filename, data|
+        zipfile.get_output_stream(File.join(@local_dir_path, filename)) { |f| f << data }
+      }
+    end
+
+  end
+end

data/lib/rubyXL/objects/border.rb

@@ -0,0 +1,53 @@
+module RubyXL
+
+  class BorderEdge < OOXMLObject
+    define_attribute(:style,   :string)
+    define_child_node(RubyXL::Color, :default => 'none', :values => 
+                        %w{ none thin medium dashed dotted thick double hair
+                            mediumDashed dashDot mediumDashDot dashDotDot slantDashDot } )
+
+    def ==(other)
+      style == other.style
+    end
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_border-2.html
+  class Border < OOXMLObject
+    define_attribute(:diagonalUp,   :bool)
+    define_attribute(:diagonalDown, :bool)
+    define_attribute(:outline,      :bool, :default => true)
+    define_child_node(RubyXL::BorderEdge, :node_name => :left)
+    define_child_node(RubyXL::BorderEdge, :node_name => :right)
+    define_child_node(RubyXL::BorderEdge, :node_name => :top)
+    define_child_node(RubyXL::BorderEdge, :node_name => :bottom)
+    define_child_node(RubyXL::BorderEdge, :node_name => :diagonal)
+    define_child_node(RubyXL::BorderEdge, :node_name => :vertical)
+    define_child_node(RubyXL::BorderEdge, :node_name => :horizontal)
+    define_element_name 'border'
+    set_countable
+
+    def get_edge_style(direction)
+      edge = self.send(direction)
+      edge && edge.style
+    end
+
+    def set_edge_style(direction, style)
+      self.send("#{direction}=", RubyXL::BorderEdge.new(:style => style))
+    end
+
+    def ==(other)
+      (diagonal_up == other.diagonal_up) &&
+        (diagonal_down == other.diagonal_down) &&
+        (outline == other.outline) &&
+        (left == other.left) &&
+        (right == other.right) &&
+        (top == other.top) &&
+        (bottom == other.bottom) &&
+        (diagonal == other.diagonal) &&
+        (vertical == other.vertical) &&
+        (horizontal == other.horizontal)
+    end
+
+  end
+
+end

data/lib/rubyXL/objects/cell_style.rb

@@ -0,0 +1,73 @@
+module RubyXL
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_cellStyle-1.html
+  class CellStyle < OOXMLObject
+    define_attribute(:name,          :string)
+    define_attribute(:xfId,          :int,  :required => true)
+    define_attribute(:builtinId,     :int)
+    define_attribute(:iLevel,        :int)
+    define_attribute(:hidden,        :bool)
+    define_attribute(:customBuiltin, :bool)
+    define_element_name 'cellStyle'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_alignment-1.html
+  class Alignment < OOXMLObject
+    define_attribute(:horizontal,      :string,
+                       :values => %w{general left center right fill justify centerContinuous distributed})
+    define_attribute(:vertical,        :string,
+                       :values => %w{top center bottom justify distributed})
+    define_attribute(:textRotation,    :int)
+    define_attribute(:wrapText,        :bool)
+    define_attribute(:indent,          :int)
+    define_attribute(:relativeIndent,  :int)
+    define_attribute(:justifyLastLine, :bool)
+    define_attribute(:shrinkToFit,     :bool)
+    define_attribute(:readingOrder,    :int)
+    define_element_name 'alignment'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_protection-1.html
+  class Protection < OOXMLObject
+    define_attribute(:locked, :bool)
+    define_attribute(:hidden, :bool)
+    define_element_name 'protection'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_xf-1.html
+  class XF < OOXMLObject
+    define_attribute(:numFmtId,          :int)
+    define_attribute(:fontId,            :int)
+    define_attribute(:fillId,            :int)
+    define_attribute(:borderId,          :int)
+    define_attribute(:xfId,              :int)
+    define_attribute(:quotePrefix,       :bool, :default => false )
+    define_attribute(:pivotButton,       :bool, :default => false )
+    define_attribute(:applyNumberFormat, :bool)
+    define_attribute(:applyFont,         :bool)
+    define_attribute(:applyFill,         :bool)
+    define_attribute(:applyBorder,       :bool)
+    define_attribute(:applyAlignment,    :bool)
+    define_attribute(:applyProtection,   :bool)
+    define_child_node(RubyXL::Alignment)
+    define_child_node(RubyXL::Protection)
+    define_element_name 'xf'
+    set_countable
+
+    def ==(other)
+      (self.num_fmt_id == other.num_fmt_id) &&
+        (self.font_id == other.font_id) &&
+        (self.fill_id == other.fill_id) &&
+        (self.border_id == other.border_id) &&
+        (self.xf_id == other.xf_id)
+    end
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_numFmt-1.html
+  class NumFmt < OOXMLObject
+    define_attribute(:numFmtId,   :int,    :required => true)
+    define_attribute(:formatCode, :string, :required => true)
+    define_element_name 'numFmt'
+  end
+
+end

data/lib/rubyXL/objects/color.rb

@@ -0,0 +1,23 @@
+module RubyXL
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_color-4.html
+  class Color < OOXMLObject
+    define_attribute(:auto,    :bool)
+    define_attribute(:indexed, :int)
+    define_attribute(:rgb,     :string)
+    define_attribute(:theme,   :int)
+    define_attribute(:tint,    :float)
+    define_element_name 'color'
+
+    #validates hex color code, no '#' allowed
+    def self.validate_color(color)
+      if color =~ /^([a-f]|[A-F]|[0-9]){6}$/
+        return true
+      else
+        raise 'invalid color'
+      end
+    end
+
+  end
+
+end

data/lib/rubyXL/objects/column_range.rb

@@ -0,0 +1,88 @@
+module RubyXL
+
+  class ColumnRange
+    # +min+ and +max+ are column 0-based indices, as opposed to Excel's 1-based column numbers
+    attr_accessor :min, :max, :width, :custom_width, :style_index
+
+    def initialize(attrs = {})
+      @min            = attrs['min']
+      @max            = attrs['max']
+      @width          = attrs['width']
+      @custom_width   = attrs['customWidth']
+      @style_index    = attrs['style']
+    end
+
+    def self.parse(node)
+      range = self.new
+      range.min          = RubyXL::Parser.attr_int(node, 'min') - 1
+      range.max          = RubyXL::Parser.attr_int(node, 'max') - 1
+      range.width        = RubyXL::Parser.attr_float(node, 'width')
+      range.custom_width = RubyXL::Parser.attr_int(node, 'customWidth')
+      range.style_index  = RubyXL::Parser.attr_int(node, 'style')
+      range
+    end 
+
+    def delete_column(col)
+      self.min -=1 if min >= col
+      self.max -=1 if max >= col
+    end
+
+    def insert_column(col)
+      self.min +=1 if min >= col
+      self.max +=1 if max >= col - 1
+    end
+
+    def self.insert_column(col_index, ranges)
+      ranges.each { |range| range.insert_column(col_index) }
+    end
+
+    def include?(col_index)
+      (min..max).include?(col_index)
+    end
+
+    # This method is used to change attributes on a column range, which may involve 
+    # splitting existing column range into multiples.
+    def self.update(col_index, ranges, attrs)
+
+      old_range = RubyXL::ColumnRange.find(col_index, ranges)
+
+      if old_range.nil? then
+        new_range = RubyXL::ColumnRange.new(attrs.merge({ 'min' => col_index, 'max' => col_index }))
+        ranges << new_range
+        return new_range
+      elsif old_range.min == col_index && 
+              old_range.max == col_index then # Single column range, OK to change in place
+
+        old_range.width = attrs['width'] if attrs['width']
+        old_range.custom_width = attrs['customWidth'] if attrs['customWidth']
+        old_range.style_index = attrs['style'] if attrs['style']
+        return old_range
+      else
+        raise "Range splitting not implemented yet"
+      end
+    end
+
+    def self.find(col_index, ranges)
+      ranges.find { |range| range.include?(col_index) }
+    end
+
+    def self.ref2ind(ref)
+      col = 0
+      ref.each_byte { |chr| col = col * 26 + (chr - 64) }
+      col - 1
+    end
+
+    def self.ind2ref(ind)
+      str = ''
+
+      loop do
+        x = ind % 26
+        str = ('A'.ord + x).chr + str
+        ind = (ind / 26).floor - 1
+        return str if ind < 0
+      end
+    end
+
+  end
+
+end

data/lib/rubyXL/objects/data_validation.rb

@@ -0,0 +1,31 @@
+module RubyXL
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_dataValidation-1.html
+  class DataValidation < OOXMLObject
+    define_attribute(:type,             :string, :default => 'none',
+                        :values => %w{ none whole decimal list date time textLength custom })
+    define_attribute(:errorStyle,       :string, :default => 'stop',
+                        :values => %w{ stop warning information })
+    define_attribute(:imeMode,          :string, :default => 'noControl',
+                        :values => %w{ noControl off on disabled hiragana fullKatakana halfKatakana
+                            fullAlpha halfAlpha fullHangul halfHangul })
+    define_attribute(:operator,         :string, :default => 'between',
+                        :values => %w{ between notBetween equal notEqual lessThan lessThanOrEqual
+                            greaterThan greaterThanOrEqual })
+    define_attribute(:allowBlank,       :bool, :default => 'false')
+    define_attribute(:showDropDown,     :bool, :default => 'false')
+    define_attribute(:showInputMessage, :bool, :default => 'false')
+    define_attribute(:showErrorMessage, :bool, :default => 'false')
+    define_attribute(:errorTitle,       :string)
+    define_attribute(:error,            :string)
+    define_attribute(:promptTitle,      :string)
+    define_attribute(:prompt,           :string)
+    define_attribute(:sqref,            :sqref, :required => true)
+
+
+    define_child_node(RubyXL::Formula,  :node_name => :formula1)
+    define_child_node(RubyXL::Formula,  :node_name => :formula2)
+    define_element_name 'dataValidation'
+
+  end
+
+end

data/lib/rubyXL/objects/defined_name.rb

@@ -0,0 +1,27 @@
+module RubyXL
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_definedName-2.html
+  class DefinedName < OOXMLObject
+    define_attribute(:name,              :string, :required => true)
+    define_attribute(:comment,           :string)
+    define_attribute(:customMenu,        :string)
+    define_attribute(:description,       :string)
+    define_attribute(:help,              :string)
+    define_attribute(:description,       :string)
+    define_attribute(:localSheetId,      :string)
+
+    define_attribute(:hidden,            :bool, :default => false)
+    define_attribute(:function,          :bool, :default => false)
+    define_attribute(:vbProcedure,       :bool, :default => false)
+    define_attribute(:xlm,               :bool, :default => false)
+
+    define_attribute(:functionGroupId,   :int)
+    define_attribute(:shortcutKey,       :string)
+    define_attribute(:publishToServer,   :bool, :default => false)
+    define_attribute(:workbookParameter, :bool, :default => false)
+
+    define_attribute(:_,                 :string, :accessor => :reference)
+    define_element_name 'definedName'
+  end
+
+end

data/lib/rubyXL/objects/fill.rb

@@ -0,0 +1,42 @@
+module RubyXL
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_gradientFill-1.html
+  class Stop < OOXMLObject
+    define_attribute(:position, :float)
+    define_child_node(RubyXL::Color)
+    define_element_name 'stop'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_patternFill-1.html
+  class PatternFill < OOXMLObject
+    define_attribute(:patternType, :string, :values =>
+                       %w{ none solid mediumGray darkGray lightGray
+                           darkHorizontal darkVertical darkDown darkUp darkGrid darkTrellis
+                           lightHorizontal lightVertical lightDown lightUp lightGrid lightTrellis
+                           gray125 gray0625 })
+    define_child_node(RubyXL::Color, :node_name => :fgColor )
+    define_child_node(RubyXL::Color, :node_name => :bgColor )
+    define_element_name 'patternFill'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_gradientFill-1.html
+  class GradientFill < OOXMLObject
+    define_attribute(:type,   :string, :values => %w{ linear path }, :default => 'linear')
+    define_attribute(:degree, :float,  :default => 0)
+    define_attribute(:left,   :float,  :default => 0)
+    define_attribute(:right,  :float,  :default => 0)
+    define_attribute(:top,    :float,  :default => 0)
+    define_attribute(:bottom, :float,  :default => 0)
+    define_child_node(RubyXL::Stop, :collection => true)
+    define_element_name 'gradientFill'
+  end
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_fill-1.html
+  class Fill < OOXMLObject
+    define_child_node(RubyXL::PatternFill)
+    define_child_node(RubyXL::GradientFill)
+    define_element_name 'fill'
+    set_countable
+  end
+
+end

data/lib/rubyXL/objects/font.rb

@@ -0,0 +1,109 @@
+module RubyXL
+
+  class BooleanValue < OOXMLObject
+    define_attribute(:val, :bool, :required => true, :default => true)
+  end
+
+  class StringValue < OOXMLObject
+    define_attribute(:val, :string, :required => true)
+  end
+
+  class IntegerValue < OOXMLObject
+    define_attribute(:val, :int, :required => true)
+  end
+
+  class FloatValue < OOXMLObject
+    define_attribute(:val, :float, :required => true)
+  end
+
+
+  # http://www.schemacentral.com/sc/ooxml/e-ssml_font-1.html
+  class Font < OOXMLObject
+    define_child_node(RubyXL::StringValue,  :node_name => :name)
+    define_child_node(RubyXL::IntegerValue, :node_name => :charset)
+    define_child_node(RubyXL::IntegerValue, :node_name => :family)
+    define_child_node(RubyXL::BooleanValue, :node_name => :b)
+    define_child_node(RubyXL::BooleanValue, :node_name => :i)
+    define_child_node(RubyXL::BooleanValue, :node_name => :strike)
+    define_child_node(RubyXL::BooleanValue, :node_name => :outline)
+    define_child_node(RubyXL::BooleanValue, :node_name => :shadow)
+    define_child_node(RubyXL::BooleanValue, :node_name => :condense)
+    define_child_node(RubyXL::BooleanValue, :node_name => :extend)
+    define_child_node(RubyXL::Color)
+    define_child_node(RubyXL::FloatValue,   :node_name => :sz)
+    define_child_node(RubyXL::BooleanValue, :node_name => :u)
+    define_child_node(RubyXL::StringValue,  :node_name => :vertAlign)
+    define_child_node(RubyXL::StringValue,  :node_name => :scheme)
+    define_element_name 'font'
+    set_countable
+
+    def ==(other)
+     (!(self.i && self.i.val) == !(other.i && other.i.val)) &&
+       (!(self.b && self.b.val) == !(other.b && other.b.val)) &&
+       (!(self.u && self.u.val) == !(other.u && other.u.val)) &&
+       (!(self.strike && self.strike.val) == !(other.strike && other.strike.val)) &&
+       ((self.name && self.name.val) == (other.name && other.name.val)) &&
+       ((self.sz && self.sz.val) == (other.sz && other.sz.val)) &&
+       (self.color == other.color) # Need to write proper comparison for color
+    end
+
+    def is_italic
+      i && i.val
+    end
+
+    def set_italic(val)
+      self.i = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def is_bold
+      b && b.val
+    end
+
+    def set_bold(val)
+      self.b = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def is_underlined
+      u && u.val
+    end
+
+    def set_underline(val)
+      self.u = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def is_strikethrough
+      strike && strike.val
+    end
+
+    def set_strikethrough(val)
+      self.strike = RubyXL::BooleanValue.new(:val => val)
+    end
+
+    def get_name
+      name && name.val
+    end
+
+    def set_name(val)
+      self.name = RubyXL::StringValue.new(:val => val)
+    end
+
+    def get_size
+      sz && sz.val
+    end
+
+    def set_size(val)
+      self.sz = RubyXL::FloatValue.new(:val => val)
+    end
+
+    def get_rgb_color
+      color && color.rgb
+    end
+
+    # Helper method to modify the font color
+    def set_rgb_color(font_color)
+      self.color = RubyXL::Color.new(:rgb => font_color.to_s)
+    end
+
+  end
+
+end