striuct 0.6.1 → 0.9.0

data/lib/striuct/classmethods/inner.rb

@@ -1,71 +1,73 @@
-class Striuct; module ClassMethods
-
-  # @group Inner Methods
-
-  # for debug
-  # @return [Hash]
-  def attributes
-    {
-      autonyms: @autonyms.dup,
-      aliases: @aliases.dup,
-      conflict_management_level: @conflict_management_level,
-      attributes_each_autonym: @attributes.dup
-    }
-  end
-
-  private
+# frozen_string_literal: true
 
-  def _init
-    @autonyms      = []
-    @attributes    = {}.extend HashDeepDupulicatable # autonym => Attributes
-    @aliases       = {} # aliased => autonym
-    @conflict_management_level = DEFAULT_CONFLICT_MANAGEMENT_LEVEL
-  end
+class Striuct
+  module ClassMethods
+    # @group Inner Methods
 
-  def _add_autonym(autonym)
-    autonym = autonym.to_sym
-    raise NameError, 'already defined' if member? autonym
+    # for debug
+    # @return [Hash]
+    def attributes
+      {
+        autonyms: @autonyms.dup,
+        aliases: @aliases.dup,
+        conflict_management_level: @conflict_management_level,
+        attributes_each_autonym: @attributes.dup
+      }
+    end
 
-    @attributes[autonym] = Attributes.new
-    @autonyms << autonym
-  end
+    private
 
-  def _attributes_for(autonym)
-    @attributes.fetch autonym
-  end
+    def _init
+      @autonyms      = []
+      @attributes    = {}.extend HashDeepDupulicatable # autonym => Attributes
+      @aliases       = {} # aliased => autonym
+      @conflict_management_level = DEFAULT_CONFLICT_MANAGEMENT_LEVEL
+    end
 
-  def _check_frozen
-    raise "can't modify frozen Class" if frozen?
-  end
+    def _add_autonym(autonym)
+      autonym = autonym.to_sym
+      raise NameError, 'already defined' if member?(autonym)
 
-  def _check_closed
-    raise "can't modify closed member attributes in #{self}" if closed?
-  end
+      @attributes[autonym] = Attributes.new
+      @autonyms << autonym
+    end
 
-  def _def_getter(autonym) 
-    define_method autonym do
-      _get autonym
+    def _attributes_for(autonym)
+      @attributes.fetch(autonym)
     end
-    
-    nil
-  end
 
-  def _def_setter(autonym, condition, &adjuster)
-    unless ANYTHING.equal? condition
-      _attributes_for(autonym).condition = condition
+    def _check_frozen
+      raise "can't modify frozen Class" if frozen?
     end
 
-    if block_given?
-      _attributes_for(autonym).adjuster = adjuster
+    def _check_closed
+      raise "can't modify closed member attributes in #{self}" if closed?
     end
 
-    define_method :"#{autonym}=" do |value|
-      _set autonym, value
+    def _def_getter(autonym)
+      define_method(autonym) do
+        _get(autonym)
+      end
+
+      nil
     end
- 
-    nil
-  end
 
-  # @endgroup
+    def _def_setter(autonym, condition, &adjuster)
+      unless ANYTHING.equal?(condition)
+        _attributes_for(autonym).condition = condition
+      end
+
+      if adjuster
+        _attributes_for(autonym).adjuster = adjuster
+      end
 
-end; end
+      define_method(:"#{autonym}=") do |value|
+        _set(autonym, value)
+      end
+
+      nil
+    end
+
+    # @endgroup
+  end
+end

data/lib/striuct/classmethods/length.rb

@@ -1,14 +1,16 @@
-class Striuct; module ClassMethods
+# frozen_string_literal: true
 
-  # @group Length/Size
+class Striuct
+  module ClassMethods
+    # @group Length/Size
 
-  # @return [Integer]
-  def length
-    @autonyms.length
-  end
-  
-  alias_method :size, :length
+    # @return [Integer]
+    def length
+      @autonyms.length
+    end
 
-  # @endgroup
+    alias_method :size, :length
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/classmethods/macro.rb

