apfel 0.0.2

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    apfel (0.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    method_source (0.8.1)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rake (0.9.2.2)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.0)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+    slop (3.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  apfel!
+  pry
+  rake
+  rspec

data/README.md

@@ -0,0 +1,56 @@
+# Apfel
+
+## Introduction
+
+Apfel is simple parser for .strings (DotStrings) files written in Ruby. DotStrings files are used by Apple platforms for localization. Apfel reads DotStrings files, parses them for key-value pairs and comments.
+
+Once in the form of a hash, the content of the DotStrings file can easily be
+rebuilt as JSON, XML and RESX (with the help of Builder https://github.com/jimweirich/builder) and more!
+
+## Use
+
+To start using Apfel first require the gem
+```Ruby
+require 'apfel'
+```
+
+Next, pass Apfel the .strings file you want to parse:
+```Ruby
+parsed_file = Apfel.parse('path/to/file')
+```
+
+Once the file has been parsed, you can do many things with it:
+```Ruby
+# Turn it into a ruby hash (includes comments)
+parsed_file.to_hash
+
+# Turn it into json (includes comments)
+parsed_file.to_json
+
+# With either #to_hash or #to_json you can specify
+# whether you want the comments included
+parsed_file.to_hash(with_comments: false)
+
+# Get all the keys as an array
+parsed_file.keys
+
+# Get all the values as an array
+parsed_file.values
+
+# Return an array of key-value hashes
+parsed_file.key_values
+
+# Return an array of key-comment hashes
+parsed_file.comments
+
+# Return an array of all the comments without their keys
+parsed_file.comments(with_keys: false)
+```
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Commit tests (they should pass when rake is run)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--color", '--order rand']
+end
+
+desc "Run all tests and documentation checks"
+task :qa => [:spec]
+
+task :default => :qa

data/apfel.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+apfel_folder = File.join(File.dirname(__FILE__), 'lib', 'apfel')
+$:.unshift apfel_folder
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "apfel"
+  s.version     = Apfel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ryan Levick"]
+  s.email       = ["ryan.levick@gmail.com"]
+  s.homepage    = "https://github.com/rlevick/apfel"
+  s.summary     = %q{Simple parser for DotStrings Files}
+  s.description = %q{Parse valid .strings files for easy conversion to other formats}
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "pry"
+
+  s.rubyforge_project = "apfel"
+
+  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"]
+end

data/lib/apfel/dot_strings_parser.rb

@@ -0,0 +1,54 @@
+module Apfel
+  require 'line'
+  require 'kv_pair'
+  class DotStringsParser
+    KEY = "KEY"
+    COMMENT = "COMMENT"
+
+    def initialize(read_file, parsed_file = ParsedDotStrings.new)
+      @read_file = read_file
+      @parsed_file = parsed_file
+    end
+
+    def parse_file
+      state = KEY
+      current_comment = nil
+      comments_for_keys = {}
+      @read_file.each do |content_line|
+        current_line = Line.new(content_line)
+        next if current_line.empty_line? && current_line.in_comment == false
+
+        #State machine to parse the comments
+        case state
+        when KEY
+          if current_line.whole_comment?
+            unless current_line.whole_comment.strip == 'No comment provided by engineer.'
+              current_comment = current_line.whole_comment
+            end
+          elsif current_line.key_value_pair? && current_comment
+            comments_for_keys[current_line.key] = current_comment
+            current_comment = nil
+          elsif current_line.open_comment?
+            current_comment = current_line.open_comment + "\n"
+            state = COMMENT
+          end
+        when COMMENT
+          if current_line.close_comment?
+            current_comment += current_line.close_comment
+            state = KEY
+          else
+            current_line.in_comment = true
+            current_comment = current_comment + current_line.content + "\n"
+          end
+        end
+
+        unless current_line.is_comment?
+          @parsed_file.kv_pairs << KVPair.new(current_line, comments_for_keys[current_line.key])
+        end
+      end
+
+      raise "Invalid .string file: Unterminated comment" unless state == KEY
+      @parsed_file
+    end
+  end
+end

data/lib/apfel/kv_pair.rb

@@ -0,0 +1,29 @@
+module Apfel
+  class KVPair
+    attr_reader :line, :raw_comment
+
+    def initialize(line, comment)
+     @line = line
+     @raw_comment = comment
+    end
+
+    def key
+     line.key.strip unless line.key.nil?
+    end
+
+    def value
+     line.value.strip unless line.key.nil?
+    end
+
+    def comment
+      if raw_comment.nil?
+        @raw_comment = ""
+      else
+        raw_comment.gsub!(/(\/\*)|(\*\/)/,"")
+        raw_comment.gsub!("\n", " ")
+        raw_comment.gsub!(/\s+/, " ")
+        raw_comment.strip
+      end
+    end
+  end
+end

data/lib/apfel/line.rb

@@ -0,0 +1,72 @@
+module Apfel
+  class Line
+    attr_reader :content
+    attr_accessor :in_comment
+
+    def initialize(line)
+      @content = line
+      @in_comment = false
+      raise "Line does not end in ;" unless valid?
+    end
+
+    def empty_line?
+      /^\s*$/.match(content) || false
+    end
+
+    def whole_comment
+      /((^\/\*(.+)\*\/)|(^\/\/(.+)))/.match(content).to_s
+    end
+
+    def whole_comment?
+      !(whole_comment.empty?)
+    end
+
+    def open_comment
+      /^\/\*(.+)$/.match(content).to_s
+    end
+
+    def open_comment?
+      !(open_comment.empty?)
+    end
+
+    def close_comment
+      /^(.+)\*\/\s*$/.match(content).to_s
+    end
+
+    def close_comment?
+      !(close_comment.empty?)
+    end
+
+    def key_value_pair?
+      !!(/^\s*"([^"]+)"\s*=/.match(content))
+    end
+
+    def cleaned_content
+      content.gsub(/;\s*$/, "")
+    end
+
+    def valid?
+      if key_value_pair?
+        !!(/;[\s]*$/.match(content))
+      else
+        true
+      end
+    end
+
+    def key
+      if key_value_pair?
+        cleaned_content.partition(/"\s*=\s*"/)[0].gsub!(/(^"|"$)/, "")
+      end
+    end
+
+    def value
+      if key_value_pair?
+        cleaned_content.partition(/"\s*=\s*"/)[2].gsub!(/(^"|"$)/, "")
+      end
+    end
+
+    def is_comment?
+     whole_comment? || open_comment? || close_comment? || in_comment
+    end
+  end
+end

data/lib/apfel/parsed_dot_strings.rb

@@ -0,0 +1,65 @@
+module Apfel
+  require 'json'
+  class ParsedDotStrings
+    attr_accessor :kv_pairs
+
+    def initialize
+      @kv_pairs = []
+    end
+
+    def key_values
+      kv_pairs.map do |pair|
+        {pair.key => pair.value}
+      end
+    end
+
+    def keys
+      kv_pairs.map do |pair|
+        pair.key
+      end
+    end
+
+    def values
+      kv_pairs.map do |pair|
+        pair.value
+      end
+    end
+
+    def comments(args={})
+      with_keys = args[:with_keys].nil? ? true : args[:with_keys]
+      cleaned_pairs = kv_pairs.map do |pair|
+        pair
+      end
+      with_keys ? build_comment_hash(cleaned_pairs) : cleaned_pairs.map(&:comment)
+    end
+
+    def to_hash(args={})
+      with_comments = args[:with_comments].nil? ? true : args[:with_comments]
+
+      build_hash { |hash, pair|
+      hash_value = with_comments ? { pair.value => pair.comment } : pair.value
+        hash[pair.key] = hash_value
+      }
+    end
+
+    def to_json(args={})
+      self.to_hash(with_comments: args[:with_comments]).to_json
+    end
+
+    private
+
+      def build_comment_hash(kv_pairs)
+        build_hash { |hash, pair|
+          hash[pair.key] = pair.comment
+        }
+      end
+
+      def build_hash(&block)
+        hash = {}
+        kv_pairs.each do |pair|
+          yield hash, pair
+        end
+        hash
+      end
+  end
+end

data/lib/apfel/reader.rb

@@ -0,0 +1,18 @@
+module Apfel
+  # Class for reading in files and returning an array of its content
+  class Reader
+    # Reads in a file and returns an array consisting of each line of input
+    # cleaned of new line characters
+    def self.read(file)
+      File.open(file, "r") do |f|
+      content_array=[]
+      content = f.read
+        content.each_line do |line|
+          line.gsub!("\n","")
+          content_array.push(line)
+        end
+        content_array
+      end
+    end
+  end
+end

data/lib/apfel/version.rb

@@ -0,0 +1,3 @@
+module Apfel
+  VERSION = "0.0.2"
+end

data/lib/apfel.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Apfel
+require 'apfel/reader'
+require 'apfel/dot_strings_parser'
+  # Public module for parsing DotStrings files and returning a parsed dot
+  # strings object
+  def self.parse(file)
+    file = read(file)
+    DotStringsParser.new(file).parse_file
+  end
+
+  def self.read(file)
+   Reader.read(file)
+  end
+end

data/spec/apfel_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'apfel'
+require 'apfel/parsed_dot_strings'
+
+describe Apfel do
+  describe '::parse_file' do
+    context 'when given a valid DotStrings file'do
+
+      let(:parsed_file) do
+        Apfel.parse(valid_file)
+      end
+
+      it 'returns a ParsedDotStrings object' do
+        parsed_file.should be_a(Apfel::ParsedDotStrings)
+      end
+    end
+
+    context 'when given an invalid strings file' do
+      context 'missing a semicolon' do
+
+        let(:invalid_file_semicolon) do
+          create_temp_file(  <<-EOS
+/* This is the first comment */
+"key_number_one" = "value number one"
+            EOS
+          )
+        end
+
+        it 'returns an error' do
+          expect {
+            Apfel.parse(invalid_file_semicolon)
+          }.to raise_error
+        end
+      end
+
+      context 'not closed comment' do
+        let(:invalid_file_comment) do
+          create_temp_file(<<-EOS
+/* This is the first comment
+"key_number_one" = "value number one";
+
+/* This is
+a
+multiline comment */
+        end
+          EOS
+          )
+        end
+
+        it 'raises an error' do
+          expect {
+            Apfel.parse(invalid_file_semicolon)
+          }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/parsed_dot_strings_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'apfel'
+require 'parsed_dot_strings'
+
+module Apfel
+  describe ParsedDotStrings do
+    let(:parsed_file) do
+      Apfel.parse(valid_file)
+    end
+
+    describe '#keys' do
+      it 'returns an array of all the keys'do
+        parsed_file.keys.should eq(
+        ["key_number_one",
+         "key_number_two",
+         "key_number_three"]
+        )
+      end
+    end
+
+    describe '#values' do
+      it 'returns an array of all the values'do
+        parsed_file.values.should eq(
+        ["value number one",
+         "value number two",
+         "value number three"]
+        )
+      end
+    end
+
+    describe '#comments' do
+      context 'when :with_keys is passed as true' do
+        it 'returns a hash of the comments mapped to their correct keys' do
+          parsed_file.comments(with_keys: true).should eq(
+            {"key_number_one" => "This is the first comment",
+             "key_number_two" => "This is a multiline comment",
+             "key_number_three" => "This is comment number 3"}
+          )
+        end
+      end
+
+      context 'when with_keys is passed as false' do
+        it 'returns an array of just the comments' do
+          parsed_file.comments(with_keys: false).should eq(
+          ["This is the first comment",
+           "This is a multiline comment",
+           "This is comment number 3"]
+          )
+        end
+      end
+
+      it 'defaults to returning a hash' do
+          parsed_file.comments.should be_a(Hash)
+      end
+    end
+
+    describe '#key_values' do
+      it 'returns an array of hashes of key and values' do
+          parsed_file.key_values.should eq(
+          [
+            {"key_number_one" => "value number one"},
+            {"key_number_two" => "value number two"},
+            {"key_number_three" => "value number three"}
+          ]
+          )
+      end
+    end
+
+    describe '#to_hash' do
+     it 'returns a hash with the key = key, value = { value => comments }' do
+      parsed_file.to_hash.should eq(
+        {
+          "key_number_one" => { "value number one" => "This is the first comment" },
+          "key_number_two" => { "value number two" => "This is a multiline comment" },
+          "key_number_three" => { "value number three" => "This is comment number 3" }
+        }
+      )
+      end
+
+      context 'when :no_comments is passed as true' do
+        it 'returns a hash of just keys and values' do
+          parsed_file.to_hash(with_comments: false).should eq(
+            {
+              "key_number_one" => "value number one",
+              "key_number_two" => "value number two",
+              "key_number_three" => "value number three"
+            }
+          )
+        end
+      end
+    end
+
+    describe 'to_json' do
+      it 'returns a valid json representation of .strings file' do
+        parsed_file.to_json.should eq(
+        {
+          "key_number_one" => { "value number one" => "This is the first comment" },
+          "key_number_two" => { "value number two" => "This is a multiline comment" },
+          "key_number_three" => { "value number three" => "This is comment number 3" }
+        }.to_json
+        )
+      end
+      context 'when :no_comments is passed as true' do
+        it 'returns a valid json representation of just keys and values' do
+          parsed_file.to_json(with_comments: false).should eq(
+            {
+              "key_number_one" => "value number one",
+              "key_number_two" => "value number two",
+              "key_number_three" => "value number three"
+            }.to_json
+          )
+        end
+      end
+    end
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'reader'
+
+module Apfel
+  describe Reader do
+    describe '#read' do
+      let(:temp_file) do
+        create_temp_file(<<-EOS
+This is a file with some lines.
+Roses are red, violets are blue.
+This text is really boring,
+and so are you!
+        EOS
+        )
+      end
+
+      it 'reads a file a returns an array of its output' do
+        Reader.read(temp_file).should eq([
+        "This is a file with some lines.",
+        "Roses are red, violets are blue.",
+        "This text is really boring,",
+        "and so are you!"
+        ])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'tempfile'
+require 'json'
+def create_temp_file(string)
+  temp_file = Tempfile.new('temp')
+  temp_file << string
+  temp_file.flush
+end
+
+def valid_file
+  create_temp_file(<<-EOS
+/* This is the first comment */
+"key_number_one" = "value number one";
+
+/* This is
+a
+
+multiline comment */
+"key_number_two"   =   "value number two";
+/* This is comment number 3 */
+"key_number_three" = " value number three ";
+          EOS
+  )
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: apfel
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Levick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse valid .strings files for easy conversion to other formats
+email:
+- ryan.levick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- apfel.gemspec
+- lib/apfel.rb
+- lib/apfel/dot_strings_parser.rb
+- lib/apfel/kv_pair.rb
+- lib/apfel/line.rb
+- lib/apfel/parsed_dot_strings.rb
+- lib/apfel/reader.rb
+- lib/apfel/version.rb
+- spec/apfel_spec.rb
+- spec/parsed_dot_strings_spec.rb
+- spec/reader_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rlevick/apfel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2408211664317922349
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2408211664317922349
+requirements: []
+rubyforge_project: apfel
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple parser for DotStrings Files
+test_files:
+- spec/apfel_spec.rb
+- spec/parsed_dot_strings_spec.rb
+- spec/reader_spec.rb
+- spec/spec_helper.rb