google-apis-generator 0.1.0

data/lib/google/apis/generator/model.rb

@@ -0,0 +1,195 @@
+# Copyright 2015 Google Inc.
+#
+# 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.
+
+require 'active_support/inflector'
+require 'google/apis/discovery_v1'
+
+# Extend the discovery API classes with additional data needed to make
+# code generation produce better results
+module Google
+  module Apis
+    module DiscoveryV1
+      TYPE_MAP = {
+        'string' => 'String',
+        'boolean' => 'Boolean',
+        'number' => 'Float',
+        'integer' => 'Fixnum',
+        'any' => 'Object'
+      }
+
+      class JsonSchema
+        attr_accessor :name
+        attr_accessor :generated_name
+        attr_accessor :generated_class_name
+        attr_accessor :base_ref
+        attr_accessor :parent
+        attr_accessor :discriminant
+        attr_accessor :discriminant_value
+        attr_accessor :path
+
+        def properties
+          Hash[(@properties || {}).sort]
+        end
+
+        def qualified_name
+          parent.qualified_name + '::' + generated_class_name
+        end
+
+        def generated_type
+          case type
+          when 'string', 'boolean', 'number', 'integer', 'any'
+            return 'DateTime' if format == 'date-time'
+            return 'Date' if format == 'date'
+            return 'Fixnum' if format == 'int64'
+            return 'Fixnum' if format == 'uint64'
+            return TYPE_MAP[type]
+          when 'array'
+            if items == self
+              return sprintf('Array<%s>', qualified_name)
+            end
+            return sprintf('Array<%s>', items.generated_type)
+          when 'hash'
+            if additional_properties == self
+              return sprintf('Hash<String,%s>', qualified_name)
+            end
+            return sprintf('Hash<String,%s>', additional_properties.generated_type)
+          when 'object'
+            return qualified_name
+          end
+        end
+      end
+
+      class RestMethod
+        attr_accessor :generated_name
+        attr_accessor :parent
+
+        def parameters
+          Hash[(@parameters || {}).sort]
+        end
+
+        def path_parameters
+          return [] if parameter_order.nil? || parameters.nil?
+          parameter_order.map { |name| parameters[name] }.select { |param| param.location == 'path' }
+        end
+
+        def query_parameters
+          return [] if parameters.nil?
+          parameters.values.select { |param| param.location == 'query' }
+        end
+
+        def required_parameters
+          return [] if parameter_order.nil? || parameters.nil?
+          parameter_order.map { |name| parameters[name] }.select { |param| param.location == 'path' || param.required }
+        end
+
+        def optional_query_parameters
+          query_parameters.select { |param| param.required != true }
+        end
+
+      end
+
+      class RestResource
+        attr_accessor :parent
+
+        def api_methods
+          Hash[(@api_methods || {}).sort]
+        end
+
+        def resources
+          Hash[(@resources || {}).sort]
+        end
+
+        def all_methods
+          m = []
+          m << api_methods.values unless api_methods.nil?
+          m << resources.map { |_k, r| r.all_methods } unless resources.nil?
+          m.flatten
+        end
+      end
+
+      class RestDescription
+        attr_accessor :force_alt_json
+        alias_method :force_alt_json?, :force_alt_json
+
+        # Don't expose these in the API directly.
+        PARAMETER_BLACKLIST = %w(alt access_token bearer_token oauth_token pp prettyPrint
+                                 $.xgafv callback upload_protocol uploadType)
+
+        def version
+          ActiveSupport::Inflector.camelize(@version.gsub(/\W/, '-')).gsub(/-/, '_')
+        end
+
+        def name
+          ActiveSupport::Inflector.camelize(@name)
+        end
+
+        def module_name
+          name + version
+        end
+
+        def qualified_name
+          sprintf('Google::Apis::%s', module_name)
+        end
+
+        def base_path
+          ActiveSupport::Inflector.underscore(qualified_name)
+        end
+
+        def gem_name
+          base_path.tr("/", "-")
+        end
+
+        def service_name
+          class_name = (canonical_name || name).gsub(/\W/, '')
+          ActiveSupport::Inflector.camelize(sprintf('%sService', class_name))
+        end
+
+        def api_methods
+          Hash[(@api_methods || {}).sort]
+        end
+
+        def resources
+          Hash[(@resources || {}).sort]
+        end
+
+        def all_methods
+          m = []
+          m << api_methods.values unless api_methods.nil?
+          m << resources.map { |_k, r| r.all_methods } unless resources.nil?
+          m.flatten
+        end
+
+        def parameters
+          Hash[(@parameters || {}).sort].delete_if { |k, _v| PARAMETER_BLACKLIST.include?(k) }
+        end
+
+        def schemas
+          Hash[(@schemas || {}).sort]
+        end
+
+        class Auth
+          class Oauth2
+            class Scope
+              attr_accessor :constant
+            end
+
+            def scopes
+              Hash[(@scopes || {}).sort]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/generator/template.rb

