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/validation.rb,
lib/striuct/classmethods/constructor.rb,
lib/striuct/classmethods/conflict_management.rb

Macro for Member Definition collapse

ANYTHING = 
::Validation::Condition::ANYTHING
ADD_MEMBER_OptArg =

Returns:

  • (Class) 
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
}

Constructor collapse

DEFINE_OptArg =

Returns:

  • (Class) 
OptionalArgument.define {
  opt :lock, default: true, condition: BOOLEAN?
  opt :strict, default: true, condition: BOOLEAN?
}

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

Macro for Member Definition 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.



34
35
36
 
# File 'lib/striuct/classmethods/conflict_management.rb', line 34

def conflict_management_level
  @conflict_management_level
end

Instance Method Details

#_add_autonym(autonym) ⇒ Object (private)

Raises:

  • (NameError) 


25
26
27
28
29
30
31
 
# File 'lib/striuct/classmethods/inner.rb', line 25

def _add_autonym(autonym)
  autonym = autonym.to_sym
  raise NameError, 'already defined' if member? autonym

  @attributes[autonym] = Attributes.new
  @autonyms << autonym
end

#_attributes_for(autonym) ⇒ Object (private) 



33
34
35
 
# File 'lib/striuct/classmethods/inner.rb', line 33

def _attributes_for(autonym)
  @attributes.fetch autonym
end

#_autonyms ⇒ Hash (private)

for direct access inner data from own instance

Returns:

  • (Hash) —

    alias => autonym



69
70
71
 
# File 'lib/striuct/classmethods/names.rb', line 69

def _autonyms
  @autonyms
end

#_check_closed ⇒ Object (private) 



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

def _check_closed
  raise "can't modify closed member attributes in #{self}" if closed?
end

#_check_frozen ⇒ Object (private) 



37
38
39
 
# File 'lib/striuct/classmethods/inner.rb', line 37

def _check_frozen
  raise "can't modify frozen Class" if frozen?
end

#_check_safety_naming(name) {|r| ... } ⇒ void (private)

This method returns an undefined value.

Parameters:

  • name (Symbol)

Yields:

  • (r)

Yield Returns:

  • (Boolean) 


67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/striuct/classmethods/conflict_management.rb', line 67

def _check_safety_naming(name)
  estimation = _estimate_naming name
  risk    = NAMING_RISKS.fetch estimation
  plevels = CONFLICT_MANAGEMENT_LEVELS.fetch @conflict_management_level
  caution = "undesirable naming '#{name}', because #{estimation}"

  r = (
    case
    when risk >= plevels.fetch(:error)
      raise NameError, caution unless block_given?
      false
    when risk >= plevels.fetch(:warn)
      warn caution unless block_given?
      false
    else
      true
    end
  )

  yield r if block_given?
end

#_def_getter(autonym) ⇒ Object (private) 



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

def _def_getter(autonym) 
  define_method autonym do
    _get autonym
  end
  
  nil
end

#_def_setter(autonym, condition, &adjuster) ⇒ Object (private) 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/striuct/classmethods/inner.rb', line 53

def _def_setter(autonym, condition, &adjuster)
  unless ANYTHING.equal? condition
    _attributes_for(autonym).condition = condition
  end

  if block_given?
    _attributes_for(autonym).adjuster = adjuster
  end

  define_method :"#{autonym}=" do |value|
    _set autonym, value
  end
 
  nil
end

#_estimate_naming(name) ⇒ Symbol (private)

Parameters:

  • name (Symbol)

Returns:

  • (Symbol) 


91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/striuct/classmethods/conflict_management.rb', line 91

def _estimate_naming(name)
  if (instance_methods + private_instance_methods).include? name
    return :conflict
  end

  return :no_ascii unless name.encoding.equal? Encoding::ASCII

  case name
  when /[\W]/, /\A[^a-zA-Z_]/, :''
    :no_identifier
  when /\Aeach/, /\A__[^_]*__\z/, /\A_[^_]*\z/, /[!?]\z/, /\Ato_/
    :bad_manners
  when /\A[a-zA-Z_]\w*\z/
    :strict
  else
    raise 'must not happen'
  end
end

#_init ⇒ Object (private) 



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

def _init
  @autonyms      = []
  @attributes    = {}.extend HashDeepDupulicatable # autonym => Attributes
  @aliases       = {} # aliased => autonym
  @conflict_management_level = DEFAULT_CONFLICT_MANAGEMENT_LEVEL
