kube-config-parser 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84b5c93956801a3bd81dc17afa74621218b90f94
-  data.tar.gz: 871d57b9aaff2baa7be01c8203af1ad2fdbae090
+  metadata.gz: 9c8dcb06918e59549d84796e1574254de4e0e2cf
+  data.tar.gz: 23649ff20456176905ca92ab0265d603451eb9d0
 SHA512:
-  metadata.gz: 7c5b4612ec20c67a1daffb23b6dfe6829fd6dba18c8e03f4f7d7d932837f3527b72566ac717cebaaa2653d693c7ecf85888018941d3802d84cd3260552a10e77
-  data.tar.gz: b92497c81cf9f90b3dc7518ccb79ff16272d4493bd2719663b1341656248b943f310d47dcc8d44e59f27807de7a50dc2cd0585879d071ff7cd4075573edc3d93
+  metadata.gz: 9362cd8199e860c6729f1308560912607abc91ce6cdf450d36b1f512a20bc7d54e01209515e3a5ccb8940eb2c0a53b5afe3a5d5a83ce34609f7e03772810b04b
+  data.tar.gz: 0b1d6b7cadbe0797e447ad3ab762dd9f4431f7408b308a085df8dfc29dddace25171096d415c1bbce50760870e3d34fa8b6e59ad34af68b65f639671c77e5f85

data/lib/extensions/to_os.rb

@@ -0,0 +1,9 @@
+require 'ostruct'
+
+class OpenStruct
+  def self.to_os(hash)
+    OpenStruct.new(hash.each_with_object({}) do |(key, val), memo|
+      memo[key] = val.is_a?(Hash) ? to_os(val) : val
+    end)
+  end
+end

data/lib/utils/kube_config_parser.rb

@@ -1,168 +1,23 @@
 require 'yaml'
 
-module ::YAML
-  def self.kube_load(all_str)
-    all_str.split("---\n").reject(&:empty?).map do |paragraph|
-      YAML.load(paragraph)
-    end
-  end
-end
+require_relative 'kube_config_parser/paragraph'
 
 module ParserModule
