fanforce-app-factory 2.0.0.rc5 → 2.0.0.rc7

data/lib/fanforce/app_factory/cli/git.rb

@@ -0,0 +1,58 @@
+class Fanforce::AppFactory::CLI::Git
+  include Fanforce::AppFactory::CLI::Utils
+
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def setup
+    if init.include?('Reinitialized')
+      puts "#{'Found '.format(:green,:bold)}" + 'existing local repository'
+    else
+      puts "#{'Initialized '.format(:green,:bold)}" + 'local repository'
+      add_files          and log '- git add .'
+      make_first_commit  and log '- git commit -m "initial fanforce commit"'
+      puts "#{'Created '.format(:green,:bold)}" + 'initial fanforce commit'
+    end
+  end
+
+  def self.status_table_header(app_column_width)
+    sprintf('%-12s %-50s %85s', 'GIT STATUS', 'APP NAME', 'STATS OVERVIEW').format(:bold)
+  end
+
+  def status_row(app_column_width)
+    sprintf("%s%-12s#{fmt_end} %-50s %28s %28s %28s",
+            fmt_start(is_committed ? :green : :red),
+            (is_committed ? 'Committed' : 'Uncommitted'),
+            app.name,
+            *changed_stats
+    )
+  end
+
+  def is_committed
+    `git status`.include?('nothing to commit') ? true : false
+  end
+
+  def changed_stats
+    `git diff --stat`.split("\n").last.split(', ')
+  end
+
+  private
+
+  def init
+    response = `git init`
+    `git config core.fileMode false`
+    return response
+  end
+
+  def add_files
+    `git add .`
+  end
+
+  def make_first_commit
+    `git commit -m "initial fanforce commit"`
+  end
+
+end

data/lib/fanforce/app_factory/cli/iron.rb

@@ -0,0 +1,61 @@
+class Fanforce::AppFactory::CLI::Iron
+  include Fanforce::AppFactory::CLI::Utils
+
+  require_gem 'iron_worker_ng', 'iron_worker_ng'
+
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def upload(environment)
+    if !File.directory?("#{app.dir}/workers")
+      return log "#{'Skipped '.format(:bold)} no workers folder was found"
+    end
+
+    env = Fanforce::AppFactory::CLI::Env.new(app)
+    vars = env.app_vars(environment) || {}
+
+    return puts "#{'Skipped '.format(:bold)} #{environment.to_s.titleize} is missing IRON_TOKEN and/or IRON_PROJECT_ID env variables" if vars['IRON_TOKEN'].blank? or vars['IRON_PROJECT_ID'].blank?
+
+    puts "#{'Updating Env'.format(:green,:bold)} #{environment.to_s.titleize}... and workers have #{vars.size} env variables"
+    env.push_env_to(environment, vars, true)
+
+    iron_worker = IronWorkerNG::Client.new(:token => vars['IRON_TOKEN'], :project_id => vars['IRON_PROJECT_ID'])
+    Dir.chdir("#{app.dir}/workers") do
+      workers = Dir['*.worker']
+      return puts "#{'Skipped  '.format(:bold)} #{environment.to_s.titleize} has 0 workers" if workers.size == 0
+
+      upload_processes = []
+      FileUtils.cp("#{app.dir}/workers/.env/#{environment}.rb", "#{app.dir}/workers/.env/.#{environment}env.rb")
+      workers.each do |filename|
+        code_name = filename.gsub('.worker', '')
+
+        puts "#{'Uploading'.format(:green,:bold)} #{filename.gsub('.worker', '')} to #{environment.to_s.titleize}..."
+        code = IronWorkerNG::Code::Base.new(:workerfile => "#{app.dir}/workers/#{filename}")
+        code.remote
+        code.name = code_name
+        code.file("#{app.dir}/workers/.env/.#{environment}env.rb")
+
+        upload_processes << upload_iron_worker(iron_worker, code, filename, environment)
+      end
+      upload_processes.each { |pid| Process.waitpid(pid) }
+      FileUtils.remove_file("#{app.dir}/workers/.env/.#{environment}env.rb")
+    end
+  end
+
+  def upload_iron_worker(iron_worker, code, filename, environment)
+    fork do
+      begin
+        iron_worker.codes.create(code, max_concurrency: 5)
+      rescue Exception => e
+        puts "#{'Aborted  '.format(:red,:bold)} upload of #{filename.gsub('.worker', '')} to #{environment.to_s.titleize}..."
+        puts e.message
+        puts e.backtrace
+        puts ''
+      end
+    end
+  end
+
+end

