intprog_hackery/lol.rb

require_relative 'find_algos'
require_relative 'sorting_algos'


# Hi! Steffan was here...

def construct_class(name_of_class, parameters, to_string_template)
  fields = ""
  parameters.each do |x|
    fields += "private #{x[:type]} #{x[:name]};"
  end

  tmptmp = parameters.map { |x| "#{x[:type]} #{x[:name]}"}
  constructor_parameters = tmptmp.join ","

  lel = parameters.map do |x|
    "public #{x[:type]} get#{x[:name]}(){
        return #{x[:name]};
     }"
  end

  getters = lel.join "\n"

  lol = parameters.map do |x|
    "this.#{x[:name]} = #{x[:name]};"
  end

  (0...parameters.length).each do |x|
    pls = '" + '
    pls += parameters[x][:name]
    pls += '+ "'
    to_string_template.sub! "#{x}", pls
  end

  "
    public class #{name_of_class} {
      #{fields}

      public #{name_of_class}(#{constructor_parameters}) {

        #{lol.join("\n")}
      }

      #{getters}

      public String toString() {
        return " + '"' +  "#{to_string_template}" + '"' + ";
      }
    }
  "

end

def construct_driver(class_name, parameters, methods, container_class, container_params)

  def args(parameters)
    tmp = parameters.map do |x|
      type = x[:type]

      res_string = ""
      if type == "int"
        res_string += "#{rand(max=100)}"
      else
        res_string += '"' + (0...10).map { ('a'..'z').to_a[rand(26)] }.join + '"'
      end
      res_string
    end
    tmp.join ","
  end



  methods_to_print = ""
  maggie = methods.map do |x|

    "
      System.out.println(lol.#{x[:name]}(#{args x[:parameters]}));
    "
  end

  driver_string = "
    public class TestDriver {

      public TestDriver(){}

      public static void test() {
        var tmp1 = new #{class_name}(#{args parameters});
        var tmp2 = new #{class_name}(#{args parameters});
        var tmp3 = new #{class_name}(#{args parameters});
        var tmp4 = new #{class_name}(#{args parameters});
        var tmp5 = new #{class_name}(#{args parameters});

        System.out.println(tmp1);
        System.out.println(tmp2);
        System.out.println(tmp3);
        System.out.println(tmp4);
        System.out.println(tmp5);

        #{container_class} lol = new #{container_class}(#{args container_params});

        lol.add#{class_name}(tmp1);
        lol.add#{class_name}(tmp2);
        lol.add#{class_name}(tmp3);
        lol.add#{class_name}(tmp4);
        lol.add#{class_name}(tmp5);
        System.out.println(\"\");
        System.out.println(\"Some checkpoint\");
        #{maggie.join "\n System.out.println(\"Some Checkpoint\"); \n"}

      }

      public static void main(String[] args) {
        TestDriver.test();
      }

    }
  "
end

def construct_container(name, parameters, given_fields, methods, arraylist_name)
  fields = ""

  parameters.each do |x|
    fields += "private #{x[:type]} #{x[:name]};"
  end

  given_fields.each do |x|
    fields += " private #{x[:type]} #{x[:name]};"
  end

  maggie = methods.map do |x|
    "
      public #{x[:return_type]} #{x[:name]} (#{x[:params].map {|y| "#{y[:type]} #{y[:name]}"}.join ","}) {
        #{x[:method_type]}
      }
    "
  end

  construtor_params = parameters.map do |x|
    "#{x[:type]} #{x[:name]}"
  end

  constructor_handlers = parameters.map do |x|
    print(x[:name])
    "this.#{x[:name]} = #{x[:name]};"
  end

  container_string = "
  import java.util.*;

  public class #{name} {
    #{fields}

    public #{name}(#{construtor_params.join ","}) {
      #{constructor_handlers.join "\n"}
      this.#{arraylist_name} = new ArrayList<>();
    }

    #{maggie.join "\n"}
  }
  "

  container_string

end

name = "Ferry"
file = File.open("#{name}.java", "w")
params = [{:type => "String", :name => "Name"}, {:type => "int", :name => "Length"}, {:type => "int", :name => "width"}]
file.puts(construct_class name, params, "0 1 x 2 meter")
file.close


container_methods = [
    {
        :return_type => "void",
        :name => "addFerry",
        :params => [{
            :type => "Ferry",
            :name => "f"
        }],
        :method_type => add_method("ferries", "f")
    },
    {
        :return_type => "ArrayList<Ferry>",
        :name => "smallFerries",
        :params => [{
            :type => "int",
            :name => "maxLength"
        }],
        :method_type => find_all("ferries", "Length", " < ", "#{name}", "maxLength")
    },
    {
        :return_type => "#{name}",
        :name => "longFerry",
        :params => [{
            :type => "String",
            :name => "Name"
                    }],
        :method_type => find_best_with_extra_parameter("ferries", "Length", " > ", "#{name}", "Name", ".equals", "Name", "int")
    }
]
container_class = "Harbour"
another_another_file = File.open("#{container_class}.java", "w")
another_another_file.puts(construct_container(container_class, [{:type => "String", :name => "Name"}], [ {:type => "ArrayList<#{name}>", :name => "ferries"}], container_methods, "ferries"))
another_another_file.close

# TODO: When creating find algorithms, remember to add a space or two (lol for consistency) for <, >, <=, >=

another_file = File.open("TestDriver.java", "w")
another_file.puts(construct_driver name, params, [{:name => "smallFerries", :parameters => [{:type => "int"}], :print => true},
                                                          {:name => "longFerry", :parameters => [{:type => "String"}], :print => true}], "Harbour", [{:type => "String"}])
another_file.close


`javac *.java`
`java TestDriver`