axlsx 1.0.0

data/lib/axlsx/util/simple_typed_list.rb

@@ -0,0 +1,150 @@
+module Axlsx
+  # A SimpleTypedList is a type restrictive collection that allows some of the methods from Array and supports basic xml serialization.  
+  # @private
+  class SimpleTypedList
+    # The class constants of allowed types
+    # @return [Array]
+    attr_reader :allowed_types
+
+    # The index below which items cannot be removed
+    # @return [Integer]
+    attr_reader :locked_at
+
+    # The tag name to use when serializing this object
+    # by default the parent node for all items in the list is the classname of the first allowed type with the first letter in lowercase. 
+    # @return [String]
+    attr_reader :serialize_as
+
+    # Creats a new typed list
+    # @param [Array, Class] type An array of Class objects or a single Class object
+    # @param [String] serialize The tag name to use in serialization
+    # @raise [ArgumentError] if all members of type are not Class objects    
+    def initialize type, serialize_as=nil
+      if type.is_a? Array
+        type.each { |item| raise ArgumentError, "All members of type must be Class objects" unless item.is_a? Class }
+        @allowed_types = type
+      else
+        raise ArgumentError, "Type must be a Class object or array of Class objects" unless type.is_a? Class
+        @allowed_types = [type]
+      end
+      @list = []
+      @locked_at = nil
+      @serialize_as = serialize_as
+    end
+
+    # Lock this list at the current size
+    # @return [self]
+    def lock
+      @locked_at = @list.size
+      self
+    end
+
+    # Unlock the list
+    # @return [self]
+    def unlock
+      @locked_at = nil
+      self
+    end
+
+    # Concat operator
+    # @param [Any] v the data to be added
+    # @raise [ArgumentError] if the value being added is not one fo the allowed types
+    # @return [Integer] returns the index of the item added.
+    def <<(v)
+      DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
+      @list << v
+      @list.size - 1      
+    end
+
+    # alternate of << method
+    # @see <<
+    def push(v)
+      self.<< v
+    end
+
+    # delete the item from the list
+    # @param [Any] v The item to be deleted.
+    # @raise [ArgumentError] if the item's index is protected by locking
+    # @return [Any] The item deleted
+    def delete(v)
+      return unless @list.include? v
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? @list.index(v)
+      @list.delete v
+    end
+
+    # delete the item from the list at the index position provided
+    # @raise [ArgumentError] if the index is protected by locking
+    # @return [Any] The item deleted
+    def delete_at(index)
+      @list[index]
+      raise ArgumentError, "Item is protected and cannot be deleted" if protected? index
+      @list.delete_at index
+    end
+
+    # positional assignment. Adds the item at the index specified
+    # @param [Integer] index
+    # @param [Any] v
+    # @raise [ArgumentError] if the index is protected by locking
+    # @raise [ArgumentError] if the item is not one of the allowed types
+    def []=(index, v)
+      DataTypeValidator.validate "SimpleTypedList.<<", @allowed_types, v
+      raise ArgumentError, "Item is protected and cannot be changed" if protected? index
+      @list[index] = v
+      v
+    end
+
+    # determines if the index is protected
+    # @param [Integer] index
+    def protected? index
+      return false unless @locked_at.is_a? Fixnum
+      index < @locked_at
+    end
+    
+    # method_mission override to pass allowed methods to the list.
+    # @note 
+    #  the following methods are not allowed
+    #   :replace
+    #   :insert
+    #   :collect!
+    #   :map!
+    #   :pop
+    #   :delete_if
+    #   :reverse!
+    #   :shift
+    #   :shuffle!
+    #   :slice!
+    #   :sort!
+    #   :uniq!
+    #   :unshift
+    #   :zip
+    #   :flatten!
+    #   :fill
+    #   :drop
+    #   :drop_while
+    #   :delete_if
+    #   :clear
+    #   :concat
+    def method_missing(meth, *args, &block)
+      raise ArgumentError, "#{meth} not supported" if [:replace, :insert, :collect!, :map!, :pop, :delete_if, :reverse!, :shift, :shuffle!, :slice!, :sort!, :uniq!, :unshift, :zip, :flatten!, :fill, :drop, :drop_while, :delete_if, :clear, :concat].include? meth.to_sym        
+      if @list.respond_to? meth
+        @list.send(meth, *args, &block)      
+      else
+        super
+      end
+    end
+
+    # Serializes the list
+    # If the serialize_as property is set, it is used as the parent node name. 
+    # If the serialize_as property is nil, the first item in the list of allowed_types will be used, having the first letter of the class changed to lower case.
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String]
+    def to_xml(xml)
+      classname = @allowed_types[0].name.split('::').last
+      el_name = serialize_as || (classname[0,1].downcase + classname[1..-1]).pluralize
+      xml.send(el_name, :count=>@list.size) {
+        @list.each { |item| item.to_xml(xml) }
+      }
+    end
+  end
+
+end

