localio 0.1.6 → 0.2.0

data/spec/localio/processors/csv_processor_spec.rb

@@ -0,0 +1,89 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/csv_processor'
+
+RSpec.describe CsvProcessor do
+  let(:fixture_path) { File.expand_path('../../../fixtures/sample.csv', __FILE__) }
+  let(:platform_options) { {} }
+  let(:options) { { path: fixture_path } }
+
+  describe '.load_localizables' do
+    subject(:result) { CsvProcessor.load_localizables(platform_options, options) }
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language (marked with *)' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 8 terms between [key] and [end]' do
+      expect(result[:segments].count).to eq(8)
+    end
+
+    it 'parses term keywords correctly' do
+      keywords = result[:segments].map(&:keyword)
+      expect(keywords).to include('app_name', 'greeting', '[comment]', '[init-node]', '[end-node]')
+    end
+
+    it 'parses translations for each language' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+      expect(app_name.values['es']).to eq('Mi Aplicación')
+      expect(app_name.values['fr']).to eq('Mon Application')
+    end
+
+    it 'identifies comment rows' do
+      comment = result[:segments].find { |t| t.keyword == '[comment]' }
+      expect(comment.is_comment?).to be true
+    end
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { CsvProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'raises IndexError when [key] marker is missing' do
+      Dir.mktmpdir do |tmpdir|
+        path = File.join(tmpdir, 'bad.csv')
+        File.write(path, "no,key,row\ndata,here,\n[end],,,\n")
+        expect { CsvProcessor.load_localizables({}, { path: path }) }
+          .to raise_error(IndexError, /Could not find any \[key\]/)
+      end
+    end
+
+    it 'raises IndexError when [end] marker is missing' do
+      Dir.mktmpdir do |tmpdir|
+        path = File.join(tmpdir, 'bad.csv')
+        File.write(path, "title,,,\n[key],*en,es,\ndata,val,val,\n")
+        expect { CsvProcessor.load_localizables({}, { path: path }) }
+          .to raise_error(IndexError, /Could not find any \[end\]/)
+      end
+    end
+
+    context 'with override_default option' do
+      let(:platform_options) { { override_default: 'es' } }
+
+      it 'uses the overridden default language' do
+        expect(result[:default_language]).to eq('es')
+      end
+    end
+
+    context 'with avoid_lang_downcase option' do
+      let(:tmpdir) { Dir.mktmpdir }
+      let(:options) do
+        path = File.join(tmpdir, 'upper.csv')
+        File.write(path, "Title,,,\n[key],*EN,ES,FR\napp_name,My App,Mi App,Mon App\n[end],,,\n")
+        { path: path }
+      end
+      let(:platform_options) { { avoid_lang_downcase: true } }
+
+      after { FileUtils.rm_rf(tmpdir) }
+
+      it 'preserves language case' do
+        expect(result[:languages].keys).to contain_exactly('EN', 'ES', 'FR')
+      end
+    end
+  end
+end

data/spec/localio/processors/google_drive_processor_spec.rb

@@ -0,0 +1,107 @@
+# google_drive transitively loads nokogiri.  Nokogiri is now built for arm64
+# and loads correctly, so we no longer need to stub it out.  We only stub
+# google_drive itself (which requires OAuth flow and network access) by:
+#   1. Defining minimal stub modules for GoogleDrive before anything tries to
+#      reference them.
+#   2. Pre-populating $LOADED_FEATURES with the google_drive gem paths so that
+#      every subsequent `require 'google_drive'` is treated as already loaded.
+# All runtime calls are intercepted by RSpec doubles.
+
+module GoogleDrive
+  module Session
+    def self.from_config(_config, _opts = {}); end
+    def self.from_service_account_key(_path, _scope = nil); end
+  end
+end
+
+begin
+  _gd_spec  = Gem::Specification.find_by_name('google_drive')
+  _gd_base  = File.join(_gd_spec.gem_dir, 'lib')
+  Dir["#{_gd_base}/**/*.rb"].sort.each do |f|
+    $LOADED_FEATURES << f unless $LOADED_FEATURES.include?(f)
+  end
+  ["#{_gd_base}/google_drive.rb"].each do |f|
+    $LOADED_FEATURES << f unless $LOADED_FEATURES.include?(f)
+  end
+end
+
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/google_drive_processor'
+
+RSpec.describe GoogleDriveProcessor do
+  let(:ws_data) do
+    {
+      [1, 1] => '[key]',    [1, 2] => '*en',  [1, 3] => 'es',
+      [2, 1] => 'app_name', [2, 2] => 'My App', [2, 3] => 'Mi Aplicación',
+      [3, 1] => 'greeting', [3, 2] => 'Hello',  [3, 3] => 'Hola',
+      [4, 1] => '[end]',    [4, 2] => '',        [4, 3] => '',
+    }
+  end
+
+  let(:worksheet) do
+    ws = double('worksheet')
+    allow(ws).to receive(:[]) { |row, col| ws_data[[row, col]].to_s }
+    allow(ws).to receive(:max_rows).and_return(4)
+    allow(ws).to receive(:max_cols).and_return(3)
+    ws
+  end
+
+  let(:spreadsheet_double) { double('spreadsheet', title: 'My Translations') }
+  let(:session_double) { double('session') }
+
+  before do
+    allow(spreadsheet_double).to receive(:worksheets).and_return([worksheet])
+    allow(session_double).to receive(:spreadsheets).and_return([spreadsheet_double])
+
+    # Mock the google_drive 3.x session creation method used by the processor.
+    # from_config is used for the OAuth2 client_id/client_secret flow.
+    allow(GoogleDrive::Session).to receive(:from_config).and_return(session_double)
+
+    # Allow File.file? to return false for the :client_token option in OAuth tests
+    # so the processor takes the from_config path (not the service-account path).
+    allow(File).to receive(:file?).and_call_original
+    allow(File).to receive(:file?).with('token').and_return(false)
+  end
+
+  let(:options) do
+    { spreadsheet: 'My Translations', client_id: 'id', client_secret: 'secret', client_token: 'token', sheet: 0 }
+  end
+
+  describe '.load_localizables' do
+    subject(:result) { GoogleDriveProcessor.load_localizables({}, options) }
+
+    it 'raises when :spreadsheet is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { client_id: 'a', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:spreadsheet required/)
+    end
+
+    it 'raises when :login is provided (deprecated)' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', login: 'u', client_id: 'a', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:login is deprecated/)
+    end
+
+    it 'raises when :client_id is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', client_secret: 'b' }) }
+        .to raise_error(ArgumentError, /:client_id required/)
+    end
+
+    it 'raises when :client_secret is missing' do
+      expect { GoogleDriveProcessor.load_localizables({}, { spreadsheet: 'x', client_id: 'a' }) }
+        .to raise_error(ArgumentError, /:client_secret required/)
+    end
+
+    it 'returns languages en and es' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'parses translations' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+    end
+  end
+end

