Class: Fanforce::CLI::Files

Inherits:
Object
  • Object
show all
Defined in:
lib/fanforce/cli/files.rb

Class Method Summary collapse

Class Method Details

.config_ru_required_lines ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/fanforce/cli/files.rb', line 52

def self.config_ru_required_lines
  [
      "require 'bundler'; Bundler.setup",
      "require 'fanforce/app_factory'"
  ]
end

.create_config_ru(app) ⇒ Object

CONFIG.RU #######################################################################



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/fanforce/cli/files.rb', line 5

def self.create_config_ru(app)
  file = config_ru_required_lines.join("\n") + "\n\n"
  if (fanforce_config_lines = fanforce_config_lines(app._id)).size > 0
    file += "FanforceApp.config do |config|\n"
    file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
    file += "end\n"
  end
  file += "run FanforceApp\n"
  File.open("#{app.dir}/config.ru", 'w') {|f| f.write file }
end

.create_gemfile(app) ⇒ Object

GEMFILE #######################################################################



173
174
175
176
177
178
 
# File 'lib/fanforce/cli/files.rb', line 173

def self.create_gemfile(app)
  file  = gemfile_source_lines.join("\n") + "\n"
  file += gemfile_ruby_version + "\n\n"
  file += gemfile_factory_line + "\n\n"
  File.open("#{app.dir}/Gemfile", 'w') {|f| f.write file }
end

.create_gitignore(app) ⇒ Object

.GITIGNORE #######################################################################



222
223
224
225
 
# File 'lib/fanforce/cli/files.rb', line 222

def self.create_gitignore(app)
  file = gitignore_lines.join("\n") + "\n"
  File.open("#{app.dir}/.gitignore", 'w') {|f| f.write file }
end

.create_powenv(app) ⇒ Object

.POWENV #######################################################################



269
270
271
272
 
# File 'lib/fanforce/cli/files.rb', line 269

def self.create_powenv(app)
  file = powenv_lines.join("\n") + "\n"
  File.open("#{app.dir}/.powenv", 'w') {|f| f.write file }
end

.create_rakefile(app) ⇒ Object

RAKEFILE #######################################################################



61
62
63
64
65
66
67
68
69
70
 
# File 'lib/fanforce/cli/files.rb', line 61

def self.create_rakefile(app)
  file = rakefile_required_lines.join("\n") + "\n\n"
  if (fanforce_config_lines = fanforce_config_lines(app._id)).size > 0
    file += "FanforceApp.config do |config|\n"
    file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
    file += "end\n"
  end
  file += "load 'fanforce/app_factory.rake'\n"
  File.open("#{app.dir}/Rakefile", 'w') {|f| f.write file }
end

.extract_fanforce_config_block(lines, filename) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/fanforce/cli/files.rb', line 135

def self.extract_fanforce_config_block(lines, filename)
  code = lines.join('')
  regex = Regexp.compile('( *FanforceApp\.config\s*(do|{)\s*\|\s*([A-Za-z]+)\s*\|(.*)(end|})\s*(run\s+FanforceApp|load\s+(\'|")fanforce/app_factory.rake(\'|")))', Regexp::MULTILINE)
  if code !~ regex || ($2 == '{' and $5 != '}') || ($2 == 'do' and $5 != 'end')
    return nil
  end
  {
      :code          => $1,
      :start_keyword => $2,
      :config_var    => $3,
      :config_code   => $4,
      :end_keyword   => $5
  }
end

.extract_fanforce_config_options(lines, filename) ⇒ Object 



150
151
152
153
154
155
 
# File 'lib/fanforce/cli/files.rb', line 150

def self.extract_fanforce_config_options(lines, filename)
  block = extract_fanforce_config_block(lines, filename)
  return [] if !block
  regex = Regexp.compile(block[:config_var]+'\.([\w]+)\s*=\s*(((?!'+block[:config_var]+'\.).)+)', Regexp::MULTILINE)
  block[:config_code].scan(regex).inject({}) {|result, match| result.update "config.#{match[0]}" => match[1].strip }
end

.extract_load_fanforce_line(lines) ⇒ Object 



117
118
119
120
121
122
123
124
 
# File 'lib/fanforce/cli/files.rb', line 117

def self.extract_load_fanforce_line(lines)
  code = lines.join('')
  regex = Regexp.compile('( *load\s+(\'|")fanforce/app_factory.rake(\'|"))', Regexp::MULTILINE)
  if code !~ regex
    raise "No valid \"load 'fanforce/app_factory.rake'\" line was found in your Rakefile."
  end
  {:code => $1}
