Module: LEON

Includes:
Constants
Defined in:
lib/io.rb,
lib/leon.rb,
lib/types.rb,
lib/string-buffer.rb,
lib/buffer-iterator.rb

Defined Under Namespace

Classes: BufferIterator, Channel, Encoder, NaN, Parser, RegExp, StringBuffer, Undefined

Constant Summary

Constants included from Constants

Constants::ARRAY, Constants::BOOLEAN, Constants::BUFFER, Constants::CHAR, Constants::DATE, Constants::DOUBLE, Constants::FLOAT, Constants::INFINITY, Constants::INT, Constants::MINUS_INFINITY, Constants::NAN, Constants::NATIVE_OBJECT, Constants::NULL, Constants::OBJECT, Constants::REGEXP, Constants::SHORT, Constants::STRING, Constants::UNDEFINED, Constants::UNSIGNED_CHAR, Constants::UNSIGNED_INT, Constants::UNSIGNED_SHORT

Class Method Summary collapse

Class Method Details

.gather_layouts(*args) ⇒ Object 



483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'lib/io.rb', line 483

def self.gather_layouts(*args)
  if args.length > 3
    branch = args[3]
  else
    branch = args[0]
  end
  if args.length > 2
    ret = args[2]
  else
    ret = Array.new
  end
  val = args[0]
  stringIndex = args[1]
  if branch.kind_of? Array
    branch.each { |v|
      LEON::gather_layouts(val, stringIndex, ret, v)
    }
  elsif branch.kind_of? Hash
    ret.push Array.new
    branch.each { |k, v|
      if k.kind_of? Symbol
        k = k.to_s
      end
      ret[ret.length - 1].push stringIndex.index(k)
    }
    branch.each { |k, v|
      LEON::gather_layouts(val, stringIndex, ret, v)
    }
  elsif branch.kind_of? Object
    ret.push Array.new
    vars = branch.instance_variables
    vars.map! { |v|
      v.to_s.sub("@", "")
    }
    vars.each { |v|
      ret[ret.length - 1].push stringIndex.index(v)
    }
    vars.each { |v|
      LEON::gather_layouts(val, stringIndex, ret, branch.send(v))
    }
  end
  return ret
end

.gather_strings(*args) ⇒ Object 



526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/io.rb', line 526

def self.gather_strings(*args)
  if args.length > 2
    branch = args[2]
  else
    branch = args[0]
  end
  if args.length > 1
    ret = args[1]
  else
    ret = Array.new
  end
  val = args[0]
  if branch.kind_of? Array
    branch.each { |v|
      LEON::gather_strings(val, ret, v)
    }
  elsif branch.kind_of? Hash
    branch.each { |k, v|
      if k.kind_of? Symbol
        k = k.to_s
      end
      set_push(ret, k)
    }
    branch.each { |k, v|
      LEON::gather_strings(val, ret, v)
    }
  elsif branch.kind_of? String
    set_push(ret, branch)
  elsif branch.kind_of? Symbol
    set_push(ret, branch.to_s)
  elsif branch.kind_of? Object
    vars = branch.instance_variables
    vars.map! { |v|
      v.to_s.sub("@", "")
    }
    vars.each { |v|
      set_push(ret, v)
    }
    vars.each { |v|
      LEON::gather_strings(val, ret, branch.send(v))
    }
  end
  return ret
end

.generate(payload) ⇒ Object 



20
21
22
 
# File 'lib/leon.rb', line 20

def self.generate(payload)
  Encoder.new(payload).writeSI().writeOLI().writeData().export()
end

.match_layout(val, stringIndex, oli) ⇒ Object 



457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
 
# File 'lib/io.rb', line 457

