Class: MediaTypes::Scheme::Rules

Inherits:
Hash
  • Object
show all
Defined in:
lib/media_types/scheme/rules.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(allow_empty:, expected_type:) ⇒ Rules

Returns a new instance of Rules.



11
12
13
14
15
16
17
18
19
20
 
# File 'lib/media_types/scheme/rules.rb', line 11

def initialize(allow_empty:, expected_type:)
  super({})

  self.allow_empty = allow_empty
  self.expected_type = expected_type
  self.optional_keys = []
  self.original_key_type = {}

  self.default = MissingValidation.new
end

Instance Attribute Details

#expected_type ⇒ Object

Returns the value of attribute expected_type.



9
10
11
 
# File 'lib/media_types/scheme/rules.rb', line 9

def expected_type
  @expected_type
end

Instance Method Details

#[](key) ⇒ Object Also known as: get 



26
27
28
 
# File 'lib/media_types/scheme/rules.rb', line 26

def [](key)
  __getobj__[normalize_key(key)]
end

#[]=(key, val) ⇒ Object 



69
70
71
 
# File 'lib/media_types/scheme/rules.rb', line 69

def []=(key, val)
  add(key, val, optional: false)
end

#add(key, val, optional: false) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
 
# File 'lib/media_types/scheme/rules.rb', line 30

def add(key, val, optional: false)
  validate_input(key, val)

  normalized_key = normalize_key(key)
  __getobj__[normalized_key] = val
  optional_keys << normalized_key if optional
  original_key_type[normalized_key] = key.class

  self
end

#allow_empty? ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/media_types/scheme/rules.rb', line 22

def allow_empty?
  allow_empty
end

#clone ⇒ Object 



98
99
100
101
102
 
# File 'lib/media_types/scheme/rules.rb', line 98

def clone
  super.tap do |cloned|
    cloned.__setobj__(__getobj__.clone)
  end
end

#default=(input_default) ⇒ Object 



150
151
152
153
154
155
156
157
158
 
# File 'lib/media_types/scheme/rules.rb', line 150

def default=(input_default)
  unless default.nil?
    raise DuplicateAnyRuleError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
    raise DuplicateNotStrictRuleError if default.is_a?(NotStrict) && input_default.is_a?(NotStrict)
    raise NotStrictOverwritingAnyError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && input_default.is_a?(NotStrict)
    raise AnyOverwritingNotStrictError if default.is_a?(NotStrict) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
  end
  super(input_default)
end

#delete(key) ⇒ Object Also known as: remove 



77
78
79
80
 
# File 'lib/media_types/scheme/rules.rb', line 77

def delete(key)
  __getobj__.delete(normalize_key(key))
  self
end

#duplicate_string_key_name(key, val) ⇒ Object

Raises:



63
64
65
66
67
 
# File 'lib/media_types/scheme/rules.rb', line 63

def duplicate_string_key_name(key, val)
  raise DuplicateStringKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == String

  raise StringOverwritingSymbolError.new(val.class.name.split('::').last, key)
end

#duplicate_symbol_key_name(key, val) ⇒ Object

Raises:



57
58
59
60
61
 
# File 'lib/media_types/scheme/rules.rb', line 57

def duplicate_symbol_key_name(key, val)
  raise DuplicateSymbolKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == Symbol

  raise SymbolOverwritingStringError.new(val.class.name.split('::').last, key)
end

#fetch(key, &block) ⇒ Object 



73
74
75
 
# File 'lib/media_types/scheme/rules.rb', line 73

def fetch(key, &block)
  __getobj__.fetch(normalize_key(key), &block)
end

#get_original_key_type(key) ⇒ Object 



144
145
146
147
148
 
# File 'lib/media_types/scheme/rules.rb', line 144

def get_original_key_type(key)
  raise format('Key %<key>s does not exist', key: key) unless has_key?(key)

  original_key_type[normalize_key(key)]
end

#has_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


140
141
142
 
# File 'lib/media_types/scheme/rules.rb', line 140

def has_key?(key)
  __getobj__.key?(normalize_key(key))
end

#inspect(indent = 0) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/media_types/scheme/rules.rb', line 121

def inspect(indent = 0)
  prefix = '  ' * indent
  return "#{prefix}[Error]Depth limit reached[/Error]" if indent > 5_000

  [
    "#{prefix}[Rules n=#{keys.length} optional=#{optional_keys.length} allow_empty=#{allow_empty?}]",
    "#{prefix}  #{inspect_format_attribute(indent, '*', default)}",
    *keys.map { |key| "#{prefix}  #{inspect_format_attribute(indent, key)}" },
    "#{prefix}[/Rules]"
  ].join("\n")
end

#inspect_format_attribute(indent, key, value = ) ⇒ Object 



133
134
135
136
137
138
 
# File 'lib/media_types/scheme/rules.rb', line 133

def inspect_format_attribute(indent, key, value = self[key])
  [
    [key.to_s, optional_keys.include?(key) && '(optional)' || nil].compact.join(' '),
    value.is_a?(Scheme) || value.is_a?(Rules) ? "\n#{value.inspect(indent + 2)}" : value.inspect
  ].join(': ')
end

#merge(rules) ⇒ Rules

Merges another set of rules into a clone of this one

Parameters:

  • the (Rules, ::Hash) —

    other rules

Returns:



110
111
112
113
114
115
116
117
118
119
 
# File 'lib/media_types/scheme/rules.rb', line 110

def merge(rules)
  clone.instance_exec do
    __setobj__(__getobj__.merge(rules))
    if rules.respond_to?(:optional_keys, true)
      optional_keys.push(*rules.send(:optional_keys))
    end

    self
  end
end

#required ⇒ Array<Symbol>

Returns the keys that are not options

#see #merge

Returns:

  • (Array<Symbol>) —

    required keys

See Also:



90
91
92
93
94
95
96
 
# File 'lib/media_types/scheme/rules.rb', line 90

def required
  clone.tap do |cloned|
    optional_keys.each do |key|
      cloned.delete(key)
    end
  end
end

#validate_input(key, val) ⇒ Object

Raises:



41
42
43
44
45
 
# File 'lib/media_types/scheme/rules.rb', line 41

def validate_input(key, val)
  raise KeyTypeError, "Unexpected key type #{key.class.name}, please use either a symbol or string." unless key.is_a?(String) || key.is_a?(Symbol)

  validate_key_name(key, val)
end

#validate_key_name(key, val) ⇒ Object 



47
48
49
50
51
52
53
54
55
 
# File 'lib/media_types/scheme/rules.rb', line 47

def validate_key_name(key, val)
  return unless has_key?(key)

  if key.is_a?(Symbol)
    duplicate_symbol_key_name(key, val)
  else
    duplicate_string_key_name(key, val)
  end
end