striuct 0.6.1 → 0.7.0

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 ::Validation::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/keyvalidatable.rb

@@ -1,9 +1,11 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  KeyValidatable.instance_methods.each do |feature|
-    if specific_feature = feature.to_s.sub!('members'){'autonyms'}
-      def_delegator :self, feature, specific_feature.to_sym
+class Striuct
+  module InstanceMethods
+    KeyValidatable.instance_methods.each do |feature|
+      if specific_feature = feature.to_s.sub!('members') { 'autonyms' }
+        def_delegator :self, feature, specific_feature.to_sym
+      end
     end
   end
-
-end; 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

data/lib/striuct/instancemethods/object.rb

@@ -1,66 +1,68 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Basic Methods for Ruby's Object
+class Striuct
+  module InstanceMethods
+    # @group Basic Methods for Ruby's Object
 
-  # @return [self]
-  def freeze
-    @db.freeze; @locks.freeze
-    super
-  end
+    # @return [self]
+    def freeze
+      @db.freeze; @locks.freeze
+      super
+    end
 
-  private
+    private
 
-  def initialize(*values)
-    _initialize_database
+    def initialize(*values)
+      _initialize_database
 
-    replace_values(*values)
-    excess_autonyms = _autonyms.last(size - values.size)
-    _set_defaults(*excess_autonyms)
+      replace_values(*values)
+      excess_autonyms = _autonyms.last(size - values.size)
+      _set_defaults(*excess_autonyms)
 
-    each_autonym do |autonym|
-      _check_must autonym
+      each_autonym do |autonym|
+        _check_must(autonym)
+      end
     end
-  end
 
-  def initialize_for_pairs(pairs)
-    _initialize_database
-    
-    excess_autonyms = _autonyms.dup
-    pairs.each_pair do |key, value|
-      autonym = autonym_for_key key
-      self[autonym] = value
-      excess_autonyms.delete autonym
-    end
+    def initialize_for_pairs(pairs)
+      _initialize_database
 
-    _set_defaults(*excess_autonyms)
+      excess_autonyms = _autonyms.dup
+      pairs.each_pair do |key, value|
+        autonym = autonym_for_key(key)
+        self[autonym] = value
+        excess_autonyms.delete(autonym)
+      end
 
-    excess_autonyms.each do |autonym|
-      _check_must autonym
+      _set_defaults(*excess_autonyms)
+
+      excess_autonyms.each do |autonym|
+        _check_must(autonym)
+      end
     end
-  end
-  
-  def initialize_copy(original)
-    @db, @locks = @db.dup, {}
-  end
 
-  def _initialize_database
-    @db, @locks = {}, {}
-  end
+    def initialize_copy(original)
+      @db, @locks = @db.dup, {}
+    end
 
-  def _check_frozen
-    raise "can't modify frozen #{self.class}" if frozen?
-  end
+    def _initialize_database
+      @db, @locks = {}, {}
+    end
 
-  def _check_locked(key)
-    raise "can't modify locked member `#{key}`" if locked? key
-  end
+    def _check_frozen
+      raise "can't modify frozen #{self.class}" if frozen?
+    end
 
-  def _check_must(key)
-    if must?(key) && !assigned?(key)
-      raise InvalidOperationError, "`#{key}` require a value under `must` option"
+    def _check_locked(key)
+      raise "can't modify locked member `#{key}`" if locked?(key)
     end
-  end
 
-  # @endgroup
+    def _check_must(key)
+      if must?(key) && !assigned?(key)
+        raise InvalidOperationError, "`#{key}` require a value under `must` option"
+      end
+    end
 
-end; end
+    # @endgroup
+  end
+end