def self.match_layout(val, stringIndex, oli)
  if val.kind_of? Hash
    keys = val.keys
  elsif val.kind_of? Object
    keys = val.instance_variables.map { |v|
      v.to_s.sub("@", "")
    }
  end
  layout = Array.new
  for i in 0..(keys.length - 1)
    if keys[i].kind_of? Symbol
      keys[i] = keys[i].to_s
    end
    layout.push stringIndex.index(keys[i])
  end
  layout.sort! { |a, b|
    a <=> b
  }
  i = 0
  while i < oli.length
    if layout.eql? oli[i].sort { |a, b| a <=> b }
      return i
    end
    i += 1
  end
end

.parse(str) ⇒ Object 



17
18
19
 
# File 'lib/leon.rb', line 17

def self.parse(str)
  Parser.new(StringBuffer.new(str)).parseSI().parseOLI().parseValue()
end

.pluck(arr, prop) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/leon.rb', line 131

def self.pluck(arr, prop)
  ret = Array.new
  if prop.kind_of? Symbol
    prop = prop.to_s
  end
  for i in 0...(arr.length)
    if arr[i].kind_of? Hash
      if not arr[i].has_key? prop
        if not arr[i].has_key? prop.to_sym
          raise "Object #{i} in array has no such key \"#{prop}.\""
        else
          ret.push arr[i][prop.to_sym]
        end
      else
        ret.push arr[i][prop]
      end
    elsif arr[i].kind_of? Object
      begin
        ret.push arr[i].send(prop)
      rescue
        raise "Object #{i} in array has no such property \"#{prop}.\""
      end
    end
  end
  return ret
end

.set_push(arr, v) ⇒ Object 



570
571
572
573
574
 
# File 'lib/io.rb', line 570

def self.set_push(arr, v)
  if !arr.include? v
    arr.push v
  end
end

.to_template(payload) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/leon.rb', line 157

def self.to_template(payload)
  type = self.type_check(payload)
  case type
    when Constants::ARRAY
      return [self.type_gcd(payload)]
    when Constants::OBJECT
      ret = Hash.new
      payload.each { |k, v|
        ret[k] = self.to_template(v)
      }
      return ret
    when Constants::NATIVE_OBJECT
      ret = Hash.new
      payload.instance_variables.each { |k, v|
        ret[k] = self.to_template(v)
      }
    when Constants::BOOLEAN + 1
      return Constants::BOOLEAN
    else
      return type
  end
end

.type_check(v) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/io.rb', line 164

def self.type_check(v)
  if v === nil
    return Constants::NULL
  elsif v === true
    return Constants::BOOLEAN
  elsif v === false
    return Constants::BOOLEAN + 1
  elsif v.kind_of? LEON::NaN
    return Constants::NAN
  elsif v.kind_of? LEON::Undefined
    return Constants::UNDEFINED
  elsif v.kind_of? Date or v.kind_of? Time
    return Constants::DATE
  elsif v.kind_of? LEON::StringBuffer
    return Constants::BUFFER
  elsif v.kind_of? LEON::RegExp
    return Constants::REGEXP
  elsif v === Float::INFINITY
    return Constants::INFINITY
  elsif v === -1/0.0
    return Constants::MINUS_INFINITY
  elsif v.kind_of?(Array)
    return Constants::ARRAY
  elsif v.kind_of?(Hash)
    return Constants::OBJECT
  elsif v.is_a? String
    return Constants::STRING
  elsif v.kind_of? Symbol
    return Constants::STRING
  elsif v.is_a? Fixnum
    if v < 0
      v = v.abs
      if v <= (1 << 7)
        return Constants::CHAR
      elsif v <= (1 << 15)
        return Constants::SHORT
      elsif v <= (1 << 31)
        return Constants::INT
      end
      return Constants::DOUBLE
    end
    if v < (1 << 8)
      return Constants::UNSIGNED_CHAR
    end
    if v < (1 << 16)
      return Constants::UNSIGNED_SHORT
    end
    if v < (1 << 32)
      return Constants::UNSIGNED_INT
    end
    return Constants::DOUBLE
  elsif v.is_a? Float
    v = v.abs
    log = Math::log(v)/Math::log(2)
    if log < 0
      log = log.ceil
    else
      log = log.floor
    end
    exp = 103 + log
    if exp < 0 or exp > 255
      return Constants::DOUBLE
    end
    v *= 2**(-log + 24)
    if v.floor != v
      return Constants::DOUBLE
    end
    return Constants::FLOAT
  elsif v.kind_of? Object
    return Constants::NATIVE_OBJECT
  end
