Class: Udgenerator::Core

Inherits:
Object
  • Object
show all
Defined in:
lib/udgenerator.rb,
lib/udgenerator/type.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Core

Returns a new instance of Core.



20
21
 
# File 'lib/udgenerator.rb', line 20

def initialize
end

Instance Method Details

#capitalize(str) ⇒ Object 



3
4
5
 
# File 'lib/udgenerator/type.rb', line 3

def capitalize(str)
  str[0,1].capitalize + str[1..-1]
end

#define(str) ⇒ Object 



6
7
8
 
# File 'lib/udgenerator/type.rb', line 6

def define(str)
  "k" + capitalize(str)
end

#exchange(arrStr) ⇒ Object 



58
59
60
 
# File 'lib/udgenerator/type.rb', line 58

def exchange(arrStr)
  Objective.new().parse(arrStr)
end

#fileRead(fileName) ⇒ Object 



23
24
25
26
27
28
29
 
# File 'lib/udgenerator.rb', line 23

def fileRead(fileName)
  if (File.exist?(fileName)) then
    File.open(fileName, :encoding => Encoding::UTF_8).read.scan(/(.*)\n/).flatten
  else
    []
  end
end

#generator(options) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/udgenerator.rb', line 8

def generator(options)
  FileUtils.mkdir_p(options[:output]) unless FileTest.exist?(options[:output])

  if options[:swift] then
    arrType = swift_exchange(self.fileRead(options[:input]))
    File.open("#{options[:output]}#{options[:file_name]}.swift", "w:UTF-8").write swift(arrType, options[:file_name], options[:auto_init])
  else
    arrType = exchange(self.fileRead(options[:input]))
    File.open("#{options[:output]}#{options[:file_name]}.h", "w:UTF-8").write header(arrType, options[:file_name], options[:auto_init])
    File.open("#{options[:output]}#{options[:file_name]}.m", "w:UTF-8").write method(arrType, options[:file_name], options[:auto_init])
  end
end

#getter(key, value) ⇒ Object 



12
13
14
 
# File 'lib/udgenerator/type.rb', line 12

def getter(key, value)
  "- (#{value.type_name})#{key}"
end

#header(arrType, fileName, register) ⇒ Object 



37
38
39
40
41
42
43
44
 
# File 'lib/udgenerator.rb', line 37

def header(arrType, fileName, register)
  result = ""
  arrType.each_pair{|k, v| result += interface(k, v) + "\n"}
  "\#import <Foundation/Foundation.h>\n\n" +
    imp_defines(arrType) +
    "\n\@interface #{fileName} : NSObject\n\n+ (instancetype)sharedManager;\n#{self.registHeader(register)}\n" + result +
    "\@end\n"
end

#imp_define(key, value) ⇒ Object 



27
28
29
 
# File 'lib/udgenerator/type.rb', line 27

def imp_define(key, value)
  "\#define #{define(key)} #{to_nsstring(key)}\n"
end

#imp_defines(arrType) ⇒ Object 



60
61
62
63
64
 
# File 'lib/udgenerator.rb', line 60

def imp_defines(arrType)
  result = ""
  arrType.each_pair{|s, d| result += imp_define(s, d)}
  result
end

#impGetter(key, value) ⇒ Object 



40
41
42
 
# File 'lib/udgenerator/type.rb', line 40

def impGetter(key, value)
  "#{getter(key, value)} \{\n#{in_imp_getter(key, value)}\}\n"
end

#implementation(arrType) ⇒ Object 



65
66
67
68
69
 
# File 'lib/udgenerator.rb', line 65

def implementation(arrType)
  result = ""
  arrType.each_pair{|s, d| result += impGetter(s, d) + impSetter(s, d) + "\n"}
  result
end

#impSetter(key, value) ⇒ Object 



46
47
48
 
# File 'lib/udgenerator/type.rb', line 46

