striuct 0.6.1 → 0.9.0

data/lib/striuct/instancemethods/enum.rb

@@ -1,98 +1,100 @@
-class Striuct; module InstanceMethods 
+# frozen_string_literal: true
 
-  # @group Enumerative
+class Striuct
+  module InstanceMethods
+    # @group Enumerative
 
-  # @yield [autonym] 
-  # @yieldparam [Symbol] autonym - sequential under defined
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_autonym(&block)
-    return to_enum(__callee__) { self.class.size } unless block_given?
+    # @yield [autonym]
+    # @yieldparam [Symbol] autonym - sequential under defined
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_autonym(&block)
+      return to_enum(__callee__) { self.class.size } unless block
 
-    self.class.each_autonym(&block)
-    self
-  end
+      self.class.each_autonym(&block)
+      self
+    end
 
-  alias_method :each_member, :each_autonym
-
-  # @yield [value]
-  # @yieldparam [Object] value - sequential under defined
-  # @see #each_autonym
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_value
-    return to_enum(__callee__) { self.class.size } unless block_given?
-  
-    each_autonym{|autonym|yield _get(autonym)}
-  end
-  
-  alias_method :each, :each_value
-
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @yieldparam [Object] value
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  # @see #each_autonym
-  # @see #each_value 
-  def each_pair
-    return to_enum(__callee__) { self.class.size } unless block_given?
-
-    each_autonym{|autonym|yield autonym, _get(autonym)}
-  end
+    alias_method :each_member, :each_autonym
 
-  # @yield [index] 
-  # @yieldparam [Integer] index
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_index
-    return to_enum(__callee__) { self.class.size } unless block_given?
+    # @yield [value]
+    # @yieldparam [Object] value - sequential under defined
+    # @see #each_autonym
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_value
+      return to_enum(__callee__) { self.class.size } unless block_given?
 
-    self.class.each_index{|index|yield index}
-    self
-  end
+      each_autonym { |autonym| yield _get(autonym) }
+    end
 
-  # @yield [autonym, index]
-  # @yieldparam [Symbol] autonym
-  # @yieldparam [Integer] index
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_autonym_with_index
-    return to_enum(__callee__) { self.class.size } unless block_given?
+    alias_method :each, :each_value
 
-    self.class.each_autonym_with_index{|autonym, index|yield autonym, index}
-    self
-  end
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @yieldparam [Object] value
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    # @see #each_autonym
+    # @see #each_value
+    def each_pair
+      return to_enum(__callee__) { self.class.size } unless block_given?
 
-  alias_method :each_member_with_index, :each_autonym_with_index
+      each_autonym { |autonym| yield autonym, _get(autonym) }
+    end
 
-  # @yield [value, index]
-  # @yieldparam [Integer] index
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_value_with_index
-    return to_enum(__callee__) { self.class.size } unless block_given?
+    # @yield [index]
+    # @yieldparam [Integer] index
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_index
+      return to_enum(__callee__) { self.class.size } unless block_given?
 
-    each_value.with_index{|value, index|yield value, index}
-  end
-  
-  alias_method :each_with_index, :each_value_with_index
-  
-  # @yield [autonym, value, index]
-  # @yieldparam [Symbol] autonym
-  # @yieldparam [Integer] index
-  # @yieldreturn [self]
-  # @return [Enumerator]
-  def each_pair_with_index
-    return to_enum(__callee__) { self.class.size } unless block_given?
-
-    index = 0
-    each_pair do |autonym, value|
-      yield autonym, value, index
-      index += 1
+      self.class.each_index { |index| yield index }
+      self
     end
-  end
 
-  # @endgroup
+    # @yield [autonym, index]
+    # @yieldparam [Symbol] autonym
+    # @yieldparam [Integer] index
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_autonym_with_index
+      return to_enum(__callee__) { self.class.size } unless block_given?
 
-end; end
+      self.class.each_autonym_with_index { |autonym, index| yield autonym, index }
+      self
+    end
+
+    alias_method :each_member_with_index, :each_autonym_with_index
+
+    # @yield [value, index]
+    # @yieldparam [Integer] index
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_value_with_index
+      return to_enum(__callee__) { self.class.size } unless block_given?
+
+      each_value.with_index { |value, index| yield value, index }
+    end
+
+    alias_method :each_with_index, :each_value_with_index
+
+    # @yield [autonym, value, index]
+    # @yieldparam [Symbol] autonym
+    # @yieldparam [Integer] index
+    # @yieldreturn [self]
+    # @return [Enumerator]
+    def each_pair_with_index
+      return to_enum(__callee__) { self.class.size } unless block_given?
+
+      index = 0
+      each_pair do |autonym, value|
+        yield autonym, value, index
+        index += 1
+      end
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/getter.rb