end

#add_member(autonym, condition = ANYTHING, options = {}, &adjuster) ⇒ nil (private) Also known as: member

Parameters:

  • autonym (Symbol, String, #to_sym)
  • condition (#===, Proc, Method, ANYTHING) (defaults to: ANYTHING)
  • options (Hash) (defaults to: {})

Options Hash (options):

  • :default (BasicObject)
  • :default_proc (Proc)
  • :must (Boolean)
  • :reader_validation (Boolean)
  • :getter_validation (Boolean)
  • :writer_validation (Boolean)
  • :setter_validation (Boolean)

Returns:

  • (nil)

Raises:

  • (ArgumentError) 


30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/striuct/classmethods/macro.rb', line 30

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
  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
  end
  
  nil
end

#add_members(autonym, *autonyms) ⇒ nil (private)

Parameters:

  • autonym (Symbol, String, #to_sym)
  • autonyms (Symbol, String, #to_sym)

Returns:

  • (nil) 


66
67
68
69
70
71
72
 
# File 'lib/striuct/classmethods/macro.rb', line 66

def add_members(autonym, *autonyms)
  _check_frozen
  _check_closed
  
  [autonym, *autonyms].each {|_autonym|add_member _autonym}
  nil
end

#adjuster_for(key) ⇒ Object

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int) —

    • name / index

Raises:

  • (KeyError) 


6
7
8
9
10
11
 
# File 'lib/striuct/classmethods/adjustment.rb', line 6

def adjuster_for(key)
  autonym = autonym_for_key key
  raise KeyError unless with_adjuster? autonym
  
  _attributes_for(autonym).adjuster
end

#alias_member(aliased, autonym) ⇒ nil (private)

Parameters:

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

Returns:

  • (nil)

Raises:

  • (ArgumentError) 


77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/striuct/classmethods/macro.rb', line 77

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

#aliases ⇒ Hash

Returns alias => autonym.

Returns:

  • (Hash) —

    alias => autonym



61
62
63
 
# File 'lib/striuct/classmethods/names.rb', line 61

def aliases
  @aliases.dup
end

#aliases_for_autonym(autonym) ⇒ Array<Symbol>

Parameters:

  • autonym (Symbol, String, #to_sym)

Returns:

  • (Array<Symbol>)

Raises:

  • (TypeError) 


52
53
54
55
56
57
58
 
# File 'lib/striuct/classmethods/names.rb', line 52

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>

Returns:

  • (Array<Symbol>) 


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

def all_members
  @autonyms + @aliases.keys
end

#attributes ⇒ Hash

for debug

Returns:

  • (Hash) 


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

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) 


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

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



38
39
40
 
# File 'lib/striuct/classmethods/names.rb', line 38

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



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

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) 


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

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

Returns:

  • (Array<Symbol>) 


6
7
8
 
# File 'lib/striuct/classmethods/names.rb', line 6

def autonyms
  @autonyms.dup
end

#clone ⇒ Class

Returns:

  • (Class) 


6
7
8
9
10
 
# File 'lib/striuct/classmethods/copy.rb', line 6

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

#close_member ⇒ self (private) Also known as: fix_structural, close

Returns:

  • (self) 


18
19
20
21
 
# File 'lib/striuct/classmethods/fix.rb', line 18

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

#closed? ⇒ Boolean

Returns:

  • (Boolean) 


11
12
13
 
# File 'lib/striuct/classmethods/fix.rb', line 11

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

#cname?(name) ⇒ Boolean

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

Parameters:

  • name (Object)

Returns:

  • (Boolean) 


28
29
30
31
32
 
# File 'lib/striuct/classmethods/conflict_management.rb', line 28

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) 


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

def condition_for(key)
  autonym = autonym_for_key key
  raise KeyError unless with_condition? autonym
  
  _attributes_for(autonym).condition
end

#conflict_management(level = DEFAULT_CONFLICT_MANAGEMENT_LEVEL) ⇒ void (private)

This method returns an undefined value.

temp scope of a conflict_management_level

Parameters:

  • level (Symbol, String, #to_sym) (defaults to: DEFAULT_CONFLICT_MANAGEMENT_LEVEL)

Yield Returns:

  • (self)

Raises:

  • (ArgumentError) —

    if no block given

See Also:

  • Striuct::ClassMethods.[[#set_conflict_management_level]


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

def conflict_management(level=DEFAULT_CONFLICT_MANAGEMENT_LEVEL)
  before = @conflict_management_level
  set_conflict_management_level level
  
  yield
ensure
  @conflict_management_level = before
  self
end

#copy_variables!(familar_class) ⇒ familar_class (private)

Returns:

  • (familar_class) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/striuct/classmethods/copy.rb', line 34

def copy_variables!(familar_class)
  autonyms = @autonyms.dup
  aliases  = @aliases.dup
  attributes = @attributes.deep_dup
  conflict_management = @conflict_management_level

  familar_class.class_eval do      
    @autonyms = autonyms
    @aliases = aliases
    @attributes = attributes
    @conflict_management_level = conflict_management
  end

  familar_class
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) 


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

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) 


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

def default_value_for(key)
  autonym = autonym_for_key key
  raise KeyError unless with_default? autonym
 
  _attributes_for(autonym).default_value
end

#define(options = {}) {|instance| ... } ⇒ void

This method returns an undefined value.

for build the fixed object

Parameters:

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :lock (Boolean)
  • :strict (Boolean)

Yield Parameters:

Yield Returns:

Raises:

  • (ArgumentError) 


42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/striuct/classmethods/constructor.rb', line 42

def define(options={})
  raise ArgumentError, 'must with block' unless block_given?
  opts = DEFINE_OptArg.parse options
  
  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 opts.strict && !invalids.empty?
      raise Validation::InvalidWritingError,
             "invalids members are, yet '#{invalids.inspect} in #{self}'"
    end

    instance.lock_all if opts.lock
  }
end

#dup ⇒ Class

Returns:

  • (Class) 


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

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) 


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

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) 


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

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) 


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

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:

  • (TypeError) 


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

