junoser 0.1.0

data/lib/junoser/ruler.rb

@@ -0,0 +1,173 @@
+module Junoser
+  class Ruler
+    OFFSET = '    '
+
+    def initialize(input)
+      @rule = input
+    end
+
+    def to_rule
+      rule_header << rule << rule_footer
+    end
+
+    def rule
+      str = @rule.read
+      str = process_reserved_element(str)
+      str = str.split(/\n/).map {|l| format(process_line(l)) }.join("\n")
+    end
+
+
+    private
+
+    def process_line(str)
+      return str if str =~ /^(.* do|end)$/
+
+      str.gsub!(/("[^"]+")/) { "str(#$1)" }  # "foo" -> str("foo")
+
+      str.gsub!(/^(\s*)arg(\.as\(:\S+\))? \($/) { "#{$1}b(arg#$2," }  # arg ( -> b(arg,
+      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f\(|,]+)(\.as\(:\S+\))?(,?)$/) { "#{$1}a(#$2, #$3)#$4#$5" }  # str("foo") bar -> a(str("foo"), bar)
+      str.gsub!(/^(\s*)(str\(\S+\)) \((.*)\)(,?)$/) { "#{$1}a(#$2, #$3)#$4" }  # str("foo") (a | b) -> a(str("foo"), a | b)
+
+      str.gsub!(/^(\s*)(str\(\S+\)) \($/) { "#{$1}b(#$2," }  # str("foo") ( -> b(str("foo"),
+      str.gsub!(/^(\s*)(\(.*\))(\.as\(:\S\))? \($/) { "#{$1}b(#$2#$3," }  # (a | b) ( -> b((a | b),
+      str.gsub!(/^(\s*)(str\(\S+\)) ([^ \t\n\r\f\(|,]+) \($/) { "#{$1}b(a(#$2, #$3)," }  # str("foo") bar ( -> b(a(str("foo"), bar),
+      str.gsub!(/^(\s*)(str\(\S+\)) \((.*)\) \($/) { "#{$1}a(#$2, #$3," }  # str("foo") (a | b) ( -> a(str("foo"), a | b,
+
+      str
+    end
+
+    def process_reserved_element(str)
+      str.gsub! /"\$\S+"/, 'arg'
+      str.gsub! '"as-number" arg', 'arg'
+      str.gsub! '"equal-literal"', '"="'
+      str.gsub! '"plus-literal"', '"+"'
+      str.gsub! '"minus-literal"', '"-"'
+
+      str.gsub!(/\((.*) \| "name"\)/) { "(#$1 | arg)" }
+      str.gsub! '"vlan" ("id-name" | "all")', '"vlan" ("all" | arg)'
+      str.gsub!(/("ssh-\S+") arg/) { "#$1 (quote | arg)" }
+      str.gsub! '"metric-value" arg', 'arg'
+      str.gsub! '"limit-threshold" arg', 'arg'
+      str.gsub! '"filename" arg', 'arg'
+      str.gsub! '"description" arg', '"description" (quote | arg)'
+      str.gsub! '"as-path-prepend" arg', '"as-path-prepend" (quote | arg)'
+
+
+      str.gsub!(/^(\s*)"inline-services"/) do
+        format(['"inline-services" (',
+                '  "bandwidth" ("1g" | "10g")',
+                ')'], $1)
+      end
+      str.gsub!(/^(\s*)"ieee-802.3ad" \(\s*sc\(\s*"lacp" \(\s*sc\(/) do
+        format(['"802.3ad" (',
+                '  sc(',
+                '    arg,',
+                '    "lacp" (',
+                '      sc(',
+                '        "force-up",'], $1)
+      end
+      str.gsub!(/^(\s*)"as-path" \(\s*sc\(\s*"path" arg/) do
+        format(['"as-path" (',
+                '  sc(',
+                '    arg'], $1)
+      end
+      str.gsub!(/^(\s*)"as-path" arg \(\s*sc\(\s*"path" arg\s*\)/) do
+        format(['"as-path" arg (',
+                '  sc(',
+                '    quote,',
+                '    arg',
+                '  )'], $1)
+      end
+
+      %w[metric metric2 metric3 metric4 tag tag2 preference preference2 color color2 local-preference].each do |key|
+        str.gsub!(/^(\s*"#{key}" \(\s*sc\(\s*c\(\s*)"#{key}" arg/) { "#{$1}arg" }
+      end
+
+      str.gsub!(/(s\(\s*)"address" \(\s*arg\s*\)/) { "#{$1}arg" }
+      str.gsub!(/^(\s*"idle-timeout" \(\s*sc\(\s*c\(\s*"forever",\s*)"timeout" arg/) { "#{$1}arg" }
+
+      str = omit_label(str, 'contents', 'syslog_object')
+      str = omit_label(str, 'interface', 'cos_interfaces_type')
+      str = omit_label(str, 'interface', 'ir_interfaces_type')
+      str = omit_label(str, 'interface', 'interfaces_type')
+      str = omit_label(str, 'client-address-list', 'client_address_object')
+      str = omit_label(str, 'prefix-list-item', 'prefix_list_items')
+      str = omit_label(str, 'instance', 'juniper_routing_instance')
+      str = omit_label(str, 'vlan', 'vlan_type')
+
+      str.gsub!(/"icmp"(.*)"icmp6"/) { %["icmpv6"#$1"icmp"] }
+      str.gsub!(/"http"(.*)"https"/) { %["https"#$1"http"] }
+      str.gsub!(/"snmp"(.*)"snmptrap"/) { %["snmptrap"#$1"snmp"] }
+
+      str
+    end
+
+    def omit_label(str, label, content)
+      str.gsub(/(\s*)"#{label}" \(\s*#{content}\s*\)/) { "#{$1}#{content}" }
+    end
+
+    def format(str, offset=OFFSET)
+      case str
+      when String
+        str.empty? ? '' : offset + str
+      when Array
+        str.map {|s| s.empty? ? '' : offset + s.to_s }.join("\n")
+      end
+    end
+
+    def rule_header
+      <<-EOS
+require 'parslet'
+
+module Junoser
+  class Parser < Parslet::Parser
+    # block with children maybe
+    def b(object, *children)
+      children.inject(object) {|rule, child| rule.as(:label) >> (space >> child.as(:child) | eos) }
+    end
+
+    # with an argument, and children maybe
+    def a(object, arg, *children)
+      b(object.as(:statement) >> space >> arg.as(:argument), *children)
+    end
+
+    # choice
+    def c(*objects)
+      objects.inject {|rule, object| rule | object }
+    end
+
+    # sequence
+    def s(*objects)
+      # TODO:  eval "minOccurs" attribute of choice element
+      objects.inject {|rule, object| rule >> (space >> object).maybe }
+    end
+
+    # sequential choice
+    def sc(*objects)
+      (c(*objects) >> space.maybe).repeat(0)
+    end
+
+    rule(:arg)     { match('\\S').repeat(1) }
+    rule(:space)   { match('\\s').repeat(1) }
+    rule(:any)     { match('.').repeat(1) }
+    rule(:eos)     { match('$') }
+    rule(:dotted)  { match('[^. \\t\\n\\r\\f]').repeat(1) >> match('\.') >> match('[^. \\t\\n\\r\\f]').repeat(1) }
+    rule(:quote)   { match('"') >> match('[^"]').repeat(1) >> match('"') }
+    rule(:address) { match('[0-9a-fA-F:\.]').repeat(1) }
+    rule(:prefix ) { address >> (match('/') >> match('[0-9]').repeat(1)).maybe }
+
+    root(:set)
+    rule(:set) { (str('set') | str('deactivate')) >> space >> configuration.as(:config) }
+
+      EOS
+    end
+
+    def rule_footer
+      <<-EOS
+
+  end
+end
+      EOS
+    end
+  end
+end

data/lib/junoser/transformer.rb

@@ -0,0 +1,41 @@
+require 'parslet'
+
+module Junoser
+  class Transformer < Parslet::Transform
+    rule(config: simple(:config)) do
+      config.to_s
+    end
+
+    rule(config: sequence(:configs)) do
+      configs.join("\n")
+    end
+
+    rule(arg: simple(:arg)) do
+      "arg(#{arg})"
+    end
+
+    rule(label: simple(:label)) do
+      label.to_s
+    end
+
+    rule(label: simple(:label), child: simple(:child)) do
+      "#{label}\n#{child}"
+    end
+
+    rule(label: simple(:label), child: sequence(:children)) do
+      %[#{label}\n#{children.join("\n")}]
+    end
+
+    rule(statement: simple(:statement), argument: simple(:argument)) do
+      "#{statement} #{argument}"
+    end
+
+    rule(statement: simple(:statement), argument: sequence(:arguments)) do
+      %[#{statement}\n#{arguments.join("\n")}]
+    end
+
+    rule(oneline: simple(:str)) do
+      str.gsub "\n", ' '
+    end
+  end
+end

data/lib/junoser/version.rb

@@ -0,0 +1,3 @@
+module Junoser
+  VERSION = "0.1.0"
+end

data/lib/junoser/xsd/base.rb

@@ -0,0 +1,54 @@
+module Junoser
+  module Xsd
+    module Base
+      attr_reader :xml
+
+      OFFSET = '  '
+
+      def initialize(xml, options={})
+        @xml = xml
+        @depth = options[:depth] || 0
+      end
+
+      def config
+        raise "ERROR: no implementation"
+      end
+
+      def children
+        @children||= xml.xpath('./*[not(self::xsd:annotation)]')
+      end
+
+      def root?
+        @depth == 1
+      end
+
+      def inspect
+        ["#<#{self.class}:0x#{object_id}",
+         "xml=#{xml.namespace.prefix}:#{xml.name}" <<
+         " attributes=" << Hash[xml.attributes.map {|k, v| [k, v.value] }].to_s <<
+         (respond_to?(:label) ? " label=#{label}" : ''),
+         "config=[",
+         *config.map {|c| c.inspect },
+         ']>'].join("\n#{OFFSET*(@depth+1)}")
+      end
+
+
+      private
+
+      def oneliner?
+        @oneliner ||= !xml.xpath('./xsd:annotation/xsd:appinfo/flag[contains(text(), "oneliner")]').empty?
+      end
+
+      def has_single_child_of?(klass)
+        config.size == 1 && config.first.is_a?(klass)
+      end
+
+      def format(header, content=nil, footer=nil)
+        str = OFFSET*@depth << header.to_s
+        str << "\n" << content if content
+        str << "\n" << OFFSET*@depth << footer if footer
+        str
+      end
+    end
+  end
+end

data/lib/junoser/xsd/choice.rb

@@ -0,0 +1,33 @@
+require 'junoser/xsd/base'
+require 'junoser/xsd/element'
+
+module Junoser
+  module Xsd
+    class Choice
+      include Base
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'element'
+            Junoser::Xsd::Element.new(child, depth: @depth+1)
+          when 'choice'
+            Junoser::Xsd::Choice.new(child, depth: @depth+1)
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        case
+        when config.empty?
+        when has_single_child_of?(Junoser::Xsd::Choice)
+          format('c(', config.first.config.map(&:to_s).compact.join(",\n"), ')')
+        else
+          format('c(', config.map(&:to_s).compact.join(",\n"), ')')
+        end
+      end
+    end
+  end
+end

data/lib/junoser/xsd/complex_type.rb

@@ -0,0 +1,74 @@
+require 'junoser/xsd/base'
+require 'junoser/xsd/element'
+require 'junoser/xsd/sequence'
+require 'junoser/xsd/simple_content'
+
+module Junoser
+  module Xsd
+    class ComplexType
+      include Base
+
+      def initialize(xml, options={})
+        super
+        raise "ERROR: #{xml.name} shouldn't have name '#{xml['name']}'" if xml['name'] && !root?
+        @argument = find_name_element
+      end
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'sequence'
+            Junoser::Xsd::Sequence.new(child, depth: @depth+1)
+          when 'simpleContent'
+            Junoser::Xsd::SimpleContent.new(child, depth: @depth+1)
+          when 'attribute'
+            'arg'
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        str = config.map {|c| c.is_a?(String) ? format(OFFSET + c) : c.to_s }.compact.join("\n")
+
+        str = case [!argument.nil?, !str.empty?]
+              when [true, true]
+                format("#{argument} (", str, ')')
+              when [true, false]
+                format(argument)
+              when [false, true]
+                simple_argument?(str) ? "#{str}.as(:arg)" : str
+              else
+                ''
+              end
+
+        oneliner? ? "#{str}.as(:oneline)" : str
+      end
+
+
+      private
+
+      def argument
+        return unless @argument
+
+        arg = Junoser::Xsd::Element.new(@argument, depth: @depth+1).config
+        raise "ERROR: argument shouldn't consist of multiple elements" if arg.size > 1
+
+        if root?
+          arg.first.to_s.strip + ".as(:arg)"
+        else
+          arg.first.to_s.strip
+        end
+      end
+
+      def find_name_element
+        xml.xpath('./xsd:sequence/xsd:element[@name="name"]').remove.first
+      end
+
+      def simple_argument?(str)
+        root? && str =~ /\A\s*arg\z/
+      end
+    end
+  end
+end

data/lib/junoser/xsd/element.rb

@@ -0,0 +1,100 @@
+require 'active_support/inflector'
+require 'junoser/xsd/base'
+require 'junoser/xsd/complex_type'
+
+module Junoser
+  module Xsd
+    class Element
+      include Base
+
+      def initialize(xml, options={})
+        super
+        @argument = find_name_element || find_single_simple_type || find_simple_type_attribute
+      end
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'complexType'
+            Junoser::Xsd::ComplexType.new(child, depth: @depth+1)
+          when 'simpleType'
+            'arg'
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        str = config.map {|c| c.is_a?(String) ? format(OFFSET + c) : c.to_s }.compact.join("\n")
+
+        str = case
+              when str.empty? && xml['type']
+                l = label ? "#{label} (" : '('
+                format(l, format(OFFSET + xml['type'].underscore), ')')
+              when str.empty?
+                format(label)
+              else
+                l = label ? "#{label} (" : '('
+                format(l, str, ')')
+              end
+
+        oneliner? ? "#{str}.as(:oneline)" : str
+      end
+
+      def content
+        str = config.map {|c| c.is_a?(String) ? format(OFFSET + c) : c.to_s }.compact.join("\n")
+
+        case
+        when str.empty? && xml['type']
+          format(OFFSET + xml['type'].underscore)
+        when str.empty?
+          ''
+        else
+          str
+        end
+      end
+
+
+      private
+
+      def label
+        return unless xml['name']
+
+        %["#{xml['name']}" #{argument}].strip
+      end
+
+      def argument
+        return unless @argument
+
+        case
+        when @argument.is_a?(String)
+          @argument
+        when @argument.name == 'simpleType'
+          'arg'
+        else
+          arg = Junoser::Xsd::Element.new(@argument, depth: @depth+1).config
+          raise "ERROR: argument shouldn't consist of multiple elements" if arg.size > 1
+          arg.first.to_s.strip
+        end
+      end
+
+      def find_name_element
+        xml.xpath('./xsd:complexType/xsd:sequence/xsd:element[@name="name"]').remove.first
+      end
+
+      def find_single_simple_type
+        simples = xml.xpath('./xsd:simpleType').remove
+        raise "ERROR: Element shouldn't have simpleType child and another" if simples.size > 1
+        simples.first
+      end
+
+      def find_simple_type_attribute
+        if xml['type'] =~ /^xsd:.*/
+          xml.remove_attribute 'type'
+          'arg'
+        end
+      end
+    end
+  end
+end

data/lib/junoser/xsd/enumeration.rb

@@ -0,0 +1,30 @@
+require 'junoser/xsd/base'
+
+module Junoser
+  module Xsd
+    class Enumeration
+      include Base
+
+      def initialize(xml, options={})
+        super
+      end
+
+      def config
+        raise "ERROR: unknown Enumeration format" if children.size > 1
+
+        has_match? ? 'arg' : %["#{xml['value']}"]
+      end
+
+      def to_s
+        format(OFFSET + config)
+      end
+
+
+      private
+
+      def has_match?
+        return true unless xml.xpath('.//match').empty?
+      end
+    end
+  end
+end

data/lib/junoser/xsd/parsable.rb

@@ -0,0 +1,33 @@
+require 'active_support/inflector'
+require 'junoser/xsd/complex_type'
+require 'junoser/xsd/element'
+require 'nokogiri'
+
+module Junoser
+  module Xsd
+    module Parsable
+      def to_config
+        rule = "rule(:#{self['name'].underscore}) do\n"
+
+        case name
+        when 'complexType'
+          rule << Junoser::Xsd::ComplexType.new(self, depth: 1).to_s
+        when 'element'
+          rule << Junoser::Xsd::Element.new(self, depth: 1).content
+        else
+          raise "ERROR: unknown element: #{name}"
+        end
+
+        rule << "\nend\n\n"
+      end
+
+      def remove_unused
+        xpath('/xsd:schema/*[self::xsd:import]').remove
+        xpath('//xsd:element[@ref="undocumented" or @ref="junos:comment"]').remove
+        self
+      end
+    end
+  end
+end
+
+Nokogiri::XML::Element.include Junoser::Xsd::Parsable

data/lib/junoser/xsd/restriction.rb

@@ -0,0 +1,34 @@
+require 'junoser/xsd/base'
+require 'junoser/xsd/enumeration'
+
+module Junoser
+  module Xsd
+    class Restriction
+      include Base
+
+      def children
+        @children||= xml.xpath('./*[not(self::xsd:annotation or ' +
+                               'self::xsd:minInclusive or self::xsd:maxInclusive or ' +
+                               'self::xsd:minLength or self::xsd:maxLength)]')
+      end
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'enumeration'
+            Junoser::Xsd::Enumeration.new(child, depth: @depth+1)
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        return format('arg') if config.empty?
+
+        str = '(' + config.map {|c| c.to_s.strip }.compact.join(' | ') + ')'
+        format(str)
+      end
+    end
+  end
+end

data/lib/junoser/xsd/sequence.rb

@@ -0,0 +1,39 @@
+require 'junoser/xsd/base'
+require 'junoser/xsd/choice'
+require 'junoser/xsd/element'
+
+module Junoser
+  module Xsd
+    class Sequence
+      include Base
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'choice'
+            Junoser::Xsd::Choice.new(child, depth: @depth+1)
+          when 'element'
+            Junoser::Xsd::Element.new(child, depth: @depth+1)
+          when 'any'
+            'any'
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        case
+        when config.empty?
+        when has_single_child_of?(Junoser::Xsd::Choice)
+          child = config.first
+          str = child.config.map(&:to_s).compact.join(",\n")
+          format('sc(', str, ')') unless str.empty?
+        else
+          str = config.map {|c| c.is_a?(String) ? format(OFFSET + c) : c.to_s }.compact.join(",\n")
+          format('s(', str, ')')
+        end
+      end
+    end
+  end
+end

data/lib/junoser/xsd/simple_content.rb

@@ -0,0 +1,31 @@
+require 'junoser/xsd/base'
+require 'junoser/xsd/restriction'
+
+module Junoser
+  module Xsd
+    class SimpleContent
+      include Base
+
+      def config
+        @config ||= children.map {|child|
+          case child.name
+          when 'restriction'
+            Junoser::Xsd::Restriction.new(child, depth: @depth+1)
+          when 'extension'
+            'arg'
+          else
+            raise "ERROR: unknown element: #{child.name}"
+          end
+        }.compact
+      end
+
+      def to_s
+        return if config.empty?
+        raise "ERROR: simpleContent shouldn't have multiple children" if config.size > 1
+
+        child = config.first
+        child.is_a?(String) ? format(OFFSET + child) : child.to_s
+      end
+    end
+  end
+end

data/lib/junoser.rb

@@ -0,0 +1,3 @@
+require 'junoser/display'
+require 'junoser/parser'
+require 'junoser/version'