triad 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1506f956e5cf2624d48a561a54b55e6a421bd92f5542004eec34df90ebb814a7
-  data.tar.gz: a090e6814e78240b6081e7e5d6c730751d451c07411d01b9b6149cd84bd00d4e
+  metadata.gz: 8d4039aff99f0f7377d3c23e7f634497f2e0af40493a9e4da202b5f73d1746e3
+  data.tar.gz: 468e03146649a0fff076569e5d659942f78af0d1aee15e825f3469f1de580eb5
 SHA512:
-  metadata.gz: 2d26ec61656145fcedc646b5dafdf0a1cff341cb74e9bee9592d99ed62d1db7e118ec9ed9e791dd85e96cdd7a3192a210a9763476f36d9e3f9cb7f7ee1b74b81
-  data.tar.gz: 7035ae759c39fd4b1abf78a63b3637d84d69f2dddb0b835e056e49a1a69727e98eb2e37d588f2e24e53fd004e244289d4c3bca562ae689da3e5bb0f23da986b5
+  metadata.gz: c9280599c5af2e49ebace1860b3492a0c0dffc0b3a7bc93b0ae335c359f825c35ce602d1030c279e67da2ee89d4261bed26474343d4fb8b385de2527166d3a59
+  data.tar.gz: 5c8fcaec38453c0ffa91c1d14952c7d963aa45076bfb1ae0f36542ee873a30852028f3a965b3b0725aa08f13e2e711c5948831bd16138f3b0de7d3ee31d6a7aa

data/Gemfile

@@ -1,7 +1,9 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec
 
 gem "rake"
 gem "simplecov"
 gem "minitest"
+gem "standard"
+gem "reissue"

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2016 'Jim Gay'
+Copyright (c) 2013-2025 'Jim Gay'
 
 MIT License
 

data/README.md

@@ -1,7 +1,5 @@
 # Triad
 
