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 = 
{
  conflict: 10,
  no_identifier: 9,
  bad_manners: 5,
  no_ascii: 3,
  strict: 0
}.freeze
CONFLICT_MANAGEMENT_LEVELS = 
{
  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 = 
: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_level ⇒ Object (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

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

#aliases ⇒ Hash 



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

def aliases
  @aliases.dup
end

#aliases_for_autonym(autonym) ⇒ 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_members ⇒ Array<Symbol> 



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

def all_members
  @autonyms + @aliases.keys
end

#attributes ⇒ Hash

for debug



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 



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 



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 



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

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

#autonyms ⇒ Array<Symbol> Also known as: members 



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

def autonyms
  @autonyms.dup
end

#clone ⇒ 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 



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



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

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.

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

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

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

#dup ⇒ 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



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



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



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: []

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 



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

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

#freeze ⇒ 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? 



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? 



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? 



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? 



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? 



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.



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

#length ⇒ Integer Also known as: size 



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.



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_class ⇒ 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.



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 



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 



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? 



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 



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? 



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? 



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? 



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