tcl-msgcat 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d08c896d423e775ef1b282c5399bd57087c3ef7
+  data.tar.gz: c66f9414471f9a514af85e9ea1cf7f6eadf36204
+SHA512:
+  metadata.gz: e290d35a7c371da396f1a6705b7d464fddecaab9ee44748415f9d0a7569781ed3b8128995f678acb7214e291c92c90145b3a2dc3ee3e40308e5541d94ff934bf
+  data.tar.gz: b93c2286e49c180b27d5635918b993cecc804f48a357bfa400fa961dbf80a657fc5527b0ef043285648b9427d3b9e277864b985ad741869b80bbe5ab9f67082a

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tcl-msgcat.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Robert McLeod
+
+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,62 @@
+# Tcl::Msgcat
+
+Library for parsing, rendering and merging TCL msgcat (read i18n) files.
+
+TCL msgcat files are yuk, and a legacy format.  Unfortunately some of us are stuck with systems that still use these files
+for i18n in TCL applications.  Managing these files can be a bit annoying, especially when they are large and you have
+many different people translating them.  What's more, TCL doesn't report line numbers in it's error messages!!!  So if you have
+an error in your 7000 line msgcat file, good luck finding it!
+
+This library aims to solve that problem by storing the translations in JSON and compiling them to the TCL msgcat format.  JSON
+is easily lintable and most syntax checkers tell you which line any errors are on.  Plus it is a modern standard and supported
+by lots of languages which are better than TCL so you can programmatically update changes between your root message file and
+your translation files.  Which is another thing this library does.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tcl-msgcat'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tcl-msgcat
+
+## Usage
+
+You'll want to convert your existing files first.  You can do this with the following command:
+
+    msgcat parse root.msg > root.json
+    msgcat parse zh_tw.msg > zh_tw.json
+
+And render it back to the msgcat file:
+
+    msgcat render root.json > root.test.msg
+
+OK, now say you have added a bunch of strings to your `root.json` for some new stuff in the application. You
+will want to update all your other files with those strings, and send them off to your translators.  For this
+there is the `merge` action with a few ways to use it:
+
+    msgcat merge root.json fr.json de.json es.json # specify files individually
+    msgcat merge root.json *.json                  # or glob them (root.json is automatically excluded)
+
+Now you have got your files back from the translators, put them through a [linter](http://jsonlint.com/)
+and found no errors.  You are ready to put those new translations back into your application. Use the `compile`
+action to run the render command on all your json files:
+
+    msgcat compile ui/msgs                 # only one arg needed if you don't segregate source/compiled
+    msgcat compile ui/msgs/source ui/msgs  # otherwise specify the source and compile paths seperately
+
+## Contributing
+
+1. Fork it ( https://github.com/AutogrowSystems/tcl-msgcat/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 a new Pull Request

data/Rakefile

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

data/bin/msgcat

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'tcl-msgcat'
+
+case ARGV[0]
+when "parse", "p"
+  file = ARGV[1]
+  puts Tcl::Msgcat.parse(file).to_json
+when "render", "r"
+  file = ARGV[1]
+  puts Tcl::Msgcat.render(file).to_s
+when "merge", "m"
+  root = ARGV[1]
+  files = ARGV[2..-1]
+  Tcl::Msgcat.merge(root, files)
+when "compile"
+  source_path = ARGV[1]
+  target_path = ARGV[2] || ARGV[1]
+
+  Tcl::Msgcat.compile(source_path, target_path)
+else
+  puts <<-EOH
+Usage: msgcat <action> <arguments>
+
+Actions:
+  parse <file>               Parse a msgcat file and output JSON
+  render <file>              Parse a JSON file and output msgcat
+  merge <root> <files>       Merge new keys from root into the files (glob pattern)
+  compile <source> [target]  Compile from the source into the target
+
+Examples:
+  msgcat parse ROOT.msg > root.json
+  msgcat render root.json > ROOT.msg
+  msgcat merge root.json path/to/translations/*.json
+  msgcat merge root.json zh_tw.json fr.json de.json
+  msgcat compile path/to/my/json/files path/to/my/msgcat/files
+  msgcat compile path/to/my/json/msgcat/files
+  EOH
+end

data/lib/tcl/msgcat/catalog.rb

@@ -0,0 +1,20 @@
+module Tcl
+  module Msgcat
+    class Catalog
+      attr_reader :msgs
+      def initialize(msgs)
+        @msgs = msgs
+      end
+
+      def merge!(catalog)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+        @msgs = catalog.msgs.merge(@msgs, &merger)
+      end
+
+      def self.load(file)
+        msgs = JSON.parse(File.read(file))
+        Tcl::Msgcat::Catalog.new(msgs)
+      end
+    end
+  end
+end

data/lib/tcl/msgcat/parser.rb

@@ -0,0 +1,91 @@
+module Tcl
+  module Msgcat
+
+    # Parses a msgcat file into a ruby hash
+    # which can then be converted to whatever
+    class Parser
+      attr_reader :msgs
+
+      def initialize(file)
+        raise ArgumentError, "File not found" unless File.exist? file
+
+        @msgs = {}
+        @file = file
+      end
+
+      def parse
+        lines  = File.read(@file).lines
+        scopes = []
+
+        # strip the comments out
+        lines.reject! {|l| l.match(/^\s?#/) }
+
+        # run through each line and do an action
+        # depending on the kind of line it is
+        lines.each do |line|
+
+          # start of a message group/namespace definition
+          if match = line.match(/msgs (\S+) \{/)  # msg ::site::irrigation {
+            scopes << match[1]
+            next
+          end
+
+          # end of the message group/namespace definition
+          if match = line.match(/\}/)             # }
+            scopes.pop
+            next
+          end
+
+          # an actual message definition
+          if match = line.match(/m (\S+) "(.+)"/) # m label "the actual string"
+            add(scopes, match[1], match[2])
+          end
+        end
+
+        self
+      end
+
+      # Adds a key and translation to the msg hash
+      #
+      # Uses eval to dynamically create a multi dimensional
+      # hash from the scopes array that is given
+      #
+      def add(scopes, name, string)
+        chain = []
+
+        # run through each scope
+        scopes.each_with_index do |k, i|
+          chain = []
+          
+          # build the chain of send commands from the top level
+          # to the level of the current scope, for each iteration
+          #
+          # e.g. for iteration:
+          #
+          # first:  hash[:scope1]
+          # second: hash[:scope1][:scope2]
+          # third:  hash[:scope1][:scope2][:scope3]
+          subkeys = scopes[0..i]
+          subkeys.each do |k|
+            chain << "send('[]', '#{k}')"
+          end
+
+          # if the (sub)key doesn't exist for this (chain of) scopes
+          # then set it to an empty hash
+          if eval("@msgs.#{chain.join(".")}").nil?
+            set_chain = chain[0..-2] + ["send('[]=', '#{subkeys.last}', {})"]
+            eval("@msgs.#{set_chain.join(".")}")
+          end
+        end
+
+        # set the value a the end of the chain
+        chain << "send('[]=', '#{name}', %q[#{string}])"
+        eval("@msgs.#{chain.join(".")}")
+      end
+
+      def to_json(pretty=true)
+        pretty ? JSON.pretty_generate(@msgs) : @msgs.to_json
+      end
+    end
+  end
+end

data/lib/tcl/msgcat/renderer.rb

@@ -0,0 +1,47 @@
+module Tcl
+  module Msgcat
+    class Renderer
+      attr_reader :msgs, :lines
+      def initialize(msgs)
+        @msgs  = msgs
+        @lines = []
+      end
+
+      def render
+        @lines << "package require mchelper"
+        @lines << "msg_lang {}"
+        @lines << ""
+        _render(@msgs)
+
+        self
+      end
+
+      def to_s
+        @lines.join("\n")
+      end
+
+      private
+
+      # A recursive function that calls itself
+      # when the value of a key is a hash so it can
+      # iterate through every dimension of the hash
+      # to get at the translation labels and strings
+      def _render(msgs, level=0)
+        msgs.each do |key, value|
+          if value.is_a? Hash
+            @lines << "msgs #{key} {".rpad("  ", level)
+            level+=1
+            _render(value, level) # render any child hashes or translation labels/strings
+            level-=1
+            @lines << "}".rpad("  ", level)
+            @lines << ""
+          end
+
+          if value.is_a? String
+            @lines << "m #{key} \"#{value}\"".rpad("  ", level)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tcl/msgcat/version.rb

@@ -0,0 +1,5 @@
+module Tcl
+  module Msgcat
+    VERSION = "0.5"
+  end
+end

data/lib/tcl/msgcat.rb

@@ -0,0 +1,50 @@
+require 'json'
+require "tcl/msgcat/version"
+require "tcl/msgcat/catalog"
+require "tcl/msgcat/parser"
+require "tcl/msgcat/renderer"
+
+module Tcl
+  module Msgcat
+    def parse(msgcat_file)
+      Tcl::Msgcat::Parser.new(msgcat_file).parse
+    end
+
+    def render(json_file)
+      raise ArgumentError, "File not found: #{json_file}" unless File.exist? json_file
+      msgs = JSON.parse(File.read(json_file))
+      Tcl::Msgcat::Renderer.new(msgs).render
+    end
+
+    def merge(root_file, translation_files=[])
+      if translation_files.is_a? String
+        translation_files = Dir[translation_files]
+      end
+
+      root = Tcl::Msgcat::Catalog.load(root_file)
+
+      translation_files.each do |file|
+        next if File.basename(file) == File.basename(root_file)
+        print "Merging new translations into #{file}... "
+        catalog = Tcl::Msgcat::Catalog.load(file)
+        catalog.merge!(root)
+        File.open(file, "w") {|f| f.write catalog.to_json }
+        puts "done"
+      end
+    end
+
+    def compile(source, target)
+      raise ArgumentError, "Not a directory: #{source}" unless File.directory? source
+      raise ArgumentError, "Not a directory: #{target}" unless File.directory? target
+
+      Dir["#{source}/*.json"].each do |src|
+        dst = File.basename(src, ".json")+".msg"
+        print "Compiling #{src} to #{target}/#{dst}... "
+        msgs = JSON.parse(File.read(src))
+        renderer = Tcl::Msgcat::Renderer.new(msgs).render
+        File.write("#{target}/#{dst}") {|f| f.write renderer.to_s }
+        puts "done"
+      end
+    end
+  end
+end

data/tcl-msgcat.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tcl/msgcat/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tcl-msgcat"
+  spec.version       = Tcl::Msgcat::VERSION
+  spec.authors       = ["Robert McLeod"]
+  spec.email         = ["robert@autogrow.com"]
+  spec.summary       = %q{Library for parsing, rendering and merging TCL msgcat files}
+  spec.description   = %q{Library for parsing, rendering and merging TCL msgcat files}
+  spec.homepage      = "https://github.com/AutogrowSystems/tcl-msgcat"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: tcl-msgcat
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Robert McLeod
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Library for parsing, rendering and merging TCL msgcat files
+email:
+- robert@autogrow.com
+executables:
+- msgcat
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/msgcat
+- lib/tcl/msgcat.rb
+- lib/tcl/msgcat/catalog.rb
+- lib/tcl/msgcat/parser.rb
+- lib/tcl/msgcat/renderer.rb
+- lib/tcl/msgcat/version.rb
+- tcl-msgcat.gemspec
+homepage: https://github.com/AutogrowSystems/tcl-msgcat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Library for parsing, rendering and merging TCL msgcat files
+test_files: []