@@ -1,47 +1,49 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Getter
+class Striuct
+  module InstanceMethods
+    # @group Getter
 
-  # @param [Symbol, String, #to_sym] autonym
-  def fetch_by_autonym(autonym)
-    autonym = autonym.to_sym
-    raise NameError unless autonym? autonym
+    # @param [Symbol, String, #to_sym] autonym
+    def fetch_by_autonym(autonym)
+      autonym = autonym.to_sym
+      raise NameError unless autonym?(autonym)
 
-    _get autonym
-  end
-
-  # @param [Symbol, String, #to_sym] member
-  def fetch_by_member(member)
-    _get autonym_for_member(member)
-  end
+      _get(autonym)
+    end
 
-  # @param [Integer, #to_int] index
-  def fetch_by_index(index)
-    _get autonym_for_index(index)
-  end
+    # @param [Symbol, String, #to_sym] member
+    def fetch_by_member(member)
+      _get(autonym_for_member(member))
+    end
 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def fetch_by_key(key)
-    _get autonym_for_key(key)
-  end
+    # @param [Integer, #to_int] index
+    def fetch_by_index(index)
+      _get(autonym_for_index(index))
+    end
 
-  alias_method :[], :fetch_by_key
-  alias_method :fetch, :fetch_by_key
-  
-  protected
-
-  # @param [Symbol] autonym - MUST already converted to native autonym
-  def _get(autonym)
-    value = @db[autonym]
-  
-    if with_safety_getter?(autonym) and !accept?(autonym, value)
-      raise ::Validation::InvalidReadingError,
-            "#{value.inspect} is deficient for #{autonym} in #{self.class}"
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def fetch_by_key(key)
+      _get(autonym_for_key(key))
     end
 
-    value
-  end
+    alias_method :[], :fetch_by_key
+    alias_method :fetch, :fetch_by_key
+
+    protected
+
+    # @param [Symbol] autonym - MUST already converted to native autonym
+    def _get(autonym)
+      value = @db[autonym]
 
-  # @endgroup
+      if with_safety_getter?(autonym) && !accept?(autonym, value)
+        raise InvalidReadingError,
+              "#{value.inspect} is deficient for #{autonym} in #{self.class}"
+      end
 
-end; end
+      value
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/hashy.rb

@@ -1,118 +1,120 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Like Ruby's Hash
+class Striuct
+  module InstanceMethods
+    # @group Like Ruby's Hash
 
-  def has_value?(value)
-    @db.has_value? value
-  end
+    def has_value?(value)
+      @db.value?(value)
+    end
 
-  alias_method :value?, :has_value?
-
-  # keep truthy only (unassign falsy member)
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @see #each_pair
-  # @return [Enumerator]
-  # @yieldreturn [self]
-  # @yieldreturn [nil]
-  def select!
-    _check_frozen
-    return to_enum(__callee__) unless block_given?
-
-    modified = false
-    each_pair do |autonym, value|
-      unless yield autonym, value
-        unassign autonym
-        modified = true
+    alias_method :value?, :has_value?
+
+    # keep truthy only (unassign falsy member)
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @see #each_pair
+    # @return [Enumerator]
+    # @yieldreturn [self]
+    # @yieldreturn [nil]
+    def select!
+      _check_frozen
+      return to_enum(__callee__) unless block_given?
+
+      modified = false
+      each_pair do |autonym, value|
+        unless yield autonym, value
+          unassign(autonym)
+          modified = true
+        end
       end
+
+      modified ? self : nil
     end
-    
-    modified ? self : nil
-  end
 
-  # @see #select!
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @return [Enumerator]
-  def keep_if(&block)
-    _check_frozen
-    return to_enum(__callee__) unless block_given?
+    # @see #select!
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @return [Enumerator]
+    def keep_if(&block)
+      _check_frozen
+      return to_enum(__callee__) unless block
 
-    select!(&block)
-    self
-  end
+      select!(&block)
+      self
+    end
 
