junoser 0.3.3 → 0.3.4

data/junoser.gemspec

@@ -13,14 +13,18 @@ Gem::Specification.new do |spec|
   spec.description   = %q{PEG parser to vefiry and translate into different formats for JUNOS configuration.}
   spec.homepage      = "https://github.com/codeout/junoser"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "parslet"
 
-  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "nokogiri"
   spec.add_development_dependency "test-unit"

data/lib/junoser/development.rb

@@ -1,3 +1,4 @@
 require 'underscorable'
 require 'junoser/xsd/parsable'
 require 'junoser/ruler'
+require 'junoser/js_ruler'

data/lib/junoser/display/config_store.rb

@@ -42,33 +42,33 @@ module Junoser
         end
       end
 
-      def each_with_inactive(&block)
+      def each_with_inactive(str='', &block)
         each do |k, v|
           k = "inactive: #{k}" if v.deactivated
-          yield k, v
+          yield k, v, str
         end
+
+        str
       end
 
       def to_s
-        str = ''
-
-        each_with_inactive do |k, v|
-          if v.empty?
-            str << OFFSET*@depth << "#{k};\n"
-          else
-            str << OFFSET*@depth << "#{k} {\n"
-            str << v.to_s.chop << "\n"
-            str << OFFSET*@depth << "}\n"
-          end
-        end
-
-        str
+        each_with_inactive('', &method(:hash_item_to_s))
       end
 
       def_delegators :@hash, :[], :[]=, :each, :empty?
 
       private
 
+      def hash_item_to_s(key, value, str)
+        if value.empty?
+          str << OFFSET*@depth << "#{key};\n"
+        else
+          str << OFFSET*@depth << "#{key} {\n"
+          str << value.to_s.chop << "\n"
+          str << OFFSET*@depth << "}\n"
+        end
+      end
+
       def join_arg(str)
         str.gsub!(/\narg\((.*)\)$/) { " #$1" }
         str.gsub!(/arg\((.*)\)/) { "#$1" }

data/lib/junoser/display/enumerable.rb

@@ -0,0 +1,35 @@
+require 'junoser/display/config_store'
+
+module Junoser
+  module Display
+    module Enumerable
+      attr_accessor :in_from, :in_then, :in_group
+
+      def to_enum
+        if @hash.size > 1
+          "[#{@hash.keys.join(' ')}]"
+        else
+          @hash.keys.first
+        end
+      end
+
+      private
+
+      def hash_item_to_s(key, value, str)
+        value.in_from = true if key == 'from'
+        value.in_then = true if key == 'then'
+        value.in_group = true if key =~ /^group /
+
+        if in_from && ['next-header', 'port', 'protocol'].include?(key) ||
+            in_then && key == 'origin' ||
+            in_group && key == 'type'
+          str << Junoser::Display::ConfigStore::OFFSET * @depth << "#{key} #{value.to_enum};\n"
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+Junoser::Display::ConfigStore.prepend(Junoser::Display::Enumerable)

data/lib/junoser/display.rb

@@ -14,3 +14,6 @@ module Junoser
     end
   end
 end
+
+# NOTE: Apply a patch
+require 'junoser/display/enumerable'

data/lib/junoser/js_ruler.rb

