fanforce-factory 0.4.0

data/lib/fanforce/factory/commands_support.rb

@@ -0,0 +1,180 @@
+class Fanforce::Factory
+
+  def get_heroku_app_name(addon, environment)
+    heroku_app_name = "#{environment==:production ? 'prd' : 'qa'}-#{addon.dir_name}"
+    heroku_app_name.length > 30 ? heroku_app_name.gsub!(/(a|e|i|o|u)/, '') : heroku_app_name
+  end
+
+  def setup_files(addon)
+    if File.directory?("#{addon.dir}/tmp")
+      puts "#{'Found  '.format(:green,:bold)} #{addon.dir_name}/tmp/"
+    else
+      Dir.mkdir("#{addon.dir}/tmp")
+      puts "#{'Created'.format(:green,:bold)} #{addon.dir_name}/tmp/"
+    end
+
+    if File.exists?("#{addon.dir}/config.ru")
+      addon.update_file(:config_ru)
+      puts "#{'Updated'.format(:green,:bold)} #{addon.dir_name}/config.ru"
+    else
+      addon.create_file(:config_ru)
+      puts "#{'Created'.format(:green,:bold)} #{addon.dir_name}/config.ru"
+    end
+
+    if File.exists?("#{addon.dir}/.gitignore")
+      addon.update_file(:gitignore)
+      puts "#{'Updated'.format(:green,:bold)} #{addon.dir_name}/.gitignore"
+    else
+      addon.create_file(:gitignore)
+      puts "#{'Created'.format(:green,:bold)} #{addon.dir_name}/.gitignore"
+    end
+
+    if File.exists?("#{addon.dir}/Gemfile")
+      addon.update_file(:gemfile)
+      puts "#{'Updated'.format(:green,:bold)} #{addon.dir_name}/Gemfile"
+    else
+      addon.create_file(:gemfile)
+      puts "#{'Created'.format(:green,:bold)} #{addon.dir_name}/Gemfile"
+    end
+
+    if File.exists?("#{addon.dir}/Rakefile")
+      addon.update_file(:rakefile)
+      puts "#{'Updated'.format(:green,:bold)} #{addon.dir_name}/Rakefile"
+    else
+      addon.create_file(:rakefile)
+      puts "#{'Created'.format(:green,:bold)} #{addon.dir_name}/Rakefile"
+    end
+
+    restart(addon, :development)
+  end
+
+  def setup_envs(addon, environment)
+    environments = environment == :all ? [:development, :qa, :production] : [environment]
+
+    if !File.exists?("#{$HomeDir}/.env/_bind.yml")
+      return puts "#{'Oops'.format(:bold)}... you must setup .env/_bind.yml before trying to update env variables."
+    end
+
+    environments.each do |environment|
+      vars = Env.vars_by_addon(environment)[addon.dir_name]
+      has_workers = File.directory?("#{addon.dir}/workers") ? true : false
+
+      next puts "#{'Skipped'.format(:bold)} #{environment.to_s.titleize} has 0 env variables" if vars.blank? or vars.size == 0
+      puts "#{'Updated'.format(:green,:bold)} #{environment.to_s.titleize}#{has_workers ? '... and workers have' : ' has'} #{vars.size} env variables"
+
+      push_env_to(environment, addon, vars)
+    end
+  end
+
+  def setup_pow(addon)
+    Run.pow_create(addon, addon.root_domain)
+    Run.pow_create(addon, $SMARTURL_DOMAIN) if addon.plugin_type == :behavior
+  end
+
+  def setup_bitbucket(addon)
+    bitbucket = BitBucket.new(login: $Config[:bitbucket][:user], password: $Config[:bitbucket][:password])
+    begin
+      bitbucket.repos.find($Config[:bitbucket][:user], addon.dir_name)
+      "#{'Found   '.format(:green,:bold)}" + "#{addon.dir_name} repository already exists on bitbucket"
+    rescue
+      bitbucket.repos.create(name: addon.dir_name, is_private: true)
+      puts "#{'Created '.format(:green,:bold)}" + "#{addon.dir_name} repository on bitbucket"
+    end
+
+    if (`git remote`).split(/\r?\n/).include?($Config[:bitbucket][:user])
+      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{$Config[:bitbucket][:user]}"
+      `git remote rm #{$Config[:bitbucket][:user]}`
+    else
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for #{$Config[:bitbucket][:user]}"
+    end
+    `git remote add #{$Config[:bitbucket][:user]} https://#{$Config[:bitbucket][:user]}@bitbucket.org/#{$Config[:bitbucket][:user]}/#{addon.dir_name}.git`
+
+    puts "#{'Pushing '.format(:green,:bold)}" + "latest commit to #{$Config[:bitbucket][:user]}..."
+    Run.command("git push #{$Config[:bitbucket][:user]} --all")
+  end
+
+  def auth_heroku(environment)
+    @heroku ||= {}
+    @heroku[environment] ||= Heroku::API.new(:username => $Config[:heroku][environment][:user], :password => $Config[:heroku][environment][:password])
+  end
+
+  def setup_heroku(addon, environment)
+    return puts "OOPS...  #{environment.to_s.upcase}".format(:red,:bold) + ' has not been setup for Heroku' if $Config[:heroku].blank? or $Config[:heroku][environment].blank?
+
+    heroku = auth_heroku(environment)
+    heroku_app_name = get_heroku_app_name(addon, environment)
+    begin
+      heroku.get_app(heroku_app_name)
+      puts "#{'Found   '.format(:green,:bold)}" + "#{environment} app on heroku (#{heroku_app_name})"
+    rescue
+      heroku.post_app(name: heroku_app_name)
+      puts "#{'Created '.format(:green,:bold)}" + "#{environment} on heroku (#{heroku_app_name})"
+    end
+
+    vars = Env.vars_by_addon(environment)[addon.dir_name]
+    heroku.put_config_vars(heroku_app_name, vars)
+
+    # Setup standard plugin domain
+    if $Config[:heroku][environment][:"#{addon.type}_domain"]
+      domain = "#{addon._id}.#{$Config[:heroku][environment][:"#{addon.type}_domain"]}"
+      domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+      if domain_found
+        puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+      else
+        heroku.post_domain(heroku_app_name, domain)
+        puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+      end
+    end
+
+    # Setup standard plugin domain
+    if addon.type == :plugin and addon.plugin_type == :behavior and $Config[:heroku][environment][:smarturl_domain]
+      domain = "#{addon._id}.#{$Config[:heroku][environment][:smarturl_domain]}"
+      domain_found = heroku.get_domains(heroku_app_name).body.inject(false) {|result, d| d['domain'] == domain ? (break true) : false }
+      if domain_found
+        puts "#{'Found   '.format(:green,:bold)}" + "#{domain} domain on #{environment}"
+      else
+        heroku.post_domain(heroku_app_name, domain)
+        puts "#{'Added   '.format(:green,:bold)}" + "#{domain} domain to #{environment}"
+      end
+    end
+
+    remote_name = "#{environment==:qa ? 'qa' : 'prd'}-heroku"
+    if (`git remote`).split(/\r?\n/).include?(remote_name)
+      puts "#{'Updated '.format(:green,:bold)}" + "git remote for #{remote_name}"
+      `git remote rm #{remote_name}`
+    else
+      puts "#{'Created '.format(:green,:bold)}" + "git remote for #{remote_name}"
+    end
+    `git remote add #{remote_name} git@#{$Config[:heroku][environment][:git_ssh_domain] || 'heroku.com'}:#{heroku_app_name}.git`
+
+    puts "#{'Pushing '.format(:green,:bold)}" + "latest commit to #{remote_name}..."
+    Run.command("git push #{remote_name} master")
+  end
+
+  ######################################################################################################################
+
+  def push_env_to(environment, addon, vars, create_worker_env=true)
+    vars.each {|k,v| puts "  - #{k}" }
+    if environment == :development
+      addon.update_file(:powenv)
+      File.open("#{addon.dir}/.#{addon.type}env", 'w') {|f| f.write convert_hash_to_shell_env(vars) }
+      File.open("#{addon.dir}/workers/.#{addon.type}env.rb", 'w') {|f| f.write convert_hash_to_ruby_env(vars) } if create_worker_env and  File.directory?("#{addon.dir}/workers") and vars['iron_project_id']
+    else
+      File.open("#{addon.dir}/workers/.#{addon.type}env.rb", 'w') {|f| f.write convert_hash_to_ruby_env(vars) } if create_worker_env and File.directory?("#{addon.dir}/workers") and vars['iron_project_id']
+      return if $Config[:heroku][environment].blank?
+      heroku = auth_heroku(environment)
+      heroku_app_name = get_heroku_app_name(addon, environment)
+      heroku.put_config_vars(heroku_app_name, vars)
+    end
+    restart(addon, environment)
+  end
+
+  def convert_hash_to_shell_env(hash)
+    hash.inject('') {|script, (k,v)| script += "export #{k}=#{v.to_s.to_json}\n" }
+  end
+
+  def convert_hash_to_ruby_env(hash)
+    hash.inject('') {|script, (k,v)| script += "ENV['#{k}']=#{v.to_s.to_json}\n" }
+  end
+
+end

