spreadsheet_encrypt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f830286b7845e5dbdba5c935696d89c069bf0f27323a76a659dad678dfbdbfe2
+  data.tar.gz: ec8207dc7a7080f60642a95957a9431b112d87b065c736a04868bcf55eb5e7a6
+SHA512:
+  metadata.gz: 51895e92f784eb5e91b43748ea73c6b73ddfde5748f105ae58d8d4e8bc25e21a77aaee9020d3b154cb8a27d3da37dd8b31aa4a6772824878c79d08b3e33f5d09
+  data.tar.gz: 48ae9a56a4413ca549b3bb2db30206a72619b25fa46abfe54ae558cd6d0163f0a6fd9219a1d5c3692f3a051d056d93a21d5fe679186f517aa6673d96439497c2

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## [0.1.0] - 2026-09-04
+
+### Added
+
+- Encrypt `.xlsx` with an Office open password via ooxml_crypt
+- Convert `.xls` to `.xlsx` then encrypt
+- Library API `SpreadsheetEncrypt.encrypt` (positional and keyword args)
+- CLI `spreadsheet_encrypt`

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 汤宇浩
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# SpreadsheetEncrypt
+
+Encrypt Excel spreadsheet files (`.xls` / `.xlsx`) with an **open password** (Office Open XML encryption). Opening the output in Excel / WPS requires the password.
+
+- `.xlsx` — encrypted directly
+- `.xls` — converted to `.xlsx` (cell values / basic multi-sheet), then encrypted
+
+## Installation
+
+Add to your application's Gemfile:
+
+```ruby
+gem "spreadsheet_encrypt"
+```
+
+Or install locally from source:
+
+```bash
+bundle exec rake install
+```
+
+## Usage
+
+### Library
+
+```ruby
+require "spreadsheet_encrypt"
+
+# Positional arguments: input path, password, output path
+SpreadsheetEncrypt.encrypt(
+  "/path/to/input.xls",
+  "secret-password",
+  "/path/to/output.xlsx"
+)
+
+# Keyword arguments
+SpreadsheetEncrypt.encrypt(
+  input: "/path/to/book.xlsx",
+  password: "secret",
+  output: "/path/to/book.encrypted.xlsx"
+)
+```
+
+Returns the actual output path written (String). If the input is `.xls` and the output path still ends with `.xls`, the extension is automatically changed to `.xlsx`.
+
+### CLI
+
+```bash
+bundle exec spreadsheet_encrypt input.xlsx -p secret -o out.xlsx
+bundle exec spreadsheet_encrypt input.xls -p secret -o out.xlsx
+```
+
+## Limitations
+
+- Encryption targets **file open password** (not sheet/workbook edit protection).
+- Compatible with documents encrypted in the Office 2010+ OOXML style (via [ooxml_crypt](https://github.com/teamsimplepay/ooxml_crypt)).
+- `.xls` conversion preserves cell values and multiple sheets; macros, charts, and complex formatting are **not** guaranteed.
+
+## Development
+
+```bash
+bin/setup
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT. See [LICENSE.txt](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/spreadsheet_encrypt

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "spreadsheet_encrypt"
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: spreadsheet_encrypt INPUT -p PASSWORD -o OUTPUT"
+
+  opts.on("-p", "--password PASSWORD", "Open password for the output file") do |password|
+    options[:password] = password
+  end
+
+  opts.on("-o", "--output PATH", "Output file path (.xlsx)") do |path|
+    options[:output] = path
+  end
+
+  opts.on("-h", "--help", "Show help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-v", "--version", "Show version") do
+    puts SpreadsheetEncrypt::VERSION
+    exit
+  end
+end
+
+parser.parse!
+
+input = ARGV[0]
+if input.nil? || options[:password].nil? || options[:output].nil?
+  warn parser.help
+  exit 1
+end
+
+begin
+  path = SpreadsheetEncrypt.encrypt(input, options[:password], options[:output])
+  puts path
+rescue SpreadsheetEncrypt::Error => e
+  warn "Error: #{e.message}"
+  exit 1
+end

data/lib/spreadsheet_encrypt/encryptor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "ooxml_crypt"
+require_relative "errors"
+require_relative "xls_converter"
+
+module SpreadsheetEncrypt
+  # Encrypts spreadsheet files with an Office open password.
+  class Encryptor
+    SUPPORTED_EXTENSIONS = %w[.xls .xlsx].freeze
+
+    def self.encrypt(input_path, password, output_path)
+      new(input_path, password, output_path).encrypt
+    end
+
+    def initialize(input_path, password, output_path)
+      @input_path = input_path.to_s
+      @password = password.to_s
+      @output_path = output_path.to_s
+    end
+
+    # @return [String] actual output path written
+    def encrypt
+      validate!
+      ensure_output_directory!
+
+      case extension
+      when ".xlsx"
+        encrypt_xlsx(@input_path, @output_path)
+      when ".xls"
+        encrypt_xls
+      end
+    end
+
+    private
+
+    def validate!
+      raise InvalidPassword, "password must not be empty" if @password.strip.empty?
+      raise FileNotFound, "input file not found: #{@input_path}" unless File.file?(@input_path)
+
+      return if SUPPORTED_EXTENSIONS.include?(extension)
+
+      raise UnsupportedFormat,
+            "unsupported format '#{extension}'; supported: #{SUPPORTED_EXTENSIONS.join(', ')}"
+    end
+
+    def extension
+      @extension ||= File.extname(@input_path).downcase
+    end
+
+    def ensure_output_directory!
+      dir = File.dirname(@output_path)
+      FileUtils.mkdir_p(dir) unless dir.empty? || dir == "."
+    end
+
+    def normalize_output_path
+      return @output_path if File.extname(@output_path).downcase == ".xlsx"
+
+      base = @output_path.sub(/\.xls\z/i, "")
+      "#{base}.xlsx"
+    end
+
+    def encrypt_xlsx(source, destination)
+      OoxmlCrypt.encrypt_file(source, @password, destination)
+      destination
+    rescue StandardError => e
+      raise EncryptionFailed, "failed to encrypt spreadsheet: #{e.message}"
+    end
+
+    def encrypt_xls
+      destination = normalize_output_path
+      tempfile = XlsConverter.to_xlsx(@input_path)
+      encrypt_xlsx(tempfile.path, destination)
+    ensure
+      if tempfile
+        tempfile.close
+        tempfile.unlink
+      end
+    end
+  end
+end

data/lib/spreadsheet_encrypt/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SpreadsheetEncrypt
+  class Error < StandardError; end
+
+  class UnsupportedFormat < Error; end
+
+  class FileNotFound < Error; end
+
+  class InvalidPassword < Error; end
+
+  class EncryptionFailed < Error; end
+end

data/lib/spreadsheet_encrypt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SpreadsheetEncrypt
+  VERSION = "0.1.0"
+end

data/lib/spreadsheet_encrypt/xls_converter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "caxlsx"
+require "roo"
+require "roo-xls"
+require "tempfile"
+
+module SpreadsheetEncrypt
+  # Converts a legacy .xls workbook into a temporary .xlsx file (cell values only).
+  class XlsConverter
+    def self.to_xlsx(input_path)
+      new(input_path).to_xlsx
+    end
+
+    def initialize(input_path)
+      @input_path = input_path
+    end
+
+    # @return [Tempfile] caller must close/unlink when done
+    def to_xlsx
+      book = Roo::Spreadsheet.open(@input_path, extension: :xls)
+      tempfile = Tempfile.new(["spreadsheet_encrypt", ".xlsx"])
+      tempfile.binmode
+
+      package = Axlsx::Package.new
+      book.each_with_pagename do |name, sheet|
+        package.workbook.add_worksheet(name: sanitize_sheet_name(name)) do |ws|
+          next if sheet.first_row.nil? || sheet.last_row.nil?
+
+          (sheet.first_row..sheet.last_row).each do |row_index|
+            ws.add_row(Array(sheet.row(row_index)))
+          end
+        end
+      end
+
+      package.serialize(tempfile.path)
+      tempfile.rewind
+      tempfile
+    end
+
+    private
+
+    def sanitize_sheet_name(name)
+      cleaned = name.to_s.gsub(%r{[\\/*?:\[\]]}, "_")
+      cleaned = "Sheet1" if cleaned.strip.empty?
+      cleaned[0, 31]
+    end
+  end
+end

data/lib/spreadsheet_encrypt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "spreadsheet_encrypt/version"
+require_relative "spreadsheet_encrypt/errors"
+require_relative "spreadsheet_encrypt/encryptor"
+
+module SpreadsheetEncrypt
+  # Encrypt a spreadsheet file with an open password.
+  #
+  # Positional:
+  #   SpreadsheetEncrypt.encrypt(input_path, password, output_path)
+  #
+  # Keyword:
+  #   SpreadsheetEncrypt.encrypt(input:, password:, output:)
+  #
+  # @return [String] actual output path written
+  def self.encrypt(*args, **kwargs)
+    input, password, output = resolve_args(args, kwargs)
+    Encryptor.encrypt(input, password, output)
+  end
+
+  def self.resolve_args(args, kwargs)
+    if kwargs.any?
+      missing = %i[input password output] - kwargs.keys
+      raise ArgumentError, "missing keywords: #{missing.join(', ')}" if missing.any?
+
+      return [kwargs[:input], kwargs[:password], kwargs[:output]]
+    end
+
+    raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 3)" unless args.size == 3
+
+    args
+  end
+  private_class_method :resolve_args
+end

data/sig/spreadsheet_encrypt.rbs

@@ -0,0 +1,4 @@
+module SpreadsheetEncrypt
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: spreadsheet_encrypt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- 汤宇浩
+bindir: exe
+cert_chain: []
+date: 2026-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: caxlsx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ooxml_crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: roo-xls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: |
+  Encrypt existing Excel files with Office Open XML password protection.
+  .xlsx files are encrypted directly; .xls files are converted to .xlsx then encrypted.
+email:
+- tangyuhao@rippletek.com
+executables:
+- spreadsheet_encrypt
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/spreadsheet_encrypt
+- lib/spreadsheet_encrypt.rb
+- lib/spreadsheet_encrypt/encryptor.rb
+- lib/spreadsheet_encrypt/errors.rb
+- lib/spreadsheet_encrypt/version.rb
+- lib/spreadsheet_encrypt/xls_converter.rb
+- sig/spreadsheet_encrypt.rbs
+homepage: https://github.com/tom0932/spreadsheet_encrypt
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/tom0932/spreadsheet_encrypt
+  source_code_uri: https://github.com/tom0932/spreadsheet_encrypt
+  changelog_uri: https://github.com/tom0932/spreadsheet_encrypt/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Encrypt Excel spreadsheet files (.xls / .xlsx) with an open password.
+test_files: []