@@ -1,116 +1,109 @@
-class Striuct; module ClassMethods
-
-  # @group Macro for Member Definition
-
-  ANYTHING = ::Validation::Condition::ANYTHING
-  
-  # @return [Class]
-  ADD_MEMBER_OptArg = OptionalArgument.define {
-    opt :default_value, aliases: [:default]
-    opt :default_proc, aliases: [:lazy_default]
-    conflict :default_value, :default_proc
-    opt :must, default: false
-    opt :setter_validation, aliases: [:writer_validation], default: true
-    opt :getter_validation, aliases: [:reader_validation], default: false
-  }
-
-  private
-
-  # @param [Symbol, String, #to_sym] autonym
-  # @param [#===, Proc, Method, ANYTHING] condition
-  # @param [Hash] options
-  # @option options [BasicObject] :default
-  # @option options [Proc] :default_proc
-  # @option options [Boolean] :must
-  # @option options [Boolean] :reader_validation
-  # @option options [Boolean] :getter_validation
-  # @option options [Boolean] :writer_validation
-  # @option options [Boolean] :setter_validation
-  # @return [nil]
-  def add_member(autonym, condition=ANYTHING, options={}, &adjuster)
-    _check_frozen
-    _check_closed
-    
-    options = ADD_MEMBER_OptArg.parse options
-    autonym = autonym.to_sym # First difinition for an autonym
-
-    raise ArgumentError, %Q!already exist name "#{autonym}"! if member? autonym
-    _check_safety_naming autonym
-    _add_autonym autonym
-
-    _attributes_for(autonym).safety_setter = !!options.setter_validation
-    _attributes_for(autonym).safety_getter = !!options.getter_validation
-
-    if options.must
-      _attributes_for(autonym).must = true
+# frozen_string_literal: true
+
+class Striuct
+  module ClassMethods
+    # @group Macro for Member Definition
+
+    ANYTHING = Eqq.ANYTHING()
+
+    # @return [Class]
+
+    private
+
+    # @param [Symbol, String, #to_sym] autonym
+    # @param [#===, Proc, Method] pattern
+    # @param [Proc] default_proc
+    # @param [Boolean] must
+    # @param [Boolean] writer_validation
+    # @param [Boolean] reader_validation
+    # @return [void]
+    def add_member(autonym, pattern=ANYTHING, default_value: nil, default_proc: nil, must: false, writer_validation: true, reader_validation: false, &adjuster)
+      _check_frozen
+      _check_closed
+
+      raise ArgumentError if !default_value.nil? && default_proc
+
+      autonym = autonym.to_sym # First definition for an autonym
+
+      raise ArgumentError, %Q!already exist name "#{autonym}"! if member?(autonym)
+
+      _check_safety_naming(autonym)
+      _add_autonym(autonym)
+
+      _attributes_for(autonym).safety_setter = writer_validation
+      _attributes_for(autonym).safety_getter = reader_validation
+
+      if must
+        _attributes_for(autonym).must = true
+      end
+
+      _def_getter(autonym)
+      _def_setter(autonym, pattern, &adjuster)
+
+      case
+      when !default_value.nil?
+        set_default_value(autonym, default_value)
+      when default_proc
+        set_default_value(autonym, &default_proc)
+      end
+
+      nil
     end
 
-    _def_getter autonym
-    _def_setter autonym, condition, &adjuster
-    
-    case
-    when options.default_value?
-      set_default_value autonym, options.default_value
-    when options.default_proc?
-      set_default_value autonym, &options.default_proc
+    alias_method :member, :add_member
+
+    # @param [Symbol, String, #to_sym] autonym
+    # @param [Symbol, String, #to_sym] autonyms
+    # @return [nil]
+    def add_members(autonym, *autonyms)
+      _check_frozen
+      _check_closed
+
+      [autonym, *autonyms].each { |name| add_member(name) }
+      nil
     end
-    
-    nil
-  end
 
-  alias_method :member, :add_member
-
-  # @param [Symbol, String, #to_sym] autonym
-  # @param [Symbol, String, #to_sym] autonyms
-  # @return [nil]
-  def add_members(autonym, *autonyms)
-    _check_frozen
-    _check_closed
-    
-    [autonym, *autonyms].each {|_autonym|add_member _autonym}
-    nil
-  end
+    # @param [Symbol, String, #to_sym] aliased
+    # @param [Symbol, String, #to_sym] autonym
+    # @return [nil]
+    def alias_member(aliased, autonym)
+      _check_frozen
+      _check_closed
+      autonym = autonym_for_member(autonym)
+      aliased = aliased.to_sym
+      raise ArgumentError, %Q!already exist name "#{aliased}"! if member?(aliased)
+
+      _check_safety_naming(aliased)
+
+      alias_method(aliased, autonym)
+      alias_method(:"#{aliased}=", :"#{autonym}=")
+      @aliases[aliased] = autonym
+      nil
+    end
 
-  # @param [Symbol, String, #to_sym] aliased
-  # @param [Symbol, String, #to_sym] autonym
-  # @return [nil]
-  def alias_member(aliased, autonym)
-    _check_frozen
-    _check_closed
-    autonym = autonym_for_member autonym
-    aliased  = aliased.to_sym
-    raise ArgumentError, %Q!already exist name "#{aliased}"! if member? aliased
-    _check_safety_naming aliased
-
-    alias_method aliased, autonym
-    alias_method :"#{aliased}=", :"#{autonym}="
-    @aliases[aliased] = autonym
-    nil
-  end
-  
-  # @param [Symbol, String, #to_sym] name
-  # @return [nil]
-  def set_default_value(name, value=nil, &block)
-    _check_frozen
-    _check_closed
-    autonym = autonym_for_member name
-    raise "already settled default value for #{name}" if with_default? autonym
-
-    if block_given?
-      unless value.nil?
-        raise ArgumentError, 'can not use default-value with default-proc'
+    # @param [Symbol, String, #to_sym] name
+    # @return [nil]
+    def set_default_value(name, value=nil, &block)
+      _check_frozen
+      _check_closed
+      autonym = autonym_for_member(name)
+      raise "already settled default value for #{name}" if with_default?(autonym)
+
+      if block
+        unless value.nil?
+          raise ArgumentError, 'can not use default-value with default-proc'
+        end
+
+        _attributes_for(autonym).set_default(block, :lazy)
+      else
+        _attributes_for(autonym).set_default(value, :value)
       end
 