end

.extract_run_fanforce_line(lines) ⇒ Object 



126
127
128
129
130
131
132
133
 
# File 'lib/fanforce/cli/files.rb', line 126

def self.extract_run_fanforce_line(lines)
  code = lines.join('')
  regex = Regexp.compile('( *run\s+FanforceApp)', Regexp::MULTILINE)
  if code !~ regex
    raise "No valid \"run FanforceApp\" line was found in your config.ru."
  end
  {:code => $1}
end

.fanforce_config_keys_to_overwrite ⇒ Object 



166
167
168
169
 
# File 'lib/fanforce/cli/files.rb', line 166

def self.fanforce_config_keys_to_overwrite
  keys = []
  return keys
end

.fanforce_config_keys_to_require ⇒ Object 



162
163
164
 
# File 'lib/fanforce/cli/files.rb', line 162

def self.fanforce_config_keys_to_require
  []
end

.fanforce_config_lines(app_id) ⇒ Object 



157
158
159
160
 
# File 'lib/fanforce/cli/files.rb', line 157

def self.fanforce_config_lines(app_id)
  lines = {}
  return lines
end

.gemfile_factory_line ⇒ Object 



210
211
212
213
214
215
216
217
218
 
# File 'lib/fanforce/cli/files.rb', line 210

def self.gemfile_factory_line
  line = "gem 'fanforce-app-factory'"
  return line if !$Config[:app_factory_gem].is_a?(Hash)

  line += ", '#{$Config[:app_factory_gem][:version]}'" if $Config[:app_factory_gem][:version].present?
  line += ", :path => '#{$Config[:app_factory_gem][:path]}'" if $Config[:app_factory_gem][:path].present?
  line += ", :git => '#{$Config[:app_factory_gem][:git]}'" if $Config[:app_factory_gem][:git].present?
  line
end

.gemfile_ruby_version ⇒ Object 



206
207
208
 
# File 'lib/fanforce/cli/files.rb', line 206

def self.gemfile_ruby_version
  "ruby '1.9.3'"
end

.gemfile_source_lines ⇒ Object 



200
201
202
203
204
 
# File 'lib/fanforce/cli/files.rb', line 200

def self.gemfile_source_lines
  [
    "source 'https://rubygems.org'",
  ]
end

.gitignore_lines ⇒ Object 



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'lib/fanforce/cli/files.rb', line 239

def self.gitignore_lines; [
  '*.gem',
  '*.rbc',
  '.bundle',
  '.config',
  'coverage',
  'InstalledFiles',
  'lib/bundler/man',
  'pkg',
  'rdoc',
  'spec/reports',
  'test/tmp',
  'test/version_tmp',
  'tmp',
  '.idea/',
  '.sass-cache/',
  '.DS_STORE',
  '.powenv',
  '.env/',
  '.pluginenv',
  '.appenv',
  '.widgetenv',
  '.*env.rb',
  '.yardoc',
  '_yardoc',
  'doc/',
] end

.powenv_lines ⇒ Object 



286
287
288
 
# File 'lib/fanforce/cli/files.rb', line 286

def self.powenv_lines
  ['source .appenv']
end

.rakefile_required_lines ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/fanforce/cli/files.rb', line 108

def self.rakefile_required_lines
  [
      "require 'bundler'; Bundler.setup",
      "require 'fanforce/app_factory'"
  ]
end

.replace_fanforce_config_options_in_config_ru(lines, config_options) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/fanforce/cli/files.rb', line 39

def self.replace_fanforce_config_options_in_config_ru(lines, config_options)
  if (block = extract_fanforce_config_block(lines, 'config.ru'))
    new_block  = "FanforceApp.config do |config|\n"
    new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
    new_block += "end\n"
    new_block += "run FanforceApp"
  else
    block = extract_run_fanforce_line(lines)
    new_block = "run FanforceApp"
  end
  lines.join('').gsub(block[:code], new_block).lines.to_a
end

.replace_fanforce_config_options_in_rakefile(lines, config_options) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/fanforce/cli/files.rb', line 95

