rubyXL 3.4.25 → 3.4.38

data/rdoc/js/{navigation.js → search_navigation.js}

@@ -1,12 +1,12 @@
 /*
- * Navigation allows movement using the arrow keys through the search results.
+ * SearchNavigation allows movement using the arrow keys through the search results.
  *
  * When using this library you will need to set scrollIntoView to the
  * appropriate function for your layout.  Use scrollInWindow if the container
  * is not scrollable and scrollInElement if the container is a separate
  * scrolling region.
  */
-Navigation = new function() {
+SearchNavigation = new function() {
   this.initNavigation = function() {
     var _this = this;
 
@@ -23,24 +23,24 @@ Navigation = new function() {
 
   this.onkeydown = function(e) {
     if (!this.navigationActive) return;
-    switch(e.keyCode) {
-      case 37: //Event.KEY_LEFT:
+    switch(e.key) {
+      case 'ArrowLeft':
         if (this.moveLeft()) e.preventDefault();
         break;
-      case 38: //Event.KEY_UP:
-        if (e.keyCode == 38 || e.ctrlKey) {
+      case 'ArrowUp':
+        if (e.key == 'ArrowUp' || e.ctrlKey) {
           if (this.moveUp()) e.preventDefault();
         }
         break;
-      case 39: //Event.KEY_RIGHT:
+      case 'ArrowRight':
         if (this.moveRight()) e.preventDefault();
         break;
-      case 40: //Event.KEY_DOWN:
-        if (e.keyCode == 40 || e.ctrlKey) {
+      case 'ArrowDown':
+        if (e.key == 'ArrowDown' || e.ctrlKey) {
           if (this.moveDown()) e.preventDefault();
         }
         break;
-      case 13: //Event.KEY_RETURN:
+      case 'Enter':
         if (this.current) e.preventDefault();
         this.select(this.current);
         break;

data/rdoc/js/search_ranker.js

@@ -0,0 +1,239 @@
+/**
+ * Aliki Search Implementation
+ *
+ * Search algorithm with the following priorities:
+ * 1. Exact full_name match always wins (for namespace/method queries)
+ * 2. Exact name match gets high priority
+ * 3. Match types:
+ *    - Namespace queries (::) and method queries (# or .) match against full_name
+ *    - Regular queries match against unqualified name
+ *    - Prefix (10000) > substring (5000) > fuzzy (1000)
+ * 4. First character determines type priority:
+ *    - Starts with lowercase: methods first
+ *    - Starts with uppercase: classes/modules/constants first
+ * 5. Within same type priority:
+ *    - Unqualified match > qualified match
+ *    - Shorter name > longer name
+ * 6. Class methods > instance methods
+ * 7. Result limit: 30
+ * 8. Minimum query length: 1 character
+ */
+
+var MAX_RESULTS = 30;
+var MIN_QUERY_LENGTH = 1;
+
+/*
+ * Scoring constants - organized in tiers where each tier dominates lower tiers.
+ * This ensures match type always beats type priority, etc.
+ *
+ * Tier 0: Exact matches (immediate return)
+ * Tier 1: Match type (prefix > substring > fuzzy)
+ * Tier 2: Exact name bonus
+ * Tier 3: Type priority (method vs class based on query case)
+ * Tier 4: Minor bonuses (top-level, class method, name length)
+ */
+var SCORE_EXACT_FULL_NAME = 1000000;  // Tier 0: Query exactly matches full_name
+var SCORE_MATCH_PREFIX    = 10000;    // Tier 1: Query is prefix of name
+var SCORE_MATCH_SUBSTRING = 5000;     // Tier 1: Query is substring of name
+var SCORE_MATCH_FUZZY     = 1000;     // Tier 1: Query chars appear in order
+var SCORE_EXACT_NAME      = 500;      // Tier 2: Name exactly equals query
+var SCORE_TYPE_PRIORITY   = 100;      // Tier 3: Preferred type (method/class)
+var SCORE_TOP_LEVEL       = 50;       // Tier 4: Top-level over namespaced
+var SCORE_CLASS_METHOD    = 10;       // Tier 4: Class method over instance method
+
+/**
+ * Check if all characters in query appear in order in target
+ * e.g., "addalias" fuzzy matches "add_foo_alias"
+ */
+function fuzzyMatch(target, query) {
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    ti = target.indexOf(query[qi], ti);
+    if (ti === -1) return false;
+    ti++;
+  }
+  return true;
+}
+
+/**
+ * Parse and normalize a search query
+ * @param {string} query - The raw search query
+ * @returns {Object} Parsed query with normalized form and flags
+ */
+function parseQuery(query) {
+  // Lowercase for case-insensitive matching (so "hash" finds both Hash class and #hash methods)
+  var normalized = query.toLowerCase();
+  var isNamespaceQuery = query.includes('::');
+  var isMethodQuery = query.includes('#') || query.includes('.');
+
+  // Normalize . to :: (RDoc uses :: for class methods in full_name)
+  if (query.includes('.')) {
+    normalized = normalized.replace(/\./g, '::');
+  }
+
+  return {
+    original: query,
+    normalized: normalized,
+    isNamespaceQuery: isNamespaceQuery,
+    isMethodQuery: isMethodQuery,
+    // Namespace and method queries match against full_name instead of name
+    matchesFullName: isNamespaceQuery || isMethodQuery,
+    // If query starts with lowercase, prioritize methods; otherwise prioritize classes/modules/constants
+    prioritizeMethod: !/^[A-Z]/.test(query)
+  };
+}
+
+/**
+ * Main search function
+ * @param {string} query - The search query
+ * @param {Array} index - The search index to search in
+ * @returns {Array} Array of matching entries, sorted by relevance
+ */
+function search(query, index) {
+  if (!query || query.length < MIN_QUERY_LENGTH) {
+    return [];
+  }
+
+  var q = parseQuery(query);
+  var results = [];
+
+  for (var i = 0; i < index.length; i++) {
+    var entry = index[i];
+    var score = computeScore(entry, q);
+
+    if (score !== null) {
+      results.push({ entry: entry, score: score });
+    }
+  }
+
+  results.sort(function(a, b) {
+    return b.score - a.score;
+  });
+
+  return results.slice(0, MAX_RESULTS).map(function(r) {
+    return r.entry;
+  });
+}
+
+/**
+ * Compute the relevance score for an entry
+ * @param {Object} entry - The search index entry
+ * @param {Object} q - Parsed query from parseQuery()
+ * @returns {number|null} Score or null if no match
+ */
+function computeScore(entry, q) {
+  var name = entry.name;
+  var fullName = entry.full_name;
+  var type = entry.type;
+
+  var nameLower = name.toLowerCase();
+  var fullNameLower = fullName.toLowerCase();
+
+  // Exact full_name match (e.g., "Array#filter" matches Array#filter)
+  if (q.matchesFullName && fullNameLower === q.normalized) {
+    return SCORE_EXACT_FULL_NAME;
+  }
+
+  var matchScore = 0;
+  var target = q.matchesFullName ? fullNameLower : nameLower;
+
+  if (target.startsWith(q.normalized)) {
+    matchScore = SCORE_MATCH_PREFIX;     // Prefix (e.g., "Arr" matches "Array")
+  } else if (target.includes(q.normalized)) {
+    matchScore = SCORE_MATCH_SUBSTRING;  // Substring (e.g., "ray" matches "Array")
+  } else if (fuzzyMatch(target, q.normalized)) {
+    matchScore = SCORE_MATCH_FUZZY;      // Fuzzy (e.g., "addalias" matches "add_foo_alias")
+  } else {
+    return null;
+  }
+
+  var score = matchScore;
+  var isMethod = (type === 'instance_method' || type === 'class_method');
+
+  if (q.prioritizeMethod ? isMethod : !isMethod) {
+    score += SCORE_TYPE_PRIORITY;
+  }
+
+  if (type === 'class_method') score += SCORE_CLASS_METHOD;
+  if (name === fullName) score += SCORE_TOP_LEVEL;  // Top-level (Hash) > namespaced (Foo::Hash)
+  if (nameLower === q.normalized) score += SCORE_EXACT_NAME;  // Exact name match
+  score -= name.length;
+
+  return score;
+}
+
+/**
+ * SearchRanker class for compatibility with the Search UI
+ * Provides ready() and find() interface
+ */
+function SearchRanker(index) {
+  this.index = index;
+  this.handlers = [];
+}
+
+SearchRanker.prototype.ready = function(fn) {
+  this.handlers.push(fn);
+};
+
+SearchRanker.prototype.find = function(query) {
+  var q = parseQuery(query);
+  var rawResults = search(query, this.index);
+  var results = rawResults.map(function(entry) {
+    return formatResult(entry, q);
+  });
+
+  var _this = this;
+  this.handlers.forEach(function(fn) {
+    fn.call(_this, results, true);
+  });
+};
+
+/**
+ * Format a search result entry for display
+ */
+function formatResult(entry, q) {
+  var result = {
+    title: highlightMatch(entry.full_name, q),
+    path: entry.path,
+    type: entry.type
+  };
+
+  if (entry.snippet) {
+    result.snippet = entry.snippet;
+  }
+
+  return result;
+}
+
+/**
+ * Add highlight markers (\u0001 and \u0002) to matching portions of text
+ * @param {string} text - The text to highlight
+ * @param {Object} q - Parsed query from parseQuery()
+ */
+function highlightMatch(text, q) {
+  if (!text || !q) return text;
+
+  var textLower = text.toLowerCase();
+  var query = q.normalized;
+
+  // Try contiguous match first (prefix or substring)
+  var matchIndex = textLower.indexOf(query);
+  if (matchIndex !== -1) {
+    return text.substring(0, matchIndex) +
+      '\u0001' + text.substring(matchIndex, matchIndex + query.length) + '\u0002' +
+      text.substring(matchIndex + query.length);
+  }
+
+  // Fall back to fuzzy highlight (highlight each matched character)
+  var result = '';
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    var charIndex = textLower.indexOf(query[qi], ti);
+    if (charIndex === -1) return text;
+    result += text.substring(ti, charIndex);
+    result += '\u0001' + text[charIndex] + '\u0002';
+    ti = charIndex + 1;
+  }
+  result += text.substring(ti);
+  return result;
+}

data/rdoc/js/theme-toggle.js

@@ -0,0 +1,112 @@
+(function() {
+  'use strict';
+
+  const STORAGE_KEY = 'rdoc-theme';
+  const THEME_LIGHT = 'light';
+  const THEME_DARK = 'dark';
+
+  /**
+   * Get the user's theme preference
+   * Priority: localStorage > system preference > light (default)
+   */
+  function getThemePreference() {
+    // Check localStorage first
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored === THEME_LIGHT || stored === THEME_DARK) {
+      return stored;
+    }
+
+    // Check system preference
+    if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+      return THEME_DARK;
+    }
+
+    return THEME_LIGHT;
+  }
+
+  /**
+   * Apply theme to document
+   */
+  function applyTheme(theme) {
+    document.documentElement.setAttribute('data-theme', theme);
+    localStorage.setItem(STORAGE_KEY, theme);
+
+    // Update toggle button icon
+    const toggleBtn = document.getElementById('theme-toggle');
+    if (toggleBtn) {
+      const icon = toggleBtn.querySelector('.theme-toggle-icon');
+      if (icon) {
+        icon.textContent = theme === THEME_DARK ? '☀️' : '🌙';
+      }
+      toggleBtn.setAttribute('aria-label',
+        theme === THEME_DARK ? 'Switch to light mode' : 'Switch to dark mode'
+      );
+    }
+  }
+
+  /**
+   * Toggle between light and dark themes
+   */
+  function toggleTheme() {
+    const currentTheme = document.documentElement.getAttribute('data-theme') || THEME_LIGHT;
+    const newTheme = currentTheme === THEME_LIGHT ? THEME_DARK : THEME_LIGHT;
+    applyTheme(newTheme);
+
+    // Announce to screen readers
+    announceThemeChange(newTheme);
+  }
+
+  /**
+   * Announce theme change to screen readers
+   */
+  function announceThemeChange(theme) {
+    const announcement = document.createElement('div');
+    announcement.setAttribute('role', 'status');
+    announcement.setAttribute('aria-live', 'polite');
+    announcement.className = 'sr-only';
+    announcement.textContent = `Switched to ${theme} mode`;
+    document.body.appendChild(announcement);
+
+    // Remove after announcement
+    setTimeout(() => {
+      document.body.removeChild(announcement);
+    }, 1000);
+  }
+
+  /**
+   * Initialize theme on page load
+   */
+  function initTheme() {
+    // Apply theme immediately to prevent flash
+    const theme = getThemePreference();
+    applyTheme(theme);
+
+    // Set up toggle button listener
+    const toggleBtn = document.getElementById('theme-toggle');
+    if (toggleBtn) {
+      toggleBtn.addEventListener('click', toggleTheme);
+    }
+
+    // Listen for system theme changes
+    if (window.matchMedia) {
+      window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
+        // Only auto-switch if user hasn't manually set a preference
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (!stored) {
+          applyTheme(e.matches ? THEME_DARK : THEME_LIGHT);
+        }
+      });
+    }
+  }
+
+  // Initialize immediately (before DOMContentLoaded to prevent flash)
+  if (document.readyState === 'loading') {
+    // Apply theme as early as possible
+    const theme = getThemePreference();
+    document.documentElement.setAttribute('data-theme', theme);
+
+    document.addEventListener('DOMContentLoaded', initTheme);
+  } else {
+    initTheme();
+  }
+})();

data/rubyXL.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: rubyXL 3.4.25 ruby lib
+# stub: rubyXL 3.4.38 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rubyXL".freeze
-  s.version = "3.4.25"
+  s.version = "3.4.38".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Vivek Bhagwat".freeze, "Wesha".freeze]
-  s.date = "2022-05-19"
+  s.date = "2026-06-15"
   s.description = "rubyXL is a gem which allows the parsing, creation, and manipulation of Microsoft Excel (.xlsx/.xlsm) Documents".freeze
   s.email = "bhagwat.vivek@gmail.com".freeze
   s.extra_rdoc_files = [
@@ -21,8 +21,9 @@ Gem::Specification.new do |s|
   s.files = [
     ".circleci/config.yml",
     ".codeclimate.yml",
+    ".rubocop.yml",
+    "CHANGELOG.md",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE.txt",
     "README.rdoc",
     "Rakefile",
@@ -79,6 +80,7 @@ Gem::Specification.new do |s|
     "rdoc/RubyXL/AdjustHandleList.html",
     "rdoc/RubyXL/Alignment.html",
     "rdoc/RubyXL/AlternateContent.html",
+    "rdoc/RubyXL/AlternateUrls.html",
     "rdoc/RubyXL/Authors.html",
     "rdoc/RubyXL/AutoFilter.html",
     "rdoc/RubyXL/AutoFilterColumn.html",
@@ -351,6 +353,7 @@ Gem::Specification.new do |s|
     "rdoc/RubyXL/Pane.html",
     "rdoc/RubyXL/Parser.html",
     "rdoc/RubyXL/PatternFill.html",
+    "rdoc/RubyXL/PersonMetadata.html",
     "rdoc/RubyXL/PhoneticProperties.html",
     "rdoc/RubyXL/PhoneticRun.html",
     "rdoc/RubyXL/PivotArea.html",
@@ -455,49 +458,16 @@ Gem::Specification.new do |s|
     "rdoc/RubyXL/WorksheetViews.html",
     "rdoc/RubyXL/XF.html",
     "rdoc/created.rid",
-    "rdoc/css/fonts.css",
     "rdoc/css/rdoc.css",
-    "rdoc/fonts/Lato-Light.ttf",
-    "rdoc/fonts/Lato-LightItalic.ttf",
-    "rdoc/fonts/Lato-Regular.ttf",
-    "rdoc/fonts/Lato-RegularItalic.ttf",
-    "rdoc/fonts/SourceCodePro-Bold.ttf",
-    "rdoc/fonts/SourceCodePro-Regular.ttf",
-    "rdoc/images/add.png",
-    "rdoc/images/arrow_up.png",
-    "rdoc/images/brick.png",
-    "rdoc/images/brick_link.png",
-    "rdoc/images/bug.png",
-    "rdoc/images/bullet_black.png",
-    "rdoc/images/bullet_toggle_minus.png",
-    "rdoc/images/bullet_toggle_plus.png",
-    "rdoc/images/date.png",
-    "rdoc/images/delete.png",
-    "rdoc/images/find.png",
-    "rdoc/images/loadingAnimation.gif",
-    "rdoc/images/macFFBgHack.png",
-    "rdoc/images/package.png",
-    "rdoc/images/page_green.png",
-    "rdoc/images/page_white_text.png",
-    "rdoc/images/page_white_width.png",
-    "rdoc/images/plugin.png",
-    "rdoc/images/ruby.png",
-    "rdoc/images/tag_blue.png",
-    "rdoc/images/tag_green.png",
-    "rdoc/images/transparent.png",
-    "rdoc/images/wrench.png",
-    "rdoc/images/wrench_orange.png",
-    "rdoc/images/zoom.png",
     "rdoc/index.html",
-    "rdoc/js/darkfish.js",
-    "rdoc/js/navigation.js",
-    "rdoc/js/navigation.js.gz",
-    "rdoc/js/search.js",
-    "rdoc/js/search_index.js",
-    "rdoc/js/search_index.js.gz",
-    "rdoc/js/searcher.js",
-    "rdoc/js/searcher.js.gz",
-    "rdoc/table_of_contents.html",
+    "rdoc/js/aliki.js",
+    "rdoc/js/bash_highlighter.js",
+    "rdoc/js/c_highlighter.js",
+    "rdoc/js/search_controller.js",
+    "rdoc/js/search_data.js",
+    "rdoc/js/search_navigation.js",
+    "rdoc/js/search_ranker.js",
+    "rdoc/js/theme-toggle.js",
     "rubyXL.gemspec",
     "spec/lib/cell_spec.rb",
     "spec/lib/color_spec.rb",
@@ -516,33 +486,20 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/gilt/rubyXL".freeze
   s.licenses = ["MIT".freeze]
-  s.rubygems_version = "3.3.12".freeze
+  s.rubygems_version = "3.5.22".freeze
   s.summary = "rubyXL is a gem which allows the parsing, creation, and manipulation of Microsoft Excel (.xlsx/.xlsm) Documents".freeze
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
-  end
+  s.specification_version = 4
 
-  if s.respond_to? :add_runtime_dependency then
-    s.add_runtime_dependency(%q<nokogiri>.freeze, [">= 1.10.8"])
-    s.add_runtime_dependency(%q<rubyzip>.freeze, [">= 1.3.0"])
-    s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
-    s.add_development_dependency(%q<rake>.freeze, [">= 0"])
-    s.add_development_dependency(%q<juwelier>.freeze, [">= 0"])
-    s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
-    s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
-    s.add_development_dependency(%q<ruby-prof>.freeze, [">= 0"])
-    s.add_development_dependency(%q<rspec_junit_formatter>.freeze, [">= 0"])
-  else
-    s.add_dependency(%q<nokogiri>.freeze, [">= 1.10.8"])
-    s.add_dependency(%q<rubyzip>.freeze, [">= 1.3.0"])
-    s.add_dependency(%q<bundler>.freeze, [">= 0"])
-    s.add_dependency(%q<rake>.freeze, [">= 0"])
-    s.add_dependency(%q<juwelier>.freeze, [">= 0"])
-    s.add_dependency(%q<rspec>.freeze, [">= 0"])
-    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
-    s.add_dependency(%q<ruby-prof>.freeze, [">= 0"])
-    s.add_dependency(%q<rspec_junit_formatter>.freeze, [">= 0"])
-  end
+  s.add_runtime_dependency(%q<nokogiri>.freeze, [">= 1.10.8".freeze])
+  s.add_runtime_dependency(%q<rubyzip>.freeze, [">= 3.2.2".freeze])
+  s.add_development_dependency(%q<bundler>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<rake>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<juwelier>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<simplecov>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<ruby-prof>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<rspec_junit_formatter>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<rubocop>.freeze, [">= 0".freeze])
 end
 

data/spec/lib/cell_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'bigdecimal'
 require 'rubyXL/convenience_methods/font'
@@ -8,8 +10,8 @@ describe RubyXL::Cell do
     @workbook  = RubyXL::Workbook.new
     @worksheet = @workbook.add_worksheet('Test Worksheet')
     @workbook.worksheets << @worksheet
-    (0..10).each do |i|
-      (0..10).each do |j|
+    11.times do |i|
+      11.times do |j|
         @worksheet.add_cell(i, j, "#{i}:#{j}")
       end
     end
@@ -45,14 +47,14 @@ describe RubyXL::Cell do
       cell.set_number_format('ddd mmm dd, yyyy HH:MM:SS')
 
       # Due to rounding errors, we allow microsecond precision on DateTime.
-      expect((cell.value - tm).to_f).to be_within(1.0/86400e6).of(0)
+      expect((cell.value - tm).to_f).to be_within(1.0 / 86400e6).of(0)
 
       tm = Time.now
       cell = @worksheet.add_cell(r, c, tm)
       cell.set_number_format('ddd mmm dd, yyyy HH:MM:SS')
 
       # Due to rounding errors, we allow microsecond precision on Time.
-      expect(cell.value - tm.to_datetime).to be_within(1.0/86400e6).of(0)
+      expect(cell.value - tm.to_datetime).to be_within(1.0 / 86400e6).of(0)
 
       expected_date = '2020-10-15T14:00:00Z'
       expected_datetime = Time.parse(expected_date).utc
@@ -66,6 +68,30 @@ describe RubyXL::Cell do
       # We expect exactly the same date
       expect(cell.value.to_time.utc.iso8601).to eq(expected_datetime.iso8601)
     end
+
+    it 'should raise against too long String' do
+      ok_data = 'A' * 32767  # The limit is 32767
+
+      expect {
+        @worksheet.add_cell(0, 1, ok_data) # 32767 -> OK
+      }.not_to raise_error
+      expect {
+        # 1 longer than the limit, so an exception must be thrown.
+        @worksheet.add_cell(0, 2, "#{ok_data}x")
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should raise against too long RichText' do
+      ok_data = 'A' * 32767  # The limit is 32767
+
+      expect {
+        @worksheet.add_cell(0, 1, RubyXL::RichText.new(:t => RubyXL::Text.new(:value => ok_data))) # 32767 -> OK
+      }.not_to raise_error
+      expect {
+        # 1 longer than the limit, so an exception must be thrown.
+        @worksheet.add_cell(0, 2, RubyXL::RichText.new(:t => RubyXL::Text.new(:value => "#{ok_data}x")))
+      }.to raise_error(ArgumentError)
+    end
   end
 
   describe '.change_fill' do
@@ -237,6 +263,16 @@ describe RubyXL::Cell do
       expect(@cell.get_border_color(:top)).to eq('FF0000')
       expect(@cell.get_border(:top)).to eq('thin')
     end
+
+    it 'should not change the border color of another cell with the same style' do
+      another_cell = @worksheet[0][1]
+      @cell.change_border(:right, 'medium')
+      another_cell.change_border(:right, 'medium')
+      @cell.change_border_color(:right, 'FF0000')
+      another_cell.change_border_color(:right, '008000')
+      expect(@cell.get_border_color(:right)).to eq('FF0000')
+      expect(another_cell.get_border_color(:right)).to eq('008000')
+    end
   end
 
   describe '.change_border' do
@@ -599,4 +635,20 @@ describe RubyXL::Cell do
       expect(@cell.text_rotation).to eq(45)
     end
   end
+
+  describe '.add_shared_string' do
+    let(:add_shared_string) { Article.create(title: 'test', description: 'test') }
+
+    it 'should correctly add a new shared string to the list' do
+      @cell = @worksheet.add_cell(7, 0, 1)
+      expect(@cell.datatype).to be_nil
+
+      prior_strings = @workbook.shared_strings_container.strings.dup
+      @cell.add_shared_string('testTEST')
+      expect(@workbook.shared_strings_container.strings.size).to eq(prior_strings.size + 1)
+      expect(@cell.datatype).to eq(RubyXL::DataType::SHARED_STRING)
+      expect(@cell.value).to eq('testTEST')
+    end
+  end
+
 end

data/spec/lib/color_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'rubyXL/convenience_methods/color'
 
@@ -7,8 +9,13 @@ describe RubyXL::Color do
       expect(RubyXL::Color.validate_color('0fbCAd')).to eq(true)
     end
 
+    it 'should return true if a valid hex color with alpha is passed' do
+      expect(RubyXL::Color.validate_color('01AbCdeF')).to eq(true)
+    end
+
     it 'should cause an error if an invalid hex color code or one with a # is passed' do
       expect { RubyXL::Color.validate_color('#G') }.to raise_error(RuntimeError)
+      expect { RubyXL::Color.validate_color('1234567') }.to raise_error(RuntimeError)
     end
   end
 end