thefox-ext 1.10.0 → 3.0.0.pre.rc.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,41 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ # x-y/n
6
+ class Interval < Base
7
+ def initialize()
8
+ super()
9
+ # puts '-> Interval.initialize()'
10
+ @number = nil
11
+ end
12
+
13
+ # :nocov:
14
+ def inspect()
15
+ if @number.nil?
16
+ 'Interval()'
17
+ else
18
+ 'Interval(%s)' % [@number.char]
19
+ end
20
+ end
21
+ # :nocov:
22
+
23
+ def number()
24
+ @number
25
+ end
26
+ def number=(number)
27
+ @number = number.dup
28
+ end
29
+
30
+ def resolve()
31
+ # puts '-> %s.resolve' % [inspect]
32
+ if @number.nil?
33
+ 1
34
+ else
35
+ @number.resolve
36
+ end
37
+ end
38
+ end # Interval
39
+ end # Lexer
40
+ end # Range
41
+ end # TheFox
@@ -0,0 +1,94 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ class Lexer
6
+ def initialize(chars)
7
+ # puts '-> Lexer2.initialize'
8
+ @chars = chars
9
+ end
10
+
11
+ def resolve()
12
+ # puts
13
+ # puts '-> Lexer2.resolve L1 [Create Object for each character]'
14
+
15
+ block_level = BlockLevel.new
16
+ item_collection1 = Collection.new
17
+ position = 0
18
+ @chars.each do |char|
19
+ position += 1
20
+ curr_item = case char
21
+ when ' '
22
+ # Skip space
23
+ when "\r"
24
+ # Skip
25
+ when ',', "\n"
26
+ Separator.new()
27
+ when '{'
28
+ BlockDown.new(block_level)
29
+ when '}'
30
+ BlockUp.new(block_level)
31
+ when '+'
32
+ Operator.new()
33
+ when '-', '.'
34
+ Range.new(char)
35
+ when '/'
36
+ Interval.new()
37
+ when '0'..'9'
38
+ Number.new(char)
39
+ else
40
+ raise 'Unknown character at position %d: "%s" (ord=%d)' % [
41
+ position, char, char.ord
42
+ ]
43
+ end
44
+
45
+ item_collection1.push(curr_item)
46
+ end
47
+
48
+ # puts '-> Lexer2.resolve L1 Items'
49
+ # pp item_collection1.items.map{ |item| item.inspect }
50
+
51
+ # puts
52
+ # puts '-> Lexer2.resolve L2 [Append Number]'
53
+ item_collection2 = Collection.new
54
+ item_collection1.items.each do |item|
55
+ # puts '--> L2 item: %s' % [item.inspect]
56
+
57
+ case item
58
+ when Number
59
+ if item_collection2.curr.is_a?(Number)
60
+ item_collection2.curr.append(item)
61
+ else
62
+ item_collection2.push(item)
63
+ end
64
+ when Range
65
+ # puts '--> L2 Its Range: %s %s %s %s %s' % [
66
+ # item.inspect,
67
+ # item_collection2.curr.inspect,
68
+ # item_collection2.curr.is_a?(Range) ? 'Y' : 'n',
69
+ # item_collection2.curr.symbole == '.' ? 'Y' : 'n',
70
+ # item.symbole == '.' ? 'Y' : 'n',
71
+ # ]
72
+ if item_collection2.curr.is_a?(Range) && item_collection2.curr.symbole == '.' && item.symbole == '.'
73
+ # puts '--> L2 Skip'
74
+ else
75
+ item_collection2.push(item)
76
+ end
77
+ else
78
+ # puts '--> L2 ELSE'
79
+ item_collection2.push(item)
80
+ end # case item
81
+
82
+ end # item_collection1.items
83
+
84
+ # puts '-> Lexer2.resolve L2 Items'
85
+ # pp item_collection2.items.map{ |item| item.inspect }
86
+
87
+ # puts
88
+ scope = Scope.new(item_collection2.items)
89
+ scope.resolve
90
+ end
91
+ end # Lexer
92
+ end # Lexer
93
+ end # Range
94
+ end # TheFox
@@ -0,0 +1,103 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ # 0123456789
6
+ class Number < Base
7
+ def initialize(char)
8
+ super()
9
+ # puts '-> Number.initialize(%s)' % [char]
10
+ #@nonce = rand(10 ** 3).to_s.rjust(3, '0')
11
+ @char = char
12
+ @is_ref_item = false
13
+ end
14
+
15
+ # :nocov:
16
+ def inspect()
17
+ a = [
18
+ # '#' + @nonce.to_s,
19
+ # 'c' + @char,
20
+ @char,
21
+ ]
22
+ if !@parent_item.nil?
23
+ a.push('^%s' % @parent_item.inspect)
24
+ end
25
+ a.push('IRI=%d' % [@is_ref_item])
26
+ # if @children.length > 0
27
+ # a.push('v%d' % @children.length)
28
+ # end
29
+ 'Number(%s)' % [a.join(' ')]
30
+ end
31
+ def dup()
32
+ # puts '-> Number.dup(%s) -> %s %s' % [@char, inspect, self.is_ref_item ? 'Y' : 'n']
33
+ # puts '-> %s.dup' % [inspect]
34
+ o = super()
35
+ o.is_ref_item = self.is_ref_item
36
+ # puts '-> Number.dup(%s) -> %s' % [@char, o.inspect]
37
+ o
38
+ end
39
+ # :nocov:
40
+
41
+ def char
42
+ @char
43
+ end
44
+
45
+ def is_ref_item
46
+ @is_ref_item
47
+ end
48
+ def is_ref_item=(is_ref_item)
49
+ @is_ref_item = is_ref_item
50
+ end
51
+
52
+ def append(obj)
53
+ if obj.is_a?(Number)
54
+ self.append(obj.char)
55
+ else
56
+ @char += obj
57
+ end
58
+ end
59
+
60
+ def inc()
61
+ f = '%%0%dd' % [@char.length]
62
+ @char = f % [@char.to_i + 1]
63
+ end
64
+
65
+ def resolve(level = 0)
66
+ # puts '-> %s.resolve(%d)' % [self.inspect, @char, level]
67
+ if self.has_parent_item
68
+ if @parent_item.is_a?(Number)
69
+ ('%s%s' % [@parent_item.resolve(level + 1), @char]).to_i
70
+ elsif @parent_item.is_a?(Scope)
71
+ curr_item = @parent_item
72
+ stack = [@char]
73
+ while !curr_item.parent_scope.nil? do
74
+ # puts '-----> CI=%s RI=%s' % [curr_item.inspect, curr_item.ref_item.inspect]
75
+
76
+ if !curr_item.ref_item.nil?
77
+ stack.push(curr_item.ref_item.char)
78
+ end
79
+ curr_item = curr_item.parent_scope
80
+ end
81
+
82
+ # pp stack.reverse
83
+
84
+ stack.reverse.join.to_i
85
+
86
+ # if @char == '5'
87
+ # 2102
88
+ # else
89
+ # 9999
90
+ # end
91
+ elsif @parent_item.is_a?(Interval)
92
+ @char.to_i
93
+ else
94
+ nil
95
+ end
96
+ else
97
+ @char.to_i
98
+ end
99
+ end
100
+ end # Number
101
+ end # Lexer
102
+ end # Range
103
+ end # TheFox
@@ -0,0 +1,20 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ # +
6
+ class Operator < Base
7
+ def initialize()
8
+ super()
9
+ # puts '-> Operator.initialize'
10
+ end
11
+
12
+ # :nocov:
13
+ def inspect()
14
+ 'Operator()'
15
+ end
16
+ # :nocov:
17
+ end # Operator
18
+ end # Lexer
19
+ end # Range
20
+ end # TheFox
@@ -0,0 +1,65 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ # - ..
6
+ class Range < Base
7
+ def initialize(symbole)
8
+ super(symbole)
9
+ # puts '-> Range.initialize(%s)' % [symbole]
10
+
11
+ @left_item = nil
12
+ @right_item = nil
13
+ @interval = nil
14
+ end
15
+
16
+ # :nocov:
17
+ def inspect()
18
+ if !@left_item.nil? && !@right_item.nil?
19
+ 'Range(#%s s=%s l=%s r=%s i=%s)' % [
20
+ @nonce,
21
+ @symbole,
22
+ @left_item.inspect,
23
+ @right_item.inspect,
24
+ @interval.inspect
25
+ ]
26
+ else
27
+ 'Range(#%s %s)' % [@nonce, @symbole]
28
+ end
29
+ end
30
+ # :nocov:
31
+
32
+ def left_item=(left_item)
33
+ @left_item = left_item.dup
34
+ end
35
+
36
+ def right_item=(right_item)
37
+ @right_item = right_item.dup
38
+ end
39
+ def right_item()
40
+ @right_item
41
+ end
42
+
43
+ def interval()
44
+ @interval
45
+ end
46
+ def interval=(interval)
47
+ @interval = interval.dup
48
+ end
49
+
50
+ def resolve()
51
+ # puts '-> %s.resolve()'.colorize(:red) % [inspect]
52
+ if @left_item.is_a?(Number) && @right_item.is_a?(Number)
53
+ r = ::Range.new(@left_item.resolve, @right_item.resolve)
54
+ if @interval.is_a?(Interval)
55
+ # puts '--> I=%s'.colorize(:red) % [@interval.inspect]
56
+ r = r.step(@interval.resolve)
57
+ end
58
+ # puts '--> %s'.colorize(:red) % [r.inspect]
59
+ r.to_a
60
+ end
61
+ end
62
+ end # Range
63
+ end # Lexer
64
+ end # Range
65
+ end # TheFox
@@ -0,0 +1,266 @@
1
+
2
+ module TheFox
3
+ module Range
4
+ module Lexer
5
+ class Scope < Base
6
+ def initialize(items = nil, parent_scope = nil, level = 0)
7
+ super()
8
+
9
+ @item_collection = Collection.new(items)
10
+ @parent_scope = parent_scope
11
+ @level = level
12
+ @ref_item = nil
13
+
14
+ # puts '%s-> Scope(#%s).initialize(p=%s lev=%d)'.colorize(:red) % [' ' * (@level * 2), @instance_id, @parent_scope.inspect, @level]
15
+ end
16
+
17
+ # :nocov:
18
+ def name()
19
+ 'Scope(#%s)' % [@instance_id]
20
+ end
21
+ def inspect()
22
+ 'Scope(#%s len=%d)' % [@instance_id, @item_collection.length]
23
+ end
24
+ # :nocov:
25
+
26
+ def push(item)
27
+ # puts '%s-> %s.push(%s) -> PS=%s PRI=%s'.colorize(:green) % [' ' * (@level * 2),
28
+ # inspect,
29
+ # item.inspect,
30
+ # @parent_scope.inspect,
31
+ # @parent_scope.ref_item.inspect,
32
+ # ]
33
+ @item_collection.push(item)
34
+ end
35
+
36
+ def items()
37
+ @item_collection.items
38
+ end
39
+
40
+ def curr()
41
+ @item_collection.curr
42
+ end
43
+
44
+ def prev()
45
+ @item_collection.prev
46
+ end
47
+
48
+ def parent_scope()
49
+ @parent_scope
50
+ end
51
+ def parent_scope=(parent_scope)
52
+ @parent_scope = parent_scope
53
+ end
54
+
55
+ def ref_item()
56
+ @ref_item
57
+ end
58
+ def ref_item=(ref_item)
59
+ # puts '%s--> Set Ref Item: %s'.colorize(:green) % [' ' * (@level * 2), inspect]
60
+ ref_item.is_ref_item = true
61
+ @ref_item = ref_item
62
+ end
63
+
64
+ def resolve()
65
+ # puts '-> %s.resolve(%d)' % [self.inspect, @level]
66
+
67
+ # puts '%s-> SL1: %s P=%s' % [' ' * (@level * 2), inspect, @parent_item.inspect]
68
+
69
+ scopes = Collection.new([Scope.new(nil, self, @level + 1)])
70
+ block_stack = Collection.new()
71
+ parent_item = nil
72
+ @item_collection.items.each do |item|
73
+ # puts '%s-> SL1 Item: %s' % [' ' * (@level * 2), item.inspect]
74
+
75
+ push_to_scope = false
76
+
77
+ case item
78
+ when Separator
79
+ if block_stack.length == 0
80
+ scopes.push(Scope.new(nil, self, @level + 1))
81
+ else
82
+ push_to_scope = true
83
+ end
84
+ when BlockDown
85
+ if block_stack.length == 0
86
+ # puts '%s--> BlockDown: Curr=%s'.colorize(:green) % [' ' * (@level * 2),
87
+ # scopes.curr.curr.inspect,
88
+ # ]
89
+
90
+ prev_item = scopes.curr.curr
91
+
92
+ scopes.push(Scope.new(nil, self, @level + 1))
93
+ # scopes.curr.ref_item = item.prev_item
94
+ scopes.curr.ref_item = prev_item
95
+
96
+ # puts '%s--> BlockDown: PrevItem=%s'.colorize(:green) % [' ' * (@level * 2),
97
+ # scopes.curr.ref_item.inspect,
98
+ # ]
99
+ else
100
+ push_to_scope = true
101
+ end
102
+
103
+ # Block Stack
104
+ block_stack.push(item)
105
+ when BlockUp
106
+ block_stack.pop
107
+
108
+ prev_ref_item = scopes.curr.ref_item
109
+ # puts '-> BlockUp: %s' % [prev_ref_item.inspect]
110
+
111
+ # TODO: THIS!!!!
112
+ scopes.push(Scope.new(nil, self, @level + 1))
113
+ scopes.curr.ref_item = prev_ref_item
114
+ else
115
+ push_to_scope = true
116
+ end # case item
117
+
118
+ if push_to_scope
119
+ # puts '%s--> Push Item: %s PS=%s PI=%s RI=%s,%s' % [' ' * (@level * 2),
120
+ # item.inspect,
121
+ # scopes.curr.parent_scope.inspect,
122
+ # scopes.curr.parent_item.inspect,
123
+ # @ref_item.inspect,
124
+ # scopes.curr.ref_item.inspect,
125
+ # ]
126
+ scopes.curr.push(item)
127
+ scopes.curr.curr.parent_item = self
128
+ # puts '%s--> Pushed Item: %s' % [' ' * (@level * 2), item.inspect]
129
+ end
130
+ end # @item_collection.items
131
+
132
+ # puts
133
+ # puts '%s-> Scopes: %s'.colorize(:blue) % [' ' * (@level * 2), scopes.inspect]
134
+ # scopes.items.each do |scope|
135
+ # puts scope.inspect.colorize(:blue)
136
+ # puts scope.items.map{ |i| i.inspect }.to_s.colorize(:blue)
137
+ # end
138
+
139
+ if scopes.length > 1
140
+ resolved = []
141
+ scopes.items.each do |scope|
142
+ resolved.push(scope.resolve)
143
+ end
144
+ resolved
145
+ else
146
+ # puts
147
+ # puts '%s-> SL1 Items' % [' ' * (@level * 2)]
148
+ # pp scopes.curr.items.map{ |item| item.inspect }
149
+
150
+ # puts '%s-> SL2 ' % [' ' * (@level * 2)]
151
+ item_collection1 = Collection.new
152
+ scopes.curr.items.each do |item|
153
+ # puts '%s-> SL2 Item: %s (P=%s)' % [
154
+ # ' ' * (@level * 2),
155
+ # item.inspect,
156
+ # item.parent_item.inspect,
157
+ # ]
158
+
159
+ case item
160
+ when Number
161
+ # puts '--> Its %s' % [item.inspect]
162
+ if item.next_item.is_a?(Range) || item.prev_item.is_a?(Range)
163
+ # Skip Range
164
+ # puts '--> Skip Range'
165
+ elsif item.prev_item.is_a?(Interval)
166
+ # Skip Interval
167
+ # puts '%s--> Skip Interval' % [' ' * (@level * 2)]
168
+ # item.prev_item.next_item = nil
169
+ # item.parent_item = item.prev_item
170
+ # item.prev_item = nil
171
+ # item.next_item = nil
172
+ elsif item.next_item.is_a?(Operator)
173
+ # Skip Operator
174
+ # puts '--> Skip Operator'
175
+ elsif item.has_children
176
+ # Skip
177
+ # puts '--> Skip Has Children'
178
+ elsif item.is_ref_item
179
+ # puts '--> Skip Ref Item'
180
+ else
181
+ # puts '--> Push'
182
+ # puts '--> Push: %s' % [item.inspect]
183
+ item_collection1.push(item)
184
+ end
185
+ when Range
186
+ if item.prev_item.is_a?(Number) && item.next_item.is_a?(Number)
187
+ # puts '--> Range normal'
188
+ item_collection1.push(item)
189
+ item_collection1.curr.left_item = item.prev_item
190
+ item_collection1.curr.right_item = item.next_item
191
+
192
+ # 1-10/3
193
+ # item.prev_item Number
194
+ # item Range
195
+ # item.next_item Number
196
+ # item.next_item.next_item Interval
197
+ # item.next_item.next_item.next_item Number
198
+
199
+ interval_item = item.next_item.next_item
200
+ if interval_item.is_a?(Interval)
201
+ item_collection1.curr.interval = interval_item
202
+ item_collection1.curr.interval.number = item.next_item.next_item.next_item
203
+ item_collection1.curr.interval.number.parent_item = item_collection1.curr.interval
204
+ end
205
+ else
206
+ raise 'Invalid Range: %s %s' % [
207
+ item.prev_item.inspect,
208
+ item.next_item.inspect,
209
+ ]
210
+ end
211
+ when Interval
212
+ # Skip
213
+ when Operator
214
+ if item_collection1.curr.is_a?(Range)
215
+ # puts '%s-> Operator, Curr Range'.colorize(:cyan) % [' ' * (@level * 2)]
216
+
217
+ if item_collection1.curr.right_item.is_a?(Number)
218
+ item_collection1.curr.right_item.inc
219
+ end
220
+ elsif item.prev_item.is_a?(Number)
221
+ # puts '%s-> Operator, Number'.colorize(:cyan) % [' ' * (@level * 2)]
222
+
223
+ item_collection1.push(Range.new(item.symbole))
224
+ item_collection1.curr.left_item = item.prev_item
225
+ item_collection1.curr.right_item = item.prev_item
226
+ item_collection1.curr.right_item.inc
227
+ elsif item.prev_item.is_a?(Operator)
228
+ # puts '%s-> Operator, Prev Operator'.colorize(:cyan) % [' ' * (@level * 2)]
229
+
230
+ if item_collection1.curr.is_a?(Range)
231
+ if item_collection1.curr.right_item.is_a?(Number)
232
+ item_collection1.curr.right_item.inc
233
+ end
234
+ end
235
+ # else
236
+ # puts '%s-> Operator ELSE: %s' % [' ' * (@level * 2), item.prev_item.inspect]
237
+ end
238
+ else
239
+ item_collection1.push(item)
240
+ end # case item
241
+ end # scopes.curr.items.each
242
+
243
+ # puts '%s-> L3 Items' % [' ' * (@level * 2)]
244
+ # pp item_collection1.items.map{ |item| item.inspect }
245
+
246
+ # puts '%s-> L4 [convert to int]'.colorize(:blue) % [' ' * (@level * 2)]
247
+ items2 = []
248
+ item_collection1.items.each do |item|
249
+ items2.push(item.resolve)
250
+ end
251
+ items2
252
+ end
253
+ end
254
+
255
+ class << self
256
+ def keep_nonce_on_dup()
257
+ true
258
+ end
259
+ def keep_instance_id_on_dup()
260
+ true
261
+ end
262
+ end
263
+ end # Scope
264
+ end # Lexer
265
+ end # Range
266
+ end # TheFox