yamlt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 31ebdd1c019feb3155c4ea520ec2c81c6f7fc0a0
+  data.tar.gz: 51d7d3b140f9394a13786e6fda384181d268877d
+SHA512:
+  metadata.gz: bbe927ff3463528669f4f6d57c4fd3bf6f66a37bde301b902079410d3d77c08f6e6b78fbfce3f924d229b71c1ef34df715fc95bd38e31149bdafe647a472323f
+  data.tar.gz: f074c43f9fbf5c9b0a60a290a91a4c995a99bf46afb5d9918a1dfc094c3ce0fd9184da2eccb4b38019cfa6d01e888f3008aafd4850a4117e548aae382048ece3

data/lib/yamlt/checker/reporter.rb

@@ -0,0 +1,33 @@
+# ------------------------------------------------------------------------------
+# @class: Yamlt::Checker::Reporter
+# @description: Default checker reporter
+# ------------------------------------------------------------------------------
+
+module Yamlt
+  class Checker
+    class Reporter
+      def absent(key, old_value)
+        print " * Key is absent: #{key}, old_value: "
+        puts_value(old_value)
+      end
+
+      def unchanged(key, old_value)
+        puts " * Key is unchanged: #{key}, old_value: "
+        puts_value(old_value)
+      end
+
+      private
+
+      def puts_value(value)
+        if value.include?($/)
+          lines = value.split($/)
+          max_length = lines.map(&:length).max
+          puts $/ + value.split($/).map{|s|" | #{s}"} * $/
+          puts " `-" + "-" * max_length
+        else
+          puts value
+        end
+      end
+    end
+  end
+end

data/lib/yamlt/checker.rb

@@ -0,0 +1,58 @@
+# ------------------------------------------------------------------------------
+# @class: Yamlt::Checker
+# @description: Makes a diff between two yaml files
+# ------------------------------------------------------------------------------
+require "yamlt/parser"
+require "yamlt/loader"
+require "yamlt/checker/reporter"
+
+module Yamlt
+  class Checker
+    def initialize(source, target, reporter = Yamlt::Checker::Reporter.new)
+      @source = source
+      @target = target
+      @reporter = reporter
+    end
+
+    def call
+      check
+    end
+
+    def self.call(source, target, reporter)
+      new(source, target, reporter).()
+    end
+
+    private
+
+    def state
+      @state ||=
+        if @source.is_a?(String)
+          Yamlt::Parser.new(@source).parse
+        else
+          @source
+        end
+    end
+
+    def loader
+      @loader ||=
+        if @target.is_a?(String)
+          Yamlt::Loader.new(@target)
+        else
+          @target
+        end
+    end
+
+    def check
+      state.values.keys.each do |key|
+        source_value = state.values[key]
+        target_value = loader[key]
+
+        if target_value.nil?
+          @reporter.absent(key, source_value)
+        elsif target_value == source_value
+          @reporter.unchanged(key, source_value)
+        end
+      end
+    end
+  end
+end

data/lib/yamlt/language_pair.rb

@@ -0,0 +1,15 @@
+#
+#
+#
+#
+
+module Yamlt
+  class LanguagePair
+    def initialize(from: "en", to: "ru")
+      @from = from
+      @to = to
+    end
+
+    attr_reader :from, :to
+  end
+end

data/lib/yamlt/loader.rb

@@ -0,0 +1,61 @@
+#
+#
+#
+#
+#
+require "yaml"
+
+module Yamlt
+  class Loader
+    def initialize(filepath)
+      @filepath = filepath
+      @loaded = false
+    end
+
+    def [](key)
+      path = path0(key)
+      value = values
+      path.each do |fragment|
+        value = value[fragment]
+        return nil unless value
+      end
+      value
+    end
+
+    def language
+      @locale ||=
+        begin
+          values.keys.first || @filepath[/(\w+)\.yml$/, 1]
+        end
+    end
+
+    private
+
+    def path0(key)
+      keys = values.keys
+
+      raise Yamlt::LoaderException "Locale file should have only one root key" if keys.size != 1
+
+      key.split(".").tap do |path|
+        path[0] = keys.first
+      end
+    end
+
+    def values
+      @values ||= (load unless @loaded)
+    end
+
+    def load
+      begin
+        @values = YAML.load_file(@filepath)
+      rescue Errno::ENOENT => noent
+        @values = {}
+      end
+
+      @loaded = true
+      @values
+    end
+  end
+
+  class LoaderException < ::StandardError; end
+end

data/lib/yamlt/parser/line/serializer.rb