data/lib/fanforce/app_factory/cli/pow.rb

@@ -0,0 +1,46 @@
+class Fanforce::AppFactory::CLI::Pow
+  include Fanforce::AppFactory::CLI::Utils
+
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def setup
+    create_domain(app.root_domain)
+    create_domain(Fanforce.default_short_domain)
+  end
+
+  def destroy
+    destroy_domain(app.root_domain)
+    destroy_domain(Fanforce.default_short_domain)
+  end
+
+  def remove_domain_extension(domain)
+    domain.gsub(/\.[a-z]+$/, '')
+  end
+
+  def create_domain(root_domain)
+    domain = "#{app._id}.#{root_domain.gsub(/\.([a-z]+)$/, '')}"
+    domain_extension = $1
+    symlink = "#{ENV['HOME']}/.pow/#{domain}"
+
+    File.delete(symlink) if File.exists?(symlink) or File.symlink?(symlink)
+    `ln -s #{app.dir} #{symlink}`
+    puts "#{'Connected'.format(:bold,:green)} #{domain}.#{domain_extension} to #{app.dir}/"
+  end
+
+  def destroy_domain(root_domain)
+    domain = "#{app._id}.#{root_domain.gsub(/\.([a-z]+)$/, '')}"
+    domain_extension = $1
+    symlink = "#{ENV['HOME']}/.pow/#{domain}"
+    if File.exists?(symlink)
+      File.delete(symlink)
+      puts "#{'Removed'.format(:bold,:green)} #{domain}.#{domain_extension}"
+    else
+      puts "#{'Already Removed'.format(:bold,:green)} #{domain}.#{domain_extension} to #{app.dir}/"
+    end
+  end
+
+end

data/lib/fanforce/app_factory/cli/scaffolding.rb

@@ -0,0 +1,74 @@
+class Fanforce::AppFactory::CLI::Scaffolding
+  include Fanforce::AppFactory::CLI::Utils
+
+  require_relative 'scaffolding_file'
+
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+    error 'Your .fanforce-app-factory file must specify a default fanforce_version_dependency' if !config[:fanforce_version_dependency]
+  end
+
+  def setup
+    if File.directory?("#{app.dir}/tmp")
+      log "#{'Found  '.format(:green,:bold)} #{app.dir}/tmp/"
+    else
+      Dir.mkdir("#{app.dir}/tmp")
+      log "#{'Created'.format(:green,:bold)} #{app.dir}/tmp/"
+    end
+    files.each {|file| file.create }
+  end
+
+  def update
+    files_updated = false
+    files.each {|file| files_updated = true if file.update }
+    return files_updated
+  end
+
+  def metadata
+    # status = :exists, :current, :missing, :previous, :diverged, :forked
+    change_data = {}
+    files.each do |file|
+      next change_data[file.filepath] = {
+          status: File.directory?(file.filepath) ? :exists : :missing,
+      } if File.directory?(file.scaffold_filepath)
+
+      status = file.status
+      diff = file.diff_changes if [:previous,:diverged].include?(status)
+      insertions = 0
+      deletions = 0
+      diff.lines do |line|
+        next deletions += 1 if line[0] == '-'
+        next insertions += 1 if line[0] == '+'
+      end if diff
+
+      change_data[file.filepath] = {
+          status: status,
+          diff: diff,
+          insertions: insertions,
+          deletions: deletions
+      }
+    end
+    return change_data
+  end
+
+  ######################################################################################################################
+
+  def files
+    Dir.glob("#{self.class.dir}/**/*", File::FNM_DOTMATCH).inject([]) do |files, scaffold_filepath|
+      next files if scaffold_filepath =~ /\.registry$/
+      next files if scaffold_filepath =~ /\/\.\.?$/
+      scaffold_filepath = "#{scaffold_filepath}/" if File.directory?(scaffold_filepath) and scaffold_filepath !~ /\/$/
+      files << Fanforce::AppFactory::CLI::ScaffoldingFile.new(scaffold_filepath, app)
+    end
+  end
+
+  ######################################################################################################################
+
+  def self.dir
+    File.expand_path('scaffolding', Fanforce::AppFactory.base_dir)
+  end
+
+end
+