data/lib/fanforce/factory/developer_config.rb

@@ -0,0 +1,112 @@
+module Fanforce::Factory::DeveloperConfig
+  ########################################################################
+  def self.app(addon)
+    response = <<-eos
+    "public_urls": {
+        "marketplace_img": "http://${PRIMARY_DOMAIN}/assets/marketplace.png",
+        "icon_16": "http://${PRIMARY_DOMAIN}/assets/icon-16.png",
+        "icon_32": "http://${PRIMARY_DOMAIN}/assets/icon-32.png",
+        "icon_42": "http://${PRIMARY_DOMAIN}/assets/icon-42.png"
+    },
+    "staffer_ui_urls": {
+        "dashboard": "http://${PRIMARY_DOMAIN}/dashboard.html"
+    },
+    "callback_urls": {
+        "install": "http://${PRIMARY_DOMAIN}/install",
+        "uninstall": "http://${PRIMARY_DOMAIN}/uninstall"
+    },
+    "plugin_dependencies": []
+    eos
+    strip(response)
+  end
+
+  ########################################################################
+  def self.plugin(addon)
+    plugin_type = addon.plugin_type
+
+    response  = "    \"type\": \"#{plugin_type}\",\n"
+    response += "    \"#{plugin_type}_config\": {\n"
+    if plugin_type == :data_connector
+      response += <<-eos
+      "category_id": "bulk_messaging"
+      eos
+    elsif plugin_type == :data_processor
+    elsif plugin_type == :broadcaster
+      response += <<-eos
+      "new_button_label": "#{addon._id.humanize.titleize}"
+      eos
+    elsif plugin_type == :identifier
+    elsif plugin_type == :behavior
+      response += <<-eos
+      "nouns": {
+          "common": "action"
+      },
+      "verbs": {
+          "simple": "do",
+          "progressive": "doing",
+          "perfect": "did"
+      },
+      "default_total_steps": 1,
+      "valuerank_formula": [],
+      "engagement_js_url": "http://${PRIMARY_DOMAIN}/assets/engage.js"
+      eos
+    end
+    response += "    },\n"
+
+    response += <<-eos
+    "public_urls": {
+      "icon_16": "http://${PRIMARY_DOMAIN}/assets/icon-16.png",
+      "icon_32": "http://${PRIMARY_DOMAIN}/assets/icon-32.png",
+      "icon_42": "http://${PRIMARY_DOMAIN}/assets/icon-42.png"
+    },
+    eos
+
+    response += "    \"staffer_ui_urls\": {\n"
+    if plugin_type == :data_connector
+      response += <<-eos
+      "add_source": "http://${PRIMARY_DOMAIN}/add_source.html",
+      "source_details": "http://${PRIMARY_DOMAIN}/source_details.html"
+      eos
+    elsif plugin_type == :data_processor
+    elsif plugin_type == :broadcaster
+      response += <<-eos
+      "new_message": "http://${PRIMARY_DOMAIN}/new_message.html"
+      eos
+    elsif plugin_type == :identifier
+    elsif plugin_type == :behavior
+      response += <<-eos
+      "add_initiative": "http://${PRIMARY_DOMAIN}/add_initiative.html",
+      "edit_initiative": "http://${PRIMARY_DOMAIN}/edit_initiative.html",
+      "new_message": "http://${PRIMARY_DOMAIN}/new_message.html"
+      eos
+    end
+    response += "    },\n"
+
+    response += "    \"staffer_js_urls\": {\n"
+    if plugin_type == :data_connector
+      response += <<-eos
+      "add_source": "http://${PRIMARY_DOMAIN}/assets/add_source_popup.js"
+      eos
+    elsif plugin_type == :data_processor
+    elsif plugin_type == :broadcaster
+    elsif plugin_type == :identifier
+    elsif plugin_type == :behavior
+    end
+    response += "    },\n"
+
+    response += <<-eos
+    "callback_urls": {
+      "install": "http://${PRIMARY_DOMAIN}/install",
+      "uninstall": "http://${PRIMARY_DOMAIN}/uninstall"
+    },
+    eos
+    response += '    "widget_dependencies": []' if plugin_type == :behavior
+
+    strip response.gsub!(/,\s*\z/, '')
+  end
+
+  def self.strip(data)
+    data.gsub(/^    /, '')
+  end
+
+end