def for_pairs(pairs)
  raise TypeError, 'no pairs object' unless pairs.respond_to?(:each_pair)
  KeyValidatable.validate_array KeyValidatable.keys_for(pairs).map(&:to_sym),
                                let: all_members

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

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

Returns:



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

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

#freeze ⇒ self

Returns:

  • (self) 


6
7
8
9
 
# File 'lib/striuct/classmethods/fix.rb', line 6

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) 


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

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

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

Parameters:

  • name (Symbol, String, #to_sym)

Returns:

  • (Boolean) 


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

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) 


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

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) 


51
52
53
 
# File 'lib/striuct/classmethods/predicate.rb', line 51

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) 


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

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

#inherited(subclass) ⇒ Object (private) 



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

def inherited(subclass)
  ret = super subclass
  copy_variables! subclass
  ret
end

#initialize_copy(original) ⇒ Object (private) 



25
26
27
28
29
30
31
 
# File 'lib/striuct/classmethods/copy.rb', line 25

def initialize_copy(original)
  ret = super original
  @autonyms = @autonyms.dup
  @aliases = @aliases.dup
  @attributes = @attributes.deep_dup
  ret
end

#length ⇒ Integer Also known as: size

Returns:

  • (Integer) 


6
7
8
 
# File 'lib/striuct/classmethods/length.rb', line 6

def length
  @autonyms.length
end

#set_conflict_management_level(level) ⇒ Symbol (private)

change level of management conflict member names

Parameters:

  • level (Symbol, String, #to_sym)

Returns:

  • (Symbol) —

    level

Raises:

  • (NameError) 


41
42
43
44
45
46
 
# File 'lib/striuct/classmethods/conflict_management.rb', line 41

def set_conflict_management_level(level)
  level = level.to_sym
  raise NameError unless CONFLICT_MANAGEMENT_LEVELS.has_key? level

  @conflict_management_level = level
end

#set_default_value(name, value = nil, &block) ⇒ nil (private) Also known as: default

Parameters:

  • name (Symbol, String, #to_sym)

Returns:

  • (nil) 


93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/striuct/classmethods/macro.rb', line 93

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'
    end

    _attributes_for(autonym).set_default block, :lazy
  else
    _attributes_for(autonym).set_default value, :value
  end
  
  nil
end

#to_struct_class ⇒ Class

Returns:

  • (Class) 


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

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

#with_adjuster?(key) ⇒ Boolean

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int) —

    • name / index

Returns:

  • (Boolean) 


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

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) 


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

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

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

Parameters:

  • key (Symbol, String, #to_sym, Integer, #to_int) —

    • name / index

Returns:

  • (Boolean) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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