tash 1.0.0

data/sig/tash.rbs

@@ -0,0 +1,178 @@
+module Tash
+  VERSION: String
+
+  class Tash[unchecked out K, unchecked out V] < Object
+    include Enumerable[[ K, V ]]
+
+    def self.[]: [U, V] (Tash[U, V]) -> Tash[U, V]
+               | [U, V] (_ToHash[U, V]) { (U) -> unchecked out U } -> Tash[U, V]
+               | [U, V] (Array[[ U, V ]])  { (U) -> unchecked out U } -> Tash[U, V]
+               | (*untyped) { (U) -> unchecked out U } -> Tash[untyped, untyped]
+
+    public
+
+    def <: [A, B] ((Tash | Hash)[A, B]) -> bool
+
+    def <=: [A, B] ((Tash | Hash)[A, B]) -> bool
+
+    def ==: (untyped other) -> bool
+
+    def >: [A, B] ((Tash | Hash)[A, B]) -> bool
+
+    def >=: [A, B] ((Tash | Hash)[A, B]) -> bool
+
+    def []: (K) -> V
+
+    def []=: (K, V) -> V
+
+    def assoc: (K) -> [ K, V ]?
+
+    def clear: () -> self
+
+    def compact: () -> Tash[K, V]
+
+    def compact!: () -> self?
+
+    def compare_by_identity: () -> self
+
+    def compare_by_identity?: () -> bool
+
+    def deconstruct_keys: (Array[K] | nil) -> self
+
+    def default: (?K) -> V?
+
+    def default=: (V) -> V
+
+    def default_proc: () -> (Proc | nil)
+
+    def default_proc=: (Proc | _ToProc | nil) -> (Proc | _ToProc | nil)
+
+    def delete: (K) -> V?
+              | [U] (K) { (K) -> U } -> (U | V)
+
+    def delete_if: () { (K, V) -> boolish } -> self
+                 | () -> Enumerator[[ K, V ], self]
+
+    def dig: (K, *untyped) -> untyped
+
+    def each: () { ([ K, V ]) -> untyped } -> self
+            | () -> ::Enumerator[[ K, V ], self]
+
+    def each_key: () { (K) -> untyped } -> Tash[K, V]
+                | () -> Enumerator[K, self]
+
+    alias each_pair each
+
+    def each_value: () { (V) -> untyped } -> self
+                  | () -> Enumerator[V, self]
+
+    def empty?: () -> bool
+
+    def eql?: (untyped) -> bool
+
+    def except: (*K) -> Tash[K, V]
+
+    def fetch: (K) -> V
+             | [X] (K, X) -> (V | X)
+             | [X] (K) { (K) -> X } -> (V | X)
+
+    def fetch_values: (*K) -> Array[V]
+                    | [X] (*K) { (K) -> X } -> Array[V | X]
+
+    alias filter select
+
+    alias filter! select!
+
+    def flatten: () -> Array[K | V]
+               | (1 level) -> Array[K | V]
+               | (Integer level) -> Array[untyped]
+
+    alias has_key? key?
+
+    alias has_value? value?
+
+    def hash: () -> Integer
+
+    alias include? has_key?
+
+    def inspect: () -> String
+
+    def invert: () -> Tash[V, K]
+
+    def keep_if: () { (K, V) -> boolish } -> self
+               | () -> Enumerator[[ K, V ], self]
+
+    def key: (V) -> K?
+
+    def key?: (K) -> bool
+
+    def keys: () -> Array[K]
+
+    alias length size
+
+    alias member? has_key?
+
+    def merge: [A, B] (*(Tash | Hash)[A, B] other_tashes_or_hashes) -> Tash[A | K, B | V]
+             | [A, B, C] (*(Tash | Hash)[A, B] other_tashes_or_hashes) { (K key, V oldval, B newval) -> C } -> Tash[A | K, B | V | C]
+
+    def merge!: (*(Tash | Hash)[K, V] other_tashes_or_hashes) -> self
+              | (*(Tash | Hash)[K, V] other_tashes_or_hashes) { (K key, V oldval, V newval) -> V } -> self
+
+    def rassoc: (V) -> [ K, V ]?
+
+    def rehash: () -> self
+
+    def reject: () { (K, V) -> boolish } -> Tash[K, V]
+              | () -> Enumerator[[ K, V ], Tash[K, V]]
+
+    def reject!: () { (K, V) -> boolish } -> self?
+               | () -> Enumerator[[ K, V ], self?]
+
+    def replace: ((Tash | Hash)[K, V]) -> self
+
+    def select: () { (K, V) -> boolish } -> Tash[K, V]
+              | () -> Enumerator[[ K, V ], Tash[K, V]]
+
+    def select!: () { (K, V) -> boolish } -> self?
+               | () -> Enumerator[[ K, V ], self?]
+
+    def shift: () -> [ K, V ]?
+
+    def size: () -> Integer
+
+    def slice: (*K) -> Tash[K, V]
+
+    alias store []=
+
+    def to_a: () -> Array[[ K, V ]]
+
+    def to_h: () -> Hash[K, V]
+            | [A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B]
+
+    def to_hash: () -> Hash[K, V]
+
+    def to_proc: () -> ^(K) -> V?
+
+    alias to_s inspect
+
+    def transform_proc: () -> (Proc | nil)
+
+    def transform_values: () -> Enumerator[V, Tash[K, untyped]]
+                        | [A] () { (V) -> A } -> Tash[K, A]
+
+    def transform_values!: () -> Enumerator[V, self]
+                         | () { (V) -> V } -> self
+
+    alias update merge!
+
+    def value?: (V) -> bool
+
+    def values: () -> Array[V]
+
+    def values_at: (*K) -> Array[V?]
+
+    private
+
+    def initialize: () { (K) -> unchecked out K } -> void
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'tash'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.on_potential_false_positives = :nothing
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.filter_run_when_matching :focus
+
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.order = :random
+  Kernel.srand config.seed
+end
+
+def when_ruby_above(version)
+  yield if Tash.send(:current_ruby_version) > version
+end