Runtime assertions for Ruby
literal.fun
ruby
Various improvements
+136
-98
+1
-1
.rubocop.yml
+1
-1
.rubocop.yml
+11
-3
lib/literal.rb
+11
-3
lib/literal.rb
···
17
17
end
18
18
19
19
def self.Enum(type, &block)
20
-
Enum.define(type, &block)
20
+
Enum.define(type, &block)
21
21
end
22
22
23
23
def self.Value(type, &block)
24
-
Value.define(type, &block)
25
-
end
24
+
Value.define(type, &block)
25
+
end
26
+
27
+
def self.Data(&block)
28
+
Class.new(Data, &block)
29
+
end
30
+
31
+
def self.Struct(&block)
32
+
Class.new(Struct, &block)
33
+
end
26
34
end
-1
lib/literal/attributes.rb
-1
lib/literal/attributes.rb
-2
lib/literal/data.rb
-2
lib/literal/data.rb
+60
-36
lib/literal/value.rb
+60
-36
lib/literal/value.rb
···
1
-
class Literal::Value
2
-
class << self
3
-
attr_reader :__type__
4
-
5
-
def define(type, &block)
6
-
value_class = Class.new(self) do
7
-
@__type__ = type
8
-
9
-
case type
10
-
when Literal::Types::_Class(String)
11
-
alias_method :to_s, :value
12
-
alias_method :to_str, :value
13
-
when Literal::Types::_Class(Symbol)
14
-
alias_method :to_sym, :value
15
-
when Literal::Types::_Class(Integer)
16
-
alias_method :to_i, :value
17
-
when Literal::Types::_Class(Float)
18
-
alias_method :to_f, :value
19
-
when Literal::Types::_Class(Set)
20
-
alias_method :to_set, :value
21
-
when Literal::Types::_Class(Array)
22
-
alias_method :to_a, :value
23
-
alias_method :to_ary, :value
24
-
when Literal::Types::_Class(Hash)
25
-
alias_method :to_h, :value
26
-
when Literal::Types::_Class(Proc)
27
-
alias_method :to_proc, :value
28
-
end
29
-
end
30
-
31
-
value_class.class_exec(&block) if block
32
-
value_class
33
-
end
34
-
end
1
+
# frozen_string_literal: true
35
2
3
+
class Literal::Value
36
4
def initialize(value)
37
5
type = self.class.__type__
38
6
raise Literal::TypeError, "Expected value: `#{value.inspect}` to be: `#{type.inspect}`." unless type === value
7
+
39
8
@value = value.frozen? ? value : value.dup.freeze
40
9
freeze
41
10
end
···
43
12
attr_reader :value
44
13
45
14
def inspect
46
-
"#{self.class.name}(#{value.inspect})"
47
-
end
15
+
"#{self.class.name}(#{value.inspect})"
16
+
end
17
+
18
+
class StringValue < Literal::Value
19
+
alias_method :to_s, :value
20
+
alias_method :to_str, :value
21
+
end
22
+
23
+
class SymbolValue < Literal::Value
24
+
alias_method :to_sym, :value
25
+
end
26
+
27
+
class IntegerValue < Literal::Value
28
+
alias_method :to_i, :value
29
+
end
30
+
31
+
class FloatValue < Literal::Value
32
+
alias_method :to_f, :value
33
+
end
34
+
35
+
class SetValue < Literal::Value
36
+
alias_method :to_set, :value
37
+
end
38
+
39
+
class ArrayValue < Literal::Value
40
+
alias_method :to_a, :value
41
+
alias_method :to_ary, :value
42
+
end
43
+
44
+
class HashValue < Literal::Value
45
+
alias_method :to_h, :value
46
+
end
47
+
48
+
class ProcValue < Literal::Value
49
+
alias_method :to_proc, :value
50
+
end
51
+
52
+
TYPE_CLASSES = {
53
+
String => StringValue,
54
+
Symbol => SymbolValue,
55
+
Integer => IntegerValue,
56
+
Float => FloatValue,
57
+
Set => SetValue,
58
+
Array => ArrayValue,
59
+
Hash => HashValue,
60
+
Proc => ProcValue
61
+
}
62
+
63
+
class << self
64
+
attr_reader :__type__
65
+
66
+
def define(type, &block)
67
+
type_class = Class.new(TYPE_CLASSES[type] || self, &block)
68
+
type_class.instance_variable_set(:@__type__, type)
69
+
type_class
70
+
end
71
+
end
48
72
end
+1
-1
literal.gemspec
+1
-1
literal.gemspec
···
12
12
spec.description = "Strict Attributes is a gem that allows you to define strict attributes on your models."
13
13
spec.homepage = "https://github.com/joeldrapper/literal"
14
14
spec.license = "MIT"
15
-
spec.required_ruby_version = ">= 2.7"
15
+
spec.required_ruby_version = ">= 3.0"
16
16
17
17
spec.metadata["homepage_uri"] = spec.homepage
18
18
spec.metadata["source_code_uri"] = "https://github.com/joeldrapper/literal"
+63
-54
test/literal/value.rb
+63
-54
test/literal/value.rb
···
1
+
# frozen_string_literal: true
2
+
1
3
let def type = Literal::Value(Integer)
2
4
let def example = type.new(1)
3
5
4
6
context "with Integer" do
5
-
let def type = Literal::Value(Integer)
6
-
let def example = type.new(1)
7
+
let def value = 1
8
+
let def type = Literal::Value(Integer)
9
+
let def example = type.new(value)
7
10
8
-
test "invalid type" do
9
-
expect { type.new(1.0) }.to_raise(Literal::TypeError)
10
-
end
11
+
test "invalid type" do
12
+
expect { type.new(1.0) }.to_raise(Literal::TypeError)
13
+
end
11
14
12
-
test do
13
-
expect(example.value) == 1
14
-
expect(example.to_i) == 1
15
-
end
15
+
test do
16
+
expect(example.value) == value
17
+
expect(example.to_i) == value
18
+
end
16
19
end
17
20
18
21
context "with String" do
19
-
let def type = Literal::Value(String)
20
-
let def example = type.new("foo")
22
+
let def value = "foo"
23
+
let def type = Literal::Value(String)
24
+
let def example = type.new(value)
21
25
22
-
test do
23
-
expect(example.value) == "foo"
24
-
expect(example.to_s) == "foo"
25
-
expect(example.to_str) == "foo"
26
-
end
26
+
test do
27
+
expect(example.value) == value
28
+
expect(example.to_s) == value
29
+
expect(example.to_str) == value
30
+
end
27
31
end
28
32
29
33
context "with Symbol" do
30
-
let def type = Literal::Value(Symbol)
31
-
let def example = type.new(:foo)
34
+
let def value = :foo
35
+
let def type = Literal::Value(Symbol)
36
+
let def example = type.new(value)
32
37
33
-
test do
34
-
expect(example.value) == :foo
35
-
expect(example.to_sym) == :foo
36
-
end
38
+
test do
39
+
expect(example.value) == value
40
+
expect(example.to_sym) == value
41
+
end
37
42
end
38
43
39
44
context "with Float" do
40
-
let def type = Literal::Value(Float)
41
-
let def example = type.new(1.0)
45
+
let def value = 1.0
46
+
let def type = Literal::Value(Float)
47
+
let def example = type.new(value)
42
48
43
-
test do
44
-
expect(example.value) == 1.0
45
-
expect(example.to_f) == 1.0
46
-
end
49
+
test do
50
+
expect(example.value) == value
51
+
expect(example.to_f) == value
52
+
end
47
53
end
48
54
49
55
context "with Set" do
50
-
let def type = Literal::Value(Set)
51
-
let def example = type.new(Set[1, 2, 3])
56
+
let def value = Set[1, 2, 3]
57
+
let def type = Literal::Value(Set)
58
+
let def example = type.new(value)
52
59
53
-
test do
54
-
expect(example.value) == Set[1, 2, 3]
55
-
expect(example.to_set) == Set[1, 2, 3]
56
-
end
60
+
test do
61
+
expect(example.value) == value
62
+
expect(example.to_set) == value
63
+
end
57
64
end
58
65
59
66
context "with Array" do
60
-
let def type = Literal::Value(Array)
61
-
let def example = type.new([1, 2, 3])
67
+
let def value = [1, 2, 3]
68
+
let def type = Literal::Value(Array)
69
+
let def example = type.new(value)
62
70
63
-
test do
64
-
expect(example.value) == [1, 2, 3]
65
-
expect(example.to_a) == [1, 2, 3]
66
-
expect(example.to_ary) == [1, 2, 3]
67
-
end
71
+
test do
72
+
expect(example.value) == value
73
+
expect(example.to_a) == value
74
+
expect(example.to_ary) == value
75
+
end
68
76
end
69
77
70
78
context "with Hash" do
71
-
let def type = Literal::Value(Hash)
72
-
let def example = type.new({ foo: :bar })
79
+
let def value = { foo: :bar }
80
+
let def type = Literal::Value(Hash)
81
+
let def example = type.new(value)
73
82
74
-
test do
75
-
expect(example.value) == { foo: :bar }
76
-
expect(example.to_h) == { foo: :bar }
77
-
end
83
+
test do
84
+
expect(example.value) == value
85
+
expect(example.to_h) == value
86
+
end
78
87
end
79
88
80
89
context "with Proc" do
81
-
let def type = Literal::Value(Proc)
82
-
let def value = -> { :foo }
83
-
let def example = type.new(value)
90
+
let def value = -> { :foo }
91
+
let def type = Literal::Value(Proc)
92
+
let def example = type.new(value)
84
93
85
-
test do
86
-
expect(example.value) == value
87
-
expect(example.to_proc) == value
88
-
end
94
+
test do
95
+
expect(example.value) == value
96
+
expect(example.to_proc) == value
97
+
end
89
98
end