@@ -0,0 +1,74 @@
+module Yamlt
+  class Parser
+    class Line
+      class Serializer
+        def initialize(line, overrides = {})
+          @line = line
+          @overrides = overrides
+        end
+
+        def to_s
+          [ level_string,
+            fragment_string,
+            prefix_string,
+            value_string,
+            comment
+          ].join("")
+        end
+
+        private
+
+        def level_string
+          if @line.level
+            indent(@line.level)
+          end.to_s
+        end
+
+        def indent(lvl)
+          "  " * lvl
+        end
+
+        def fragment_string
+          if fragment
+            "#{fragment}:"
+          end.to_s
+        end
+
+        def fragment
+          @overrides[:fragment] || @line.fragment
+        end
+
+        def comment
+          if @line.comment
+            "##{@line.comment}"
+          end.to_s
+        end
+
+        def prefix_string
+          @line.prefix.to_s
+        end
+
+        def value_string
+          if @line.fragment && value
+            if value.include?($/)
+              "|\n" +
+              value.split($/).map do |value_part|
+                "#{indent(@line.level + 1)}\"#{escaped(value_part)}\""
+              end.join($/)
+            else
+              "\"#{escaped(value)}\""
+            end
+          end.to_s
+        end
+
+        def value
+          @overrides[:value] || @line.value
+        end
+
+        def escaped(string)
+          string.gsub(/\"/, "\\\"")
+        end
+      end
+    end
+  end
+end

data/lib/yamlt/parser/line.rb