end

.type_gcd(arr) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/leon.rb', line 67

def self.type_gcd(arr)
  type = LEON::type_check(arr[0])
  if type === Constants::BOOLEAN + 1
    type = Constants::BOOLEAN
  end
  case type
    when Constants::ARRAY
      return [ self.type_gcd(arr[0]) ]
    when Constants::OBJECT
      ret = Hash.new
      arr[0].each { |k, v|
        ret[k] = self.type_gcd(self.pluck(arr, k))
      }
      return ret
    when Constants::NATIVE_OBJECT
      ret = Hash.new
      vars = arr[0].instance_variables.map { |v|
        v.to_sym.sub("@", "")
      }
      vars.each { |v|
        ret[v] = self.type_gcd(self.pluck(arr, v))
      }
      return ret
    when Constants::UNSIGNED_CHAR, Constants::CHAR, Constants::UNSIGNED_SHORT, Constants::SHORT, Constants::UNSIGNED_INT, Constants::INT, Constants::FLOAT, Constants::DOUBLE
      highestMagnitude = arr[0].abs
      if arr[0] < 0
        sign = 1
      else
        sign = 0
      end
      if type === Constants::FLOAT or type === Constants::DOUBLE
        fp = 1
      else
        fp = 0
      end
      for i in 1...arr.length
        type = LEON::type_check(arr[i])
        if not arr[i].kind_of? Float and not arr[i].kind_of? Fixnum
          raise "Expected a numerical value but got #{self.type_to_str(type)}."
        end
        if arr[i].abs > highestMagnitude
          highestMagnitude = arr[1]
        end
        if arr[i].ceil != arr[i]
          fp = 1
        else
          fp = 0
        end
      end
      return self.type_check((fp ? Float((sign ? -highestMagnitude : highestMagnitude )) : (sign ? -highestMagnitude : highestMagnitude )))
    else
      for i in 1...(arr.length)
        thisType = self.type_check(arr[i])
        if thisType === Constants::BOOLEAN + 1
          thisType = Constants::BOOLEAN
        end
        if type != thisType
          raise "Was expecting a #{self.type_to_str(type)} but got a #{self.type_to_str(thisType)}."
        end
      end
      return type
  end
  return type
end

.type_to_str(type) ⇒ Object 



23
24
25
26
27
28
29
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
60
61
62
63
64
65
66
 
# File 'lib/leon.rb', line 23

def self.type_to_str(type)
  case type
    when Constants::UNSIGNED_CHAR
      return "unsigned char"
    when Constants::CHAR
      return "char"
    when Constants::UNSIGNED_SHORT
      return "unsigned short"
    when Constants::SHORT
      return "short"
    when Constants::UNSIGNED_INT
      return "unsigned int"
    when Constants::INT
      return "int"
    when Constants::FLOAT
      return "float"
    when Constants::DOUBLE
      return "double"
    when Constants::STRING
      return "string"
    when Constants::BOOLEAN
      return "boolean"
    when Constants::NULL
      return "null"
    when Constants::UNDEFINED
      return "undefined"
    when Constants::OBJECT, Constants::NATIVE_OBJECT
      return "object"
    when Constants::ARRAY
      return "array"
    when Constants::DATE
      return "date"
    when Constants::BUFFER
      return "buffer"
    when Constants::REGEXP
      return "RegExp"
    when Constants::NAN
      return "NaN"
    when Constants::INFINITY
      return "infinity"
    when Constants::MINUS_INFINITY
      return "minus infinity"
  end
end