@@ -0,0 +1,334 @@
+module Junoser
+  class JsRuler
+
+    def initialize(input)
+      @rule = input
+      @sequence = 0
+    end
+
+    def sequence
+      @sequence += 1
+    end
+
+    def to_rule
+      rule_header << rule.gsub(/^/, '  ') << rule_footer
+    end
+
+    def rule
+      str = @rule.read
+      str = str.split(/\n/).map {|l| format(process_line(l))}.join("\n")
+      finalize(str)
+    end
+
+
+    private
+
+    def process_line(str)
+      remove_undefined_variables(str)
+      process_common_syntax(str)
+      process_argument_syntax(str)
+      process_structural_syntax(str)
+      process_word(str)
+      process_reserved_word(str)
+      process_comment(str)
+
+      str
+    end
+
+    def remove_undefined_variables(str)
+      str.gsub! '.as(:oneline)', ''
+
+      # "$junos-interface-unit" |
+      str.gsub! /"\$[\w-]+" \| /, ''
+
+      str
+    end
+
+    def process_common_syntax(str)
+      # rule(:foo) do  ->  foo(...args) {
+      str.gsub!(/^rule\(:(\S+)\) do/) {"#$1(...args) { return_next_line"}
+      # end  ->  }
+      str.gsub!(/^(\s*)end$/) {"#$1}"}
+
+      # arg.as(:arg) (  ->  {"arg":
+      str.gsub! /arg\.as\(:arg\) \(/, '{"arg":'
+      # arg.as(:arg)  ->  {"arg": null}
+      str.gsub! /arg.as\(:arg\)/, '{"arg": null}'
+      # ("foo" | "bar").as(:arg) (  ->  {"(bar|baz)":
+      str.gsub!(/\(([^)]+)\)\.as\(:arg\) \(/) {"{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":"}
+      # enum(("foo" | "bar")).as(:arg) (  ->  {"(bar|baz)":  # TODO: support "enum" in the middle of line
+      str.gsub!(/enum\(\(([^)]+)\)\)\.as\(:arg\) \(/) {"{\"(#{$1.gsub('"', '').split(' | ').join('|')})\":"}
+
+      str.gsub! '.as(:arg)', ''
+
+      # any  ->  "any"
+
+      # c(  ->  {
+      str.gsub!(/^(\s*)c\(/) {"#$1{"}
+
+      # foo  /* doc */,  ->  foo()  /* doc */,
+      str.gsub!(%r|^(\s*)(?!arg)(\w+)(  /\* (.*) \*/,?)$|) {"#$1this.#$2()#$3"}
+      # foo,  ->  foo(),
+      str.gsub!(%r|^(\s*)(?!arg)(\w+)(,?)$|) {"#$1this.#$2()#$3"}
+
+      # )  ->  }
+      str.gsub!(/^(\s+)\)/) {"#$1}"}
+
+      str
+    end
+
+    def process_argument_syntax(str)
+      # "foo" (("bar" | "baz")) (  ->  "foo(bar|baz)": {
+      # "foo" enum(("bar" | "baz")) (  ->  "foo(bar|baz)": {  # TODO: support "enum" in the middle of line
+      str.gsub!(/^(\s*)"(\S+)" (?:enum)?\(\((.*)\)\) \(/) {"#$1\"#$2(#{$3.gsub('"', '').split(' | ').join('|')})\": {"}
+      # "foo" arg (  ->  "foo(arg)": {
+      str.gsub!(/^(\s*)"(\S+)" arg \(/) {"#$1\"#$2(arg)\": {"}
+
+      # "foo" (... | arg)  /* doc */  ->  "foo": "arg"
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": arg#$4"}
+
+      # "foo" (... | arg) (  /* doc */  ->  "foo(arg)": {
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \(  /\* (.*) \*/$|) {"#$1\"#$2(arg) | #$3\": {"}
+      # "foo" (... | arg) (  ->  "foo(arg)": {
+      str.gsub!(%r|^(\s*)"(\S+)" \(.* \| arg ?.*\) \($|) {"#$1\"#$2(arg)\": {"}
+
+      # "foo" (arg | ...)  /* doc */  ->  "foo": "arg"
+      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": arg#$4"}
+
+      # "foo" (arg | ...) (  /* doc */  ->  "foo(arg)": {
+      str.gsub!(%r|^(\s*)"(\S+)" \(arg ?.*\) \(  /\* (.*) \*/(,?)$|) {"#$1\"#$2(arg) | #$3\": {#$4"}
+
+      # "foo" ("bar" | "baz") (  /* doc */  ->  "foo(bar|baz)": {
+      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \(  /\* (.*) \*/$|) {"#$1\"#$2(#{$3.split('" | "').join('|')}) | #$4\": {"}
+      # "foo" ("bar" | "baz") (  ->  "foo(bar|baz)": {
+      str.gsub!(%r|^(\s*)"(\S+)" \("([^)]+)"\) \($|) {"#$1\"#$2(#{$3.split('" | "').join('|')})\": {"}
+
+      # "foo" ("bar" | "baz") /* doc */,  ->  "foo": ["bar", "baz"],
+      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$4\": [#{$3.split(' | ').join(', ')}]#$5"}
+      # "foo" ("bar" | "baz"),  ->  "foo": ["bar", "baz"],
+      str.gsub!(%r|^(\s*)"(\S+)" \(([^)]+)\)(,?)$|) {"#$1\"#$2\": [#{$3.split(' | ').join(', ')}]#$4"}
+
+      # "foo" enum(("bar" | "baz"))  ->  "foo": new Enumeration(["bar", "baz"])
+      str.gsub!(/^(\s*)("\S+") enum\(\((.*)\)\)/) {"#$1#$2: new Enumeration(#{$3.gsub('"', '').split(' | ')})"}
+
+      # "foo" arg  /* doc */,  ->  "foo | doc": "arg",
+      str.gsub!(%r|^(\s*)"([^"]+)" arg  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": \"arg\"#$4"}
+      # "foo" arg,  ->  "foo": "arg",
+      str.gsub!(%r|(\s*)"([^"]+)" arg(,?)$|) {"#$1\"#$2\": \"arg\"#$3"}
+
+      # "foo" ipaddr,  -> "foo": this.ipaddr(),
+      str.gsub!(%r|(\s*)"([^"]+)" ipaddr(,?)$|) {"#$1\"#$2\": this.ipaddr()#$3"}
+
+      str
+    end
+
+    def process_structural_syntax(str)
+      # "foo" (  /* doc */  ->  "foo | doc": (...args) => {
+      str.gsub!(%r|^(\s*)"(\S+)" \(  /\* (.*) \*/|) {"#$1\"#$2 | #$3\": {"}
+      # "foo" (  ->  "foo": (...args) => {
+      str.gsub!(%r|^(\s*)"(\S+)" \($|) {"#$1\"#$2\": {"}
+
+      # "foo" arg (  /* doc */  ->  "foo | doc": (...args) => {
+      str.gsub!(%r|^(\s*)"(\S+)" arg \(  /\* (.*) \*/|) {"#$1\"#$2 | #$3\": {"}
+
+      str
+    end
+
+    def process_word(str)
+      # arg  ->  "arg"
+      # (arg)  ->  "arg"
+      # enum(arg)  ->  "arg"
+      str.gsub!(/ ((?!arg\w)(arg)|(enum)?\(arg\))/, ' "arg"')
+
+      # "foo"  /* doc */,  ->  "foo | doc": null,
+      str.gsub!(%r|^(\s*)"([^"]+)"  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$3\": null#$4"}
+      # "foo",  ->  "foo": null,
+      str.gsub!(%r|^(\s*)"([^"]+)"(,?)$|) {"#$1\"#$2\": null#$3"}
+
+      # ("foo" | "bar")  ->  ["foo", "bar"]
+      str.gsub!(/^(\s*) \(+("[^"]+(?:" \| "[^"]+)*")\)+(,?)$/) do
+        comma = $3
+        "#$1#{$2.gsub('"', '').split(' | ')}#{comma}"
+      end
+
+      # enum(("bar" | "baz"))  ->  "foo": new Enumeration(["bar", "baz"])
+      str.gsub!(/^(\s*)enum\(\((.*)\)\)/) {"#$1new Enumeration(#{$2.gsub('"', '').split(' | ')})"}
+
+      # (arg | "foo")  ->  ["arg", "foo"]
+      str.gsub!(/^(\s*) \(arg( \| "[^"]+")+\)/) {"#$1[\"arg\"#{$2.split(' | ').join(', ')}]"}
+
+      str
+    end
+
+    def process_reserved_word(str)
+      # ieee-802.3ad  -> 802.3ad
+      str.gsub! 'ieee-802.3ad', '802.3ad'
+      fix_route_filter(str)
+
+      str
+    end
+
+    def fix_route_filter(str)
+      str.gsub!(/("exact \| [^"]*"): "arg"/) {"#$1: null"}
+      str.gsub!(/("longer \| [^"]*"): "arg"/) {"#$1: null"}
+      str.gsub!(/("orlonger \| [^"]*"): "arg"/) {"#$1: null"}
+    end
+
+    def process_comment(str)
+      # %  ->  %%
+      str.gsub! '%', '' % %''
+
+      # "foo": ...  /* doc */,  ->  "foo | doc": ...,
+      str.gsub!(%r|^(\s*)"([^"]+)": (.*)  /\* (.*) \*/(,?)$|) {"#$1\"#$2 | #$4\": #$3#$5"}
+
+      str
+    end
+
+    def finalize(lines)
+      lines = balance_parenthesis(lines)
+      objectize_arg_of_s(lines)
+
+      # return_next_line
+      #   ...
+      #
+      # ->
+      #
+      # return ...
+      lines.gsub!(/return_next_line\n(\s*)/m) {"\n#$1return "}
+
+      # {
+      #   {
+      #
+      # ->
+      #
+      # {
+      #   "null_1": {
+      lines.gsub!(/([{,]\n\s*){/m) {"#$1\"null_#{sequence}\": {"}
+
+      # {
+      #   foo()
+      #
+      # ->
+      #
+      # {
+      #   "null_1": foo()
+      lines.gsub!(/([{,]\n\s*)([^ "(]+)/m) {"#$1\"null_#{sequence}\": #$2"}
+
+      # "arg"  ->  "arg_1"
+      lines.gsub('"arg":') {%["arg_#{sequence}":]}
+    end
+
+    def balance_parenthesis(lines)
+      # Fixes
+      lines.gsub! 'Timeslots (1..24;', 'Timeslots (1..24);'
+
+      count = 0
+      target = nil
+      buf = ''
+      stack = []
+
+      lines.each_char do |c|
+        case c
+        when '('
+          count += 1
+          stack << target
+          target = count
+
+          buf << c
+        when '{'
+          count += 1
+
+          buf << c
+        when ')'
+          count -= 1
+          target = stack.pop
+
+          buf << c
+        when '}'
+          count -= 1
+
+          if target && count == target - 1
+            target = stack.pop
+
+            buf << ')'
+          else
+            buf << c
+          end
+        else
+          buf << c
+        end
+      end
+
+      buf
+    end
+
+    def objectize_arg_of_s(lines)
+      # s(  ->  s({
+      lines.gsub!(/^( *(?:return|\S+:)? +)s\($/m) {"#$1this.s({"}
+
+      # )  ->  })
+      lines.gsub!(/^( *)\)$/m) {"#$1})"}
+
+      lines
+    end
+
+    def rule_header
+      <<~EOS
+        class Enumeration {
+          constructor(list) {
+            this.list = list;
+            this.children = [];
+          }
+
+          map(callback) {
+            // NOTE: This is a bit hacky but assuming that it's called like "this.children.map((node) => node.name)"
+            return this.list;
+          }
+
+          find(callback) {
+            // NOTE: This is a bit hacky but assuming that it's called like "this.children.find((node) => node.name === string)"
+            return;
+          }
+
+          forEach(callback) {
+            return this.list.forEach(callback);
+          }
+
+          keywords() {
+            return this.list;
+          }
+        }
+
+        class Sequence {
+          constructor(list) {
+            this.list = list;
+          }
+
+          get(depth) {
+            return this.list[depth];
+          }
+        }
+
+        class JunosSchema {
+          any() {
+            return "any";
+          }
+
+          s(obj) {
+            const list = Object.entries(obj).map(([key, value]) => ({[key]: value}));
+            return new Sequence(list);
+          }
+
+      EOS
+    end
+
+    def rule_footer
+      <<~EOS
+
+        }
+
+        module.exports = {JunosSchema: JunosSchema, Enumeration: Enumeration, Sequence: Sequence};
+      EOS
+    end
+  end
+end