data/lib/fanforce/app_factory/cli/scaffolding_file.rb

@@ -0,0 +1,510 @@
+class Fanforce::AppFactory::CLI::ScaffoldingFile
+  include Fanforce::AppFactory::CLI::Utils
+
+  require 'digest'
+  require 'multi_json'
+  require_gem 'diffy', 'diffy'
+
+  attr_reader :scaffold_filepath, :app
+
+  def initialize(scaffold_filepath, app=nil)
+    @scaffold_filepath = scaffold_filepath
+    @app = app
+    if app
+      @filepath = "#{app.dir}/" + scaffold_filepath.gsub("#{Fanforce::AppFactory::CLI::Scaffolding.dir}/", '')
+      @relativepath = extract_relativepath(@filepath)
+    end
+  end
+
+  def create
+    if File.directory?(scaffold_filepath)
+      mkdir
+      return nil
+    end
+
+    return update if File.exists?(filepath)
+
+    contents = File.open(scaffold_filepath).read
+    File.open(filepath, 'w') {|f| f.write(cleanse_content(contents)) }
+    log "#{'Created'.format(:green,:bold)} #{relativepath}"
+    return true
+  end
+
+  def update
+    if File.directory?(scaffold_filepath)
+      mkdir
+      return nil
+    end
+
+    is_missing = is_missing?
+    if !is_missing
+      return if is_corrupted?
+      return if is_forked?
+      return if is_current_version?
+    end
+
+    content = updated_content
+    File.open(filepath, 'w') {|f| f.write(content) }
+
+    log "#{(is_missing ? 'Created' : 'Updated').format(:green,:bold)} #{relativepath}"
+    return true
+  end
+
+  def status
+    return @status unless @status.nil?
+    if is_missing?
+      @status = :missing
+    elsif is_corrupted?
+      @status = :corrupted
+    elsif is_forked?
+      @status = :forked
+    elsif is_previous_version?
+      @status = :previous
+    elsif is_diverged?
+      @status = :diverged
+    elsif is_current_version?
+      @status = :current
+    else
+      error "Unknown status for #{relativepath}"
+    end
+  end
+
+  def diff_changes
+    return nil if scaffold_filepath =~ /\/Routes\.rb$/
+    return nil if is_missing?
+    return nil if is_image_file?
+
+    original_contents = File.open(filepath).read
+    Diffy::Diff.new(original_contents, updated_content).to_s(:text)
+  end
+
+  ######################################################################################################################
+
+  def mkdir
+    Dir.mkdir(filepath) if !File.directory?(filepath)
+  end
+
+  def extension
+    @extension ||= scaffold_filepath.match(/([^\/\.]+)$/)[1].to_s.downcase
+  end
+
+  def extension_type
+    @extension_type ||= extension.downcase.to_sym
+  end
+
+  ######################################################################################################################
+
+  def scaffold_type(filepath=scaffold_filepath)
+    # :file, :image, :partial, :items, :json, :skipped
+    @scaffold_types ||= {}
+    return @scaffold_types[filepath] unless @scaffold_types[filepath].nil?
+    return if !File.exists?(filepath)
+
+    if is_image_file?
+      type = :image
+    elsif filepath =~ /\/.+\.json$/
+      type = :json
+    else
+      first_line = File.open(filepath).read.split("\n").first
+      if first_line
+        matches = first_line.match(/\s*\S+\s*AppFactoryScaffolding\s*:\s*(FILE|PARTIAL|ITEMS|SKIPPED)/)
+        type = matches[1].downcase.to_sym if matches and matches[1]
+      end
+    end
+    raise "scaffold_type could not be read from file: #{filepath}" if !type
+    raise "scaffold_type (#{type}) is unknown: #{lines.first}" if ![:file, :image, :partial, :items, :json, :skipped].include?(type)
+    @scaffold_types[filepath] = type
+  end
+
+  ######################################################################################################################
+
+  def is_missing?
+    return @is_missing unless @is_missing.nil?
+    @is_missing = !File.exists?(filepath)
+  end
+
+  def is_corrupted?
+    return @is_corrupted unless @is_corrupted.nil?
+    scaffold_type = scaffold_type(filepath)
+    if !scaffold_type
+      error "The first line of #{relativepath} should specify an AppFactoryScaffolding type"
+    elsif scaffold_type == :json
+      begin MultiJson.load(File.open(filepath).read)
+      rescue Exception => e; error "Corrupted #{relativepath}: #{e.message}"; end
+    elsif scaffold_type == :partial
+      File.open(filepath).read.match(/^\s*\S+\s*END PARTIAL/)
+    end
+    @is_corrupted = false
+  end
+
+  def is_previous_version?
+    return @is_previous_version unless @is_previous_version.nil?
+    return @is_previous_version = false if is_current_version?
+
+    # :file, :image, :partial, :items, :json, :skipped
+    if [:file,:image,:partial].include?(scaffold_type)
+      @is_previous_version = digest_exists_in_registry?(current_digest)
+    elsif [:items].include?(scaffold_type)
+      list_exists_in_registry?(File.open(filepath).read)
+    elsif [:json].include?(scaffold_type)
+      json_exists_in_registry?(File.open(filepath).read)
+    elsif [:skipped].include?(scaffold_type)
+      return @is_previous_version = false
+    else
+      raise 'unknown scaffold_type'
+    end
+  end
+
+  def is_forkable?
+    return @is_forkable unless @is_forkable.nil?
+    @is_forkable = !(scaffold_filepath =~ /\/(Routes\.rb|config\.json|.gitignore)$/)
+  end
+
+  def is_image_file?
+    return @is_image_file unless @is_image_file.nil?
+    @is_image_file = scaffold_filepath =~ /\.(png|jpg|gif|ico)$/
+  end
+
+  def is_forked?
+    return @is_forked unless @is_forked.nil?
+    return @is_forked = true if is_image_file? and !is_current_version? and !is_previous_version?
+    return @is_forked = false if !is_forkable?
+    @is_forked = File.open(filepath, &:readline).include?('FORKED')
+  end
+
+  def is_diverged?
+    return @is_diverged unless @is_diverged.nil?
+    @is_diverged = !is_current_version?
+  end
+
+  def is_current_version?
+    return @is_current unless @is_current.nil?
+
+    # :file, :image, :partial, :items, :json, :skipped
+    if [:file,:image].include?(scaffold_type)
+      @is_current = (current_digest == scaffold_digest)
+    elsif [:partial].include?(scaffold_type)
+      @is_current = (current_digest == updated_digest)
+    elsif [:items].include?(scaffold_type)
+      @is_current = list_matches_latest_registry?(File.open(filepath).read)
+    elsif [:json].include?(scaffold_type)
+      @is_current = json_matches_latest_registry?(File.open(filepath).read)
+    elsif [:skipped].include?(scaffold_type)
+      @is_current = true
+    else
+      raise 'unknown scaffold_type'
+    end
+  end
+
+  ######################################################################################################################
+
+  def registry_filepath
+    scaffold_fileparts = scaffold_filepath.split('/')
+    "#{scaffold_fileparts[0...-1].join('/')}/._#{scaffold_fileparts[-1]}.registry"
+  end
+
+  def digest_exists_in_registry?(digest)
+    return false if !File.exists?(registry_filepath)
+
+    File.open(registry_filepath, 'r').each do |line|
+      version, previous_digest = line.strip.split(/:\s?/)
+      return true if digest == previous_digest
+    end
+    return false
+  end
+
+  def list_registry_rules(&block)
+    return @list_registry_rules unless @list_registry_rules.nil? or block
+    rules = {ADD: [], REM: [], OPT: []}
+    File.open(registry_filepath).each_line do |line|
+      rule_changes = MultiJson.load(line.split(':', 2)[1], symbolize_keys: true)
+
+      rule_changes[:ADD].each do |item|
+        item = item.strip
+        rules[:ADD] << item unless rules[:ADD].include?(item)
+        rules[:REM].delete(item)
+        rules[:OPT].delete(item)
+      end if rule_changes[:ADD]
+
+      rule_changes[:REM].each do |item|
+        item = item.strip
+        rules[:ADD].delete(item)
+        rules[:REM] << item unless rules[:REM].include?(item)
+        rules[:OPT].delete(item)
+      end if rule_changes[:REM]
+
+      rule_changes[:OPT].each do |item|
+        item = item.strip
+        rules[:ADD].delete(item)
+        rules[:REM].delete(item)
+        rules[:OPT] << item unless rules[:OPT].include?(item)
+      end if rule_changes[:OPT]
+
+      block.call(rules) if block
+    end
+    @list_registry_rules = rules
+  end
+
+  def list_matches_latest_registry?(contents)
+    raise if scaffold_type != :items
+    list = []
+    contents = contents.is_a?(Array) ? contents : contents.split("\n")
+    contents.each do |line|
+      line = line.strip
+      list << line if line.present? and line !~ /^\s*#/
+    end
+    list_registry_rules[:ADD].each do |item|
+      return false if !list.include?(item)
+    end
+    list_registry_rules[:REM].each do |item|
+      return false if list.include?(item)
+    end
+    return true
+  end
+
+  def list_exists_in_registry?(contents)
+    raise if scaffold_type != :items
+    list = []
+    contents = contents.is_a?(Array) ? contents : contents.split("\n")
+    contents.each do |line|
+      line = line.strip
+      list << line if line.present? and line !~ /^\s*#/
+    end
+    list_registry_rules do |rules|
+      rules[:ADD].each do |item|
+        next if !list.include?(item)
+      end
+      rules[:REM].each do |item|
+        next if list.include?(item)
+      end
+      return true
+    end
+    return false
+  end
+
+  def json_registry_rules(&block)
+    return @json_registry_rules unless @json_registry_rules.nil? or block
+    rules = {ADD: {}, REM: {}, OPT: {}}
+    File.open(registry_filepath).each_line do |line|
+      rule_changes = MultiJson.load(line.split(':', 2)[1], symbolize_keys: true)
+      update_json_registry_rules(:ADD, rule_changes[:ADD], rules, '.') if rule_changes[:ADD]
+      update_json_registry_rules(:REM, rule_changes[:REM], rules, '.') if rule_changes[:REM]
+      update_json_registry_rules(:OPT, rule_changes[:OPT], rules, '.') if rule_changes[:OPT]
+      block.call(rules) if block
+    end
+    @json_registry_rules = rules
+  end
+
+  def update_json_registry_rules(type, rule_changes, rules, key_path)
+    rule_changes.each do |rule_key, rule_value|
+      next update_json_registry_rules(type, rule_value, rules, "#{key_path}.#{rule_key}") if rule_value.is_a?(Hash)
+      if type == :ADD
+        json_rule(rules, :ADD, key_path, true)[rule_key] = rule_value
+        (rule = json_rule rules, :REM, key_path) && rule.delete(rule_key)
+        (rule = json_rule rules, :OPT, key_path) && rule.delete(rule_key)
+      elsif type == :REM
+        (rule = json_rule rules, :ADD, key_path) && rule.delete(rule_key)
+        json_rule(rules, :REM, key_path, true)[rule_key] = rule_value
+        (rule = json_rule rules, :OPT, key_path) && rule.delete(rule_key)
+      elsif type == :OPT
+        (rule = json_rule rules, :ADD, key_path) && rule.delete(rule_key)
+        (rule = json_rule rules, :REM, key_path) && rule.delete(rule_key)
+        json_rule(rules, :OPT, key_path, true)[rule_key] = rule_value
+      end
+    end
+  end
+
+  def json_rule(rules, type, key_path, create_hash_if_nil=false)
+    rule = rules[type]
+    key_path.gsub(/\.\./, '.').split('.').each do |key|
+      next if key.blank?
+      rule[key.to_sym] ||= {} if create_hash_if_nil
+      rule = rule[key.to_sym]
+    end
+    rule
+  end
+
+  def json_matches_latest_registry?(json)
+    hash = MultiJson.load(json, symbolize_keys: true)
+    subtract_hash_from_hash!(json_registry_rules[:OPT], hash)
+    return false if !hash_keys_match_hash_keys(json_registry_rules[:ADD], hash)
+    return false if hash_keys_overlap_hash_keys(json_registry_rules[:REM], hash)
+    return true
+  end
+
+  def json_exists_in_registry?(json)
+    original_hash = MultiJson.load(json, symbolize_keys: true)
+    json_registry_rules do |rules|
+      hash = original_hash.clone
+      subtract_hash_from_hash!(rules[:OPT], hash)
+      next if !hash_keys_match_hash_keys(rules[:ADD], hash)
+      next if hash_keys_overlap_hash_keys(rules[:REM], hash)
+      return true
+    end
+    return false
+  end
+
+  def subtract_hash_from_hash!(hash_to_subtract, hash_to_retain)
+    hash_to_subtract.each do |k,v|
+      next subtract_hash_from_hash!(v, hash_to_retain[k]) if v.is_a?(Hash) and hash_to_retain[k].is_a?(Hash)
+      hash_to_retain.delete(k) if hash_to_retain.is_a?(Hash)
+    end
+  end
+
+  def hash_keys_match_hash_keys(hash1, hash2)
+    hash1.each do |k,v|
+      return false if !hash_keys_match_hash_keys(v, hash2[k]) if v.is_a?(Hash) and hash2[k].is_a?(Hash)
+      return false if v.is_a?(Hash) and !hash2[k].is_a?(Hash)
+      return false if !hash2.has_key?(k)
+    end
+    return true
+  end
+
+  def hash_keys_overlap_hash_keys(hash1, hash2)
+    hash1.each do |k,v|
+      return true if hash_keys_overlap_hash_keys(v, hash2[k]) if v.is_a?(Hash) and hash2[k].is_a?(Hash)
+      return true if hash2.has_key?(k)
+    end
+    return false
+  end
+
+  def current_digest
+    return @current_digest unless @current_digest.nil?
+    if [:image,:file,:partial].include?(scaffold_type)
+      @current_digest = Digest::SHA1.file(filepath).hexdigest.strip
+    else
+      raise "There is no digest scaffold type: #{scaffold_type}"
+    end
+  end
+
+  def scaffold_digest
+    return @scaffold_digest unless @scaffold_digest.nil?
+    if [:image,:file].include?(scaffold_type)
+      @scaffold_digest = Digest::SHA1.file(scaffold_filepath).hexdigest.strip
+    elsif [:partial].include?(scaffold_type)
+      @scaffold_digest = Digest::SHA1.hexdigest(extract_partial(File.open(scaffold_filepath).read, scaffold_filepath)).strip
+    elsif [:items].include?(scaffold_type)
+      @scaffold_digest = Digest::SHA1.hexdigest(extract_items_from_scaffold).strip
+    else
+      raise "There is no digest scaffold type: #{scaffold_type}"
+    end
+  end
+
+  def updated_digest
+    return @updated_digest unless @updated_digest.nil?
+    @updated_digest = Digest::SHA1.hexdigest(updated_content).strip
+  end
+
+  def app_factory_line_for_gemfile
+    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
+
+  ######################################################################################################################
+
+  def extract_partial(content, filepath)
+    raise if scaffold_type != :partial
+    partial = ''
+    found_end = false
+    content.lines.each do |line|
+      break found_end = true if is_line_ending_partial?(line)
+      partial += line
+    end
+    raise "END PARTIAL could not be found for #{extract_relativepath(filepath)}" if !found_end
+    return partial
+  end
+
+  def extract_post_partial(content, filepath)
+    raise if scaffold_type != :partial
+    post_partial = ''
+    found_end = false
+    content.lines.each do |line|
+      found_end ||= is_line_ending_partial?(line) || next
+      post_partial += line
+    end
+    error "END PARTIAL could not be found for #{extract_relativepath(filepath)}" if !found_end
+    return post_partial
+  end
+
+  def is_line_ending_partial?(line)
+    return true if extension_type == :haml and line =~ /^\s*-#\s*END PARTIAL/
+    return true if [:css,:scss,:js].include?(extension_type) and line =~ /^\s*\/\/\s*END PARTIAL/
+    return true if [:gemfile,:rb,:gitignore,:ru,:rakefile,:coffee,:txt].include?(extension_type) and line =~ /^\s*#\s*END PARTIAL/
+  end
+
+  def updated_content
+    if is_missing? or [:file,:image].include?(scaffold_type)
+      File.open(scaffold_filepath).read
+    elsif [:partial].include?(scaffold_type)
+      scaffold_partial = extract_partial(File.open(scaffold_filepath).read, scaffold_filepath)
+      current_post_partial = extract_post_partial(File.open(filepath).read, filepath)
+      cleanse_content(scaffold_partial + current_post_partial)
+    elsif [:items].include?(scaffold_type)
+      content = ''
+      items_to_add = list_registry_rules[:ADD].clone
+      items_to_rem = list_registry_rules[:REM].clone
+      File.open(filepath).read.lines do |line|
+        item = line.strip
+        content += line if !items_to_rem.include?(item)
+        items_to_add.delete(item)
+      end
+      content += "\n" if content !~ /\n$/
+      items_to_add.each do |item|
+        content += "#{item}\n"
+      end
+      cleanse_content(content)
+    elsif [:json].include?(scaffold_type)
+      hash = MultiJson.load(File.open(filepath).read, symbolize_keys: true)
+      json_registry_rules[:ADD].each {|k,v| hash[k] = v if !hash.has_key?(k) }
+      json_registry_rules[:REM].each {|k,v| hash.delete(k) }
+      cleanse_content(hash)
+    end
+  end
+
+  ######################################################################################################################
+
+  def cleanse_content(contents)
+    if scaffold_filepath =~ /\/config\.json$/
+      cleanup_config_json(contents)
+    elsif scaffold_filepath =~ /\/Gemfile$/
+      cleanup_gemfile(contents)
+    else
+      contents
+    end
+  end
+
+  def cleanup_config_json(contents)
+    hash = contents.is_a?(Hash) ? contents : MultiJson.load(contents, symbolize_keys: true)
+    hash[:_id] ||= app._id
+    hash[:name] ||= app._id.titleize
+    hash[:description] ||= 'This is where you put a short app description.'
+    hash[:fanforce_version_dependency] = config[:fanforce_version_dependency]
+    hash[:created_with_app_factory_version] = Fanforce::AppFactory::VERSION
+    cleaned = JSON.pretty_generate(hash)
+    return cleaned
+  end
+
+  def cleanup_gemfile(contents)
+    contents.gsub('gem FANFORCE-APP-FACTORY', app_factory_line_for_gemfile)
+  end
+
+  ######################################################################################################################
+
+  def filepath
+    @filepath || (raise 'app is not set' if !app)
+  end
+
+  def relativepath
+    @relativepath || (raise 'app is not set' if !app)
+  end
+
+  def extract_relativepath(filepath)
+    filepath.gsub(Fanforce::CLI::DIR, '')
+  end
+
+end