Module: Striuct::ClassMethods

Defined in:
lib/striuct/classmethods/fix.rb,
lib/striuct/classmethods/copy.rb,
lib/striuct/classmethods/enum.rb,
lib/striuct/classmethods/inner.rb,
lib/striuct/classmethods/macro.rb,
lib/striuct/classmethods/names.rb,
lib/striuct/classmethods/length.rb,
lib/striuct/classmethods/default.rb,
lib/striuct/classmethods/predicate.rb,
lib/striuct/classmethods/to_struct.rb,
lib/striuct/classmethods/adjustment.rb,
lib/striuct/classmethods/attributes.rb,
lib/striuct/classmethods/validation.rb,
lib/striuct/classmethods/constructor.rb,
lib/striuct/classmethods/conflict_management.rb,
lib/striuct/classmethods/hashdeepdupulicatable.rb

Macro for Member Definition collapse

ANYTHING =
Eqq.ANYTHING()

Member Conflict Management collapse

NAMING_RISKS =

Returns Symbol => Fixnum.

Returns:

  • (Hash)

    Symbol => Fixnum

{
  conflict: 10,
  no_identifier: 9,
  bad_manners: 5,
  no_ascii: 3,
  strict: 0
}.freeze
CONFLICT_MANAGEMENT_LEVELS =

Returns Symbol => Hash.

Returns:

  • (Hash)

    Symbol => Hash

{
  struct: { error: 99, warn: 99 },
  warning: { error: 99, warn: 5 },
  error: { error: 9, warn: 5 },
  prevent: { error:  5, warn:  1 },
  nervous: { error:  1, warn:  1 }
}.each(&:freeze).freeze
DEFAULT_CONFLICT_MANAGEMENT_LEVEL =

Returns:

  • (Symbol)
:prevent

Member Conflict Management collapse

Fix inner data structures collapse

Basic Methods for Ruby's Object collapse

Enumerative collapse

Inner Methods collapse

Named collapse

Length/Size collapse

With default value collapse

Basic Predicate collapse

To Ruby's Struct Class collapse

Adjuster collapse

Validation collapse

Constructor collapse

Member Conflict Management collapse

Instance Attribute Details

#conflict_management_levelObject (readonly)

Returns the value of attribute conflict_management_level.



36
37
38
# File 'lib/striuct/classmethods/conflict_management.rb', line 36

def conflict_management_level
  @conflict_management_level
end

Instance Method Details

#adjuster_for(key) ⇒ Object

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Raises:

  • (KeyError)


70
71
72
73
74
75
# File 'lib/striuct/classmethods/adjustment.rb', line 70

def adjuster_for(key)
  autonym = autonym_for_key(key)
  raise KeyError unless with_adjuster?(autonym)

  _attributes_for(autonym).adjuster
end

#aliasesHash

Returns alias => autonym.

Returns:

  • (Hash)

    alias => autonym



65
66
67
# File 'lib/striuct/classmethods/names.rb', line 65

def aliases
  @aliases.dup
end

#aliases_for_autonym(autonym) ⇒ Array<Symbol>