data/spec/localio/processors/xls_processor_spec.rb

@@ -0,0 +1,65 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/xls_processor'
+
+RSpec.describe XlsProcessor do
+  let(:data) do
+    {
+      [0, 0] => '[key]',    [0, 1] => '*en',  [0, 2] => 'es',             [0, 3] => 'fr',
+      [1, 0] => 'app_name', [1, 1] => 'My App', [1, 2] => 'Mi Aplicación', [1, 3] => 'Mon Application',
+      [2, 0] => 'greeting', [2, 1] => 'Hello',  [2, 2] => 'Hola',          [2, 3] => 'Bonjour',
+      [3, 0] => '[end]',    [3, 1] => '',       [3, 2] => '',              [3, 3] => '',
+    }
+  end
+
+  let(:worksheet) do
+    ws = double('worksheet')
+    allow(ws).to receive(:[]) { |row, col| data[[row, col]].to_s }
+    allow(ws).to receive(:row_count).and_return(3)
+    allow(ws).to receive(:column_count).and_return(3)
+    ws
+  end
+
+  let(:book_double) { double('book') }
+
+  before do
+    allow(Spreadsheet).to receive(:client_encoding=)
+    allow(Spreadsheet).to receive(:open).and_return(book_double)
+    allow(book_double).to receive(:worksheet).with(0).and_return(worksheet)
+  end
+
+  let(:options) { { path: 'fake.xls' } }
+  let(:platform_options) { {} }
+
+  describe '.load_localizables' do
+    subject(:result) { XlsProcessor.load_localizables(platform_options, options) }
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { XlsProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 2 terms' do
+      expect(result[:segments].count).to eq(2)
+    end
+
+    it 'parses translations correctly' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+    end
+
+    it 'raises when worksheet is nil' do
+      allow(book_double).to receive(:worksheet).and_return(nil)
+      expect { XlsProcessor.load_localizables({}, { path: 'fake.xls' }) }
+        .to raise_error(RuntimeError, /Unable to retrieve/)
+    end
+  end
+end

data/spec/localio/processors/xlsx_processor_spec.rb

@@ -0,0 +1,59 @@
+require 'localio/term'
+require 'localio/string_helper'
+require 'localio/processors/xlsx_processor'
+
+RSpec.describe XlsxProcessor do
+  let(:rows) do
+    [
+      ['Title', nil, nil, nil],
+      ['[key]', '*en', 'es', 'fr'],
+      ['[comment]', 'Section General', 'Section General', 'Section General'],
+      ['app_name', 'My App', 'Mi Aplicación', 'Mon Application'],
+      ['greeting', 'Hello', 'Hola', 'Bonjour'],
+      ['[end]', nil, nil, nil],
+    ]
+  end
+
+  let(:sheet_double) { double('sheet', rows: rows) }
+  let(:book_double) { double('book', sheets: [sheet_double]) }
+
+  before { allow(SimpleXlsxReader).to receive(:open).and_return(book_double) }
+
+  let(:options) { { path: 'fake.xlsx', sheet: 0 } }
+  let(:platform_options) { {} }
+
+  describe '.load_localizables' do
+    subject(:result) { XlsxProcessor.load_localizables(platform_options, options) }
+
+    it 'raises ArgumentError when :path is missing' do
+      expect { XlsxProcessor.load_localizables({}, {}) }
+        .to raise_error(ArgumentError, /:path attribute is missing/)
+    end
+
+    it 'returns languages en, es, fr' do
+      expect(result[:languages].keys).to contain_exactly('en', 'es', 'fr')
+    end
+
+    it 'sets en as default language' do
+      expect(result[:default_language]).to eq('en')
+    end
+
+    it 'returns 3 terms' do
+      expect(result[:segments].count).to eq(3)
+    end
+
+    it 'parses translations correctly' do
+      app_name = result[:segments].find { |t| t.keyword == 'app_name' }
+      expect(app_name.values['en']).to eq('My App')
+      expect(app_name.values['es']).to eq('Mi Aplicación')
+    end
+
+    it 'raises when sheet is nil' do
+      named_book = double('book', sheets: [])
+      allow(SimpleXlsxReader).to receive(:open).and_return(named_book)
+      allow(named_book).to receive(:sheets).and_return([])
+      expect { XlsxProcessor.load_localizables({}, { path: 'fake.xlsx', sheet: 'Missing' }) }
+        .to raise_error(RuntimeError, /Unable to retrieve/)
+    end
+  end
+end

data/spec/localio/segment_spec.rb

@@ -0,0 +1,27 @@
+require 'localio/string_helper'
+require 'localio/segment'
+
+RSpec.describe Segment do
+  subject(:segment) { Segment.new('app_name', 'My App', 'en') }
+
+  it 'stores key, translation, and language' do
+    expect(segment.key).to eq('app_name')
+    expect(segment.translation).to eq('My App')
+    expect(segment.language).to eq('en')
+  end
+
+  it 'processes translation through replace_escaped' do
+    seg = Segment.new('key', 'hello`+world', 'en')
+    expect(seg.translation).to eq('hello+world')
+  end
+
+  describe '#is_comment?' do
+    it 'returns true when key is nil' do
+      segment.key = nil
+      expect(segment.is_comment?).to be true
+    end
+    it 'returns false when key is set' do
+      expect(segment.is_comment?).to be false
+    end
+  end
+end

data/spec/localio/segments_list_holder_spec.rb

@@ -0,0 +1,22 @@
+require 'localio/segments_list_holder'
+
+RSpec.describe SegmentsListHolder do
+  subject(:holder) { SegmentsListHolder.new('en') }
+
+  it { expect(holder.language).to eq('en') }
+  it { expect(holder.segments).to be_empty }
+
+  describe '#get_binding' do
+    it 'returns a Binding' do
+      expect(holder.get_binding).to be_a(Binding)
+    end
+
+    it 'exposes @language in the binding' do
+      expect(eval('@language', holder.get_binding)).to eq('en')
+    end
+
+    it 'exposes @segments in the binding' do
+      expect(eval('@segments', holder.get_binding)).to eq([])
+    end
+  end
+end

data/spec/localio/string_helper_spec.rb

@@ -0,0 +1,49 @@
+require 'localio/string_helper'
+
+RSpec.describe String do
+  describe '#space_to_underscore' do
+    it { expect('hello world'.space_to_underscore).to eq('hello_world') }
+    it { expect('hello'.space_to_underscore).to eq('hello') }
+  end
+
+  describe '#strip_tag' do
+    it 'strips single-letter bracket tags from the start' do
+      expect('[a]hello'.strip_tag).to eq('hello')
+    end
+    it 'does not strip multi-letter bracket tags' do
+      expect('[comment]hello'.strip_tag).to eq('[comment]hello')
+    end
+    it 'does not strip tags not at the start' do
+      expect('hello[a]'.strip_tag).to eq('hello[a]')
+    end
+  end
+
+  describe '#camel_case' do
+    it { expect('hello_world'.camel_case).to eq('HelloWorld') }
+    it { expect('HelloWorld'.camel_case).to eq('HelloWorld') }
+  end
+
+  describe '#replace_escaped' do
+    it { expect('a`+b'.replace_escaped).to eq('a+b') }
+    it { expect('a`=b'.replace_escaped).to eq('a=b') }
+    it { expect("a\\+b".replace_escaped).to eq('a+b') }
+  end
+
+  describe '#underscore' do
+    it { expect('HelloWorld'.underscore).to eq('hello_world') }
+  end
+
+  describe '#uncapitalize' do
+    it { expect('Hello'.uncapitalize).to eq('hello') }
+  end
+
+  describe '#blank?' do
+    it { expect(''.blank?).to be true }
+    it { expect('hello'.blank?).to be false }
+  end
+
+  describe '#green / #yellow / #red / #cyan' do
+    it { expect('ok'.green).to include("\e[32m") }
+    it { expect('ok'.yellow).to include("\e[33m") }
+  end
+end

data/spec/localio/template_handler_spec.rb

@@ -0,0 +1,67 @@
+require 'localio/string_helper'
+require 'localio/segment'
+require 'localio/segments_list_holder'
+require 'localio/template_handler'
+
+RSpec.describe TemplateHandler do
+  let(:holder) do
+    h = SegmentsListHolder.new('en')
+    h.segments << Segment.new('app_name', 'My App', 'en')
+    h.segments << Segment.new('greeting', 'Hello world', 'en')
+    h
+  end
+
+  describe '.process_template' do
+    it 'creates the output file in the target directory' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        target  = File.join(tmpdir, 'out')
+        Dir.chdir(workdir) do
+          TemplateHandler.process_template('rails_localizable.erb', target, 'en.yml', holder)
+          expect(File).to exist(File.join(target, 'en.yml'))
+        end
+      end
+    end
+
+    it 'renders ERB template content correctly' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        target  = File.join(tmpdir, 'out')
+        Dir.chdir(workdir) do
+          TemplateHandler.process_template('rails_localizable.erb', target, 'en.yml', holder)
+          content = File.read(File.join(target, 'en.yml'))
+          expect(content).to include('en:')
+          expect(content).to include('app_name: "My App"')
+          expect(content).to include('greeting: "Hello world"')
+        end
+      end
+    end
+
+    it 'does not leave a stray temp file in the working directory' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        target  = File.join(tmpdir, 'out')
+        Dir.chdir(workdir) do
+          TemplateHandler.process_template('rails_localizable.erb', target, 'en.yml', holder)
+          files = Dir.entries(workdir).reject { |f| f.start_with?('.') }
+          expect(files).to be_empty
+        end
+      end
+    end
+
+    it 'creates subdirectories as needed' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) do
+          subdir = File.join(tmpdir, 'out', 'values')
+          TemplateHandler.process_template('rails_localizable.erb', subdir, 'en.yml', holder)
+          expect(File).to exist(File.join(subdir, 'en.yml'))
+        end
+      end
+    end
+  end
+end