data/lib/axlsx/util/validators.rb

@@ -0,0 +1,132 @@
+module Axlsx
+  # Validate a value against a specific list of allowed values.
+  class RestrictionValidator
+    # Perform validation
+    # @param [String] name The name of what is being validatied. This is included in the error message
+    # @param [Array] choices The list of choices to validate against
+    # @param [Any] v The value to be validated  
+    # @raise [ArgumentError] Raised if the value provided is not in the list of choices.
+    # @return [Boolean] true if validation succeeds.
+    def self.validate(name, choices, v)
+      raise ArgumentError, (ERR_RESTRICTION % [v.to_s, name, choices.inspect]) unless choices.include?(v)      
+      true
+    end
+  end
+
+  # Validates the value against the regular expression provided.
+  # @param [String] name The name of what is being validated. This is included in the output when the value is invalid
+  # @param [Regexp] regex The regular expression to evaluate
+  # @param [Any] v The value to validate.
+  class RegexValidator
+    def self.validate(name, regex, v)
+      raise ArgumentError, (ERR_REGEX % [v.inspect, regex.to_s]) unless (v.respond_to?(:=~) && v =~ regex)
+    end
+  end
+  # Validate that the class of the value provided is either an instance or the class of the allowed types and that any specified additional validation returns true.
+  class DataTypeValidator
+    # Perform validation
+    # @param [String] name The name of what is being validated. This is included in the error message
+    # @param [Array, Class] types A single class or array of classes that the value is validated against.
+    # @param [Block] other Any block that must evaluate to true for the value to be valid
+    # @raise [ArugumentError] Raised if the class of the value provided is not in the specified array of types or the block passed returns false
+    # @return [Boolean] true if validation succeeds.
+    # @see validate_boolean
+    def self.validate(name, types, v, other= lambda{|v| true })
+      types = [types] unless types.is_a? Array
+      valid_type = false
+      if v.class == Class
+        types.each { |t| valid_type = true if v.ancestors.include?(t) }
+      else
+        types.each { |t| valid_type = true if v.is_a?(t) }
+      end
+      raise ArgumentError, (ERR_TYPE % [v.inspect, name, types.inspect]) unless (other.call(v) && valid_type)
+    end
+    true
+  end
+
+  # Requires that the value is a Fixnum or Integer and is greater or equal to 0
+  # @param [Any] v The value validated
+  # @raise [ArgumentError] raised if the value is not a Fixnum or Integer value greater or equal to 0
+  # @return [Boolean] true if the data is valid
+  def self.validate_unsigned_int(v)
+    DataTypeValidator.validate(:unsigned_int, [Fixnum, Integer], v, lambda { |v| v.respond_to?(:>=) && v >= 0 })
+  end
+
+  # Requires that the value is a Fixnum or Integer
+  # @param [Any] v The value validated
+  def self.validate_int(v)
+    DataTypeValidator.validate :unsigned_int, [Fixnum, Integer], v
+  end
+
+  # Requires that the value is a form that can be evaluated as a boolean in an xml document.
+  # The value must be an instance of Fixnum, String, Integer, Symbol, TrueClass or FalseClass and 
+  # it must be one of 0, 1, "true", "false", :true, :false, true, false, "0", or "1"
+  # @param [Any] v The value validated
+  def self.validate_boolean(v)
+    DataTypeValidator.validate(:boolean, [Fixnum, String, Integer, Symbol, TrueClass, FalseClass], v, lambda { |v| [0, 1, "true", "false", :true, :false, true, false, "0", "1"].include?(v) })
+  end
+
+  # Requires that the value is a String
+  # @param [Any] v The value validated
+  def self.validate_string(v)
+    DataTypeValidator.validate :string, String, v
+  end   
+
+  # Requires that the value is a Float
+  # @param [Any] v The value validated
+  def self.validate_float(v)
+    DataTypeValidator.validate :float, Float, v
+  end   
+
+  # Requires that the value is valid pattern type.
+  # valid pattern types must be one of :none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown,
+  # :darkUp, :darkGrid, :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, or :gray0625.
+  # @param [Any] v The value validated
+  def self.validate_pattern_type(v)
+    RestrictionValidator.validate :pattern_type, [:none, :solid, :mediumGray, :darkGray, :lightGray, :darkHorizontal, :darkVertical, :darkDown, :darkUp, :darkGrid,
+       :darkTrellis, :lightHorizontal, :lightVertical, :lightDown, :lightUp, :lightGrid, :lightTrellis, :gray125, :gray0625], v
+  end
+
+  # Requires that the value is a gradient_type.
+  # valid types are :linear and :path
+  # @param [Any] v The value validated
+  def self.validate_gradient_type(v)
+    RestrictionValidator.validate :gradient_type, [:linear, :path], v
+  end
+
+  # Requires that the value is a valid horizontal_alignment
+  # :general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed are allowed
+  # @param [Any] v The value validated
+  def self.validate_horizontal_alignment(v)
+    RestrictionValidator.validate :horizontal_alignment, [:general, :left, :center, :right, :fill, :justify, :centerContinuous, :distributed], v
+  end
+
+  # Requires that the value is a valid vertical_alignment
+  # :top, :center, :bottom, :justify, :distributed are allowed
+  # @param [Any] v The value validated
+  def self.validate_vertical_alignment(v)
+    RestrictionValidator.validate :vertical_alignment, [:top, :center, :bottom, :justify, :distributed], v
+  end
+
+  # Requires that the value is a valid content_type
+  # TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, DRAWING_CT are allowed
+  # @param [Any] v The value validated
+  def self.validate_content_type(v)
+    RestrictionValidator.validate :content_type, [TABLE_CT, WORKBOOK_CT, APP_CT, RELS_CT, STYLES_CT, XML_CT, WORKSHEET_CT, SHARED_STRINGS_CT, CORE_CT, CHART_CT, DRAWING_CT], v
+  end
+
+  # Requires that the value is a valid relationship_type
+  # XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R are allowed
+  # @param [Any] v The value validated
+  def self.validate_relationship_type(v)
+    RestrictionValidator.validate :relationship_type, [XML_NS_R, TABLE_R, WORKBOOK_R, WORKSHEET_R, APP_R, RELS_R, CORE_R, STYLES_R, CHART_R, DRAWING_R], v
+  end
+
+  # Requires that the value is a valid table element type
+  # :wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues are allowed
+  # @param [Any] v The value validated
+  def self.validate_table_element_type(v)
+    RestrictionValidator.validate :table_element_type, [:wholeTable, :headerRow, :totalRow, :firstColumn, :lastColumn, :firstRowStripe, :secondRowStripe, :firstColumnStripe, :secondColumnStripe, :firstHeaderCell, :lastHeaderCell, :firstTotalCell, :lastTotalCell, :firstSubtotalColumn, :secondSubtotalColumn, :thirdSubtotalColumn, :firstSubtotalRow, :secondSubtotalRow, :thirdSubtotalRow, :blankRow, :firstColumnSubheading, :secondColumnSubheading, :thirdColumnSubheading, :firstRowSubheading, :secondRowSubheading, :thirdRowSubheading, :pageFieldLabels, :pageFieldValues], v
+  end
+
+end

