You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: export_config.rb
    path of file: ./repos/texterify/app/models
    
    the code of the file until where you have to start completion: require 'poparser'

class AndroidTemplateData
  attr_accessor :data

  def initialize(data)
    @data = data
  end

  # Expose private binding() method.
  # rubocop:disable Naming/AccessorMethodName
  def get_binding
    binding
  end
  # rubocop:enable Naming/AccessorMethodName
end

class ExportConfig < ApplicationRecord
  scope :order_by_name, -> { order(arel_table['name'].lower.asc) }

  validates :name, presence: true
  validates :file_path, presence: true
  validate :no_duplicate_export_configs_for_project

  belongs_to :project
  belongs_to :flavor, optional: true
  belongs_to :file_format, optional: true

  has_many :post_processing_rules, dependent: :destroy
  has_many :language_configs, dependent: :destroy
  has_many :releases, dependent: :destroy

  def latest_release
    releases.order('version DESC').first
  end

  def name=(name)
    self[:name] = name.strip
  end

  def file_path=(file_path)
    self[:file_path] = file_path.strip
  end

  def filled_file_path(language, path_for: nil)
    path_to_use = self.file_path
    path_to_use_default_langage = self.default_language_file_path

    if path_for == 'stringsdict'
      if self.file_path_stringsdict
        path_to_use = self.file_path_stringsdict
      end

      if self.default_language_file_path_stringsdict
        path_to_use_default_langage = self.default_language_file_path_stringsdict
      end
    end

    path = path_to_use

    if language.is_default && path_to_use_default_langage.present?
      path = path_to_use_default_langage
    end

    language_config_code = language_configs.find_by(language_id: language.id)

    # Use the language code from the language config if available.
    if language_config_code
      path = path.sub('{languageCode}', language_config_code.language_code)
    elsif language.language_code
      path = path.sub('{languageCode}', language.language_code.code)
    else
      path
    end

    language.country_code ? path.sub('{countryCode}', language.country_code.code) : path
  end

  def files(
    language,
    export_data,
    language_source = nil,
    export_data_source = nil,
    skip_empty_plural_translations: false
  )
    if self.file_format.format == 'json'
      json(language, export_data, skip_empty_plural_translations: skip_empty_plural_translations)
    elsif self.file_format.format == 'json-formatjs'
      json_formatjs(language, export_data, skip_empty_plural_translations: skip_empty_plural_translations)
    elsif self.file_format.format == 'typescript'
      typescript(
        language,
        export_data
        # skip_empty_plural_translations: skip_empty_plural_translations
      )
    elsif self.file_format.format == 'android'
      android(language, export_data, skip_empty_plural_translations: skip_empty_plural_translations)
    elsif self.file_format.format == 'ios'
      ios(language, export_data, skip_e
    
  def ios(language, export_data, skip_empty_plural_translations: false)
    files = []

    plural_data = {}
    strings_file = Tempfile.new(language.id.to_s)
    export_data.each do |key, value|
      # Plural keys are handled differently in iOS via a .stringsdict file.
      if value[:pluralization_enabled]
        plural_data[key] = value
      else
        # Non-plural keys are exported as .strings file
        # Replace " with \" but don't escape \" again.
        escaped_value = value[:other].gsub(/(?<!\\)"/, '\\"')
        strings_file.puts("\"#{key}\" = \"#{escaped_value}\";")
      end
    end
    strings_file.close
    strings_file_path = self.filled_file_path(language)

    files << { path: strings_file_path, file: strings_file }

    # Handle plural keys if there are any available and create a .stringsdict file.
    if !plural_data.empty?
      stringsdict_file = Tempfile.new(language.id.to_s)
      builder =
        Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
          xml.doc.create_internal_subset(
            'plist',
            '-//Apple//DTD PLIST 1.0//EN',
            'http://www.apple.com/DTDs/PropertyList-1.0.dtd'
          )
          xml.plist version: '1.0' do
            xml.dict do
              plural_data.each do |key, value|
                xml.key { xml.text key }
                xml.dict do
                  xml.key { xml.text 'NSStringLocalizedFormatKey' }
                  xml.string { xml.text '%#@VARIABLE@' }
                  xml.key { xml.text 'VARIABLE' }
                  xml.dict do
                    xml.key { xml.text 'NSStringFormatSpecTypeKey' }
                    xml.string { xml.text 'NSStringPluralRuleType' }
                    xml.key { xml.text 'NSStringFormatValueTypeKey' }
                    xml.string { xml.text 'd' }

                    if !skip_empty_plural_translations || value[:zero].present?
                      xml.key { xml.text 'zero' }
                      xml.string { xml.text value[:zero] }
                    end

                    if !skip_empty_plural_translations || value[:one].present?
                      xml.key { xml.text 'one' }
                      xml.string { xml.text value[:one] }
                    end

                    if !skip_empty_plural_translations || value[:two].present?
                      xml.key { xml.text 'two' }
                      xml.string { xml.text value[:two] }
                    end

                    if !skip_empty_plural_translations || value[:few].present?
                      xml.key { xml.text 'few' }
                      xml.string { xml.text value[:few] }
                    end

                    if !skip_empty_plural_translations || value[:many].present?
                      xml.key { xml.text 'many' }
                      xml.string { xml.text value[:many] }
                    end

                    xml.key { xml.text 'other' }
                    xml.string { xml.text value[:other] }
                  end
                end