data/spec/localio/term_spec.rb

@@ -0,0 +1,24 @@
+require 'localio/term'
+
+RSpec.describe Term do
+  subject(:term) { Term.new('app_name') }
+
+  it 'stores the keyword' do
+    expect(term.keyword).to eq('app_name')
+  end
+
+  it 'initializes with empty values hash' do
+    expect(term.values).to be_empty
+  end
+
+  it 'stores values by language' do
+    term.values['en'] = 'My App'
+    expect(term.values['en']).to eq('My App')
+  end
+
+  describe '#is_comment?' do
+    it { expect(Term.new('[comment]').is_comment?).to be true }
+    it { expect(Term.new('[COMMENT]').is_comment?).to be true }
+    it { expect(term.is_comment?).to be false }
+  end
+end

data/spec/localio/writers/android_writer_spec.rb

@@ -0,0 +1,71 @@
+require 'localio/string_helper'
+require 'localio/term'
+require 'localio/segment'
+require 'localio/segments_list_holder'
+require 'localio/formatter'
+require 'localio/template_handler'
+require 'localio/writers/android_writer'
+
+RSpec.describe AndroidWriter do
+  include_context 'standard terms'
+
+  let(:options) { { default_language: 'en' } }
+
+  describe '.write' do
+    it 'creates values/strings.xml for the default language' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        expect(File).to exist(File.join(tmpdir, 'values', 'strings.xml'))
+      end
+    end
+
+    it 'creates values-{lang}/strings.xml for non-default languages' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        expect(File).to exist(File.join(tmpdir, 'values-es', 'strings.xml'))
+        expect(File).to exist(File.join(tmpdir, 'values-fr', 'strings.xml'))
+      end
+    end
+
+    it 'converts & to & in translations' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'values', 'strings.xml'))
+        expect(content).to include('& Jerry')
+        expect(content).not_to include('"Tom & Jerry"')
+      end
+    end
+
+    it 'converts ... to … in translations' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'values', 'strings.xml'))
+        expect(content).to include('Wait…')
+      end
+    end
+
+    it 'converts %@ to %s in translations' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'values', 'strings.xml'))
+        expect(content).to include('%s world')
+      end
+    end
+
+    it 'renders comment rows as XML comments' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'values', 'strings.xml'))
+        expect(content).to include('<!-- Section General -->')
+      end
+    end
+
+    it 'includes app_name string resource' do
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir(tmpdir) { AndroidWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'values', 'strings.xml'))
+        expect(content).to include('<string name="app_name">My App</string>')
+      end
+    end
+  end
+end