def self.replace_fanforce_config_options_in_rakefile(lines, config_options)
  if (block = extract_fanforce_config_block(lines, 'Rakefile'))
    new_block  = "FanforceApp.config do |config|\n"
    new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
    new_block += "end\n"
    new_block += "load 'fanforce/app_factory.rake'"
  else
    block = extract_load_fanforce_line(lines)
    new_block = "load 'fanforce/app_factory.rake'"
  end
  lines.join('').gsub(block[:code], new_block).lines.to_a
end

.update_config_ru(app) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/fanforce/cli/files.rb', line 16

def self.update_config_ru(app)
  return create_config_ru(app) if !File.exists?("#{app.dir}/config.ru")

  lines = File.open("#{app.dir}/config.ru", 'r') {|f| f.readlines}

  lines.clone.each {|l| lines.delete(l) if config_ru_required_lines.include?(l.strip) }
  config_ru_required_lines.reverse.each {|l| lines.unshift(l+"\n") }

  config_options = extract_fanforce_config_options(lines, 'config.ru')

  fanforce_config_keys_to_require.each do |k|
    config_options[k] = fanforce_config_lines(app._id)[k] if config_options[k].blank?
  end

  fanforce_config_keys_to_overwrite.each do |k|
    config_options[k] = fanforce_config_lines(app._id)[k]
  end

  lines = replace_fanforce_config_options_in_config_ru(lines, config_options)

  File.open("#{app.dir}/config.ru", 'w') {|f| f.write(lines.join('')) }
end

.update_gemfile(app) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/fanforce/cli/files.rb', line 180

def self.update_gemfile(app)
  return create_gemfile(app) if !File.exists?("#{app.dir}/Gemfile")

  lines = File.open("#{app.dir}/Gemfile", 'r') {|f| f.readlines}.map {|l| l.strip }
  gemfile_source_lines.reverse.each {|l| lines.delete(l); lines.unshift(l) }

  lines.clone.each {|l| lines.delete(l) if l =~ /^ruby .+/ }
  lines.each_with_index do |l,i|
    next if l =~ /^source .+/
    lines.insert(i, gemfile_ruby_version) and break
  end

  lines = lines.map do |l|
    l.include?("gem 'fanforce-app-factory'") ? gemfile_factory_line : l
  end
  lines << gemfile_factory_line if !lines.include?(gemfile_factory_line)

  File.open("#{app.dir}/Gemfile", 'w') {|f| f.write(lines.join "\n") }
end

.update_gitignore(app) ⇒ Object 



227
228
229
230
231
232
233
234
235
236
237
 
# File 'lib/fanforce/cli/files.rb', line 227

def self.update_gitignore(app)
  return create_gitignore(app) if !File.exists?("#{app.dir}/.gitignore")

  lines = File.open("#{app.dir}/.gitignore", 'r') {|f| f.readlines}.map {|l| l.strip }

  gitignore_lines.each do |line|
    lines << line if !lines.include?(line)
  end

  File.open("#{app.dir}/.gitignore", 'w') {|f| f.write(lines.join "\n") }
end

.update_powenv(app) ⇒ Object 



274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/fanforce/cli/files.rb', line 274

def self.update_powenv(app)
  return create_powenv(app) if !File.exists?("#{app.dir}/.powenv")

  lines = File.open("#{app.dir}/.powenv", 'r') {|f| f.readlines}.map {|l| l.strip }

  powenv_lines.each do |line|
    lines << line if !lines.include?(line)
  end

  File.open("#{app.dir}/.powenv", 'w') {|f| f.write(lines.join "\n") }
end

.update_rakefile(app) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/fanforce/cli/files.rb', line 72

def self.update_rakefile(app)
  return create_rakefile(app) if !File.exists?("#{app.dir}/Rakefile")

  lines = File.open("#{app.dir}/Rakefile", 'r') {|f| f.readlines}

  lines.clone.each {|l| lines.delete(l) if rakefile_required_lines.include?(l.strip) }
  rakefile_required_lines.reverse.each {|l| lines.unshift(l+"\n") }

  config_options = extract_fanforce_config_options(lines, 'Rakefile')

  fanforce_config_keys_to_require.each do |k|
    config_options[k] = fanforce_config_lines(app._id)[k] if config_options[k].blank?
  end

  fanforce_config_keys_to_overwrite.each do |k|
    config_options[k] = fanforce_config_lines(app._id)[k]
  end

  lines = replace_fanforce_config_options_in_rakefile(lines, config_options)

  File.open("#{app.dir}/Rakefile", 'w') {|f| f.write(lines.join('')) }
end