@@ -0,0 +1,124 @@
+# Copyright 2015 Google Inc.
+#
+# 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.
+
+require 'active_support/inflector'
+require 'erb'
+require 'ostruct'
+
+module Google
+  module Apis
+    # @private
+    class Generator
+      # Directory containing ERB templates
+      TEMPLATE_DIR = File.expand_path('../templates', __FILE__)
+
+      # Helpers used in ERB templates
+      module TemplateHelpers
+        # Get the include path for a ruby module/class
+        #
+        # @param [String] module_name
+        #  Fully qualified module/class name
+        # @return [String]
+        #  Path to file
+        def to_path(module_name)
+          ActiveSupport::Inflector.underscore(module_name)
+        end
+
+        # Render a block comment
+        #
+        # @param [String] str
+        #  Comment string
+        # @param [Fixnum] spaces_before
+        #  Number of spaces to indent the comment hash
+        # @param [Fixnum] spaces_after
+        #  Number of spaces to indent after the comment hash for subsequent lines
+        # @return [String] formatted comment
+        def block_comment(str, spaces_before = 0, spaces_after = 0)
+          return '' if str.nil?
+          pre = ' ' * spaces_before
+          post = ' ' * spaces_after
+          lines = str.gsub(/([{}])/, '`').scan(/.{1,78}(?:\W|$)/).map(&:strip)
+          lines.join("\n" + pre + '#' + post)
+        end
+
+        # Indent a block of text
+        #
+        # @param [String] str
+        #  Content to indent
+        # @param [Fixnum] spaces
+        #  Number of spaces to indent
+        # @return [String] formatted content
+        def indent(str, spaces)
+          pre = ' ' * spaces
+          str = pre + str.split(/\n/).join("\n" + pre) + "\n"
+          return str unless str.strip.empty?
+          nil
+        end
+
+        # Include a partial inside a template.
+        #
+        # @private
+        # @param [String] partial
+        #  Name of the template
+        # @param [Hash] context
+        #  Context used to render
+        # @return [String] rendered content
+        def include(partial, context)
+          template = Template.new(sprintf('_%s.tmpl', partial))
+          template.render(context)
+        end
+      end
+
+      # Holds local vars/helpers for template rendering
+      class Context < OpenStruct
+        include TemplateHelpers
+
+        # Get the context for ERB evaluation
+        # @return [Binding]
+        def to_binding
+          binding
+        end
+      end
+
+      # ERB template for the code generator
+      class Template
+        # Loads a template from the template dir. Automatically
+        # appends the .tmpl suffix
+        #
+        # @param [String] template_name
+        #  Name of the template file
+        def self.load(template_name)
+          Template.new(sprintf('%s.tmpl', template_name))
+        end
+
+        # @param [String] template_name
+        #  Name of the template file
+        def initialize(template_name)
+          file = File.join(TEMPLATE_DIR, template_name)
+          @erb = ERB.new(File.read(file), nil, '-')
+        end
+
+        # Render the template
+        #
+        # @param [Hash] context
+        #  Variables to set when rendering the template
+        # @return [String] rendered template
+        def render(context)
+          ctx = Context.new(context)
+          @erb.result(ctx.to_binding)
+        end
+      end
+    end
+  end
+end

data/lib/google/apis/generator/updater.rb

