genrubyfrompy.rb

#!/usr/bin/env ruby
# frozen_string_literal: true
#
# Generates the Ruby models from the Python SDK pulled from the APIC
#
# SPDX-FileCopyrightText: 2023 Georg Gadinger <nilsding@nilsding.org>
# SPDX-License-Identifier: Apache-2.0

require "fileutils"
require "set"

# transforms the relevant bits from an ACI python sdk model to a Ruby model
# the output of a class should be source-compatible to the output of the old
# genrubyfrompy.py script
class PyTonRuby
  def initialize(python_code)
    @python_code = python_code
    @class_name = nil
    @class_meta = nil
    @current_prop = nil
    @props = {}
    @rn_prefixes = []
    @ordered_naming_props = []
  end

  def transform
    return unless @python_code

    @python_code
      .lines
      # get rid of last \ns
      .map(&:chomp)
      # select only code that matters (should be in a `def create` block)
      .select { _1.start_with?("    ") }
      # ignore some control statements
      .reject { _1 =~ /^\s*(if|return|def|global)\s+/ }
      .each(&method(:transform_line))

    @python_code = nil
  end

  def generate_class
    <<~RUBY
      class #{ruby_class_name} < MO
        @class_name = #{@class_name.inspect}
        @ruby_class = #{ruby_class_name.inspect}
        @prefix = #{prefix.inspect}
        @prefixes = #{prefixes.inspect}
        @rn_format = #{rn_format.inspect}
        @containers = #{containers.inspect}
        @props = { #{formatted_props} }
        @child_classes = #{children.inspect}
        @label = #{label.inspect}
        @naming_props = #{naming_props.inspect}
        @read_only = #{read_only.inspect}

        def rn
          #{rn}
        end
      end
    RUBY
  end

  def class_name
    @class_name
  end

  def ruby_class_name(class_name = @class_name)
    class_name.tr(".", "").sub(/^./, &:upcase)
  end

  def prefix
    return "" if @rn_prefixes.empty?
    @rn_prefixes.first.first
  end

  def prefixes
    @rn_prefixes
  end

  def rn_format
    @class_meta.fetch("rnFormat", "")
  end

  def containers
    @class_meta.fetch("containers", []).map(&method(:ruby_class_name))
  end

  def props
    @props
  end

  # formats the properties in a way the python version did
  def formatted_props
    props.map do |name, flags|
      formatted_flags = flags
        .inspect
        .gsub("=>", " => ")
        .gsub("{", "{ ")
        .gsub("}", " }")
      "#{name.inspect} => #{formatted_flags}"
    end.join(",\n    ")
  end

  def children
    @class_meta.fetch("children", []).map(&method(:ruby_class_name))
  end

  def label
    @class_meta.fetch("label", "")
  end

  def naming_props
    @ordered_naming_props
  end

  def read_only
    @class_meta.fetch("isReadOnly", false)
  end

  def rn
    rn_format.inspect.gsub(/%\(([a-zA-Z]+)\)s/, %q(#{@attributes['\1']}))
  end

  private

  PROPS_OF_INTEREST = %w[
    isAdmin isImplicit isCreateOnly isDn isRn isExplicit
  ].freeze
  private_constant :PROPS_OF_INTEREST

  CLASS_PROPS_OF_INTEREST = %w[
    rnFormat label isReadOnly
  ].freeze
  private_constant :CLASS_PROPS_OF_INTEREST

  def transform_line(line)
    case line
    when %r{= Py.*ClassMeta\('(?<class_name>[^']+)'}
      # init class
      raise ArgumentError, "class was already set!" if @class_name
      @class_name = Regexp.last_match[:class_name]
      @class_meta = {}

    when %r{prop = PyPropMeta}
      # init property
      raise ArgumentError, "property was already set!" if @current_prop
      @current_prop = PROPS_OF_INTEREST.map { [_1, false] }.to_h

    when %r{prop._(?<prop_name>\S+) = (?<value>.+)}
      # normal property
      prop_name = Regexp.last_match[:prop_name]
      return unless PROPS_OF_INTEREST.include?(prop_name)

      value = Regexp.last_match[:value]
      @current_prop[prop_name] = python_to_ruby value

    when %r{_classMeta._props\['(?<prop_name>[^']+)'\] =}
      # finalise property and reset
      prop_name = Regexp.last_match[:prop_name]
      @props[prop_name] = @current_prop
      @current_prop = nil

    when %r{_classMeta._(?<kind>children|containers)\[(?<class_name>[^\]]+)\]}
      # child class or containers, we only need the name
      kind = Regexp.last_match[:kind]
      class_name = Regexp.last_match[:class_name]
      @class_meta[kind] ||= Set.new
      @class_meta[kind] << python_to_ruby(class_name)

    when %r{_classMeta._(?<prop_name>\S+) = (?<value>.+)}
      # class property
      prop_name = Regexp.last_match[:prop_name]
      return unless CLASS_PROPS_OF_INTEREST.include?(prop_name)
      value = Regexp.last_match[:value]
      @class_meta[prop_name] = python_to_ruby value

    when %r{_classMeta._rnPrefixes.append\((?<prefixes>.+)\)$}
      prefixes = Regexp.last_match[:prefixes]
      @rn_prefixes << python_to_ruby(prefixes)

    when %r{_classMeta._orderedNamingProps.append\((?<naming_prop>.+)\)$}
      naming_prop = Regexp.last_match[:naming_prop]
      @ordered_naming_props << python_to_ruby(naming_prop)

    # else puts "no match for #{line}"
    end
  rescue
    puts "====================\nfailed at line:\n#{line}\n===================="
    raise
  end

  def python_to_ruby(value)
    case value.strip
    when "True"
      true
    when "False"
      false
    when "None"
      nil
    when /^(?<hex>0x[0-9a-f]+)/i
      Integer(Regexp.last_match[:hex])
    when /^\((?<ary>.+)\)$/
      Regexp.last_match[:ary].split(',').map(&method(:python_to_ruby))
    else
      yolo value
    end
  end

  alias yolo eval
end

# small helper class for printing the current status to see what's going on
class MiniProgress
  def initialize(size)
    @size = size
  end

  def progress(value, text)
    percentage = value.to_f / @size * 100
    print "[%3d%%] #{text}\r" % [percentage]
    yield
    print "[%3d%%] #{' ' * text.size}\r" % [percentage]
  end

  def done(text)
    puts "[100%] #{text}"
  end
end

###############################################################################

models = Dir["./pysdk/insieme/model/*/*.py"]
           .reject { _1.end_with?("__init__.py") }

parsed_models = {}
$stdout.sync = true

start_time = Time.now
progress = MiniProgress.new(models.size)
models.each_with_index do |path, i|
  progress.progress(i.succ, "Parsing #{path}") do
    model = PyTonRuby.new(File.read(path)).tap(&:transform)
    parsed_models[path] = model
  end
end
end_time = Time.now
progress.done("Parsing done in %.4f seconds" % [end_time - start_time])

puts "creating Ruby models..."
# group models by package
packages = {}
progress = MiniProgress.new(parsed_models.size)
parsed_models.values.each.with_index do |model, i|
  progress.progress(i.succ, "Grouping #{model.class_name}") do
    package_name = model.class_name.split(".").first
    packages[package_name] ||= {}
    packages[package_name][model.ruby_class_name] = model.generate_class
  end
end
progress.done "Grouped models by package"
# write models by package
FileUtils.mkdir_p "./lib/acirb/model"
progress = MiniProgress.new(packages.size)
packages.each_with_index do |(package_name, package_contents), i|
  progress.progress(i.succ, "Creating #{package_name}.rb") do
    File.open("./lib/acirb/model/#{package_name}.rb", "w") do |f|
      f.puts <<~RUBY
        # auto-generated code
        require "acirb/mo"
        module ACIrb
      RUBY
      package_contents.values.each do |code|
        f.puts code.gsub(/^/m, '  ')
      end
      f.puts "end"
    end
  end
end
progress.done "Created Ruby models"

puts "creating lookup map..."
File.open("./lib/acirb/lookup.rb", "w") do |f|
  class_map = parsed_models.values.map do |model|
    key = model.class_name.tr('.', '').inspect
    value = model.ruby_class_name.inspect

    %(CLASSMAP[#{key}] = #{value})
  end

  f.puts <<~RUBY
    # auto-generated code
    module ACIrb
      CLASSMAP = Hash.new 'None'
      #{class_map.join("\n  ")}
      def lookupClass(classname)
        return CLASSMAP[classname]
      end
    end
  RUBY
end

puts "creating autoload map..."
File.open("./lib/acirb/autoloadmap.rb", "w") do |f|
  f.puts <<~RUBY
    # auto-generated code
    module ACIrb
  RUBY
  packages.each do |package_name, package_contents|
    package_contents.keys.each do |ruby_class_name|
      autoload_path = "acirb/model/#{package_name}.rb"
      f.puts %(  ACIrb.autoload(#{ruby_class_name.inspect}, #{autoload_path.inspect}))
    end
  end
  f.puts "end"
end

total_time = Time.now - start_time
puts "🎉 generating done, total time spent: %.4f seconds" % [total_time]