data/lib/axlsx/workbook/workbook.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+module Axlsx 
+
+require 'axlsx/workbook/worksheet/cell.rb'
+require 'axlsx/workbook/worksheet/row.rb'
+require 'axlsx/workbook/worksheet/worksheet.rb'
+
+  # The Workbook class is an xlsx workbook that manages worksheets, charts, drawings and styles.
+  # The following parts of the Office Open XML spreadsheet specification are not implimented in this version.
+  # 
+  #   bookViews
+  #   calcPr
+  #   customWorkbookViews
+  #   definedNames
+  #   externalReferences
+  #   extLst
+  #   fileRecoveryPr
+  #   fileSharing
+  #   fileVersion
+  #   functionGroups
+  #   oleSize
+  #   pivotCaches
+  #   smartTagPr
+  #   smartTagTypes
+  #   webPublishing
+  #   webPublishObjects
+  #   workbookProtection
+  #   workbookPr*
+  #
+  #   *workbookPr is only supported to the extend of date1904
+  class Workbook
+
+    # A collection of worksheets associated with this workbook. 
+    # @note The recommended way to manage worksheets is add_worksheet
+    # @see Workbook#add_worksheet
+    # @see Worksheet
+    # @return [SimpleTypedList]
+    attr_reader :worksheets
+
+    # A colllection of charts associated with this workbook
+    # @note The recommended way to manage charts is Worksheet#add_chart
+    # @see Worksheet#add_chart
+    # @see Chart
+    # @return [SimpleTypedList]
+    attr_reader :charts
+
+    # A colllection of drawings associated with this workbook
+    # @note The recommended way to manage drawings is Worksheet#add_chart
+    # @see Worksheet#add_chart
+    # @see Drawing
+    # @return [SimpleTypedList]
+    attr_reader :drawings
+
+    # The styles associated with this workbook
+    # @note The recommended way to manage styles is Styles#add_style
+    # @see Style#add_style
+    # @see Style
+    # @return [Styles]
+    attr_reader :styles
+
+     # The workbook relationships. This is managed automatically by the workbook
+    # @return [Relationships]
+    attr_reader :relationships
+
+    # Instance level access to the class variable 1904
+    # @return [Boolean]
+    attr_accessor :date1904
+
+
+    # Indicates if the epoc date for serialization should be 1904. If false, 1900 is used.
+    @@date1904 = false
+    
+    # Creates a new Workbook
+    # @option options [Boolean] date1904
+    def initialize(options={})
+      @styles = Styles.new
+      @worksheets = SimpleTypedList.new Worksheet
+      @drawings = SimpleTypedList.new Drawing
+      @charts = SimpleTypedList.new Chart
+      self.date1904= options[:date1904] unless options[:date1904].nil?
+    end
+
+    def date1904=(v) Axlsx::validate_boolean v; @@date1904 = v; end
+    def date1904() @@date1904; end    
+
+    # Sets the date1904 attribute to the provided boolean
+    # @return [Boolean]
+    def self.date1904=(v) Axlsx::validate_boolean v; @@date1904 = v; end
+
+    # retrieves the date1904 attribute
+    # @return [Boolean]
+    def self.date1904() @@date1904; end
+
+    # Adds a worksheet to this workbook
+    # @return [Worksheet]
+    # @option options [String] name The name of the worksheet.
+    # @see Worksheet#initialize
+    def add_worksheet(options={})
+      worksheet = Worksheet.new(self, options)
+      yield worksheet if block_given?
+      worksheet
+    end
+    
+    def relationships
+      r = Relationships.new
+      @worksheets.each do |sheet|
+        r << Relationship.new(WORKSHEET_R, WORKSHEET_PN % (r.size+1))
+      end 
+      r << Relationship.new(STYLES_R,  STYLES_PN)
+      r
+    end
+
+    # Serializes the workbook document
+    # @return [String]
+    def to_xml()
+      add_worksheet unless worksheets.size > 0
+      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
+        xml.workbook(:xmlns => XML_NS, :'xmlns:r' => XML_NS_R) {
+          xml.workbookPr(:date1904=>@@date1904)
+          xml.sheets {
+            @worksheets.each_with_index do |sheet, index|              
+              xml.sheet(:name=>sheet.name, :sheetId=>index+1, :"r:id"=>sheet.rId)
+            end
+          }
+        }
+      end      
+      builder.to_xml(:indent=>0)
+    end
+  end
+end