def impSetter(key, value)
  "#{setter(key, value)} \{\n#{in_imp_setter(key, value)}\}\n"
end

#in_imp_getter(key, value) ⇒ Object 



37
38
39
 
# File 'lib/udgenerator/type.rb', line 37

def in_imp_getter(key, value)
  "    return [defaults #{value.imp_get_message}:#{define(key)}];\n"
end

#in_imp_setter(key, value) ⇒ Object 



43
44
45
 
# File 'lib/udgenerator/type.rb', line 43

def in_imp_setter(key, value)
  "    [defaults #{value.imp_set_message}:#{key} forKey:#{define(key)}];\n    [defaults synchronize];\n"
end

#init(arrType, register) ⇒ Object 



53
54
55
56
57
58
59
 
# File 'lib/udgenerator.rb', line 53

def init(arrType, register)
  if (register)
    "- (id)init {\n    self = [super init];\n    if (self != nil) {\n        defaults = [NSUserDefaults standardUserDefaults];\n#{registerDefaults(arrType)}    }\n\n    return self;\n}\n"
  else
    "- (id)init {\n    self = [super init];\n    if (self != nil) {\n        defaults = [NSUserDefaults standardUserDefaults];\n    }\n\n    return self;\n}\n- (void)registerDefaults:(NSDictionary *)dict {\n    [defaults registerDefaults:dict];\n}\n"
  end
end

#interface(key, value) ⇒ Object 



24
25
26
 
# File 'lib/udgenerator/type.rb', line 24

def interface(key, value)
  interface_getter(key, value) + interface_setter(key, value)
end

#interface_getter(key, value) ⇒ Object 



15
16
17
 
# File 'lib/udgenerator/type.rb', line 15

def interface_getter(key, value)
  getter(key, value) + ";\n"
end

#interface_setter(key, value) ⇒ Object 



21
22
23
 
# File 'lib/udgenerator/type.rb', line 21

def interface_setter(key, value)
  setter(key, value) + ";\n"
end

#method(arrType, fileName, register) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/udgenerator.rb', line 70

def method(arrType, fileName, register)
  "\#import \"#{fileName}.h\"\n\n" +
    "\@implementation #{fileName} {\n    NSUserDefaults *defaults;\n}\n\n+ (instancetype)sharedManager {\n    static #{fileName} *sharedManager_ = nil;\n    static dispatch_once_t onceToken;\n    dispatch_once(&onceToken, ^{\n        sharedManager_ = #{fileName}.new;\n    });\n\n    return sharedManager_;\n}\n\n" +
    self.init(arrType, register) + "\n" +
    self.implementation(arrType) +
    "@end\n"
end

#register_default(key, value) ⇒ Object 



30
31
32
33
34
35
36
 
# File 'lib/udgenerator/type.rb', line 30

def register_default(key, value)
  if (0 < value.defaultValue.length ) then
    "#{define(key)} : #{value.defaultValue}"
  else
    ""
  end
end

#registerDefaults(arrType) ⇒ Object 



45
46
47
48
49
50
51
52
 
# File 'lib/udgenerator.rb', line 45

def registerDefaults(arrType)
  result = ""
  arrType.each_pair{|k, v|
    d = register_default(k, v)
    result += " "*12 + d + ",\n" if d != ""
  }
  "        [defaults registerDefaults:@{\n" + result + "        }];\n"
end

#registers(arrType, fileName) ⇒ Object 



107
108
109
110
111
112
113
114
115
 
# File 'lib/udgenerator.rb', line 107

def registers(arrType, fileName)
  if (arrType.count == 0) then
    "[:]"
  else
    result = ""
    arrType.each_pair{|k, v| result += swift_register_default(k, v, fileName)}
    "[\n#{result}        ]"
  end
end

#registHeader(register) ⇒ Object 



30
31
32
33
34
35
36
 
# File 'lib/udgenerator.rb', line 30