@@ -0,0 +1,139 @@
+# Copyright 2020 Google LLC
+#
+# 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.
+
+require "gems"
+
+module Google
+  module Apis
+    class Generator
+      # Matches generated files against current files and decides what to update
+      # @private
+      class Updater
+        def initialize
+          @gems_client = nil
+          @current_rubygems_versions = {}
+        end
+
+        def analyze(base_dir, generator_result)
+          modified_files = {}
+          version_content = changelog_content = nil
+          generator_result.files.each do |path, content|
+            full_path = File.join(base_dir, path)
+            old_content = File.binread(full_path) if File.readable?(full_path)
+            if path == generator_result.version_path
+              version_content = old_content || content
+            elsif path == generator_result.changelog_path
+              changelog_content = old_content || content
+            else
+              modified_files[path] = content unless content == old_content
+            end
+          end
+          unless modified_files.empty?
+            desired_gem_version = next_rubygems_version(generator_result.gem_name)
+            version_content, generator_version_change, revision_change =
+                update_version_content(version_content, desired_gem_version, generator_result.revision)
+            changelog_content = update_changelog_content(changelog_content, desired_gem_version, generator_version_change, revision_change)
+            modified_files[generator_result.version_path] = version_content
+            modified_files[generator_result.changelog_path] = changelog_content
+          end
+          modified_files
+        end
+
+        # @private
+        def gems_client
+          @gems_client ||= Gems::Client.new
+        end
+
+        # @private
+        def current_rubygems_version(gem_name)
+          @current_rubygems_versions[gem_name] ||= begin
+            gems_client.info(gem_name)["version"]
+          rescue Gems::NotFound
+            "0.0.0"
+          end
+        end
+
+        # @private
+        def next_rubygems_version(gem_name)
+          major, minor = current_rubygems_version(gem_name).split(".")
+          "#{major.to_i}.#{minor.to_i + 1}.0"
+        end
+
+        # @private
+        def update_version_content(content, desired_gem_version, new_revision)
+          generator_version_change = revision_change = nil
+          modified_content = content.dup
+          modified_content.sub!(/GEM_VERSION = "([\w\.]*)"/) do |*|
+            "GEM_VERSION = \"#{desired_gem_version}\""
+          end or raise "gem_version.rb is missing GEM_VERSION"
+          modified_content.sub!(/GENERATOR_VERSION = "([\w\.]*)"/) do |*|
+            generator_version_change = Generator::VERSION unless Regexp.last_match[1] == Generator::VERSION
+            "GENERATOR_VERSION = \"#{Generator::VERSION}\""
+          end or raise "gem_version.rb is missing GENERATOR_VERSION"
+          modified_content.sub!(/REVISION = "([\w\.]*)"/) do |*|
+            revision_change = new_revision unless Regexp.last_match[1] == new_revision
+            "REVISION = \"#{new_revision}\""
+          end or raise "gem_version.rb is missing REVISION"
+          [modified_content, generator_version_change, revision_change]
+        end
+
+        # @private
+        def update_changelog_content(content, desired_gem_version, generator_version_change, revision_change)
+          lines = parse_existing_changelog_entry(content, desired_gem_version)
+          modify_changelog_lines(lines, generator_version_change, revision_change)
+          entry = assemble_changelog_entry(lines, desired_gem_version)
+          replace_changelog_entry(content, desired_gem_version, entry)
+        end
+
+        # @private
+        def parse_existing_changelog_entry(content, desired_gem_version)
+          quoted_gem_version = Regexp.quote(desired_gem_version)
+          match = /\n+### v#{quoted_gem_version} \([\d-]+\)\n+((?:[^#][^\n]*\n+)*)(?=#|$)/.match content
+          return [] unless match
+          match[1].split("\n")
+        end
+
+        # @private
+        def modify_changelog_lines(lines, generator_version_change, revision_change)
+          if generator_version_change
+            lines.reject! { |line| line =~ /^\* Regenerated using generator version \d[\w\.]+/ }
+            lines.unshift("* Regenerated using generator version #{generator_version_change}")
+          end
+          if revision_change
+            lines.reject! { |line| line =~ /^\* Regenerated from discovery document revision \d+/ }
+            lines.unshift("* Regenerated from discovery document revision #{revision_change}")
+          end
+          lines << "* Unspecified changes" if lines.empty?
+        end
+
+        # @private
+        def assemble_changelog_entry(lines, desired_gem_version)
+          entry_lines = lines.join("\n")
+          date = Time.now.strftime("%Y-%m-%d")
+          "\n\n### v#{desired_gem_version} (#{date})\n\n#{entry_lines}\n\n"
+        end
+
+        # @private
+        def replace_changelog_entry(content, desired_gem_version, entry)
+          quoted_gem_version = Regexp.quote(desired_gem_version)
+          modified_content = content.dup
+          modified_content.sub!(/\n+### v#{quoted_gem_version} \([\d-]+\)\n+(?:[^#][^\n]*\n+)*(?=#|$)/, entry) or
+            modified_content.sub!(/^(\n*# [^\n]+)\n+(?=#|$)/, "\\1#{entry}") or
+            raise "CHANGELOG doesn't seem to have the expected header"
+          modified_content
+        end
+      end
+    end
+  end
+end