data/lib/fanforce/factory/env.rb

@@ -0,0 +1,37 @@
+class Fanforce::Factory::Env
+  require 'singleton'
+  require 'forwardable'
+  include Singleton
+
+  def load_vars_by_addon(environment)
+    bindings = YAML.load_file("#{$HomeDir}/.env/_bind.yml")
+    result = bindings.inject({}) do |result, (filename, dir_names)|
+      file = YAML.load_file("#{$HomeDir}/.env/#{filename}.yml").symbolize_keys
+      if file[environment].blank?
+        next result
+      end
+
+      dir_names = Fanforce::Factory::Addons.dir_names if dir_names.is_a?(String) and dir_names.upcase == 'ALL'
+      file[environment].each do |k,v|
+        dir_names.each do |d|
+          result[d] ||= {}
+          result[d]["#{filename}_#{k}".upcase] = v
+          d_parts = Fanforce::Factory::Addon.parse_dir_name(d)
+          result[d]["fanforce_#{d_parts[:type]}_id".upcase] = d_parts[:_id] if d_parts
+        end
+      end
+      result
+    end
+  end
+
+  def vars_by_addon(environment)
+    @vars ||= {}
+    @vars[environment] ||= load_vars_by_addon(environment)
+  end
+
+  class << self
+    extend Forwardable
+    def_delegators :instance, *Fanforce::Factory::Env.instance_methods(false)
+  end
+
+end

