striuct 0.6.1 → 0.7.0

data/lib/striuct/classmethods/requirements.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optionalargument'
 
 require_relative 'hashdeepdupulicatable'
@@ -15,4 +17,4 @@ require_relative 'default'
 require_relative 'adjustment'
 require_relative 'macro'
 require_relative 'conflict_management'
-require_relative 'validation'
+require_relative 'validation'

data/lib/striuct/classmethods/to_struct.rb

@@ -1,24 +1,27 @@
-class Striuct; module ClassMethods
+# frozen_string_literal: true
 
-  # @group To Ruby's Struct Class
+class Striuct
+  module ClassMethods
+    # @group To Ruby's Struct Class
 
-  # @return [Class]
-  def to_struct_class
-    raise 'No defined members' if autonyms.empty?
+    # @return [Class]
+    def to_struct_class
+      raise 'No defined members' if autonyms.empty?
 
-    struct_cls = ::Struct.new(*autonyms)
-    return struct_cls unless name
+      struct_cls = ::Struct.new(*autonyms)
+      return struct_cls unless name
 
-    const_suffix = name.slice(/[^:]+\z/).to_sym
-    if ::Striuct::Structs.const_defined?(const_suffix, false) && 
-       (already_cls = ::Striuct::Structs.const_get(const_suffix, false)).members == autonyms
-       raise unless already_cls.superclass.equal? Struct
-       already_cls
-    else
-      ::Striuct::Structs.const_set const_suffix, struct_cls
-    end
-  end
+      const_suffix = name.slice(/[^:]+\z/).to_sym
+      if ::Striuct::Structs.const_defined?(const_suffix, false) &&
+         (already_cls = ::Striuct::Structs.const_get(const_suffix, false)).members == autonyms
+        raise unless already_cls.superclass.equal?(Struct)
 
-  # @endgroup
+        already_cls
+      else
+        ::Striuct::Structs.const_set(const_suffix, struct_cls)
+      end
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/classmethods/validation.rb

@@ -1,15 +1,17 @@
-class Striuct; module ClassMethods
-
-  # @group Validation
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def condition_for(key)
-    autonym = autonym_for_key key
-    raise KeyError unless with_condition? autonym
-    
-    _attributes_for(autonym).condition
-  end
+# frozen_string_literal: true
+
+class Striuct
+  module ClassMethods
+    # @group Validation
 
-  # @endgroup
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def condition_for(key)
+      autonym = autonym_for_key(key)
+      raise KeyError unless with_condition?(autonym)
 
-end; end
+      _attributes_for(autonym).condition
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/README.md

@@ -1,5 +1,5 @@
 Note
 =====
 
-This dir's tree is diveded under roles/features.  
-Not under CONSTANT names.
+This dir's tree is divided under roles/features.
+Not under CONSTANT names.

data/lib/striuct/instancemethods/assign.rb

@@ -1,33 +1,35 @@
-class Striuct; module InstanceMethods 
+# frozen_string_literal: true
 
-  # @group Assign / Unassign
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def assigned?(key)
-    @db.has_key? autonym_for_key(key)
-  end
+class Striuct
+  module InstanceMethods
+    # @group Assign / Unassign
 
-  alias_method :assign?, :assigned?
-  
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @return value / nil - value assigned under the key
-  def unassign(key)
-    _check_frozen
-    _check_locked key
-    if must? key
-      raise InvalidOperationError, "`#{key}` require a value under `must` option"
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def assigned?(key)
+      @db.key?(autonym_for_key(key))
     end
-    
-    @db.delete autonym_for_key(key)
-  end
-  
-  alias_method :delete_at, :unassign
 
-  # true if all members are not yet assigned
-  def empty?
-    _autonyms.none?{|autonym|@db.has_key? autonym}
-  end
+    alias_method :assign?, :assigned?
 
-  # @endgroup
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @return value / nil - value assigned under the key
+    def unassign(key)
+      _check_frozen
+      _check_locked(key)
+      if must?(key)
+        raise InvalidOperationError, "`#{key}` require a value under `must` option"
+      end
+
+      @db.delete(autonym_for_key(key))
+    end
 
-end; end
+    alias_method :delete_at, :unassign
+
+    # true if all members are not yet assigned
+    def empty?
+      _autonyms.none? { |autonym| @db.key?(autonym) }
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/cast.rb

@@ -1,32 +1,34 @@
-class Striuct; module InstanceMethods 
+# frozen_string_literal: true
 
-  # @group Cast
+class Striuct
+  module InstanceMethods
+    # @group Cast
 
-  # @return [self]
-  def to_striuct
-    self
-  end
+    # @return [self]
+    def to_striuct
+      self
+    end
 
-  # @return [Struct]
-  def to_struct
-    self.class.to_struct_class.new(*values)
-  end
-  
-  # @param [Boolean] include_no_assign
-  # @return [Hash]
-  def to_h(include_no_assign=true)
-    return @db.dup unless include_no_assign
+    # @return [Struct]
+    def to_struct
+      self.class.to_struct_class.new(*values)
+    end
 
-    Hash[each_pair.to_a]
-  end
-  
-  # @return [Array]
-  def values
-    each_value.to_a
-  end
-  
-  alias_method :to_a, :values
+    # @param [Boolean] include_no_assign
+    # @return [Hash]
+    def to_h(include_no_assign: true)
+      return @db.dup unless include_no_assign
 