-  class SimpleHash
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def method_missing(method_name_sym)
-      result = @hash[method_name_sym.to_s] || @hash[method_name_sym]
-      return nil if result.nil?
-      SimpleHash.new(result)
-    end
-
-    def inspect
-      @hash.inspect
-    end
-
-    def to_s
-      @hash.to_s
-    end
-  end
-
-  class EnvParser
-
-
-    False = false
-    True = true
-
-    def initialize(input_table, ifelse_stack)
-      @input_table = input_table
-      @variable_table = {}
-      @ifelse_stack = ifelse_stack
-    end
-
-    def ifelse_stack
-      @ifelse_stack
-    end
-
-    def update(line)
-      command = line.gsub(/\s?\|\s?/, ' || ').gsub(/set (.*?) =/, 'set[\'\1\'] =')
-      eval(command)
-    end
-
-    def set
-      @variable_table
-    end
-
-    def item
-      return SimpleHash.new(@input_table)
-    end
-
-    def default(value_str)
-      value_str
-    end
-
-    def method_missing(method_name_sym)
-      @variable_table[method_name_sym.to_s] || @variable_table[method_name_sym]
-    end
-
-    def echo(str)
-      command = '"' + str + '"'
-      #puts command
-      eval(command)
-    end
-
-  end
-
-  class IfElseStack
-    def initialize
-      @seq = []
-    end
-
-    def push(condition, str)
-      @seq.push([condition, str])
-    end
-
-    def top
-      condition, str = @seq.delete_at(0)
-      is_ruby_value = str.match(/#\{(.*?)\}/)
-      if is_ruby_value
-        value = @env_parser.instance_eval(is_ruby_value[1])
-        str = str.gsub(/#\{(.*?)\}/, value.to_s)
-      end
-      @env_parser.instance_eval(condition) ? str : nil
-    end
-
-    def set_env_parser(env_parser)
-      @env_parser = env_parser
-    end
-
-  end
-
-  class RubyStrParser
-    def self.parse(str)
-      str.gsub(/\{\{(.*?)\}\}/, '#{\1}').gsub(/\s?\|\s?/, ' || ').gsub('"', '\"')
-    end
-  end
-
   class KubeConfigParser
     def self.parse(template_path, variable_path)
-      ifelse_stack = IfElseStack.new
-
-      yml_content = File.open(template_path).read.each_line.map(&:chomp).to_a
-      env_lines = []
-      normal_lines = []
-
-      in_if_else_block = false
-      if_else_matched_condition = nil
-      if_else_matched_lines = []
-
-      yml_content.each do |line|
-        match_result = line.match(/^\{\% (set (.*?)) \%\}$/)
-        if match_result
-          env_lines << match_result[1]
-        else
-          if in_if_else_block
-            match_if_else_end = line.match(/\{\% endif -?\%\}/)
-            if match_if_else_end
-              ifelse_stack.push(if_else_matched_condition, if_else_matched_lines.join("\n"))
-              normal_lines << '#{ifelse_stack.top}'
-              in_if_else_block = false
-              if_else_matched_condition = nil
-              if_else_matched_lines = []
-            else
-              if line.match(/\{\{.*?\}\}/)
-                if_else_matched_lines << RubyStrParser.parse(line)
-              else
-                if_else_matched_lines << line
-              end
-            end
-          else  # not in if else block
-            match_if_else_start = line.match(/\{\% if (.*?) (is defined )?-?\%\}/)
-            if match_if_else_start
-              in_if_else_block = true
-              if_else_matched_condition = match_if_else_start[1]
-            else
-              normal_lines << line
-            end
-          end
-        end
-      end
+      variable_hash = YAML.load(File.open(variable_path).read)
+      config_template = File.open(template_path).read
 
-      var_table = YAML.load(File.open(variable_path).read)
-
-      normal_yml_content = normal_lines.join("\n")
-      normal_yml_content
-
-      parser = EnvParser.new(var_table, ifelse_stack)
-      ifelse_stack.set_env_parser(parser)
-
-      env_lines.each do |first_line|
-        parser.update(first_line)
-      end
-
-      ruby_style_content = RubyStrParser.parse(normal_yml_content)
-      parser.echo(ruby_style_content)
+      pm = Paragraph.new(config_template, variable_hash)
+      return pm.parse
     end
   end
 end
+
+
+if __FILE__ == $0
+  template_path = "resource/hdrs/service.yml.j2.old"
+  variable_path = "resource/hdrs/service_test.yml"
+
+  puts ParserModule::KubeConfigParser.parse(template_path, variable_path)
+end

data/lib/utils/kube_config_parser/explainer.rb

@@ -0,0 +1,116 @@
+require_relative 'expression'
+
+class Explainer
+
+  @expression_map = {}
+
+  class << self
+    attr_accessor :expression_map
+  end
+
+  def self.inherited(sub_klass)
+    sub_klass.class_eval do
+      def self.register_expression(reg_exp)
+        Explainer.expression_map[reg_exp] = self
+      end
+    end
+  end
+
+  def initialize(paragraph)
+    @paragraph = paragraph
+  end
+
+  def explain(lines)
+    new_lines = []
+
+    while not lines.empty?
+      line = lines[0]
+
+      matched_explainer_expression = self.class.expression_map.keys.find do |key|
+        line.match(key)
+      end
+
+      if matched_explainer_expression
+        matched_explainer = self.class.expression_map[matched_explainer_expression]
+        lines = matched_explainer.handle(lines)
+      else
+        new_lines << lines.shift
+      end
+    end
+
+    return new_lines
+  end
+end
+
+class GlobalSetter < Explainer
+  START_REG = /^\{% set (.*?) %\}/
+  register_expression START_REG
+
+  def self.handle(paragraph_lines)
+    line = paragraph_lines.shift
+    content = line.match(START_REG)[1].gsub(' ','')
+    target, expression_str = content.split('=')
+    value = ExpressionPipe.handle(expression_str)
+    ParameterCenter.instance.register_item({target.to_sym => value})
+    return paragraph_lines
+  end
+end
+
+class SimpleParser < Explainer
+  START_REG = /\{\{(.*?)\}\}/
+  register_expression START_REG
+
+  def self.handle(paragraph_lines)
+    line = paragraph_lines.shift
+    content = line.match(START_REG)[1]
+    value = ExpressionPipe.handle(content)
+
+    element = '{{' + content + '}}'
+    start_index = line.index(element)
+    end_index = start_index + element.size - 1
+    line[start_index..end_index] = value.to_s
+    paragraph_lines.insert(0, line)
+  end
+end
+
+class IfDefinedBlocker < Explainer
+  START_REG = /\{% if (.*?) is defined -%\}/
+  END_REG = /\{% endif -%\}/
+
+  register_expression self::START_REG
+
+  def self.handle(paragraph_lines)
+
+    block_lines = []
+    while not (line = paragraph_lines.shift).match(self::END_REG)
+      block_lines << line
+    end
+    block_lines << line
+
+    condition_line = block_lines[0]
+    content = condition_line.match(self::START_REG)[1]
+
+    begin
+      value = ExpressionPipe.handle(content)
+      raise NoMethodError if value.nil?
+
+      block_inner_lines = block_lines[1..-2]
+      paragraph_lines = block_inner_lines + paragraph_lines
+    rescue NoMethodError
+      # should be but no log currently
+    end
+
+    return paragraph_lines
+  end
+
+end
+
+
+class IfBlocker < IfDefinedBlocker
+
+  START_REG = /\{% if (.*?) %\}/
+  END_REG = /\{% endif %\}/
+  register_expression self::START_REG
+
+end
+

data/lib/utils/kube_config_parser/expression.rb

@@ -0,0 +1,69 @@
+require_relative 'parameter_center'
+
+class ExpressionPipe
+
+  def self.handle(expression_str)
+    expressions = expression_str.split('|').map {|expression_str| Expression.generate(expression_str) }
+    result = expressions.inject(nil){ |param, expression| expression.handle(param) }
+    return result
+  end
+
+end
+
+class Expression
+  @expression_map  ={}
+
+  class << self
+    attr_accessor :expression_map
+  end
+
+  def self.inherited(sub_klass)
+    sub_klass.class_eval do
+      def self.register_method(method_name)
+        Expression.expression_map[method_name] = self
+      end
+    end
+  end
+
+
+  def self.generate(expression_str)
+    result = ParameterCenter.instance.parse(expression_str)
+    result = NormalString.new(result) if not result.is_a? Expression
+
+    return result
+  end
+
+  def initialize(*parameters)
+    @parameters = parameters
+  end
+
+
+  def handle(previous_value)
+    raise NotImplementedError
+  end
+
+end
+
+
+class B64encoder < Expression
+  register_method :b64encode
+
+  def handle(_)
+    return @parameters.first
+  end
+
+end
+
+class DefaultString < Expression
+  register_method :default
+
+  def handle(previous_value)
+    previous_value || @parameters.first
+  end
+end
+
+class NormalString < Expression
+  def handle(_)
+    return @parameters.first
+  end
+end

data/lib/utils/kube_config_parser/paragraph.rb

@@ -0,0 +1,35 @@
+require 'extensions/to_os'
+
+require_relative 'parameter_center'
+require_relative 'expression'
+require_relative 'explainer'
+
+class Paragraph
+  def initialize(paragraph_content, variable_content)
+    @paragraph_lines = paragraph_content.lines.map(&:chomp)
+    @variables = {:item => OpenStruct.to_os(variable_content)}
+
+    ParameterCenter.instance.register_item(@variables)
+    ParameterCenter.instance.register_item(Expression.expression_map)
+  end
+
+  def parse
+    explainer = Explainer.new(self)
+    lines = Marshal.load(Marshal.dump(@paragraph_lines))
+    new_lines = explainer.explain(lines)
+    return new_lines
+  end
+end
+
+
+if __FILE__ == $0
+  yaml_file = 'resource/service_master.yml'
+  require 'yaml'
+  variable_hash = YAML.load(File.open(yaml_file).read)
+
+  config_template_file= 'resource/service.yml.j2'
+  config_template = File.open(config_template_file).read
+
+  pm = Paragraph.new(config_template, variable_hash)
+  pm.parse
+end

data/lib/utils/kube_config_parser/parameter_center.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+
+class ParameterCenter
+  include Singleton
+
+  False = false
+  True = true
+
+  attr_reader :registered_item_map
+
+  def initialize
+    @registered_item_map = {}
+  end
+
+  def register_item(item)
+    item.keys.each do |key|
+      @registered_item_map[key] = item[key]
+    end
+  end
+
+  def parse(str)
+    eval(str)
+  end
+
+  def method_missing(method_name_sym, *args)
+    target = @registered_item_map[method_name_sym]
+
+    if args.empty?
+      return target
+    else
+      return target.new(*args)
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kube-config-parser
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Yukai Jin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-26 00:00:00.000000000 Z
+date: 2019-01-24 00:00:00.000000000 Z
 dependencies: []
 description: a simple kube config parser
 email: fish1928@outlook.com
@@ -16,7 +16,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/extensions/to_os.rb
 - lib/utils/kube_config_parser.rb
+- lib/utils/kube_config_parser/explainer.rb
+- lib/utils/kube_config_parser/expression.rb
+- lib/utils/kube_config_parser/paragraph.rb
+- lib/utils/kube_config_parser/parameter_center.rb
 homepage: https://github.com/fish1928/KubeConfigParser
 licenses:
 - MIT
@@ -40,5 +45,5 @@ rubyforge_project:
 rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
-summary: KubeConfigparser
+summary: KubeConfigParser
 test_files: []