data/lib/axlsx/workbook/worksheet/cell.rb

@@ -0,0 +1,184 @@
+module Axlsx
+  # A cell in a worksheet. 
+  # Cell stores inforamation requried to serialize a single worksheet cell to xml. You must provde the Row that the cell belongs to and the cells value. The data type will automatically be determed if you do not specify the :type option. The default style will be applied if you do not supply the :style option. Changing the cell's type will recast the value to the type specified. Altering the cell's value via the property accessor will also automatically cast the provided value to the cell's type.
+  # @example Manually creating and manipulating Cell objects
+  #   ws = Workbook.new.add_worksheet 
+  #   # This is the simple, and recommended way to create cells. Data types will automatically be determined for you.
+  #   ws.add_row :values => [1,"fish",Time.now]
+  #
+  #   # but you can also do this
+  #   r = ws.add_row
+  #   r.add_cell 1
+  # 
+  #   # or even this
+  #   r = ws.add_row
+  #   c = Cell.new row, 1, :value=>integer
+  #
+  #   # cells can also be accessed via Row#cells. The example here changes the cells type, which will automatically updated the value from 1 to 1.0
+  #   r.cells.last.type = :float
+  # 
+  # @note The recommended way to generate cells is via Worksheet#add_row
+  # 
+  # @see Worksheet#add_row
+  class Cell
+
+    # The index of the cellXfs item to be applied to this cell.
+    # @return [Integer] 
+    # @see Axlsx::Styles
+    attr_accessor :style
+
+    # The row this cell belongs to.
+    # @return [Row]
+    attr_reader :row
+    
+    # The cell's data type. Currently only four types are supported, :time, :float, :integer and :string.
+    # Changing the type for a cell will recast the value into that type. If no type option is specified in the constructor, the type is 
+    # automatically determed.
+    # @see Cell#cell_type_from_value
+    # @return [Symbol] The type of data this cell's value is cast to. 
+    # @raise [ArgumentExeption] Cell.type must be one of [:time, :float, :integer, :string]
+    # @note 
+    #  If the value provided cannot be cast into the type specified, type is changed to :string and the following logic is applied.
+    #   :string to :integer or :float, type coversions always return 0 or 0.0    
+    #   :string, :integer, or :float to :time conversions always return the original value as a string and set the cells type to :string.
+    #  No support is currently implemented for parsing time strings.
+    #
+    attr_accessor :type
+
+    # The value of this cell.
+    # @return casted value based on cell's type attribute.
+    attr_accessor :value
+
+    # @param [Row] row The row this cell belongs to.
+    # @param [Any] value The value associated with this cell. 
+    # @option options [Symbol] type The intended data type for this cell. If not specified the data type will be determined internally based on the vlue provided.
+    # @option options [Integer] style The index of the cellXfs item to be applied to this cell. If not specified, the default style (0) will be applied.
+    def initialize(row, value="", options={})
+      self.row=row
+      #reference for validation
+      @styles = row.worksheet.workbook.styles
+      @type= options[:type] || cell_type_from_value(value)
+      self.style = options[:style] || 0 
+      @value = cast_value(value)
+      @row.cells << self
+    end
+
+    # @return [Integer] The index of the cell in the containing row.
+    def index
+      @row.cells.index(self)
+    end
+
+    # @return [String] The alpha(column)numeric(row) reference for this sell.
+    # @example Relative Cell Reference
+    #   ws.rows.first.cells.first.r #=> "A1" 
+    def r
+      "#{col_ref}#{@row.index+1}"      
+    end
+
+    # @return [String] The absolute alpha(column)numeric(row) reference for this sell.
+    # @example Absolute Cell Reference
+    #   ws.rows.first.cells.first.r #=> "$A$1" 
+    def r_abs
+      "$#{r.split('').join('$')}"
+    end
+
+    # @return [Integer] The cellXfs item index applied to this cell.
+    # @raise [ArgumentError] Invalid cellXfs id if the value provided is not within cellXfs items range.
+    def style=(v)
+      Axlsx::validate_unsigned_int(v)
+      count = @styles.cellXfs.size
+      raise ArgumentError, "Invalid cellXfs id" unless v < count
+      @style = v
+    end
+
+    def type=(v) 
+      RestrictionValidator.validate "Cell.type", [:time, :float, :integer, :string], v      
+      @type=v 
+      self.value = @value
+    end
+
+    def value=(v)
+      #TODO: consider doing value based type determination first?
+      @value = cast_value(v)
+    end
+
+    # Serializes the cell
+    # @param [Nokogiri::XML::Builder] xml The document builder instance this objects xml will be added to.
+    # @return [String] xml text for the cell
+    # @note
+    #   Shared Strings are not used in this library. All values are set directly in the each sheet.
+    def to_xml(xml)
+      if @type == :string
+        #NOTE not sure why, but xml.t @v renders the text as html entities of unicode data
+        xml.c(:r => r, :t=>:inlineStr, :s=>style) { xml.is { xml << "<t>#{value}</t>" } }
+      else
+        xml.c(:r => r, :s => style) { xml.v value }
+      end
+    end
+
+    private 
+
+    # assigns the owning row for this cell.
+    def row=(v) DataTypeValidator.validate "Cell.row", Row, v; @row=v end
+    
+    # converts the column index into alphabetical values.
+    # @note This follows the standard spreadsheet convention of naming columns A to Z, followed by AA to AZ etc.
+    # @return [String]
+    def col_ref
+      chars = []
+      index = self.index
+      while index >= 26 do
+        chars << ((index % 26) + 65).chr
+        index /= 26
+      end
+      chars << ((chars.empty? ? index : index-1) + 65).chr
+      chars.reverse.join
+    end
+
+    # Determines the cell type based on the cell value. 
+    # @note This is only used when a cell is created but no :type option is specified, the following rules apply:
+    #   1. If the value is an instance of Time, the type is set to :time
+    #   2. :float and :integer types are determined by regular expression matching.
+    #   3. Anything that does not meet either of the above is determined to be :string.
+    # @return [Symbol] The determined type
+    def cell_type_from_value(v)      
+      if v.is_a? Time
+        :time
+      elsif v.to_s.match(/\A[+-]?\d+?\Z/) #numeric
+        :integer
+      elsif v.to_s.match(/\A[+-]?\d+\.\d+?\Z/) #float
+        :float
+      else
+        :string
+      end
+    end
+
+    # Cast the value into this cells data type. 
+    # @note 
+    #   About Time - Time in OOXML is *different* from what you might expect. The history as to why is interesting,  but you can safely assume that if you are generating docs on a mac, you will want to specify Workbook.1904 as true when using time typed values.
+    # @see Axlsx#date1904
+    def cast_value(v)
+      if @type == :time && v.is_a?(Time)
+        #todo consider a time parsing method to convert strings to time
+        epoc = Workbook.date1904 ? Time.local(1904,1,1,0,0,0,0,v.zone) : Time.local(1900,1,1,0,0,0,0,v.zone)
+        ((v - epoc) /60.0/60.0/24.0).to_f
+      elsif @type == :float
+        v.to_f
+      elsif @type == :integer
+        v.to_i
+      else
+        @type = :string
+        v.to_s
+        # curious as to why this would be the cells responsibility
+        # convert your values before passing them in wankers! CGI.unescapeHTML(v.to_s).to_xs
+        # to revert, load this once when the gem is loaded.
+        # unless String.method_defined? :to_xs
+        #   require 'fast_xs' #dep
+        #   class String
+        #     alias_method :to_xs, :fast_xs
+        #   end
+        # end
+      end
+    end    
+  end
+end