dotstrings 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c23d2110a873db44936fc87e1c89e41300a82edfdde9c8a357679c1b378cc27
+  data.tar.gz: 81363243a7425d43383246594362b23740ee22a03b3d8d74f871cf8ea113809c
+SHA512:
+  metadata.gz: 01a9055615619969260d1012c0a027338d85d73495ac664e6ac72c4a6bb7d3368eb4554496d5622940e660ea01d44fe2949bbf3aa88149ab05b284c021792456
+  data.tar.gz: ca19e173e63d4b820b9cd2ebbd4030ef70bb33080822738a4e290e4ce01b6f6be64c9578a858dffd8ae46d6423e343f0345611f1f1a5a04ca48a2ad9fc7b145f

data/.editorconfig

@@ -0,0 +1,13 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[{*.rb,Gemfile,Rakefile,*.yml}]
+charset = utf-8
+indent_style = space
+indent_size = 2

data/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: "*"
+  pull_request:
+    branches: "*"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+          - "2.5"
+          - "2.6"
+          - "2.7"
+          - "3.0"
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Lint
+      run: bundle exec rake rubocop
+    - name: Run tests
+      run: bundle exec rake
+    - name: Install
+      run: bundle exec rake install

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+.vscode

data/.rubocop.yml

@@ -0,0 +1,33 @@
+require:
+  - rubocop-rake
+  - rubocop-minitest
+
+AllCops:
+  TargetRubyVersion: 2.5
+  NewCops: enable
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Metrics/ClassLength:
+  Enabled: true
+  Max: 150
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ParallelAssignment:
+  Enabled: false
+
+Minitest/AssertInDelta:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    dotstrings (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    minitest (5.15.0)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rubocop (1.28.2)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.17.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.17.0)
+      parser (>= 3.1.1.0)
+    rubocop-minitest (0.19.1)
+      rubocop (>= 0.90, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  dotstrings!
+  minitest (~> 5.14)
+  rake
+  rubocop
+  rubocop-minitest
+  rubocop-rake
+
+BUNDLED WITH
+   2.2.18

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Ramon Torres
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+# DotStrings
+
+A parser for Apple *strings* files (`.strings`) written in Ruby. Some of the features of DotStrings include:
+
+* A fast and memory-efficient streaming parser.
+* Support for multiline (`/* ... */`) comments as well as single-line comments (`// ...`).
+* An API for creating strings files programmatically.
+* Handles Unicode and escaped characters.
+* Helpful error messages: know which line and column fail to parse and why.
+
+## Installing
+
+You can install DotStrings manually by running:
+
+```shell
+$ gem install dotstrings
+```
+
+Or by adding the following entry to your [Gemfile](https://guides.cocoapods.org/using/a-gemfile.html), then running `$ bundle install`.
+
+```ruby
+gem "dotstrings"
+```
+
+## Usage
+
+You can load `.strings` files using the `DotString.parse()` utility method. This method returns a `DotStrings::File` object or raises an exception if the file is invalid.
+
+```ruby
+file = DotStrings.parse_file('en-US/Localizable.strings')
+file.items.each do |item|
+  puts item.comment
+  puts item.key
+  puts item.value
+end
+```
+
+## Examples
+
+### Listing keys
+
+```ruby
+puts file.keys
+# => ["key 1", "key 2", ...]
+```
+
+### Accessing items by key
+
+```ruby
+puts file['key 1'].value
+# => "value 1"
+```
+
+### Deleting items by key
+
+```ruby
+file.delete('key 1')
+```
+
+### Appending items
+
+```ruby
+file << DotStrings::Item(
+  comment: 'Title for the cancel button',
+  key: 'button.cancel.title',
+  value: 'Cancel'
+)
+```
+
+### Saving a file
+
+```ruby
+File.write('en-US/Localizable.strings', file.to_s)
+```

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new
+RuboCop::RakeTask.new
+
+task default: :test

data/dotstrings.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require './lib/dotstrings/version'
+
+Gem::Specification.new do |s|
+  s.name = 'dotstrings'
+  s.version = DotStrings::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Ramon Torres']
+  s.email = ['raymondjavaxx@gmail.com']
+  s.homepage = 'https://github.com/raymondjavaxx/dotstrings'
+  s.description = s.summary = 'Parse and create .strings files used in localization of iOS and macOS apps.'
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.license = 'MIT'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'minitest', '~> 5.14'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop-minitest'
+  s.add_development_dependency 'rubocop-rake'
+
+  s.required_ruby_version = '>= 2.5.0'
+  s.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/dotstrings/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module DotStrings
+  class ParsingError < RuntimeError
+  end
+end

data/lib/dotstrings/file.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'dotstrings/parser'
+require 'dotstrings/errors'
+require 'dotstrings/item'
+
+module DotStrings
+  class File
+    attr_reader :items
+
+    def initialize(items = [])
+      @items = items
+    end
+
+    def self.parse(io)
+      items = []
+
+      parser = Parser.new
+      parser.on_item { |item| items << item }
+      parser << normalize_encoding(io.read)
+
+      File.new(items)
+    end
+
+    def self.parse_file(path)
+      ::File.open(path, 'r') do |file|
+        parse(file)
+      end
+    end
+
+    def keys
+      @items.map(&:key)
+    end
+
+    def [](key)
+      @items.find { |item| item.key == key }
+    end
+
+    def <<(item)
+      @items << item
+    end
+
+    def append(item)
+      self << item
+    end
+
+    def delete(key)
+      @items.delete_if { |item| item.key == key }
+    end
+
+    def to_s
+      result = []
+
+      @items.each do |item|
+        result << item.to_s
+        result << ''
+      end
+
+      result.join("\n")
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.normalize_encoding(str)
+      if str.bytesize >= 3 && str.getbyte(0) == 0xEF && str.getbyte(1) == 0xBB && str.getbyte(2) == 0xBF
+        # UTF-8 BOM
+        str.byteslice(3, str.bytesize - 3)
+      elsif str.bytesize >= 2 && str.getbyte(0) == 0xFE && str.getbyte(1) == 0xFF
+        # UTF-16 (BE) BOM
+        converter = Encoding::Converter.new('UTF-16BE', 'UTF-8')
+        str = converter.convert(str)
+        str.byteslice(3, str.bytesize - 3)
+      elsif str.bytesize >= 2 && str.getbyte(0) == 0xFF && str.getbyte(1) == 0xFE
+        # UTF-16 (LE) BOM
+        converter = Encoding::Converter.new('UTF-16LE', 'UTF-8')
+        str = converter.convert(str)
+        str.byteslice(3, str.bytesize - 3)
+      else
+        str.force_encoding('UTF-8')
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    private_class_method :normalize_encoding
+  end
+end

data/lib/dotstrings/item.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DotStrings
+  class Item
+    attr_reader :comment, :key, :value
+
+    def initialize(key:, value:, comment: nil)
+      @comment = comment
+      @key = key
+      @value = value
+    end
+
+    def to_s
+      result = []
+
+      result << "/* #{comment} */" unless comment.nil?
+      result << "\"#{serialize_string(key)}\" = \"#{serialize_string(value)}\";"
+
+      result.join("\n")
+    end
+
+    private
+
+    def serialize_string(string)
+      replacements = [
+        ['"', '\\"'],
+        ["'", "\\'"],
+        ["\t", '\t'],
+        ["\n", '\n'],
+        ["\r", '\r'],
+        ["\0", '\\0']
+      ]
+
+      replacements.each do |replacement|
+        string = string.gsub(replacement[0]) { replacement[1] }
+      end
+
+      string
+    end
+  end
+end

data/lib/dotstrings/parser.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'dotstrings/errors'
+
+module DotStrings
+  # rubocop:disable Metrics/ClassLength
+  class Parser
+    # Special tokens
+    TOK_SLASH        = '/'
+    TOK_ASTERISK     = '*'
+    TOK_QUOTE        = '"'
+    TOK_SINGLE_QUOTE = "'"
+    TOK_BACKSLASH    = '\\'
+    TOK_EQUALS       = '='
+    TOK_SEMICOLON    = ';'
+    TOK_NEW_LINE     = "\n"
+    TOK_N            = 'n'
+    TOK_R            = 'r'
+    TOK_T            = 't'
+    TOK_CAP_U        = 'U'
+    TOK_ZERO         = '0'
+    TOK_HEX_DIGIT    = /[0-9a-fA-F]/.freeze
+
+    # States
+    STATE_START               = 0
+    STATE_COMMENT_START       = 1
+    STATE_COMMENT             = 2
+    STATE_MULTILINE_COMMENT   = 3
+    STATE_COMMENT_END         = 4
+    STATE_KEY                 = 5
+    STATE_KEY_END             = 6
+    STATE_VALUE_SEPARATOR     = 7
+    STATE_VALUE               = 8
+    STATE_VALUE_END           = 9
+    STATE_UNICODE             = 10
+    STATE_UNICODE_SURROGATE   = 11
+    STATE_UNICODE_SURROGATE_U = 12
+
+    attr_reader :items
+
+    def initialize
+      @state = STATE_START
+      @temp_state = nil
+
+      @buffer = []
+      @unicode_buffer = []
+      @high_surrogate = nil
+
+      @escaping = false
+
+      @current_comment = nil
+      @current_key = nil
+      @current_value = nil
+
+      @item_block = nil
+
+      @offset = 0
+      @line = 1
+      @column = 1
+    end
+
+    def on_item(&block)
+      @item_block = block
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockLength
+    def <<(data)
+      data.each_char do |ch|
+        case @state
+        when STATE_START
+          start_value(ch)
+        when STATE_COMMENT_START
+          case ch
+          when TOK_SLASH
+            @state = STATE_COMMENT
+          when TOK_ASTERISK
+            @state = STATE_MULTILINE_COMMENT
+          else
+            raise_error("Unexpected character '#{ch}'")
+          end
+        when STATE_COMMENT
+          if ch == TOK_NEW_LINE
+            @state = STATE_COMMENT_END
+            @current_comment = @buffer.join.strip
+            @buffer.clear
+          else
+            @buffer << ch
+          end
+        when STATE_MULTILINE_COMMENT
+          if ch == TOK_SLASH && @buffer.last == TOK_ASTERISK
+            @state = STATE_COMMENT_END
+            @current_comment = @buffer.slice(0, @buffer.length - 1).join.strip
+            @buffer.clear
+          else
+            @buffer << ch
+          end
+        when STATE_COMMENT_END
+          @state = STATE_KEY if ch == TOK_QUOTE
+        when STATE_KEY
+          parse_string(ch) do |key|
+            @current_key = key
+            @state = STATE_KEY_END
+          end
+        when STATE_KEY_END
+          @state = STATE_VALUE_SEPARATOR if ch == TOK_EQUALS
+        when STATE_VALUE_SEPARATOR
+          if ch == TOK_QUOTE
+            @state = STATE_VALUE
+          else
+            raise_error("Unexpected character '#{ch}'") unless ch.strip.empty?
+          end
+        when STATE_VALUE
+          parse_string(ch) do |value|
+            @current_value = value
+            @state = STATE_VALUE_END
+
+            @item_block&.call(Item.new(
+              comment: @current_comment,
+              key: @current_key,
+              value: @current_value
+            ))
+          end
+        when STATE_VALUE_END
+          @state = STATE_START if ch == TOK_SEMICOLON
+        when STATE_UNICODE
+          parse_unicode(ch) do |unicode_ch|
+            @buffer << unicode_ch
+            # Restore state
+            @state = @temp_state
+          end
+        when STATE_UNICODE_SURROGATE
+          if ch == TOK_BACKSLASH
+            @state = STATE_UNICODE_SURROGATE_U
+          else
+            raise_error("Unexpected character '#{ch}', expecting another unicode codepoint")
+          end
+        when STATE_UNICODE_SURROGATE_U
+          if ch == TOK_CAP_U
+            @state = STATE_UNICODE
+          else
+            raise_error("Unexpected character '#{ch}', expecting '#{TOK_CAP_U}'")
+          end
+        end
+
+        update_position(ch)
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/BlockLength
+
+    private
+
+    def raise_error(message)
+      raise ParsingError, "#{message} at line #{@line}, column #{@column} (offset: #{@offset})"
+    end
+
+    def parse_string(ch, &block)
+      if @escaping
+        parse_escaped_character(ch, &block)
+      else
+        case ch
+        when TOK_BACKSLASH
+          @escaping = true
+        when TOK_QUOTE
+          block.call(@buffer.join)
+          @buffer.clear
+        else
+          @buffer << ch
+        end
+      end
+    end
+
+    def parse_escaped_character(ch)
+      @escaping = false
+
+      case ch
+      when TOK_QUOTE, TOK_SINGLE_QUOTE, TOK_BACKSLASH
+        @buffer << ch
+      when TOK_N
+        @buffer << "\n"
+      when TOK_R
+        @buffer << "\r"
+      when TOK_T
+        @buffer << "\t"
+      when TOK_CAP_U
+        @temp_state = @state
+        @state = STATE_UNICODE
+      when TOK_ZERO
+        @buffer << "\0"
+      else
+        raise_error("Unexpected character '#{ch}'")
+      end
+    end
+
+    # rubocop:disable Style/GuardClause
+    def parse_unicode(ch, &block)
+      raise_error("Unexpected character '#{ch}', expecting a hex digit") unless ch =~ TOK_HEX_DIGIT
+
+      @unicode_buffer << ch
+
+      if @unicode_buffer.length == 4
+        codepoint = @unicode_buffer.join.hex
+
+        if codepoint >= 0xD800 && codepoint <= 0xDBFF
+          @high_surrogate = codepoint
+          @state = STATE_UNICODE_SURROGATE
+        elsif codepoint >= 0xDC00 && codepoint <= 0xDFFF
+          character = ((@high_surrogate - 0xD800) * 0x400) + (codepoint - 0xDC00) + 0x10000
+          block.call(character.chr('UTF-8'))
+        else
+          block.call(codepoint.chr('UTF-8'))
+        end
+
+        # Clear buffer after codepoint is parsed
+        @unicode_buffer.clear
+      end
+    end
+    # rubocop:enable Style/GuardClause
+
+    def update_position(ch)
+      @offset += 1
+
+      if ch == TOK_NEW_LINE
+        @column = 1
+        @line += 1
+      else
+        @column += 1
+      end
+    end
+
+    def start_value(ch)
+      case ch
+      when TOK_SLASH
+        @state = STATE_COMMENT_START
+        reset_state
+      when TOK_QUOTE
+        @state = STATE_KEY
+        reset_state
+      else
+        raise_error("Unexpected character '#{ch}'") unless ch.strip.empty?
+      end
+    end
+
+    def reset_state
+      @current_comment = nil
+      @current_key = nil
+      @current_value = nil
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/dotstrings/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DotStrings
+  VERSION = '0.1.0'
+end

data/lib/dotstrings.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dotstrings/version'
+require 'dotstrings/file'
+require 'dotstrings/item'
+require 'dotstrings/errors'
+
+module DotStrings
+  def self.parse(io)
+    File.parse(io)
+  end
+
+  def self.parse_file(path)
+    File.parse_file(path)
+  end
+end

data/test/fixtures/escaped_backslashes.strings

@@ -0,0 +1,2 @@
+/* Escaped carriage backslashes */
+"some\\key" = "some\\value";

data/test/fixtures/escaped_carriage_returns.strings

@@ -0,0 +1,2 @@
+/* Escaped carriage returns */
+"some\rkey" = "some\rvalue";

data/test/fixtures/escaped_new_lines.strings

@@ -0,0 +1,2 @@
+/* Escaped new lines */
+"some\nkey" = "some\nvalue";

data/test/fixtures/escaped_nil.strings

@@ -0,0 +1,2 @@
+/* Escaped nil */
+"key\0" = "value\0";

data/test/fixtures/escaped_quotes.strings

@@ -0,0 +1,2 @@
+/* Escaped quotes */
+"some \"key\"" = "some \"value\"";

data/test/fixtures/escaped_single_quotes.strings

@@ -0,0 +1,2 @@
+/* Escaped quotes */
+"some \'key\'" = "some \'value\'";

data/test/fixtures/escaped_tabs.strings

@@ -0,0 +1,2 @@
+/* Escaped tabs */
+"some\tkey" = "some\tvalue";

data/test/fixtures/escaped_unicode.strings

@@ -0,0 +1,2 @@
+/* Unicode characters. Key is a dollar sign, value is: ⚡👻 */
+"\U0024" = "\U26A1\UD83D\UDC7B";

data/test/fixtures/utf8_bom.strings

@@ -0,0 +1,2 @@
+/* Comment */
+"key" = "value";

data/test/fixtures/valid.strings

@@ -0,0 +1,8 @@
+// Single line comment
+"key 1" = "value 1";
+
+/* Multi line
+comment */
+"key 2" = "value 2";
+
+"key 3" = "value 3";

data/test/helper.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+gem 'minitest'
+
+require 'minitest/pride'
+require 'minitest/autorun'
+
+require_relative '../lib/dotstrings'

data/test/test_dotstrings.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestDotStrings < MiniTest::Test
+  def test_parse_can_parse_valid_files
+    file = DotStrings.parse_file('test/fixtures/valid.strings')
+
+    assert_equal 3, file.items.size
+
+    assert_equal 'Single line comment', file.items[0].comment
+    assert_equal 'key 1', file.items[0].key
+    assert_equal 'value 1', file.items[0].value
+
+    assert_equal "Multi line\ncomment", file.items[1].comment
+    assert_equal 'key 2', file.items[1].key
+    assert_equal 'value 2', file.items[1].value
+  end
+
+  def test_can_parse_file_with_escaped_quotes
+    file = DotStrings.parse_file('test/fixtures/escaped_quotes.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'some "key"', file.items[0].key
+    assert_equal 'some "value"', file.items[0].value
+  end
+
+  def test_can_parse_file_with_escaped_single_quotes
+    file = DotStrings.parse_file('test/fixtures/escaped_single_quotes.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'some \'key\'', file.items[0].key
+    assert_equal 'some \'value\'', file.items[0].value
+  end
+
+  def test_can_parse_file_with_escaped_tabs
+    file = DotStrings.parse_file('test/fixtures/escaped_tabs.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal "some\tkey", file.items[0].key
+    assert_equal "some\tvalue", file.items[0].value
+  end
+
+  def test_can_parse_files_with_escaped_carriage_returns
+    file = DotStrings.parse_file('test/fixtures/escaped_carriage_returns.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal "some\rkey", file.items[0].key
+    assert_equal "some\rvalue", file.items[0].value
+  end
+
+  def test_can_parse_files_with_escaped_nil
+    file = DotStrings.parse_file('test/fixtures/escaped_nil.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal "key\0", file.items[0].key
+    assert_equal "value\0", file.items[0].value
+  end
+
+  def test_can_parse_files_with_escaped_new_lines
+    file = DotStrings.parse_file('test/fixtures/escaped_new_lines.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal "some\nkey", file.items[0].key
+    assert_equal "some\nvalue", file.items[0].value
+  end
+
+  def test_can_parse_files_with_escaped_backslashes
+    file = DotStrings.parse_file('test/fixtures/escaped_backslashes.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'some\\key', file.items[0].key
+    assert_equal 'some\\value', file.items[0].value
+  end
+
+  def test_can_parse_files_with_escaped_unicode
+    file = DotStrings.parse_file('test/fixtures/escaped_unicode.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal '$', file.items[0].key
+    assert_equal '⚡👻', file.items[0].value
+  end
+
+  def test_can_parse_utf16le_files_with_bom
+    file = DotStrings.parse_file('test/fixtures/utf16le_bom.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'key', file.items[0].key
+    assert_equal 'value', file.items[0].value
+  end
+
+  def test_can_parse_utf16be_files_with_bom
+    file = DotStrings.parse_file('test/fixtures/utf16be_bom.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'key', file.items[0].key
+    assert_equal 'value', file.items[0].value
+  end
+
+  def test_can_parse_utf8_files_with_bom
+    file = DotStrings.parse_file('test/fixtures/utf8_bom.strings')
+
+    assert_equal 1, file.items.size
+    assert_equal 'key', file.items[0].key
+    assert_equal 'value', file.items[0].value
+  end
+end

data/test/test_file.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFile < MiniTest::Test
+  def test_delete
+    items = [
+      DotStrings::Item.new(key: 'key 1', value: 'value 1'),
+      DotStrings::Item.new(key: 'key 2', value: 'value 2'),
+      DotStrings::Item.new(key: 'key 3', value: 'value 3')
+    ]
+
+    file = DotStrings::File.new(items)
+
+    file.delete('key 2')
+    assert_equal 2, file.items.size
+    assert_equal ['key 1', 'key 3'], file.keys
+  end
+
+  def test_access_by_key
+    items = [
+      DotStrings::Item.new(key: 'key 1', value: 'value 1'),
+      DotStrings::Item.new(key: 'key 2', value: 'value 2'),
+      DotStrings::Item.new(key: 'key 3', value: 'value 3')
+    ]
+
+    file = DotStrings::File.new(items)
+
+    assert_equal 'value 1', file['key 1'].value
+    assert_equal 'value 2', file['key 2'].value
+    assert_equal 'value 3', file['key 3'].value
+  end
+
+  def test_append
+    file = DotStrings::File.new
+    file.append(DotStrings::Item.new(key: 'key 1', value: 'value 1'))
+    assert_equal 1, file.items.size
+  end
+
+  def test_to_string
+    items = [
+      DotStrings::Item.new(comment: 'Comment 1', key: 'key 1', value: 'value 1'),
+      DotStrings::Item.new(comment: 'Comment 2', key: 'key 2', value: 'value 2'),
+      DotStrings::Item.new(comment: 'Comment 3', key: 'key 3', value: '👻'),
+      DotStrings::Item.new(comment: 'Comment 4', key: "\"'\t\n\r\0", value: "\"'\t\n\r\0")
+    ]
+
+    file = DotStrings::File.new(items)
+
+    expected = <<~'END_OF_DOCUMENT'
+      /* Comment 1 */
+      "key 1" = "value 1";
+
+      /* Comment 2 */
+      "key 2" = "value 2";
+
+      /* Comment 3 */
+      "key 3" = "👻";
+
+      /* Comment 4 */
+      "\"\'\t\n\r\0" = "\"\'\t\n\r\0";
+    END_OF_DOCUMENT
+
+    assert_equal expected, file.to_s
+  end
+end

data/test/test_item.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFile < MiniTest::Test
+  def test_to_s
+    item = DotStrings::Item.new(comment: 'Comment', key: 'key 1', value: 'value 1')
+    assert_equal "/* Comment */\n\"key 1\" = \"value 1\";", item.to_s
+  end
+
+  def test_to_s_with_nil_comment
+    item = DotStrings::Item.new(comment: nil, key: 'key 1', value: 'value 1')
+    assert_equal '"key 1" = "value 1";', item.to_s
+  end
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: dotstrings
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ramon Torres
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse and create .strings files used in localization of iOS and macOS
+  apps.
+email:
+- raymondjavaxx@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- dotstrings.gemspec
+- lib/dotstrings.rb
+- lib/dotstrings/errors.rb
+- lib/dotstrings/file.rb
+- lib/dotstrings/item.rb
+- lib/dotstrings/parser.rb
+- lib/dotstrings/version.rb
+- test/fixtures/escaped_backslashes.strings
+- test/fixtures/escaped_carriage_returns.strings
+- test/fixtures/escaped_new_lines.strings
+- test/fixtures/escaped_nil.strings
+- test/fixtures/escaped_quotes.strings
+- test/fixtures/escaped_single_quotes.strings
+- test/fixtures/escaped_tabs.strings
+- test/fixtures/escaped_unicode.strings
+- test/fixtures/utf16be_bom.strings
+- test/fixtures/utf16le_bom.strings
+- test/fixtures/utf8_bom.strings
+- test/fixtures/valid.strings
+- test/helper.rb
+- test/test_dotstrings.rb
+- test/test_file.rb
+- test/test_item.rb
+homepage: https://github.com/raymondjavaxx/dotstrings
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key:
+specification_version: 4
+summary: Parse and create .strings files used in localization of iOS and macOS apps.
+test_files:
+- test/fixtures/escaped_backslashes.strings
+- test/fixtures/escaped_carriage_returns.strings
+- test/fixtures/escaped_new_lines.strings
+- test/fixtures/escaped_nil.strings
+- test/fixtures/escaped_quotes.strings
+- test/fixtures/escaped_single_quotes.strings
+- test/fixtures/escaped_tabs.strings
+- test/fixtures/escaped_unicode.strings
+- test/fixtures/utf16be_bom.strings
+- test/fixtures/utf16le_bom.strings
+- test/fixtures/utf8_bom.strings
+- test/fixtures/valid.strings
+- test/helper.rb
+- test/test_dotstrings.rb
+- test/test_file.rb
+- test/test_item.rb