@@ -0,0 +1,67 @@
+#
+#
+#
+#
+#
+require "yamlt/parser/line/serializer"
+
+module Yamlt
+  class Parser
+    class Line
+      def initialize(text)
+        @text = text
+        parse
+      end
+
+      attr_reader :comment, :prefix, :fragment, :level, :multiline
+      attr_accessor :full_path, :value
+
+      def as_text(opts={})
+        serializer = Serializer.new(self, opts)
+        serializer.to_s
+      end
+
+      def empty?
+        !@fragment && !@value
+      end
+
+      private
+
+      def parse
+        case @text
+        when /^\s*$/
+          # do nothing
+        when /^(\s*)#(.*)$/; @comment = $~[2]; @prefix = $~[1]
+        when /^(\s*)(\w+):(\s*)(#(.*))?$/
+          if $~[1].length % 2 == 0
+            @fragment = $~[2]
+            @level = $~[1].length / 2
+            @prefix = $~[3]
+            @comment = $~[5]
+          end
+        when /^(\s*)(\w+):(\s*)([\'\"])(.*)\4/
+          if $~[1].length % 2 == 0
+            @fragment = $~[2]
+            @level = $~[1].length / 2
+            @prefix = $~[3]
+            @value = $~[5]
+          end
+        when /^(\s*)(\w+):(\s*)\|(\s*)$/
+          if $~[1].length % 2 == 0
+            @fragment = $~[2]
+            @level = $~[1].length / 2
+            @prefix = $~[3] || $~[4]
+            @multiline = true
+          end
+
+        when /^(\s*)([\'\"]?)(.*)\2\s*$/
+          if $~[1].length % 2 == 0
+            @level = $~[1].length / 2
+            @value = $~[3]
+            @multiline = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yamlt/parser/state.rb

@@ -0,0 +1,87 @@
+module Yamlt
+  class Parser
+    class State
+      def initialize
+        @path = []
+        @level = 0
+        @multiline = []
+        @line = nil
+
+        @lines = []
+        @values = {}
+
+        @languate = nil
+      end
+
+      attr_reader :path, :level, :multiline, :line, :lines, :values, :language
+
+      def apply(line)
+        pass_through(line)   if line.empty?
+        apply_fragment(line) if line.fragment
+        apply_value(line)    if !line.fragment && line.value
+      end
+
+      def flush
+        if @line && @line.multiline && !@multiline.empty?
+          add_value
+        end
+      end
+
+      private
+
+      def pass_through(line)
+        @lines.push(line)
+      end
+
+      def apply_fragment(line)
+        if line.level > @level
+          raise StateException, "Path fragment level is too high\n#{line.as_text}"
+        elsif line.level < @level
+          if !@multiline.empty? && @line
+            add_value
+          end
+        end
+
+        if line.level == 0 && line.fragment
+          @language ||= line.fragment
+        end
+
+        @path = @path[0, line.level]
+        @path.push(line.fragment)
+        @level = line.level + 1
+
+        @lines.push(line)
+
+        if line.value
+          full_path = @path.join(".")
+          line.full_path = full_path
+          @values[full_path] = line.value
+        end
+
+        if line.multiline
+          @line = line
+          @multiline = []
+        end
+      end
+
+      def apply_value(line)
+        if line.level != @level
+          raise Yamlt::Parser::StateException, "Wrong identation in multiline value\n#{line.as_text}"
+        end
+        @multiline.push(line.value)
+      end
+
+      def add_value
+        full_path = @path.join(".")
+        value = @multiline.join($/)
+        @values[full_path] = value
+        @line.full_path = full_path
+        @line.value = value
+        @multiline = []
+        @line = nil
+      end
+    end
+
+    class StateException < ::StandardError; end
+  end
+end

data/lib/yamlt/parser.rb

@@ -0,0 +1,38 @@
+# ------------------------------------------------------------------------------
+# @class: Yamlt::Parser
+# @description: Parse yaml file structure and store it into state object
+# ------------------------------------------------------------------------------
+require "yamlt/parser/line"
+require "yamlt/parser/state"
+
+module Yamlt
+  #
+  #
+  class Parser
+    #
+    #
+    #
+    def initialize(filepath)
+      @filepath = filepath
+      @state = Yamlt::Parser::State.new
+    end
+
+    #
+    #
+    def parse
+      IO.read(@filepath).each_line do |line|
+        parse_line(line)
+      end
+
+      @state.flush
+
+      @state
+    end
+
+    private
+
+    def parse_line(text)
+      @state.apply(Yamlt::Parser::Line.new(text))
+    end
+  end
+end

data/lib/yamlt/translator.rb

@@ -0,0 +1,21 @@
+# ------------------------------------------------------------------------------
+# @class: Yamlt::Translator
+# @description: Default class for translating from lang1 to lang2
+# ------------------------------------------------------------------------------
+
+module Yamlt
+  class Translator
+    def initialize(source_lang, target_lang)
+      @source_lang = source_lang
+      @target_lang = target_lang
+    end
+
+    def translate(original,target = nil)
+      if respond_to?(:custom_translate)
+        self.custom_translate(original, target)
+      else
+        original
+      end
+    end
+  end
+end

data/lib/yamlt/updater.rb

@@ -0,0 +1,64 @@
+# ------------------------------------------------------------------------------
+# @class: Yamlt::Updater
+# @description: Takes first yaml file as template and writes second file copy
+# ------------------------------------------------------------------------------
+
+require "yamlt/loader"
+require "yamlt/parser"
+require "yamlt/translator"
+
+module Yamlt
+  class Updater
+    def initialize(source, target, translator_class = Yamlt::Translator)
+      @source = source
+      @target = target
+      @translator = translator_class.new(state.language, loader.language)
+    end
+
+    def call
+      of = File.new(target_updated, "w")
+
+      state.lines.each do |line|
+        of.puts format_line(line)
+      end
+
+      of.close
+    end
+
+    def rename_updated
+      File.rename(target_updated, target)
+    end
+
+    private
+
+    def state
+      @state ||=
+        if @source.is_a?(String)
+          Yamlt::Parser.new(@source).parse
+        else
+          @source
+        end
+    end
+
+    def loader
+      @loader ||= Yamlt::Loader.new(@target)
+    end
+
+    def target_updated
+      @target_updated ||=
+        if /\.yml$/ === @target
+          @target[/^(.*)\.yml$/, 1] + ".updated.yml"
+        else
+          @target + ".updated.yml"
+        end
+    end
+
+    def format_line(line)
+      if line.level == 0 && line.fragment
+        line.as_text(fragment: loader.language)
+      else
+        line.as_text
+      end
+    end
+  end
+end

data/lib/yamlt/writer.rb

@@ -0,0 +1,56 @@
+#
+#
+#
+#
+#
+module Yamlt
+  class Writer
+    def initialize(state, loader,
+        opts = {from: "en", to: "ru"},
+        callback = -> (old_value, path, from_l, to_l) { old_value } )
+      @state = state
+      @loader = loader
+      @opts = opts
+      @callback = callback
+    end
+
+    def write(stream)
+      @state.lines.each do |line|
+        unless line.value
+          stream.write(line.as_text)
+        else
+          stream.write(format_line(line))
+        end
+      end
+    end
+
+    private
+
+    def value_by_path(path)
+      value = @loader[path]
+
+      raise Yamlt::WriterException unless [String, NilClass].include?(value.class)
+
+      value
+    end
+
+    def format_line(line)
+      old_value = value_by_path(line.full_path) || line.value
+
+      new_value = @callback.(old_value, line.full_path, @opts[:from], @opts[:to])
+
+      multiline = new_value.to_s.split($/)
+
+      if multiline.size > 1
+        ([ "  " * line.level + line.fragment + ": |" ] +
+          multiline.map { |str| "  " * (line.level + 1) + str }) * $/
+      else
+        "  " * line.level + line.fragment + ": " + escaped_value(new_value)
+      end
+    end
+
+    def escaped_value(value)
+      "\"" + value.gsub("\"", "\\\"") + "\""
+    end
+  end
+end

data/lib/yamlt.rb

@@ -0,0 +1,8 @@
+#
+#
+#
+#
+#
+require "yamlt/parser"
+require "yamlt/loader"
+require "yamlt/checker"

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: yamlt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tangerine Cat
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Take yaml structure from locale file and apply to another one
+email: kaineer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yamlt.rb
+- lib/yamlt/checker.rb
+- lib/yamlt/checker/reporter.rb
+- lib/yamlt/language_pair.rb
+- lib/yamlt/loader.rb
+- lib/yamlt/parser.rb
+- lib/yamlt/parser/line.rb
+- lib/yamlt/parser/line/serializer.rb
+- lib/yamlt/parser/state.rb
+- lib/yamlt/translator.rb
+- lib/yamlt/updater.rb
+- lib/yamlt/writer.rb
+homepage: http://rubygems.org/gems/yamlt
+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: Take yaml structure from locale file and apply to another one
+test_files: []