-  # @endgroup
+      each_pair.to_a.to_h
+    end
 
-end; end
+    # @return [Array]
+    def values
+      each_value.to_a
+    end
+
+    alias_method :to_a, :values
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/compare.rb

@@ -1,30 +1,32 @@
-class Striuct; module InstanceMethods
-
-  # @group Compare with other
-  
-  # @return [Boolean]
-  def ==(other)
-    other.instance_of?(self.class) && 
-      each_pair.all?{|autonym, val|other._get(autonym) == val}
-  end
+# frozen_string_literal: true
 
-  alias_method :===, :==
-  
-  def eql?(other)
-    other.instance_of?(self.class) && other._db.eql?(@db)
-  end
+class Striuct
+  module InstanceMethods
+    # @group Compare with other
 
-  # @return [Integer]
-  def hash
-    @db.hash
-  end
+    # @return [Boolean]
+    def ==(other)
+      other.instance_of?(self.class) &&
+        each_pair.all? { |autonym, val| other._get(autonym) == val }
+    end
 
-  protected
+    alias_method :===, :==
 
-  def _db
-    @db
-  end
+    def eql?(other)
+      other.instance_of?(self.class) && other._db.eql?(@db)
+    end
 
-  # @endgroup
+    # @return [Integer]
+    def hash
+      @db.hash
+    end
 
-end; end
+    protected
+
+    def _db
+      @db
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/default.rb

@@ -1,36 +1,38 @@
-class Striuct; module InstanceMethods 
+# frozen_string_literal: true
 
-  # @group Default Value
- 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  def default?(key)
-    autonym = autonym_for_key key
+class Striuct
+  module InstanceMethods
+    # @group Default Value
 
-    default_value_for(autonym) == fetch_by_autonym(autonym)
-  end
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    def default?(key)
+      autonym = autonym_for_key(key)
+
+      default_value_for(autonym) == fetch_by_autonym(autonym)
+    end
 
-  private
+    private
 
-  # @param [Symbol] target_autonyms - MUST already converted to native autonym
-  # @return [self]
-  def _set_defaults(*target_autonyms)
-    target_autonyms.each do |autonym|
-      if with_default? autonym
-        default = default_value_for autonym
-        _set autonym, (
-          if default_type_for(autonym) == :lazy
-            args = [self, autonym][0, default.arity]
-            default.call(*args)
-          else
-            default
-          end
-        )
+    # @param [Symbol] target_autonyms - MUST already converted to native autonym
+    # @return [self]
+    def _set_defaults(*target_autonyms)
+      target_autonyms.each do |autonym|
+        if with_default?(autonym)
+          default = default_value_for(autonym)
+          _set(autonym, (
+            if default_type_for(autonym) == :lazy
+              args = [self, autonym][0, default.arity]
+              default.call(*args)
+            else
+              default
+            end
+          ))
+        end
       end
-    end
-    
-    self
-  end
 
-  # @endgroup
+      self
+    end
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/instancemethods/delegate_class_methods.rb

@@ -1,37 +1,39 @@
-class Striuct; module InstanceMethods
+# frozen_string_literal: true
 
-  # @group Delegate Class Methods
-  
-  def_delegators :'self.class',
-    :autonym_for_alias,
-    :autonym_for_member,
-    :autonym_for_index,
-    :autonym_for_key,
-    :autonyms, :members, :all_members, :aliases, :attributes,
-    :has_autonym?, :autonym?,
-    :has_alias?, :alias?, :aliased?,
-    :has_member?, :member?,
-    :has_index?, :index?,
-    :has_key?, :key?,
-    :with_aliases?,
-    :aliases_for_autonym,
-    :length, :size,
-    :with_condition?, :restrict?,
-    :condition_for,
-    :with_safety_getter?, :with_safety_reader?,
-    :with_safety_setter?, :with_safety_writer?,
-    :with_must?, :must?,
-    :with_default?,
-    :default_value_for, :default_type_for,
-    :with_adjuster?,
-    :adjuster_for
+class Striuct
+  module InstanceMethods
+    # @group Delegate Class Methods
 
-  private
+    def_delegators :'self.class',
+                   :autonym_for_alias,
+                   :autonym_for_member,
+                   :autonym_for_index,
+                   :autonym_for_key,
+                   :autonyms, :members, :all_members, :aliases, :attributes,
+                   :has_autonym?, :autonym?,
+                   :has_alias?, :alias?, :aliased?,
+                   :has_member?, :member?,
+                   :has_index?, :index?,
+                   :has_key?, :key?,
+                   :with_aliases?,
+                   :aliases_for_autonym,
+                   :length, :size,
+                   :with_condition?, :restrict?,
+                   :condition_for,
+                   :with_safety_getter?, :with_safety_reader?,
+                   :with_safety_setter?, :with_safety_writer?,
+                   :with_must?, :must?,
+                   :with_default?,
+                   :default_value_for, :default_type_for,
+                   :with_adjuster?,
+                   :adjuster_for
 
-  def _autonyms
-    self.class.__send__ :_autonyms
-  end
+    private
+
+    def _autonyms
+      self.class.__send__(:_autonyms)
+    end
 
-  # @endgroup
-  
-end; end
+    # @endgroup
+  end
+end

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