triad 0.3.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c509af042f22f2fb764c0d6218b0ed45d0cce53d
-  data.tar.gz: 5958c9b4e43aeba09e4956393918730a30c25189
+SHA256:
+  metadata.gz: 8d4039aff99f0f7377d3c23e7f634497f2e0af40493a9e4da202b5f73d1746e3
+  data.tar.gz: 468e03146649a0fff076569e5d659942f78af0d1aee15e825f3469f1de580eb5
 SHA512:
-  metadata.gz: 0bc285d97ec8e4f1418d27f53d5cec3822faf793e32a45871cbc2e84e6e403ddb01756864f56eb1d007555871dd10a03f0c7dc1d4bf88e9d247dd25fd3c58f18
-  data.tar.gz: e3f7700cc6f6410994b627c05a573c219df2ba41e055f99452a64499b98cb476a637be78bc674d6fe2adbad43d6b2a053cefa2a045fecfe1972b5ccdb26658c4
+  metadata.gz: c9280599c5af2e49ebace1860b3492a0c0dffc0b3a7bc93b0ae335c359f825c35ce602d1030c279e67da2ee89d4261bed26474343d4fb8b385de2527166d3a59
+  data.tar.gz: 5c8fcaec38453c0ffa91c1d14952c7d963aa45076bfb1ae0f36542ee873a30852028f3a965b3b0725aa08f13e2e711c5948831bd16138f3b0de7d3ee31d6a7aa

data/Gemfile

@@ -1,9 +1,9 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 gemspec
 
-group :test do
-  gem "simplecov"
-  gem "minitest"
-  gem "coveralls"
-end
+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,8 +1,5 @@
 # Triad
 
-[![Build Status](https://travis-ci.org/saturnflyer/triad.png?branch=master)](https://travis-ci.org/saturnflyer/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 = "0.3.0"
+  VERSION = "1.0.1"
 end

data/lib/triad.rb

@@ -5,86 +5,123 @@ 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
 
-  def keys(arg=:__no_argument_given__)
-    if arg == :__no_argument_given__
+  # Return the keys for a given descriptor or value
+  def keys(arg = nil)
+    if arg.nil?
       storage.keys
     else
-      with_interest(arg).map{|key, _, _| key }
+      with_interest(arg).map { |key, _, _| key }
     end
   end
 
-  def descriptors(arg=:__no_argument_given__)
-    if arg == :__no_argument_given__
-      storage.map{|_,(descriptor,_)| descriptor }
+  # Return the descriptors for a given key or value
+  def descriptors(arg = nil)
+    if arg.nil?
+      storage.map { |_, data| data[:descriptor] }
     else
-      with_interest(arg).map{|_, descriptor, _| descriptor }
+      with_interest(arg).map { |_, descriptor, _| descriptor }
     end
   end
 
-  def values(arg=:__no_argument_given__)
+  # Return the values for a given key or descriptor
+  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
 
+  # Add new entries to the object
   def <<(array)
-    array_key = array[0]
     raise InvalidAddition.new("your array length must be 3") if array.length != 3
+    array_key = array.fetch(0)
+    raise InvalidAddition.new("the provided key must be a Symbol") unless array_key.is_a?(Symbol)
     raise InvalidAddition.new("the provided key already exists") if key_exists?(array_key)
 
-    array_descriptor = array[1]
-    array_value =      array[2]
+    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)
 
-    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)
-    storage[key] = [descriptor, value]
+    raise InvalidAddition.new("the provided descriptor cannot be nil") if descriptor.nil?
+    remove_from_indices(key) if storage.key?(key)
+    add_to_storage(key, descriptor, value)
   end
 
-  def each(&block)
-    storage.each do |key, (descriptor, value)|
-      block.call key, descriptor, value
+  def each
+    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.has_key?(key)
+    storage.key?(key)
   end
-  
+
   def descriptor_exists?(descriptor)
-    storage.values.map{|arr| arr[0] }.include?(descriptor)
+    descriptor_index.key?(descriptor)
   end
-  
+
   def value_exists?(value)
-    storage.values.map{|arr| arr[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,186 +1,219 @@
-require '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]
-    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) {
+      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) {
+      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)
+  end
+
+  it "does not allow a nil descriptor" do
+    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)
+  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
+end

data/triad.gemspec

@@ -1,25 +1,20 @@
-# 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      = ""
-  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         = `git ls-files`.split($/)
-  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"
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: triad
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.1
 platform: ruby
 authors:
 - "'Jim Gay'"
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-07 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,34 +23,6 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Triad allows you to access data from keys, descriptors, and values
 email:
 - jim@saturnflyer.com
@@ -59,22 +30,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/triad.rb
 - lib/triad/version.rb
-- test/test_helper.rb
 - test/triad_test.rb
 - triad.gemspec
-homepage: ''
+homepage: https://github.com/saturnflyer/triad
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -89,12 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Manage a collection with 3 data points
-test_files:
-- test/test_helper.rb
-- test/triad_test.rb
-has_rdoc: 
+test_files: []

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/.travis.yml

@@ -1,16 +0,0 @@
-before_install:
-  - gem install bundler
-language: ruby
-cache: bundler
-rvm:
-  - 2.3.1
-  - 2.2.5
-  - 2.1.10
-  - ruby-head
-  - jruby-head
-env:
-- COVERALLS=true
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: jruby-head

data/test/test_helper.rb

@@ -1,13 +0,0 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter 'test'
-end
-require 'coveralls'
-
-if ENV['COVERALLS']
-  Coveralls.wear!
-end
-
-require 'minitest/autorun'
-
-require 'triad'