def registHeader(register)
  if (register)
    ""
  else
    "- (void)registerDefaults:(NSDictionary *)dict;\n"
  end
end

#setter(key, value) ⇒ Object 



18
19
20
 
# File 'lib/udgenerator/type.rb', line 18

def setter(key, value)
  "- (void)set#{capitalize(key)}:(#{value.type_name})#{key}"
end

#struct(key) ⇒ Object 



49
50
51
 
# File 'lib/udgenerator/type.rb', line 49

def struct(key)
  "    static let #{key} = \"#{key}\""
end

#structs(arrType) ⇒ Object 



116
117
118
119
120
 
# File 'lib/udgenerator.rb', line 116

def structs(arrType)
  result = ""
  arrType.each_pair{|s, d| result += struct(s) + "\n"}
  result
end

#swift(arrType, fileName, register) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/udgenerator.rb', line 77

def swift(arrType, fileName, register)
  "import Foundation\n\nstruct #{fileName}Register {\n#{structs(arrType)}}\n\nclass #{fileName} {" + '
  class func sharedManager() -> UserDefaults {
      struct Static {
          static let instance = UserDefaults()
      }
      return Static.instance
  }
  init() {
' + swift_register_defaults(arrType, fileName, register) + '
  }
  func defaults() -> NSUserDefaults {
      return NSUserDefaults.standardUserDefaults()
  }
  func set(value: AnyObject?, forKey: String) {
      defaults().setObject(value, forKey: forKey)
      defaults().synchronize()
  }
  func get(key: String) -> AnyObject? {
      return defaults().objectForKey(key)
  }
' + swift_get_sets(arrType, fileName) + "}\n"
end

#swift_exchange(arrStr) ⇒ Object 



61
62
63
 
# File 'lib/udgenerator/type.rb', line 61

def swift_exchange(arrStr)
  Swift.new().parse(arrStr)
end

#swift_get_sets(arrType, fileName) ⇒ Object 



121
122
123
124
125
 
# File 'lib/udgenerator.rb', line 121

def swift_get_sets(arrType, fileName)
  result = ""
  arrType.each_pair{|s, d| result += "\n    #{swift_getter(s, d)} {\n        return get(#{fileName}Register.#{s}) as! #{d.swift_type_name}\n    }\n    #{swift_setter(s, d)} {\n        set(#{s}, forKey: #{fileName}Register.#{s})\n    }\n"}
  result
end

#swift_getter(key, value) ⇒ Object 



52
53
54
 
# File 'lib/udgenerator/type.rb', line 52

def swift_getter(key, value)
  "func #{key}() -> #{value.swift_type_name}"
end

#swift_register_default(key, value, fileName) ⇒ Object 



64
65
66
67
68
69
70
 
# File 'lib/udgenerator/type.rb', line 64

def swift_register_default(key, value, fileName)
  if (0 < value.swift_default_value.length) then
    " "*12 + "#{fileName}Register.#{key}: #{value.swift_default_value},\n"
  else
    ""
  end
end

#swift_register_defaults(arrType, fileName, register) ⇒ Object 



100
101
102
103
104
105
106
 
# File 'lib/udgenerator.rb', line 100

def swift_register_defaults(arrType, fileName, register)
  if register then
    "        defaults().registerDefaults(" + registers(arrType, fileName) + ")"
  else
    "    }\n    func registerDefaults(dict: [String: AnyObject]) {\n        defaults().registerDefaults(dict)"
  end
end

#swift_setter(key, value) ⇒ Object 



55
56
57
 
# File 'lib/udgenerator/type.rb', line 55

def swift_setter(key, value)
  "func set#{capitalize(key)}(#{key}: #{value.swift_type_name})"
end

#to_nsstring(str) ⇒ Object 



9
10
11
 
# File 'lib/udgenerator/type.rb', line 9

def to_nsstring(str)
  '@"' + str + '"'
end