PoParser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93ef3b40331e9ddb92b0e2e80cecdda8931c792d
+  data.tar.gz: fb04bd5618a796539cc22654c35f819cfaa1ba95
+SHA512:
+  metadata.gz: 5db31ba15259828ab3fbd12f39ac9929ce3baa7244e2f51511ac9d46f31278c13aa40606af22c249e74d2ae3ccbc65b4996f9b0b0a62936dedaa2724260609ac
+  data.tar.gz: 351db54dfc9b1e1b75945c13a1ecc4ad7da2cd7c6d4a0e659466f904f1b319c538081042dbb4b790ffd6ebbf580e9686fa066dd510eaad2870cfdacac5ff9c35

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.0
+script: bundle exec rspec spec

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## Version 0.1.0
+
+* initial release
+

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'coveralls', :require => false
+
+# Specify your gem's dependencies in poparser.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Arash Mousavi
+
+MIT License
+
+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,159 @@
+# Poparser
+
+[![Build Status](https://travis-ci.org/arashm/PoParser.svg?branch=master)](https://travis-ci.org/arashm/PoParser)
+[![Coverage Status](https://img.shields.io/coveralls/arashm/PoParser.svg)](https://coveralls.io/r/arashm/PoParser)
+
+A Ruby PO file parser, editor and generator. PO files are translation files generated by GNU/Gettext tool. This GEM is compatible with [GNU PO file specification](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html). report misbehaviours and bugs, to the [issue tracker](https://github.com/arashm/PoParser/issues).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'poparser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install poparser
+
+## Usage
+
+Working with the GEM is pretty easy:
+
+```ruby
+path = Pathname.new('example.po')
+po   = PoParser.parse(path)
+=> <PoParser::Po, Translated: 68.1% Untranslated: 20.4% Fuzzy: 11.5%>
+```
+
+The `parse` method returns a `PO` object which contains all `Entries`:
+
+```ruby
+# get all entries
+po.entries # or .all alias
+
+# get all fuzzy entries
+po.fuzzy
+
+# get all untranslated entries
+po.untranslated
+
+# get all translated entries
+po.translated
+
+# returns a hash representation of the PO file
+po.to_h
+
+# returns a string representation of the PO file
+po.to_s
+```
+
+You can add a new entry to the PO file:
+
+```ruby
+new_entry = {
+              translator_comment: 'comment',
+              refrence: 'refrence comment',
+              msgid: 'untranslated',
+              msgstr: 'translated string'
+            }
+
+po.add_entry(new_entry)
+
+# There's also an alias for add_entry
+po << new_entry
+```
+
+You can pass an array of hashes to `new_entry` and it will be added to `PO` file.
+
+### Entry
+
+Each entry can have following properties (for more information see [GNU PO file specification](https://www.gnu.org/software/gettext/manual/html_node/PO-Files.html)):
+
+```
+translator_comment
+refrence
+extracted_comment
+flag
+previous_untraslated_string
+msgid
+msgid_plural
+msgstr
+msgctxt
+```
+
+#### Working with entries
+
+The `PO` object contains many `Entry` objects. Number of methods are available to check state of the `Entry`:
+
+```ruby
+entry.untranslated? # or .incomplete? alias
+#=> false
+entry.translated? # or .complete? alias
+#=> true
+entry.fuzzy?
+#=> true
+entry.plural?
+#=> false
+```
+
+You can get or edit each of property of the `Entry`:
+
+```ruby
+entry.msgid
+#=> "This is an msgid that needs to get translated"
+entry.translate = "This entry is translated" # or msgstr= alias
+entry.msgstr
+#=> "This entry is translated"
+```
+
+You can mark an entry as fuzzy:
+
+```ruby
+entry.flag_as_fuzzy
+entry.fuzzy?
+#=> true
+```
+
+It's possible to get Hash and String representation of the `Entry`:
+
+```ruby
+entry.to_h
+entry.to_s(true)
+```
+
+### Searching
+
+`PO` is an `Enumerable`. All exciting methods from `Enumerable` are available in `PO`. the `PO` yields `Entry`.
+
+### Saving
+You can simply save the PO file using the `PO` object:
+
+```ruby
+po.save_file
+```
+
+If you want to save as the file in diffrent location change the `path`:
+
+```ruby
+po.path
+#=> example.po
+po.path = 'example2.po'
+po.save_file
+```
+
+##To-Do
+
+* Streaming support
+* Better error reporting
+
+## Contributing
+
+1. Fork it ( http://github.com/arashm/poparser/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/poparser/comment.rb

@@ -0,0 +1,28 @@
+module PoParser
+  class Comment
+    attr_accessor :type, :str
+
+    def initialize(type, str)
+      @type = type
+      @str  = str
+    end
+
+    def to_s(with_label = false)
+      return @str unless with_label
+      if @str.is_a? Array
+        string = []
+        @str.each do |str|
+          string << "#{COMMENTS_LABELS[@type]} #{str}\n".gsub(/[^\S\n]+$/, '')
+        end
+        return string.join
+      else
+        # removes the space but not newline at the end
+        "#{COMMENTS_LABELS[@type]} #{@str}\n".gsub(/[^\S\n]+$/, '')
+      end
+    end
+
+    def to_str
+      @str
+    end
+  end
+end

data/lib/poparser/constants.rb

@@ -0,0 +1,18 @@
+module PoParser
+  COMMENTS_LABELS = {
+    :translator_comment => '#',
+    :refrence => '#:',
+    :extracted_comment => '#.',
+    :flag => '#,',
+    :previous_untraslated_string => '#|',
+  }
+
+  ENTRIES_LABELS = {
+    :msgid => 'msgid',
+    :msgid_plural => 'msgid_plural',
+    :msgstr => 'msgstr',
+    :msgctxt => 'msgctxt'
+  }
+
+  LABELS = COMMENTS_LABELS.merge(ENTRIES_LABELS).keys
+end

data/lib/poparser/entry.rb

@@ -0,0 +1,154 @@
+module PoParser
+  class Entry
+    # TODO: raise error if a label is not known
+    def initialize(args= {})
+      # Defining all instance variables to prevent warnings
+      LABELS.each do |label|
+        instance_variable_set "@#{label.to_s}".to_sym, nil
+      end
+
+      # Set passed arguments
+      args.each do |type, string|
+        if COMMENTS_LABELS.include? type
+          instance_variable_set "@#{type.to_s}".to_sym, Comment.new(type, string)
+        elsif ENTRIES_LABELS.include? type
+          instance_variable_set "@#{type.to_s}".to_sym, Message.new(type, string)
+        elsif type.to_s.match(/^msgstr\[[0-9]\]/)
+          # If it's a plural msgstr
+          @msgstr ||= []
+          @msgstr << Message.new(type, string)
+        end
+      end
+
+      define_writer_methods
+      define_reader_methods
+    end
+
+    # Checks if the entry is untraslated
+    # 
+    # @return [Boolean]
+    def untranslated?
+      @msgstr.nil? || @msgstr.to_s == ''
+    end
+    alias_method :incomplete? , :untranslated?
+
+    # Checks if the entry is translated
+    # 
+    # @return [Boolean]
+    def translated?
+      not untranslated?
+    end
+    alias_method :complete? , :translated?
+
+    # Checks if the entry is plural
+    # 
+    # @return [Boolean]
+    def plural?
+      @msgid_plural != nil
+    end
+
+    # Checks if the entry is fuzzy
+    # 
+    # @return [Boolean]
+    def fuzzy?
+      @flag.to_s == 'fuzzy'
+    end
+
+    # Flag the entry as Fuzzy
+    # @return [Entry]
+    def flag_as_fuzzy
+      @flag = 'fuzzy'
+      self
+    end
+
+    # Set flag to a custome string
+    def flag_as(flag)
+      raise ArgumentError if flag.class != String
+      @flag = flag
+    end
+
+    # Convert entry to a hash key value
+    # @return [Hash]
+    def to_h
+      hash = {}
+      instance_variables.each do |label|
+        object = instance_variable_get(label)
+        # If it's a plural msgstr
+        if object.is_a? Array
+          object.each do |entry|
+            hash[entry.type] = entry.to_s if not entry.nil?
+          end
+        else
+          hash[object.type] = object.to_s if not object.nil?
+        end
+      end
+      hash
+    end
+
+    # Convert entry to a string
+    # @return [String]
+    def to_s
+      lines = []
+      LABELS.each do |label|
+        object = instance_variable_get("@#{label}".to_sym)
+        # If it's a plural msgstr
+        if object.is_a? Array
+          object.each do |entry|
+            lines << entry.to_s(true) if not entry.nil?
+          end
+        else
+          lines << object.to_s(true) if not object.nil?
+        end
+      end
+
+      lines.join
+    end
+  
+  private
+
+    def define_writer_methods
+      COMMENTS_LABELS.each do |type, mark|
+        unless Entry.method_defined? "#{type}=".to_sym
+          self.class.send(:define_method, "#{type}=".to_sym, lambda { |val|
+            if instance_variable_get("@#{type}".to_sym).is_a? Comment
+              comment = instance_variable_get "@#{type}".to_sym
+              comment.type = type
+              comment.str = val
+            else
+              instance_variable_set "@#{type}".to_sym, Comment.new(type, val)
+            end
+            instance_variable_get "@#{type}".to_sym
+          })
+        end
+      end
+
+      ENTRIES_LABELS.each do |type, mark|
+        unless Entry.method_defined? "#{type}=".to_sym
+          self.class.send(:define_method, "#{type}=".to_sym, lambda { |val|
+            if instance_variable_get("@#{type}".to_sym).is_a? Message
+              message = instance_variable_get "@#{type}".to_sym
+              message.type = type
+              message.str = val
+            else
+              instance_variable_set "@#{type}".to_sym, Message.new(type, val)
+            end
+            instance_variable_get "@#{type}".to_sym
+          })
+        end
+      end
+
+      self.class.send(:alias_method, :translate, :msgstr=)
+    end
+
+    def define_reader_methods
+      LABELS.each do |label|
+        unless Entry.method_defined? "#{label}".to_sym
+          self.class.send(:define_method, label.to_sym) do
+            instance_variable_get "@#{label}".to_sym
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/poparser/message.rb

@@ -0,0 +1,51 @@
+module PoParser
+  class Message
+    attr_accessor :type
+    attr_writer :str
+
+    def initialize(type, str)
+      @type = type
+      @str  = str
+
+      remove_empty_line
+    end
+
+    def str
+      @str.join
+    end
+
+    def to_s(with_label = false)
+      return @str unless with_label
+      if @str.is_a? Array
+        remove_empty_line
+        # multiline messages should be started with an empty line
+        lines = ["#{label} \"\"\n"]
+        @str.each do |str|
+          lines << "\"#{str}\"\n"
+        end
+        return lines.join
+      else
+        "#{label} \"#{@str}\"\n"
+      end
+    end
+
+    def to_str
+      @str.join
+    end
+
+  private
+    def remove_empty_line
+      if @str.is_a? Array
+        @str.shift if @str.first == ''
+      end
+    end
+
+    def label
+      if @type.to_s.match(/msgstr\[[0-9]\]/)
+        @type
+      else
+        ENTRIES_LABELS[@type]
+      end
+    end
+  end
+end

data/lib/poparser/parser.rb

@@ -0,0 +1,66 @@
+module PoParser
+  class Parser < Parslet::Parser
+    root(:document)
+
+    rule(:document) { lines.repeat }
+    rule(:lines)    { comments | entries }
+
+    # Comments
+    rule(:comments) do
+      refrence |
+      extracted_comment | flag |
+      previous_untraslated_string |
+      translator_comment
+    end
+
+    rule(:translator_comment)         { spaced('#') >> comment_text_line.as(:translator_comment) }
+    rule(:extracted_comment)          { spaced('#.') >> comment_text_line.as(:extracted_comment) }
+    rule(:refrence)                   { spaced('#:') >> comment_text_line.as(:refrence) }
+    rule(:flag)                       { spaced('#,') >> comment_text_line.as(:flag) }
+    rule(:previous_untraslated_string){ spaced('#|') >> comment_text_line.as(:previous_untraslated_string) }
+
+    # Entries
+    rule(:entries) do
+      msgid.as(:msgid) | 
+      msgid_plural.as(:msgid_plural) |
+      msgstr.as(:msgstr) |
+      msgstr_plural.as(:msgstr_plural) |
+      msgctxt.as(:msgctxt)
+    end
+
+    rule(:multiline)    { str('"').present? >> msg_text_line.repeat.maybe }
+    rule(:msgid)        { spaced('msgid') >> msg_text_line >> multiline.repeat }
+    rule(:msgid_plural) { spaced('msgid_plural') >> msg_text_line >> multiline.repeat }
+    
+    rule(:msgstr)       { spaced('msgstr') >> msg_text_line >> multiline.repeat }
+    rule(:msgstr_plural){ str('msgstr') >> bracketed(match["[0-9]"].as(:plural_id)) >> space? >> msg_text_line >> multiline.repeat }
+    rule(:msgctxt)      { spaced('msgctxt') >> msg_text_line >> multiline.repeat }
+
+    # Helpers
+    rule(:space)       { match['[^\S\n]'] } #match only whitespace and not newline
+    rule(:space?)      { space.maybe }
+    rule(:newline)     { match["\n"] }
+    rule(:eol)         { newline | any.absent? }
+    rule(:character)   { escaped | text }
+    rule(:text)        { any }
+    rule(:escaped)     { str('\\') >> any }
+    rule(:msg_line_end){ str('"') >> eol }
+
+    rule(:comment_text_line) do
+      (eol.absent? >> character).repeat.maybe.as(:text) >> eol
+    end
+
+    rule(:msg_text_line) do
+      str('"') >> (msg_line_end.absent? >> character).repeat.maybe.as(:text) >> msg_line_end
+    end
+
+    def bracketed(atom)
+      str('[') >> atom >> str(']')
+    end
+
+    def spaced(character)
+      str(character) >> space?
+    end
+  end
+end
+

data/lib/poparser/po.rb

@@ -0,0 +1,134 @@
+module PoParser
+  # Po class keeps all entries of a Po file
+  # 
+  class Po
+    include Enumerable
+    attr_reader :entries
+    attr_accessor :path
+    alias_method :all, :entries
+
+    def initialize(args = {})
+      @entries = []
+      @path    = args.fetch(:path, nil)
+    end
+
+    # add new entries to po file
+    # 
+    # @example
+    #   entry = { 
+    #             translator_comment: 'comment',
+    #             refrence: 'refrense comment',
+    #             flag: 'fuzzy',
+    #             msgstr: 'translatable string',
+    #             msgstr: 'translation'
+    #           }
+    #   add_entry(entry)
+    # 
+    # @param entry [Hash, Array] a hash of entry contents or an array of hashes
+    def add_entry(entry)
+      if entry.kind_of? Hash
+        @entries << Entry.new(entry)
+        @entries.last
+      elsif entry.kind_of? Array
+        entry.each do |en|
+          @entries << Entry.new(en)
+        end
+      else
+        raise ArgumentError, 'Must be a hash or an array of hashes'
+      end
+    end
+    alias_method :<<, :add_entry
+
+    # Finds all entries that are flaged as fuzzy
+    # 
+    # @return [Array] an array of fuzzy entries
+    def fuzzy
+      find_all do |entry|
+        entry.fuzzy?
+      end
+    end
+
+    # Finds all entries that are untranslated
+    # 
+    # @return [Array] an array of untranslated entries
+    def untranslated
+      find_all do |entry|
+        entry.untranslated?
+      end
+    end
+
+    # Finds all entries that are translated
+    # 
+    # @return [Array] an array of translated entries
+    def translated
+      find_all do |entry|
+        entry.translated?
+      end
+    end
+
+    # Shows statistics and status of the provided file in percentage.
+    # 
+    # @return [Hash] a hash of translated, untranslated and fuzzy percentages
+    def stats
+      untranslated_size = untranslated.size
+      translated_size = translated.size
+      fuzzy_size = fuzzy.size
+
+      {
+        translated: percentage(translated_size - fuzzy_size),
+        untranslated: percentage(untranslated_size),
+        fuzzy: percentage(fuzzy_size)
+      }
+    end
+
+    # Converts Po file to an hashes of entries
+    # 
+    # @return [Array] array of hashes of entries
+    def to_h
+      array = []
+      @entries.each do |entry|
+        array << entry.to_h
+      end
+      array
+    end
+
+    # Shows a String representation of the Po file
+    # 
+    # @return [String]
+    def to_s
+      array = []
+      @entries.each do |entry|
+        array << entry.to_s
+      end
+      array.join("\n")
+    end
+
+    # Saves the file to the provided path
+    def save_file
+      raise ArgumentError, 'Need a Path to save the file' if @path.nil?
+      File.open(@path, 'w') do |f|
+        f.write to_s
+      end
+    end
+
+    def each
+      @entries.each do |entry|
+        yield entry
+      end
+    end
+
+    def inspect
+      "<#{self.class.name}, Translated: #{stats[:translated]}% Untranslated: #{stats[:untranslated]}% Fuzzy: #{stats[:fuzzy]}%>"
+    end
+
+  private
+    # calculates percentages based on total number of entries
+    # 
+    # @param [Integer] number of entries
+    # @return [Float] percentage of the provided entries
+    def percentage(size)
+      total = @entries.size
+      ((size.to_f / total) * 100).round(1)
+    end
+  end
+end