Cleanup unused grpc targets

* Merge grpc (core), grpc++ and gpr libraries into contrib/libs/grpc
* Drop unused grpc_unsecure, grpc++_unsecure and grpc++_error_details
* Remove abundance of hacks from import routine

1 files changed, 215 insertions, 0 deletions

diff --git a/contrib/libs/grpc/src/compiler/ruby_generator.cc b/contrib/libs/grpc/src/compiler/ruby_generator.cc
new file mode 100644
index 00000000000..f5b9e9db870
--- /dev/null
+++ b/contrib/libs/grpc/src/compiler/ruby_generator.cc
@@ -0,0 +1,215 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/compiler/ruby_generator.h"
+
+#include <cctype>
+#include <map>
+#include <vector>
+
+#include "src/compiler/config.h"
+#include "src/compiler/ruby_generator_helpers-inl.h"
+#include "src/compiler/ruby_generator_map-inl.h"
+#include "src/compiler/ruby_generator_string-inl.h"
+
+using grpc::protobuf::FileDescriptor;
+using grpc::protobuf::MethodDescriptor;
+using grpc::protobuf::ServiceDescriptor;
+using grpc::protobuf::io::Printer;
+using grpc::protobuf::io::StringOutputStream;
+using std::map;
+using std::vector;
+
+namespace grpc_ruby_generator {
+namespace {
+
+// Prints out the method using the ruby gRPC DSL.
+void PrintMethod(const MethodDescriptor* method, Printer* out) {
+  TString input_type = RubyTypeOf(method->input_type());
+  if (method->client_streaming()) {
+    input_type = "stream(" + input_type + ")";
+  }
+  TString output_type = RubyTypeOf(method->output_type());
+  if (method->server_streaming()) {
+    output_type = "stream(" + output_type + ")";
+  }
+  std::map<TString, TString> method_vars = ListToDict({
+      "mth.name",
+      method->name(),
+      "input.type",
+      input_type,
+      "output.type",
+      output_type,
+  });
+  out->Print(GetRubyComments(method, true).c_str());
+  out->Print(method_vars, "rpc :$mth.name$, $input.type$, $output.type$\n");
+  out->Print(GetRubyComments(method, false).c_str());
+}
+
+// Prints out the service using the ruby gRPC DSL.
+void PrintService(const ServiceDescriptor* service, Printer* out) {
+  if (service->method_count() == 0) {
+    return;
+  }
+
+  // Begin the service module
+  std::map<TString, TString> module_vars = ListToDict({
+      "module.name",
+      Modularize(service->name()),
+  });
+  out->Print(module_vars, "module $module.name$\n");
+  out->Indent();
+
+  out->Print(GetRubyComments(service, true).c_str());
+  out->Print("class Service\n");
+
+  // Write the indented class body.
+  out->Indent();
+  out->Print("\n");
+  out->Print("include ::GRPC::GenericService\n");
+  out->Print("\n");
+  out->Print("self.marshal_class_method = :encode\n");
+  out->Print("self.unmarshal_class_method = :decode\n");
+  std::map<TString, TString> pkg_vars =
+      ListToDict({"service_full_name", service->full_name()});
+  out->Print(pkg_vars, "self.service_name = '$service_full_name$'\n");
+  out->Print("\n");
+  for (int i = 0; i < service->method_count(); ++i) {
+    PrintMethod(service->method(i), out);
+  }
+  out->Outdent();
+
+  out->Print("end\n");
+  out->Print("\n");
+  out->Print("Stub = Service.rpc_stub_class\n");
+
+  // End the service module
+  out->Outdent();
+  out->Print("end\n");
+  out->Print(GetRubyComments(service, false).c_str());
+}
+
+}  // namespace
+
+// The following functions are copied directly from the source for the protoc
+// ruby generator
+// to ensure compatibility (with the exception of int and string type changes).
+// See
+// https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/compiler/ruby/ruby_generator.cc#L250
+// TODO: keep up to date with protoc code generation, though this behavior isn't
+// expected to change
+bool IsLower(char ch) { return ch >= 'a' && ch <= 'z'; }
+
+char ToUpper(char ch) { return IsLower(ch) ? (ch - 'a' + 'A') : ch; }
+
+// Package names in protobuf are snake_case by convention, but Ruby module
+// names must be PascalCased.
+//
+//   foo_bar_baz -> FooBarBaz
+TString PackageToModule(const TString& name) {
+  bool next_upper = true;
+  TString result;
+  result.reserve(name.size());
+
+  for (TString::size_type i = 0; i < name.size(); i++) {
+    if (name[i] == '_') {
+      next_upper = true;
+    } else {
+      if (next_upper) {
+        result.push_back(ToUpper(name[i]));
+      } else {
+        result.push_back(name[i]);
+      }
+      next_upper = false;
+    }
+  }
+
+  return result;
+}
+// end copying of protoc generator for ruby code
+
+TString GetServices(const FileDescriptor* file) {
+  TString output;
+  {
+    // Scope the output stream so it closes and finalizes output to the string.
+
+    StringOutputStream output_stream(&output);
+    Printer out(&output_stream, '$');
+
+    // Don't write out any output if there no services, to avoid empty service
+    // files being generated for proto files that don't declare any.
+    if (file->service_count() == 0) {
+      return output;
+    }
+
+    TString package_name = RubyPackage(file);
+
+    // Write out a file header.
+    std::map<TString, TString> header_comment_vars = ListToDict({
+        "file.name",
+        file->name(),
+        "file.package",
+        package_name,
+    });
+    out.Print("# Generated by the protocol buffer compiler.  DO NOT EDIT!\n");
+    out.Print(header_comment_vars,
+              "# Source: $file.name$ for package '$file.package$'\n");
+
+    TString leading_comments = GetRubyComments(file, true);
+    if (!leading_comments.empty()) {
+      out.Print("# Original file comments:\n");
+      out.PrintRaw(leading_comments.c_str());
+    }
+
+    out.Print("\n");
+    out.Print("require 'grpc'\n");
+    // Write out require statemment to import the separately generated file
+    // that defines the messages used by the service. This is generated by the
+    // main ruby plugin.
+    std::map<TString, TString> dep_vars = ListToDict({
+        "dep.name",
+        MessagesRequireName(file),
+    });
+    out.Print(dep_vars, "require '$dep.name$'\n");
+
+    // Write out services within the modules
+    out.Print("\n");
+    std::vector<TString> modules = Split(package_name, '.');
+    for (size_t i = 0; i < modules.size(); ++i) {
+      std::map<TString, TString> module_vars = ListToDict({
+          "module.name",
+          PackageToModule(modules[i]),
+      });
+      out.Print(module_vars, "module $module.name$\n");
+      out.Indent();
+    }
+    for (int i = 0; i < file->service_count(); ++i) {
+      auto service = file->service(i);
+      PrintService(service, &out);
+    }
+    for (size_t i = 0; i < modules.size(); ++i) {
+      out.Outdent();
+      out.Print("end\n");
+    }
+
+    out.Print(GetRubyComments(file, false).c_str());
+  }
+  return output;
+}
+
+}  // namespace grpc_ruby_generator