fanforce-cli 1.7.1 → 2.0.0.rc1

data/lib/fanforce/cli/commands_support.rb

@@ -1,205 +0,0 @@
-class Fanforce::CLI
-  require 'fileutils'
-
-  def setup_files(app)
-    if File.directory?("#{app.dir}/tmp")
-      puts "#{'Found  '.format(:green,:bold)} #{app.dir_name}/tmp/"
-    else
-      Dir.mkdir("#{app.dir}/tmp")
-      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/tmp/"
-    end
-
-    if File.exists?("#{app.dir}/config.ru")
-      app.update_file(:config_ru)
-      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/config.ru"
-    else
-      app.create_file(:config_ru)
-      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/config.ru"
-    end
-
-    if File.exists?("#{app.dir}/.gitignore")
-      app.update_file(:gitignore)
-      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/.gitignore"
-    else
-      app.create_file(:gitignore)
-      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/.gitignore"
-    end
-
-    if File.exists?("#{app.dir}/Gemfile")
-      app.update_file(:gemfile)
-      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/Gemfile"
-    else
-      app.create_file(:gemfile)
-      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/Gemfile"
-    end
-
-    if File.exists?("#{app.dir}/Rakefile")
-      app.update_file(:rakefile)
-      puts "#{'Updated'.format(:green,:bold)} #{app.dir_name}/Rakefile"
-    else
-      app.create_file(:rakefile)
-      puts "#{'Created'.format(:green,:bold)} #{app.dir_name}/Rakefile"
-    end
-
-    restart(app, :development)
-  end
-
-  def setup_envs(app, environment)
-    environments = environment == :all ? [:development, :staging, :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_app(environment)[app.dir_name]
-      has_workers = File.directory?("#{app.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, app, vars)
-    end
-  end
-
-  def setup_pow(app)
-    Run.pow_create(app, app.root_domain)
-    Run.pow_create(app, Fanforce.default_short_domain)
-  end
-
-  def setup_local_git(app)
-    if Run.git_init.include?('Reinitialized')
-      puts "#{'Found '.format(:green,:bold)}" + 'local repository'
-    else
-      puts "#{'Initialized '.format(:green,:bold)}" + 'local repository'
-      Run.git_add
-      Run.git_first_commit
-      puts "#{'Created     '.format(:green,:bold)}" + 'initial fanforce commit'
-    end
-  end
-
-  def setup_bitbucket(app)
-    bitbucket = BitBucket.new(login: $Config[:bitbucket][:user], password: $Config[:bitbucket][:password])
-    begin
-      find_bitbucket_repo(bitbucket, app.dir_name)
-      "#{'Found   '.format(:green,:bold)}" + "#{app.dir_name} repository already exists on bitbucket"
-    rescue
-      create_bitbucket_repo(bitbucket, app.dir_name)
-      puts "#{'Created '.format(:green,:bold)}" + "#{app.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]}`
-    elsif (`git remote`).split(/\r?\n/).include?('bitbucket')
-      `git remote rm bitbucket`
-      puts "#{'Removed '.format(:red,:bold)}" + "git remote for #{$Config[:bitbucket][:user]}"
-      puts "#{'Created '.format(:green,:bold)}" + "git remote for bitbucket"
-    else
-      puts "#{'Created '.format(:green,:bold)}" + "git remote for bitbucket"
-    end
-    `git remote add bitbucket git@bitbucket.org:#{$Config[:bitbucket][:user]}/#{app.dir_name}.git`
-
-    puts "#{'Pushing '.format(:green,:bold)}" + "latest commit to #{$Config[:bitbucket][:user]}..."
-    Run.command("git push bitbucket --all")
-  end
-
-  def find_bitbucket_repo(bitbucket, repo)
-    bitbucket.repos.find($Config[:bitbucket][:user], repo)
-  end
-
-  def create_bitbucket_repo(bitbucket, repo)
-    bitbucket.repos.create(name: repo, is_private: true)
-  rescue BitBucket::Error::Unauthorized => e
-    raise "Bitbucket user #{$Config[:bitbucket][:user]} does not seem to exist: #{e.message}"
-    raise
-  end
-
-  def auth_heroku(environment)
-    @heroku ||= {}
-    @heroku[environment] ||= Heroku::API.new(:username => $Config[:heroku][environment][:user], :password => $Config[:heroku][environment][:password])
-  rescue Exception => e
-    raise "Heroku user #{$Config[:heroku][environment][:user]} does not seem to exist: #{e.message}" if e.response.status == 404
-    raise
-  end
-
-  def setup_heroku(app, 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(app, 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_app(environment)[app.dir_name]
-    heroku.put_config_vars(heroku_app_name, vars) if vars
-
-    # Setup standard app domain
-    domain = "#{app._id}.#{Fanforce::DomainEnvironments.method(environment).call[:apps_base]}"
-    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
-
-    # Setup default short domain
-    domain = "#{app._id}.#{Fanforce::DomainEnvironments.method(environment).call[:default_short_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
-
-    remote_name = "#{env(environment)}-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, app, vars, create_worker_env=true)
-    vars.each {|k,v| puts "  - #{k}" }
-    workers_dir = "#{app.dir}/workers"
-    workers_env_dir = "#{workers_dir}/.env"
-    if create_worker_env and File.directory?(workers_dir) and vars['IRON_PROJECT_ID']
-      FileUtils.mkdir_p(workers_env_dir) unless File.directory?(workers_env_dir)
-      File.open("#{workers_env_dir}/#{environment}.rb", 'w') {|f| f.write convert_hash_to_ruby_env(vars) }
-    end
-    if environment == :development
-      app.update_file(:powenv)
-      File.open("#{app.dir}/.appenv", 'w') {|f| f.write convert_hash_to_shell_env(vars) }
-    else
-      return if $Config[:heroku][environment].blank?
-      heroku = auth_heroku(environment)
-      heroku_app_name = get_heroku_app_name(app, environment)
-      heroku.put_config_vars(heroku_app_name, vars)
-    end
-    restart(app, 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/cli/env.rb

@@ -1,41 +0,0 @@
-class Fanforce::CLI::Env
-  require 'singleton'
-  require 'forwardable'
-  include Singleton
-
-  def load_vars_by_app(environment)
-    vars = {}
-    Fanforce::CLI::Apps.dir_names.each do |dir_name|
-      vars[dir_name] ||= {}
-      vars[dir_name]['FANFORCE_APP_ID'] = Fanforce::CLI::App.parse_dir_name(dir_name)[:_id]
-    end
-
-    raw_yaml = File.read("#{$HomeDir}/.env/_bind.yml")
-    bindings = (raw_yaml.present?) ? YAML.load(raw_yaml) : {}
-    bindings.each do |filename, dir_names|
-      file = YAML.load_file("#{$HomeDir}/.env/#{filename}.yml").symbolize_keys
-      next if file[environment].blank?
-
-      dir_names = Fanforce::CLI::Apps.dir_names if dir_names.is_a?(String) and dir_names.upcase == 'ALL'
-      file[environment].each do |k,v|
-        dir_names.each do |dir_name|
-          vars[dir_name] ||= {}
-          vars[dir_name]["#{filename}_#{k}".upcase] = v
-        end
-      end
-    end
-
-    return vars
-  end
-
-  def vars_by_app(environment)
-    @vars ||= {}
-    @vars[environment] ||= load_vars_by_app(environment)
-  end
-
-  class << self
-    extend Forwardable
-    def_delegators :instance, *Fanforce::CLI::Env.instance_methods(false)
-  end
-
-end

data/lib/fanforce/cli/files.rb

@@ -1,290 +0,0 @@
-class Fanforce::CLI::Files
-
-# CONFIG.RU #######################################################################
-
-  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
-
-  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
-
-  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
-
-  def self.config_ru_required_lines
-    [
-        "require 'bundler'; Bundler.setup",
-        "require 'fanforce/app_factory'"
-    ]
-  end
-
-  # RAKEFILE #######################################################################
-
-  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
-
-  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
-
-  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
-
-  def self.rakefile_required_lines
-    [
-        "require 'bundler'; Bundler.setup",
-        "require 'fanforce/app_factory'"
-    ]
-  end
-
-  ########################################################################
-
-  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
-
-  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
-
-  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
-
-  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
-
-  def self.fanforce_config_lines(app_id)
-    lines = {}
-    return lines
-  end
-
-  def self.fanforce_config_keys_to_require
-    []
-  end
-
-  def self.fanforce_config_keys_to_overwrite
-    keys = []
-    return keys
-  end
-
-  # GEMFILE #######################################################################
-
-  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
-
-  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
-
-  def self.gemfile_source_lines
-    [
-      "source 'https://rubygems.org'",
-    ]
-  end
-
-  def self.gemfile_ruby_version
-    "ruby '1.9.3'"
-  end
-
-  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
-
-  # .GITIGNORE #######################################################################
-
-  def self.create_gitignore(app)
-    file = gitignore_lines.join("\n") + "\n"
-    File.open("#{app.dir}/.gitignore", 'w') {|f| f.write file }
-  end
-
-  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
-
-  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 #######################################################################
-
-  def self.create_powenv(app)
-    file = powenv_lines.join("\n") + "\n"
-    File.open("#{app.dir}/.powenv", 'w') {|f| f.write file }
-  end
-
-  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
-
-  def self.powenv_lines
-    ['source .appenv']
-  end
-
-end