Parameters:

  • autonym (Symbol, String, #to_sym)

Returns:

  • (Array<Symbol>)

Raises:

  • (TypeError)


55
56
57
58
59
60
61
62
# File 'lib/striuct/classmethods/names.rb', line 55

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

#all_membersArray<Symbol>

Returns:

  • (Array<Symbol>)


15
16
17
# File 'lib/striuct/classmethods/names.rb', line 15

def all_members
  @autonyms + @aliases.keys
end

#attributesHash

for debug

Returns:

  • (Hash)


9
10
11
12
13
14
15
16
# File 'lib/striuct/classmethods/inner.rb', line 9

def attributes
  {
    autonyms: @autonyms.dup,
    aliases: @aliases.dup,
    conflict_management_level: @conflict_management_level,
    attributes_each_autonym: @attributes.dup
  }
end

#autonym_for_alias(als) ⇒ Symbol

Parameters:

  • als (Symbol, String, #to_sym)

Returns:

  • (Symbol)


21
22
23
24
25
26
27
# File 'lib/striuct/classmethods/names.rb', line 21

def autonym_for_alias(als)
  @aliases.fetch(als.to_sym)
rescue NoMethodError
  raise TypeError
rescue KeyError
  raise NameError
end

#autonym_for_index(index) ⇒ Symbol

Returns autonym.

Parameters:

  • index (Index, #to_int)

Returns:

  • (Symbol)

    autonym



41
42
43
# File 'lib/striuct/classmethods/names.rb', line 41

def autonym_for_index(index)
  @autonyms.fetch(index)
end

#autonym_for_key(key) ⇒ Symbol

Returns autonym.

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Symbol)

    autonym



47
48
49
50
51
# File 'lib/striuct/classmethods/names.rb', line 47

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

#autonym_for_member(name) ⇒ Symbol

Parameters:

  • name (Symbol, String, #to_sym)
    • autonym / aliased

Returns:

  • (Symbol)

Raises:

  • (TypeError)


31
32
33
34
35
36
37
# File 'lib/striuct/classmethods/names.rb', line 31

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

#autonymsArray<Symbol> Also known as: members

Returns:

  • (Array<Symbol>)


8
9
10
# File 'lib/striuct/classmethods/names.rb', line 8

def autonyms
  @autonyms.dup
end

#cloneClass

Returns:

  • (Class)


8
9
10
11
12
# File 'lib/striuct/classmethods/copy.rb', line 8

def clone
  ret = super
  ret.__send__(:close_member) if closed?
  ret
end

#closed?Boolean

Returns:

  • (Boolean)


13
14
15
# File 'lib/striuct/classmethods/fix.rb', line 13

def closed?
  [@autonyms, @attributes, @aliases].any?(&:frozen?)
end

#cname?(name) ⇒ Boolean

acceptable the name into own member, under protect level of runtime

Parameters:

  • name (Object)

Returns:

  • (Boolean)


30
31
32
33
34
# File 'lib/striuct/classmethods/conflict_management.rb', line 30

def cname?(name)
  _check_safety_naming(name.to_sym) { |r| r }
rescue Exception
  false
end

#condition_for(key) ⇒ Object

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Raises:

  • (KeyError)


8
9
10
11
12
13
# File 'lib/striuct/classmethods/validation.rb', line 8

def condition_for(key)
  autonym = autonym_for_key(key)
  raise KeyError unless with_condition?(autonym)

  _attributes_for(autonym).condition
end

#default_type_for(key) ⇒ Symbol

Returns :value / :proc.

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Symbol)

    :value / :proc

Raises:

  • (KeyError)


17
18
19
20
21
22
# File 'lib/striuct/classmethods/default.rb', line 17

def default_type_for(key)
  autonym = autonym_for_key(key)
  raise KeyError unless with_default?(autonym)

  _attributes_for(autonym).default_type
end

#default_value_for(key) ⇒ Object

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Raises:

  • (KeyError)


8
9
10
11
12
13
# File 'lib/striuct/classmethods/default.rb', line 8

def default_value_for(key)
  autonym = autonym_for_key(key)
  raise KeyError unless with_default?(autonym)

  _attributes_for(autonym).default_value
end

#define(lock: true, strict: true) {|instance| ... } ⇒ void

This method returns an undefined value.

for build the fixed object

Parameters:

  • lock (Boolean) (defaults to: true)
  • strict (Boolean) (defaults to: true)

Yield Parameters:

Yield Returns:

Raises:

  • (ArgumentError)


33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# File 'lib/striuct/classmethods/constructor.rb', line 33

def define(lock: true, strict: true)
  raise ArgumentError, 'must with block' unless block_given?

  new.tap { |instance|
    yield instance

    yets = autonyms.select { |autonym| !instance.assigned?(autonym) }
    unless yets.empty?
      raise "not assigned members are, yet '#{yets.inspect} in #{self}'"
    end

    invalids = autonyms.select { |autonym| !instance.valid?(autonym) }
    if strict && !invalids.empty?
      raise InvalidWritingError,
            "invalids members are, yet '#{invalids.inspect} in #{self}'"
    end

    instance.lock_all if lock
  }
end

#dupClass

Returns:

  • (Class)


15
16
17
# File 'lib/striuct/classmethods/copy.rb', line 15

def dup
  copy_variables!(super)
end

#each_autonym {|autonym| ... } ⇒ Enumerator Also known as: each_member

Yields:

  • (autonym)

Yield Parameters:

  • autonym (Symbol)
    • sequential under defined

Yield Returns:

  • (Class)

    self

Returns:

  • (Enumerator)


11
12
13
14
15
16
# File 'lib/striuct/classmethods/enum.rb', line 11

def each_autonym
  return to_enum(__callee__) { size } unless block_given?

  @autonyms.each { |autonym| yield autonym }
  self
end

#each_autonym_with_index {|autonym, index| ... } ⇒ Enumerator Also known as: each_member_with_index

Yields:

  • (autonym, index)

Yield Parameters:

  • autonym (Symbol)
  • index (Integer)

Yield Returns:

  • (Class)

    self

Returns:

  • (Enumerator)


36
37
38
39
40
41
# File 'lib/striuct/classmethods/enum.rb', line 36

def each_autonym_with_index
  return to_enum(__callee__) { size } unless block_given?

  @autonyms.each_with_index { |autonym, index| yield autonym, index }
  self
end

#each_index {|index| ... } ⇒ Enumerator

Yields:

  • (index)

Yield Parameters:

  • Index (Integer)

Yield Returns:

  • (Class)

    self

Returns:

  • (Enumerator)


24
25
26
27
28
29
# File 'lib/striuct/classmethods/enum.rb', line 24

def each_index
  return to_enum(__callee__) { size } unless block_given?

  @autonyms.each_index { |index| yield index }
  self
end

#for_pairs(pairs) ⇒ Striuct Also known as: []

Parameters:

  • pairs (Hash, Struct, Striuct, #each_pair)

Returns:

Raises:

  • (ArgumentError)


16
17
18
19
20
21
22
23
# File 'lib/striuct/classmethods/constructor.rb', line 16

def for_pairs(pairs)
  raise ArgumentError, 'no pairs object' unless pairs.respond_to?(:each_pair)
  raise ArgumentError unless pairs.each_pair { |key, _value| all_members.include?(key.to_sym) }

  instance = allocate
  instance.__send__(:initialize_for_pairs, pairs)
  instance
end

#for_values(*values) ⇒ Striuct Also known as: new

Returns:



8
9
10
# File 'lib/striuct/classmethods/constructor.rb', line 8

def for_values(*values)
  new_instance(*values)
end

#freezeself

Returns:

  • (self)


8
9
10
11
# File 'lib/striuct/classmethods/fix.rb', line 8

def freeze
  [@autonyms, @attributes, @aliases].each(&:freeze)
  super
end

#has_alias?(als) ⇒ Boolean Also known as: alias?, aliased?

Parameters:

  • als (Symbol, String, #to_sym)

Returns:

  • (Boolean)


19
20
21
22
23
24
25
# File 'lib/striuct/classmethods/predicate.rb', line 19

def has_alias?(als)
  als = als.to_sym
rescue NoMethodError
  false
else
  @aliases.key?(als)
end

#has_autonym?(name) ⇒ Boolean Also known as: autonym?

Parameters:

  • name (Symbol, String, #to_sym)

Returns:

  • (Boolean)


8
9
10
11
12
13
14
# File 'lib/striuct/classmethods/predicate.rb', line 8

def has_autonym?(name)
  name = name.to_sym
rescue NoMethodError
  false
else
  @autonyms.include?(name)
end

#has_index?(index) ⇒ Boolean Also known as: index?

Parameters:

  • index (Integer, #to_int)

Returns:

  • (Boolean)


42
43
44
45
46
47
48
# File 'lib/striuct/classmethods/predicate.rb', line 42

def has_index?(index)
  @autonyms.fetch(index)
rescue Exception
  false
else
  true
end

#has_key?(key) ⇒ Boolean Also known as: key?

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


53
54
55
# File 'lib/striuct/classmethods/predicate.rb', line 53

def has_key?(key)
  has_member?(key) || has_index?(key)
end

#has_member?(name) ⇒ Boolean Also known as: member?

Parameters:

  • name (Symbol, String, #to_sym)

Returns:

  • (Boolean)


31
32
33
34
35
36
37
# File 'lib/striuct/classmethods/predicate.rb', line 31

def has_member?(name)
  autonym_for_member(name)
rescue Exception
  false
else
  true
end

#INJECT(adjuster1, adjuster2, *adjusters) ⇒ Proc

Sequential apply all adjusters.

Parameters:

  • adjuster1 (Proc, #to_proc)
  • adjuster2 (Proc, #to_proc)
  • adjusters (Proc, #to_proc)

Returns:

  • (Proc)


29
30
31
32
33
34
35
36
37
38
39
# File 'lib/striuct/classmethods/adjustment.rb', line 29

def INJECT(adjuster1, adjuster2, *adjusters)
  adjusters = [adjuster1, adjuster2, *adjusters]

  unless adjusters.all? { |f| adjustable?(f) }
    raise ArgumentError, 'wrong object for adjuster'
  end

  ->v {
    adjusters.reduce(v) { |ret, adjuster| adjuster.call(ret) }
  }
end

#lengthInteger Also known as: size

Returns:

  • (Integer)


8
9
10
# File 'lib/striuct/classmethods/length.rb', line 8

def length
  @autonyms.length
end

#PARSE(parser) ⇒ Proc

Accept any parser when that respond to parse method.

Parameters:

  • parser (#parse)

Returns:

  • (Proc)


44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# File 'lib/striuct/classmethods/adjustment.rb', line 44

def PARSE(parser)
  if !::Integer.equal?(parser) && !parser.respond_to?(:parse)
    raise ArgumentError, 'wrong object for parser'
  end

  ->v {
    if ::Integer.equal?(parser)
      ::Kernel.Integer(v)
    else
      parser.parse(
        case v
        when String
          v
        when ->_ { v.respond_to?(:to_str) }
          v.to_str
        when ->_ { v.respond_to?(:read) }
          v.read
        else
          raise TypeError, 'wrong object for parsing source'
        end
      )
    end
  }
end

#to_struct_classClass

Returns:

  • (Class)


8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# File 'lib/striuct/classmethods/to_struct.rb', line 8

def to_struct_class
  raise 'No defined members' if autonyms.empty?

  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

#WHEN(pattern, adjuster) ⇒ Proc

Adjuster Builders Apply adjuster when passed pattern.

Parameters:

  • pattern (Proc, Method, #===)
  • adjuster (Proc, #to_proc)

Returns:

  • (Proc)


12
13
14
15
16
17
18
19
20
21
22
# File 'lib/striuct/classmethods/adjustment.rb', line 12

def WHEN(pattern, adjuster)
  unless Eqq.pattern?(pattern)
    raise ArgumentError, 'wrong object for pattern'
  end

  unless Striuct.adjustable?(adjuster)
    raise ArgumentError, 'wrong object for adjuster'
  end

  ->v { _valid?(pattern, v) ? adjuster.call(v) : v }
end

#with_adjuster?(key) ⇒ Boolean

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


122
123
124
125
126
127
128
# File 'lib/striuct/classmethods/predicate.rb', line 122

def with_adjuster?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_adjuster?
end

#with_aliases?(autonym) ⇒ Boolean

Parameters:

  • autonym (Symbol, String, #to_sym)

Returns:

  • (Boolean)


60
61
62
63
64
65
66
# File 'lib/striuct/classmethods/predicate.rb', line 60

def with_aliases?(autonym)
  autonym = autonym.to_sym
rescue NoMethodError
  false
else
  @aliases.value?(autonym)
end

#with_condition?(key) ⇒ Boolean Also known as: restrict?

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


78
79
80
81
82
83
84
# File 'lib/striuct/classmethods/predicate.rb', line 78

def with_condition?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_condition?
end

#with_default?(key) ⇒ Boolean

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


69
70
71
72
73
74
75
# File 'lib/striuct/classmethods/predicate.rb', line 69

def with_default?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_default?
end

#with_must?(key) ⇒ Boolean Also known as: must?

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


89
90
91
92
93
94
95
# File 'lib/striuct/classmethods/predicate.rb', line 89

def with_must?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_must?
end

#with_safety_getter?(key) ⇒ Boolean Also known as: with_safety_reader?

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


100
101
102
103
104
105
106
# File 'lib/striuct/classmethods/predicate.rb', line 100

def with_safety_getter?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_safety_getter?
end

#with_safety_setter?(key) ⇒ Boolean Also known as: with_safety_writer?

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int)
    • name / index

Returns:

  • (Boolean)


111
112
113
114
115
116
117
# File 'lib/striuct/classmethods/predicate.rb', line 111

def with_safety_setter?(key)
  autonym = autonym_for_key(key)
rescue Exception
  false
else
  _attributes_for(autonym).with_safety_setter?
end