data/spec/localio/writers/ios_writer_spec.rb

@@ -0,0 +1,63 @@
+require 'localio/string_helper'
+require 'localio/term'
+require 'localio/segment'
+require 'localio/segments_list_holder'
+require 'localio/formatter'
+require 'localio/template_handler'
+require 'localio/writers/ios_writer'
+
+RSpec.describe IosWriter do
+  include_context 'standard terms'
+
+  let(:options) { { default_language: 'en' } }
+
+  describe '.write' do
+    it 'creates Localizable.strings in {lang}.lproj/ for each language' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) { IosWriter.write(languages, terms, tmpdir, :smart, options) }
+        expect(File).to exist(File.join(tmpdir, 'en.lproj', 'Localizable.strings'))
+        expect(File).to exist(File.join(tmpdir, 'es.lproj', 'Localizable.strings'))
+      end
+    end
+
+    it 'creates LocalizableConstants.h by default' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) { IosWriter.write(languages, terms, tmpdir, :smart, options) }
+        expect(File).to exist(File.join(tmpdir, 'LocalizableConstants.h'))
+      end
+    end
+
+    it 'skips LocalizableConstants.h when create_constants is false' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) { IosWriter.write(languages, terms, tmpdir, :smart, options.merge(create_constants: false)) }
+        expect(File).not_to exist(File.join(tmpdir, 'LocalizableConstants.h'))
+      end
+    end
+
+    it 'renders comment rows as line comments' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) { IosWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'en.lproj', 'Localizable.strings'))
+        expect(content).to include('// Section General')
+      end
+    end
+
+    it 'includes translation values' do
+      Dir.mktmpdir do |tmpdir|
+        workdir = File.join(tmpdir, 'work')
+        FileUtils.mkdir_p(workdir)
+        Dir.chdir(workdir) { IosWriter.write(languages, terms, tmpdir, :smart, options) }
+        content = File.read(File.join(tmpdir, 'en.lproj', 'Localizable.strings'))
+        expect(content).to include('My App')
+      end
+    end
+  end
+end