-[![Code Climate](https://codeclimate.com/github/saturnflyer/triad.png)](https://codeclimate.com/github/saturnflyer/triad)
-[![Coverage Status](https://coveralls.io/repos/saturnflyer/triad/badge.png)](https://coveralls.io/r/saturnflyer/triad)
 [![Gem Version](https://badge.fury.io/rb/triad.png)](http://badge.fury.io/rb/triad)
 
 A Triad is like a Set, or a collection of three-part arrays.

data/Rakefile

@@ -1,12 +1,25 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/*_test.rb']
+  t.libs << "test"
+  t.test_files = FileList["test/*_test.rb"]
   t.ruby_opts = ["-w"]
   t.verbose = true
 end
 
-task :default => :test
+# Configure Reissue for automated versioning and changelog management
+require "reissue/gem"
+
+Reissue::Task.create :reissue do |task|
+  task.version_file = "lib/triad/version.rb"
+  task.changelog_file = "CHANGELOG.md"
+  task.version_limit = 2
+  task.commit = true
+  task.commit_finalize = true
+  task.push_finalize = true
+  task.fragment = :git
+end
+
+task default: :test

data/lib/triad/version.rb

@@ -1,3 +1,3 @@
 class Triad
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/lib/triad.rb

@@ -5,39 +5,42 @@ class Triad
   include Enumerable
 
   class InvalidAddition < StandardError; end
+
   class ItemNotPresent < StandardError; end
 
-  # stored as {key => ['Descriptor', value]}
+  # stored as {key => {descriptor: 'Descriptor', value: value}}
   def initialize
     @storage = Concurrent::Hash.new
+    @descriptor_index = Concurrent::Hash.new
+    @value_index = Concurrent::Hash.new
   end
-  attr_reader :storage
-  private :storage
+  attr_reader :storage, :descriptor_index, :value_index
+  private :storage, :descriptor_index, :value_index
 
   # Return the keys for a given descriptor or value
-  def keys(arg=nil)
-    if arg == nil
+  def keys(arg = nil)
+    if arg.nil?
       storage.keys
     else
-      with_interest(arg).map{|key, _, _| key }
+      with_interest(arg).map { |key, _, _| key }
     end
   end
 
   # Return the descriptors for a given key or value
-  def descriptors(arg=nil)
+  def descriptors(arg = nil)
     if arg.nil?
-      storage.map{|_,(descriptor,_)| descriptor }
+      storage.map { |_, data| data[:descriptor] }
     else
-      with_interest(arg).map{|_, descriptor, _| descriptor }
+      with_interest(arg).map { |_, descriptor, _| descriptor }
     end
   end
 
   # Return the values for a given key or descriptor
-  def values(arg=:__no_argument_given__)
+  def values(arg = :__no_argument_given__)
     if arg == :__no_argument_given__
-      storage.map{|_,(_,value)| value }.uniq
+      value_index.keys
     else
-      with_interest(arg).map{|_, _, value| value }
+      with_interest(arg).map { |_, _, value| value }
     end
   end
 
@@ -50,49 +53,75 @@ class Triad
 
     array_descriptor = array.fetch(1)
     raise InvalidAddition.new("the provided descriptor must be a String") unless array_descriptor.is_a?(String)
-    array_value =      array.fetch(2)
+    array_value = array.fetch(2)
 
-    storage[array_key] = [array_descriptor, array_value]
+    add_to_storage(array_key, array_descriptor, array_value)
     self
   end
 
   # Alter the descriptor and value in-place for the given key
   def update(key, descriptor, value)
     raise InvalidAddition.new("the provided descriptor cannot be nil") if descriptor.nil?
-    storage[key] = [descriptor, value]
+    remove_from_indices(key) if storage.key?(key)
+    add_to_storage(key, descriptor, value)
   end
 
   def each
-    storage.each do |key, (descriptor, value)|
-      yield key, descriptor, value
+    storage.each do |key, data|
+      yield key, data[:descriptor], data[:value]
     end
   end
 
   private
 
+  def add_to_storage(key, descriptor, value)
+    storage[key] = { descriptor: descriptor, value: value }
+    descriptor_index[descriptor] = (descriptor_index[descriptor] || []) << key
+    value_index[value] = (value_index[value] || []) << key
+  end
+
+  def remove_from_indices(key)
+    return unless storage.key?(key)
+
+    data = storage[key]
+    descriptor = data[:descriptor]
+    value = data[:value]
+
+    descriptor_index[descriptor]&.delete(key)
+    descriptor_index.delete(descriptor) if descriptor_index[descriptor]&.empty?
+
+    value_index[value]&.delete(key)
+    value_index.delete(value) if value_index[value]&.empty?
+  end
+
   def key_exists?(key)
     storage.key?(key)
   end
 
   def descriptor_exists?(descriptor)
-    storage.values.map{|arr| arr.fetch(0) }.include?(descriptor)
+    descriptor_index.key?(descriptor)
   end
 
   def value_exists?(value)
-    storage.values.map{|arr| arr.fetch(1) }.include?(value)
+    value_index.key?(value)
   end
 
   def with_interest(interest)
-    position = case
-              when key_exists?(interest)        then 0
-              when descriptor_exists?(interest) then 1
-              when value_exists?(interest)      then 2
-              else
-                raise ItemNotPresent.new
-              end
-
-    storage.select{|key, array|
-      [key, *array].fetch(position) == interest
-    }.map{|key, array| [key, *array] }
+    if key_exists?(interest)
+      data = storage[interest]
+      [[interest, data[:descriptor], data[:value]]]
+    elsif descriptor_exists?(interest)
+      descriptor_index[interest].map do |key|
+        data = storage[key]
+        [key, data[:descriptor], data[:value]]
+      end
+    elsif value_exists?(interest)
+      value_index[interest].map do |key|
+        data = storage[key]
+        [key, data[:descriptor], data[:value]]
+      end
+    else
+      raise ItemNotPresent.new
+    end
   end
 end

data/test/triad_test.rb

@@ -1,220 +1,219 @@
-require_relative 'test_helper'
+require_relative "test_helper"
 
-describe Triad, '#<<' do
-  let(:triad){ Triad.new }
+describe Triad, "#<<" do
+  let(:triad) { Triad.new }
 
-  it 'shovels 3 item arrays' do
-    assert triad << [:test, 'Test', Object.new]
+  it "shovels 3 item arrays" do
+    assert triad << [:test, "Test", Object.new]
   end
 
-  it 'rejects arrays with more than 3 items' do
-    error = assert_raises(Triad::InvalidAddition){
-      triad << [:test, 'Test', Object.new, 'Other']
+  it "rejects arrays with more than 3 items" do
+    error = assert_raises(Triad::InvalidAddition) {
+      triad << [:test, "Test", Object.new, "Other"]
     }
     assert_match(/array length must be 3/, error.message)
   end
 
-  it 'rejects arrays with fewer than 3 items' do
-    assert_raises(Triad::InvalidAddition){
-      triad << [:test, 'Test']
+  it "rejects arrays with fewer than 3 items" do
+    assert_raises(Triad::InvalidAddition) {
+      triad << [:test, "Test"]
     }
   end
 
-  it 'rejects arrays with an existing key' do
-    triad << [:test, 'Test', Object.new]
-    error = assert_raises(Triad::InvalidAddition){
-      triad << [:test, 'More', Object.new]
+  it "rejects arrays with an existing key" do
+    triad << [:test, "Test", Object.new]
+    error = assert_raises(Triad::InvalidAddition) {
+      triad << [:test, "More", Object.new]
     }
     assert_match(/key already exists/, error.message)
   end
-  
-  it 'accepts strings as values' do
+
+  it "accepts strings as values" do
     object = "a string as an value"
-    triad << [:key, 'Descriptor', object]
+    triad << [:key, "Descriptor", object]
     assert_equal [object], triad.values(:key)
   end
 
   it "rejects keys that are not Symbols" do
-    error = assert_raises(Triad::InvalidAddition){
+    error = assert_raises(Triad::InvalidAddition) {
       triad << ["key", "Descriptor", Object.new]
     }
     assert_match(/must be a Symbol/, error.message)
   end
 
   it "rejects descriptors that are not Strings" do
-    error = assert_raises(Triad::InvalidAddition){
+    error = assert_raises(Triad::InvalidAddition) {
       triad << [:key, :Descriptor, Object.new]
     }
     assert_match(/must be a String/, error.message)
   end
 end
 
-describe Triad, '#update' do
-  let(:triad){ Triad.new }
+describe Triad, "#update" do
+  let(:triad) { Triad.new }
 
-  it 'updates a descriptor and object for the given key' do
+  it "updates a descriptor and object for the given key" do
     object = Object.new
-    triad << [:test, 'Test', object]
-    assert_equal ['Test'], triad.descriptors(:test)
-    triad.update(:test, 'Updated', Object.new)
-    assert_equal ['Updated'], triad.descriptors(:test)
+    triad << [:test, "Test", object]
+    assert_equal ["Test"], triad.descriptors(:test)
+    triad.update(:test, "Updated", Object.new)
+    assert_equal ["Updated"], triad.descriptors(:test)
   end
 
   it "allows a nil object" do
-    triad << [:test, 'Test', nil]
-    assert_equal ['Test'], triad.descriptors(:test)
-    triad.update(:test, 'Updated', nil)
-    assert_equal ['Updated'], triad.descriptors(:test)
+    triad << [:test, "Test", nil]
+    assert_equal ["Test"], triad.descriptors(:test)
+    triad.update(:test, "Updated", nil)
+    assert_equal ["Updated"], triad.descriptors(:test)
   end
 
   it "does not allow a nil descriptor" do
-    err = assert_raises(Triad::InvalidAddition){
+    err = assert_raises(Triad::InvalidAddition) {
       triad.update(:test, nil, Object.new)
     }
     assert_equal "the provided descriptor cannot be nil", err.message
   end
 end
 
-describe Triad, '#keys' do
-  let(:user){ Object.new }
-  let(:triad){
+describe Triad, "#keys" do
+  let(:user) { Object.new }
+  let(:triad) {
     tri = Triad.new
-    tri << [:admin, 'Admin', user]
+    tri << [:admin, "Admin", user]
     tri
   }
 
-  it 'returns the key for the given descriptor' do
-    assert_equal [:admin], triad.keys('Admin')
+  it "returns the key for the given descriptor" do
+    assert_equal [:admin], triad.keys("Admin")
   end
 
-  it 'returns the key for the given value' do
+  it "returns the key for the given value" do
     assert_equal [:admin], triad.keys(user)
   end
 
-  it 'returns the keys for the given key' do
+  it "returns the keys for the given key" do
     assert_equal [:admin], triad.keys(:admin)
   end
 
-  it 'returns all keys when given no argument' do
-    triad << [:other, 'Other', user]
+  it "returns all keys when given no argument" do
+    triad << [:other, "Other", user]
     assert_equal [:admin, :other], triad.keys
   end
 
-  it 'errors when the given key is not found' do
-    assert_raises(Triad::ItemNotPresent){
+  it "errors when the given key is not found" do
+    assert_raises(Triad::ItemNotPresent) {
       triad.keys(:invalid_key)
     }
   end
 
-  it 'errors when the given descriptor is not found' do
-    assert_raises(Triad::ItemNotPresent){
-      triad.keys('Invalid Descriptor')
+  it "errors when the given descriptor is not found" do
+    assert_raises(Triad::ItemNotPresent) {
+      triad.keys("Invalid Descriptor")
     }
   end
 
-  it 'errors when the given value is not found' do
-    assert_raises(Triad::ItemNotPresent){
+  it "errors when the given value is not found" do
+    assert_raises(Triad::ItemNotPresent) {
       triad.keys(Object.new)
     }
   end
 end
 
-describe Triad, '#descriptors' do
-  let(:user){ Object.new }
-  let(:triad){
+describe Triad, "#descriptors" do
+  let(:user) { Object.new }
+  let(:triad) {
     tri = Triad.new
-    tri << [:admin, 'Admin', user]
+    tri << [:admin, "Admin", user]
     tri
   }
 
-  it 'returns the descriptor for the given key' do
-    assert_equal ['Admin'], triad.descriptors(:admin)
+  it "returns the descriptor for the given key" do
+    assert_equal ["Admin"], triad.descriptors(:admin)
   end
 
-  it 'returns the descriptor for the given value' do
-    assert_equal ['Admin'], triad.descriptors(user)
+  it "returns the descriptor for the given value" do
+    assert_equal ["Admin"], triad.descriptors(user)
   end
 
-  it 'returns the descriptors for the given descriptor' do
-    assert_equal ['Admin'], triad.descriptors('Admin')
+  it "returns the descriptors for the given descriptor" do
+    assert_equal ["Admin"], triad.descriptors("Admin")
   end
 
-  it 'returns all descriptors when given no argument' do
-    triad << [:other, 'Other', user]
-    assert_equal ['Admin', 'Other'], triad.descriptors
+  it "returns all descriptors when given no argument" do
+    triad << [:other, "Other", user]
+    assert_equal ["Admin", "Other"], triad.descriptors
   end
 
-  it 'errors when the given descriptor is not found' do
-    assert_raises(Triad::ItemNotPresent){
-      triad.descriptors('Not Present')
+  it "errors when the given descriptor is not found" do
+    assert_raises(Triad::ItemNotPresent) {
+      triad.descriptors("Not Present")
     }
   end
 
-  it 'errors when the given key is not found' do
-    assert_raises(Triad::ItemNotPresent){
+  it "errors when the given key is not found" do
+    assert_raises(Triad::ItemNotPresent) {
       triad.descriptors(:invalid_key)
     }
   end
 
-  it 'errors when the given value is not found' do
-    assert_raises(Triad::ItemNotPresent){
+  it "errors when the given value is not found" do
+    assert_raises(Triad::ItemNotPresent) {
       triad.descriptors(Object.new)
     }
   end
 
-  it 'assumes nil is a value' do
-    triad.update(:admin, 'Admin', nil)
-    assert_equal ['Admin'], triad.descriptors(:admin)
+  it "assumes nil is a value" do
+    triad.update(:admin, "Admin", nil)
+    assert_equal ["Admin"], triad.descriptors(:admin)
   end
 end
 
-describe Triad, '#values' do
-  let(:user){ Object.new }
-  let(:triad){
+describe Triad, "#values" do
+  let(:user) { Object.new }
+  let(:triad) {
     tri = Triad.new
-    tri << [:admin, 'Admin', user]
+    tri << [:admin, "Admin", user]
     tri
   }
 
-  it 'returns the value for the given key' do
+  it "returns the value for the given key" do
     assert_equal [user], triad.values(:admin)
   end
 
-  it 'returns the value for the given descriptor' do
-    assert_equal [user], triad.values('Admin')
+  it "returns the value for the given descriptor" do
+    assert_equal [user], triad.values("Admin")
   end
 
-  it 'returns all values when given no argument' do
-    triad << [:other, 'Other', user]
+  it "returns all values when given no argument" do
+    triad << [:other, "Other", user]
     assert_equal [user], triad.values
   end
 
-
-  it 'errors when the given key is not found' do
-    assert_raises(Triad::ItemNotPresent){
+  it "errors when the given key is not found" do
+    assert_raises(Triad::ItemNotPresent) {
       triad.values(:invalid_key)
     }
   end
 
-  it 'errors when the given descriptor is not found' do
-    assert_raises(Triad::ItemNotPresent){
-      triad.values('Invalid Descriptor')
+  it "errors when the given descriptor is not found" do
+    assert_raises(Triad::ItemNotPresent) {
+      triad.values("Invalid Descriptor")
     }
   end
 end
 
-describe Triad, 'enumeration' do
-  let(:user){ Object.new }
-  let(:triad){
+describe Triad, "enumeration" do
+  let(:user) { Object.new }
+  let(:triad) {
     tri = Triad.new
-    tri << [:admin, 'Admin', user]
+    tri << [:admin, "Admin", user]
     tri
   }
-  it 'yields each triad as 3 block variables' do
-    result = ''
+  it "yields each triad as 3 block variables" do
+    result = ""
     triad.each do |key, descriptor, value|
       result << "key: #{key}, descriptor: #{descriptor}, value: #{value.class.name}"
     end
-    assert_equal 'key: admin, descriptor: Admin, value: Object', result
+    assert_equal "key: admin, descriptor: Admin, value: Object", result
   end
 end

data/triad.gemspec

@@ -1,21 +1,19 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'triad/version'
+require "triad/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "triad"
-  spec.version       = Triad::VERSION
-  spec.authors       = ["'Jim Gay'"]
-  spec.email         = ["jim@saturnflyer.com"]
-  spec.description   = %q{Triad allows you to access data from keys, descriptors, and values}
-  spec.summary       = %q{Manage a collection with 3 data points}
-  spec.homepage      = "https://github.com/saturnflyer/triad"
-  spec.license       = "MIT"
+  spec.name = "triad"
+  spec.version = Triad::VERSION
+  spec.authors = ["'Jim Gay'"]
+  spec.email = ["jim@saturnflyer.com"]
+  spec.description = "Triad allows you to access data from keys, descriptors, and values"
+  spec.summary = "Manage a collection with 3 data points"
+  spec.homepage = "https://github.com/saturnflyer/triad"
+  spec.license = "MIT"
 
-  spec.files         = Dir['lib/**/*'] + %w[ Gemfile LICENSE.txt README.md Rakefile triad.gemspec test/triad_test.rb ]
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = Dir["lib/**/*"] + %w[Gemfile LICENSE.txt README.md Rakefile triad.gemspec test/triad_test.rb]
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "concurrent-ruby", "> 0.9"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: triad
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - "'Jim Gay'"
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -43,7 +42,6 @@ homepage: https://github.com/saturnflyer/triad
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -58,9 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.17
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Manage a collection with 3 data points
-test_files:
-- test/triad_test.rb
+test_files: []