-      _attributes_for(autonym).set_default block, :lazy
-    else
-      _attributes_for(autonym).set_default value, :value
+      nil
     end
-    
-    nil
-  end
-  
-  alias_method :default, :set_default_value
 
-  # @endgroup
+    alias_method :default, :set_default_value
 
-end; end
+    # @endgroup
+  end
+end

data/lib/striuct/classmethods/names.rb

@@ -1,75 +1,79 @@
-class Striuct; module ClassMethods
+# frozen_string_literal: true
 
-  # @group Named
+class Striuct
+  module ClassMethods
+    # @group Named
 
-  # @return [Array<Symbol>]
-  def autonyms
-    @autonyms.dup
-  end
+    # @return [Array<Symbol>]
+    def autonyms
+      @autonyms.dup
+    end
 
-  alias_method :members, :autonyms
-  
-  # @return [Array<Symbol>]
-  def all_members
-    @autonyms + @aliases.keys
-  end
- 
-  # @param [Symbol, String, #to_sym] als
-  # @return [Symbol]
-  def autonym_for_alias(als) 
-    @aliases.fetch als.to_sym
-  rescue NoMethodError
-    raise TypeError
-  rescue KeyError
-    raise NameError
-  end
+    alias_method :members, :autonyms
 
-  # @param [Symbol, String, #to_sym] name - autonym / aliased
-  # @return [Symbol]
-  def autonym_for_member(name)
-    raise TypeError unless name.respond_to? :to_sym
-    name = name.to_sym
-    
-    @autonyms.include?(name) ? name : autonym_for_alias(name)
-  end
+    # @return [Array<Symbol>]
+    def all_members
+      @autonyms + @aliases.keys
+    end
 
-  # @param [Index, #to_int] index
-  # @return [Symbol] autonym
-  def autonym_for_index(index)
-    @autonyms.fetch index
-  end
+    # @param [Symbol, String, #to_sym] als
+    # @return [Symbol]
+    def autonym_for_alias(als)
+      @aliases.fetch(als.to_sym)
+    rescue NoMethodError
+      raise TypeError
+    rescue KeyError
+      raise NameError
+    end
 
-  # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
-  # @return [Symbol] autonym
-  def autonym_for_key(key)
-    key.respond_to?(:to_sym) ? autonym_for_member(key) : autonym_for_index(key)
-  rescue NameError, IndexError, TypeError
-    raise KeyError
-  end
+    # @param [Symbol, String, #to_sym] name - autonym / aliased
+    # @return [Symbol]
+    def autonym_for_member(name)
+      raise TypeError unless name.respond_to?(:to_sym)
 
-  # @param [Symbol, String, #to_sym] autonym
-  # @return [Array<Symbol>]
-  def aliases_for_autonym(autonym)
-    raise TypeError unless autonym.respond_to?(:to_sym)
-    autonym = autonym.to_sym
-    raise NameError unless with_aliases? autonym
+      name = name.to_sym
 
-    @aliases.select{|als, aut|autonym == aut}.keys
-  end
-  
-  # @return [Hash] alias => autonym
-  def aliases
-    @aliases.dup
-  end
-  
-  private
+      @autonyms.include?(name) ? name : autonym_for_alias(name)
+    end
 
-  # for direct access inner data from own instance
-  # @return [Hash] alias => autonym
-  def _autonyms
-    @autonyms
-  end
-  
-  # @endgroup
+    # @param [Index, #to_int] index
+    # @return [Symbol] autonym
+    def autonym_for_index(index)
+      @autonyms.fetch(index)
+    end
 
-end; end
+    # @param [Symbol, String, #to_sym, Integer, #to_int] key - name / index
+    # @return [Symbol] autonym
+    def autonym_for_key(key)
+      key.respond_to?(:to_sym) ? autonym_for_member(key) : autonym_for_index(key)
+    rescue NameError, IndexError, TypeError
+      raise KeyError
+    end
+
+    # @param [Symbol, String, #to_sym] autonym
+    # @return [Array<Symbol>]
+    def aliases_for_autonym(autonym)
+      raise TypeError unless autonym.respond_to?(:to_sym)
+
+      autonym = autonym.to_sym
+      raise NameError unless with_aliases?(autonym)
+
+      @aliases.select { |_als, aut| autonym == aut }.keys
+    end
+
+    # @return [Hash] alias => autonym
+    def aliases
+      @aliases.dup
+    end
+
+    private
+
+    # for direct access inner data from own instance
+    # @return [Hash] alias => autonym
+    def _autonyms
+      @autonyms
+    end
+
+    # @endgroup
+  end
+end