data/lib/fanforce/factory/files.rb

@@ -0,0 +1,269 @@
+class Fanforce::Factory::Files
+
+# CONFIG.RU #######################################################################
+
+  def self.create_config_ru(addon)
+    file = config_ru_required_lines(addon.type).join("\n") + "\n\n"
+    if (fanforce_config_lines = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)).size > 0
+      file += "Fanforce#{addon.type.capitalize}.config do |config|\n"
+      file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      file += "end\n"
+    end
+    file += "run Fanforce#{addon.type.capitalize}\n"
+    File.open("#{addon.dir}/config.ru", 'w') {|f| f.write file }
+  end
+
+  def self.update_config_ru(addon)
+    return create_config_ru(addon) if !File.exists?("#{addon.dir}/config.ru")
+
+    lines = File.open("#{addon.dir}/config.ru", 'r') {|f| f.readlines}
+
+    lines.clone.each {|l| lines.delete(l) if config_ru_required_lines(addon.type).include?(l.strip) }
+    config_ru_required_lines(addon.type).reverse.each {|l| lines.unshift(l+"\n") }
+
+    config_options = extract_fanforce_config_options(addon.type, lines, 'config.ru')
+
+    fanforce_config_keys_to_require(addon.type, addon.plugin_type).each do |k|
+      config_options[k] = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)[k] if config_options[k].blank?
+    end
+
+    fanforce_config_keys_to_overwrite(addon.type, addon.plugin_type).each do |k|
+      config_options[k] = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)[k]
+    end
+
+    lines = replace_fanforce_config_options_in_config_ru(addon.type, lines, config_options)
+
+    File.open("#{addon.dir}/config.ru", 'w') {|f| f.write(lines.join('')) }
+  end
+
+  def self.replace_fanforce_config_options_in_config_ru(addon_type, lines, config_options)
+    if (block = extract_fanforce_config_block(addon_type, lines, 'config.ru'))
+      new_block  = "Fanforce#{addon_type.capitalize}.config do |config|\n"
+      new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      new_block += "end\n"
+      new_block += "run Fanforce#{addon_type.capitalize}"
+    else
+      block = extract_run_fanforce_line(addon_type, lines)
+      new_block = "run Fanforce#{addon_type.capitalize}"
+    end
+    lines.join('').gsub(block[:code], new_block).lines.to_a
+  end
+
+  def self.config_ru_required_lines(addon_type)
+    [
+        "require 'bundler'; Bundler.setup",
+        "require 'fanforce/#{addon_type}_factory'"
+    ]
+  end
+
+  # RAKEFILE #######################################################################
+
+  def self.create_rakefile(addon)
+    file = rakefile_required_lines(addon.type).join("\n") + "\n\n"
+    if (fanforce_config_lines = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)).size > 0
+      file += "Fanforce#{addon.type.capitalize}.config do |config|\n"
+      file += fanforce_config_lines.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      file += "end\n"
+    end
+    file += "load 'fanforce/#{addon.type}_factory.rake'\n"
+    File.open("#{addon.dir}/Rakefile", 'w') {|f| f.write file }
+  end
+
+  def self.update_rakefile(addon)
+    return create_rakefile(addon) if !File.exists?("#{addon.dir}/Rakefile")
+
+    lines = File.open("#{addon.dir}/Rakefile", 'r') {|f| f.readlines}
+
+    lines.clone.each {|l| lines.delete(l) if rakefile_required_lines(addon.type).include?(l.strip) }
+    rakefile_required_lines(addon.type).reverse.each {|l| lines.unshift(l+"\n") }
+
+    config_options = extract_fanforce_config_options(addon.type, lines, 'Rakefile')
+
+    fanforce_config_keys_to_require(addon.type, addon.plugin_type).each do |k|
+      config_options[k] = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)[k] if config_options[k].blank?
+    end
+
+    fanforce_config_keys_to_overwrite(addon.type, addon.plugin_type).each do |k|
+      config_options[k] = fanforce_config_lines(addon._id, addon.type, addon.plugin_type)[k]
+    end
+
+    lines = replace_fanforce_config_options_in_rakefile(addon.type, lines, config_options)
+
+    File.open("#{addon.dir}/Rakefile", 'w') {|f| f.write(lines.join('')) }
+  end
+
+  def self.replace_fanforce_config_options_in_rakefile(addon_type, lines, config_options)
+    if (block = extract_fanforce_config_block(addon_type, lines, 'Rakefile'))
+      new_block  = "Fanforce#{addon_type.capitalize}.config do |config|\n"
+      new_block += config_options.map {|k,v| "  #{k} = #{v}"}.join("\n") + "\n"
+      new_block += "end\n"
+      new_block += "load 'fanforce/#{addon_type}_factory.rake'"
+    else
+      block = extract_load_fanforce_line(addon_type, lines)
+      new_block = "load 'fanforce/#{addon_type}_factory.rake'"
+    end
+    lines.join('').gsub(block[:code], new_block).lines.to_a
+  end
+
+  def self.rakefile_required_lines(addon_type)
+    [
+        "require 'bundler'; Bundler.setup",
+        "require 'fanforce/#{addon_type}_factory'"
+    ]
+  end
+
+  ########################################################################
+
+  def self.extract_load_fanforce_line(addon_type, lines)
+    code = lines.join('')
+    regex = Regexp.compile('( *load\s+(\'|")fanforce/'+addon_type.to_s+'_factory.rake(\'|"))', Regexp::MULTILINE)
+    if code !~ regex
+      raise "No valid \"load 'fanforce/#{addon_type}_factory.rake'\" line was found in your Rakefile."
+    end
+    {:code => $1}
+  end
+
+  def self.extract_run_fanforce_line(addon_type, lines)
+    code = lines.join('')
+    regex = Regexp.compile('( *run\s+Fanforce'+addon_type.to_s.capitalize+')', Regexp::MULTILINE)
+    if code !~ regex
+      raise "No valid \"run Fanforce#{addon_type.to_s.capitalize}\" line was found in your config.ru."
+    end
+    {:code => $1}
+  end
+
+  def self.extract_fanforce_config_block(addon_type, lines, filename)
+    code = lines.join('')
+    regex = Regexp.compile('( *Fanforce'+addon_type.to_s.capitalize+'\.config\s*(do|{)\s*\|\s*([A-Za-z]+)\s*\|(.*)(end|})\s*(run\s+Fanforce'+addon_type.to_s.capitalize+'|load\s+(\'|")fanforce/'+addon_type.to_s+'_factory.rake(\'|")))', Regexp::MULTILINE)
+    if code !~ regex || ($2 == '{' and $5 != '}') || ($2 == 'do' and $5 != 'end')
+      raise "No valid Fanforce#{addon_type.capitalize}.config block was found in your #{filename}." if addon_type == :plugin
+      return nil
+    end
+    {
+        :code          => $1,
+        :start_keyword => $2,
+        :config_var    => $3,
+        :config_code   => $4,
+        :end_keyword   => $5
+    }
+  end
+
+  def self.extract_fanforce_config_options(addon_type, lines, filename)
+    block = extract_fanforce_config_block(addon_type, 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
+
+  def self.fanforce_config_lines(addon_id, addon_type, plugin_type)
+    lines = {}
+    lines['config.type'] = ":#{plugin_type}" if !plugin_type.nil?
+    return lines
+  end
+
+  def self.fanforce_config_keys_to_require(addon_type, plugin_type)
+    []
+  end
+
+  def self.fanforce_config_keys_to_overwrite(addon_type, plugin_type)
+    keys = []
+    keys << 'config.type' if !plugin_type.nil?
+    return keys
+  end
+
+  # GEMFILE #######################################################################
+
+  def self.create_gemfile(addon)
+    file  = gemfile_source_lines(addon.type).join("\n") + "\n"
+    file += gemfile_ruby_version(addon.type) + "\n\n"
+    file += gemfile_factory_line(addon.type) + "\n\n"
+    File.open("#{addon.dir}/Gemfile", 'w') {|f| f.write file }
+  end
+
+  def self.update_gemfile(addon)
+    return create_gemfile(addon) if !File.exists?("#{addon.dir}/Gemfile")
+
+    lines = File.open("#{addon.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-#{addon.type}-factory'") ? gemfile_factory_line(addon.type) : l
+    end
+    lines << gemfile_factory_line(addon.type) if !lines.include?(gemfile_factory_line(addon.type))
+
+    File.open("#{addon.dir}/Gemfile", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.gemfile_source_lines(addon_type=nil)
+    [
+      "source 'https://rubygems.org'",
+    ]
+  end
+
+  def self.gemfile_ruby_version(addon_type=nil)
+    "ruby '1.9.3'"
+  end
+
+  def self.gemfile_factory_line(addon_type)
+    line = "gem 'fanforce-#{addon_type}-factory'"
+    return line if !$Config[:factory_gems].is_a?(Hash) or !$Config[:factory_gems][addon_type.to_sym].is_a?(Hash)
+
+    line += ", '#{$Config[:factory_gems][addon_type][:version]}'" if $Config[:factory_gems][addon_type][:version].present?
+    line += ", :path => '#{$Config[:factory_gems][addon_type][:path]}'" if $Config[:factory_gems][addon_type][:path].present?
+    line += ", :git => '#{$Config[:factory_gems][addon_type][:git]}'" if $Config[:factory_gems][addon_type][:git].present?
+    line
+  end
+
+  # .GITIGNORE #######################################################################
+
+  def self.create_gitignore(addon)
+    file = gitignore_lines(addon.type).join("\n") + "\n"
+    File.open("#{addon.dir}/.gitignore", 'w') {|f| f.write file }
+  end
+
+  def self.update_gitignore(addon)
+    return create_gitignore(addon) if !File.exists?("#{addon.dir}/.gitignore")
+
+    lines = File.open("#{addon.dir}/.gitignore", 'r') {|f| f.readlines}.map {|l| l.strip }
+
+    gitignore_lines.each do |line|
+      lines << line if !lines.include?(line)
+    end
+
+    File.open("#{addon.dir}/.gitignore", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.gitignore_lines(addon_type=nil)
+    %w(*.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 .pluginenv .pluginenv.rb .appenv.rb .appenv .widgetenv .widgetenv.rb .yardoc _yardoc doc/)
+  end
+
+  # .POWENV #######################################################################
+
+  def self.create_powenv(addon)
+    file = powenv_lines(addon.type).join("\n") + "\n"
+    File.open("#{addon.dir}/.powenv", 'w') {|f| f.write file }
+  end
+
+  def self.update_powenv(addon)
+    return create_powenv(addon) if !File.exists?("#{addon.dir}/.powenv")
+
+    lines = File.open("#{addon.dir}/.powenv", 'r') {|f| f.readlines}.map {|l| l.strip }
+
+    powenv_lines(addon.type).each do |line|
+      lines << line if !lines.include?(line)
+    end
+
+    File.open("#{addon.dir}/.powenv", 'w') {|f| f.write(lines.join "\n") }
+  end
+
+  def self.powenv_lines(addon_type)
+    ["source .#{addon_type}env"]
+  end
+
+end