-  # @see #select!
-  # keep falsy only (unassign truthy member)
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @return [Enumerator]
-  def reject!
-    _check_frozen
-    return to_enum(__callee__) unless block_given?
-
-    modified = false
-    each_pair do |autonym, value|
-      if yield autonym, value
-        unassign autonym
-        modified = true
+    # @see #select!
+    # keep falsy only (unassign truthy member)
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @return [Enumerator]
+    def reject!
+      _check_frozen
+      return to_enum(__callee__) unless block_given?
+
+      modified = false
+      each_pair do |autonym, value|
+        if yield autonym, value
+          unassign(autonym)
+          modified = true
+        end
       end
+
+      modified ? self : nil
     end
-    
-    modified ? self : nil
-  end
 
-  # @see #reject!
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @return [Enumerator]
-  def delete_if(&block)
-    _check_frozen
-    return to_enum(__callee__) unless block_given?
+    # @see #reject!
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @return [Enumerator]
+    def delete_if(&block)
+      _check_frozen
+      return to_enum(__callee__) unless block
 
-    reject!(&block)
-    self
-  end
-
-  # @param [Symbol, String] name
-  # @return [Array] e.g [autonym, value]
-  def assoc(name)
-    autonym = autonym_for_member name
+      reject!(&block)
+      self
+    end
 
-    [autonym, self[name]]
-  end
+    # @param [Symbol, String] name
+    # @return [Array] e.g [autonym, value]
+    def assoc(name)
+      autonym = autonym_for_member(name)
 
-  # @return [Array] [autonym, value]
-  def rassoc(value)
-    each_pair.find{|_, val|val == value}
-  end
+      [autonym, self[name]]
+    end
 
-  # @see Hash#flatten
-  # @return [Array]
-  def flatten(level=1)
-    each_pair.to_a.flatten level
-  end
+    # @return [Array] [autonym, value]
+    def rassoc(value)
+      each_pair.find { |_, val| val == value }
+    end
 
-  # @see #select!
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @return [Striuct]
-  def select(&block)
-    return to_enum(__callee__) unless block_given?
+    # @see Hash#flatten
+    # @return [Array]
+    def flatten(level=1)
+      each_pair.to_a.flatten(level)
+    end
 
-    dup.tap {|r|r.select!(&block)}
-  end
+    # @see #select!
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @return [Striuct]
+    def select(&block)
+      return to_enum(__callee__) unless block
 
-  # @see #reject!
-  # @yield [autonym, value]
-  # @yieldparam [Symbol] autonym
-  # @return [Striuct]
-  def reject(&block)
-    return to_enum(__callee__) unless block_given?
+      dup.tap { |r| r.select!(&block) }
+    end
 
-    dup.tap {|r|r.reject!(&block)}
-  end
+    # @see #reject!
+    # @yield [autonym, value]
+    # @yieldparam [Symbol] autonym
+    # @return [Striuct]
+    def reject(&block)
+      return to_enum(__callee__) unless block
 
-  # @endgroup
+      dup.tap { |r| r.reject!(&block) }
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/lock.rb

@@ -1,53 +1,55 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Lock / Unlock
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @return [self]
-  def lock(key)
-    _check_frozen
+class Striuct
+  module InstanceMethods
+    # @group Lock / Unlock
 
-    @locks[autonym_for_key(key)] = true
-    self
-  end
-  
-  # @return [self]
-  def lock_all
-    _check_frozen
-    
-    each_autonym do |autonym|
-      @locks[autonym] = true
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @return [self]
+    def lock(key)
+      _check_frozen
+
+      @locks[autonym_for_key(key)] = true
+      self
     end
-  end
 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def locked?(key)
-    @locks.has_key? autonym_for_key(key)
-  end
-  
-  def all_locked?
-    _autonyms.all?{|autonym|@locks.has_key? autonym}
-  end
-  
-  private
+    # @return [self]
+    def lock_all
+      _check_frozen
 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @return [self]
-  def unlock(key)
-    _check_frozen
+      each_autonym do |autonym|
+        @locks[autonym] = true
+      end
+    end
 
-    @locks.delete autonym_for_key(key)
-    self
-  end
-  
-  # @return [self]
-  def unlock_all
-    _check_frozen
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def locked?(key)
+      @locks.key?(autonym_for_key(key))
+    end
 
-    @locks.clear
-    self
-  end
+    def all_locked?
+      _autonyms.all? { |autonym| @locks.key?(autonym) }
+    end
+
+    private
+
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @return [self]
+    def unlock(key)
+      _check_frozen
+
+      @locks.delete(autonym_for_key(key))
+      self
+    end
+
+    # @return [self]
+    def unlock_all
+      _check_frozen
 
-  # @endgroup
+      @locks.clear
+      self
+    end
 
-end; end
+    # @endgroup
+  end
+end