jets 3.1.0 → 5.0.10

data/lib/jets/router/route_set.rb

@@ -0,0 +1,214 @@
+require 'dsl_evaluator'
+
+# The Jets::Router::RouteSet mimics the Rails interface.
+# Jets works in a similar way to Rails.
+# For example the url_helpers:
+#
+#   Jets.application.routes.url_helpers
+#     => Jets.application.routes.named_routes.path_helpers_module
+#       => Jets::Router::Helpers::NamedRoutes::Generated::MainAppHelpers
+#
+# Jets makes less use of anonymous modules. It uses generated named modules
+# to help debugging. Whereas Rails:
+#
+#   Rails.application.routes.url_helpers => <Module>
+#   Rails.application.routes.named_routes.path_helpers_module => <Module>
+#   Rails.application.routes.named_routes.url_helpers_module  => <Module>
+#
+# Rails generates an anonymous module for url_helpers that wraps
+# and includes the path_helpers_module and url_helpers_module.
+#
+# Jets tries to exhibit enough of the same as Rails interface to make it
+# compatible with with ActionController and ActionView components.
+#
+module Jets::Router
+  class RouteSet
+    extend Memoist
+    include Compat::RouteSet
+    include Dsl
+
+    # With Jets, this class is not a really a Collection. It's a wrapper
+    # around Helpers::NamedRoutes::Generated which does the real work.
+    # Naming it NamedRouteCollection to be consistent with Rails and possibly
+    # in the future to make them more similar.
+    class NamedRouteCollection
+      attr_reader :url_helpers_module
+      def initialize(route_set)
+        @url_helpers_module = Helpers::NamedRoutes::Generated.create_helper_module(route_set)
+      end
+
+      # interface method
+      # Rails AbstractController::UrlFor calls this method
+      # Reason why this wrapper is needed.
+      def helper_names
+        url_helpers_module.path_helpers.map(&:to_s) +
+        url_helpers_module.url_helpers.map(&:to_s)
+      end
+
+      delegate :remove_methods!, :add_methods!, to: :url_helpers_module
+    end
+
+    attr_reader :routes, :engine
+    attr_accessor :draw_paths, :default_scope, :default_url_options,
+      :disable_clear_and_finalize
+    def initialize(engine=Jets.application)
+      @engine = engine
+      @engine_class = engine.class
+      @default_url_options = {} # {host: "localhost"}
+      @routes = []
+      @draw_paths = [] # not part of clear! addtional paths: config/routes/admin.rb
+      @prepend = []    # not part of clear! Otherwise breaks engines like sprockets-jets
+      @append = []     # not part of clear!
+      @finalized = false
+      @disable_clear_and_finalize = false
+      @default_scope = {}
+    end
+
+    # draw is called from config/routes.rb
+    # load! is what we just internally to trigger it
+    def draw(&block)
+      clear! unless @disable_clear_and_finalize
+      scope(default_scope) do
+        instance_eval(&block)
+      end
+      finalize! unless @disable_clear_and_finalize
+      check_collision!
+    end
+
+    # Be selective about what to clear. Keep other initialized instance variables
+    # like @prepend, @append, @default_scope
+    # Otherwise can break engines like sprockets-jets that use prepend.
+    def clear!
+      @finalized = false
+      @routes = []
+      @scope = Scope.new
+      named_routes.remove_methods!
+      @prepend.each { |blk| instance_eval(&blk) }
+    end
+
+    # Interface method for plugins.
+    # Plugins like kingsman use to hook into Jets after routes are loaded.
+    def finalize!
+      return if @finalized
+      @append.each { |blk| instance_eval(&blk) }
+      load_external_paths
+      named_routes.add_methods!
+      @finalized = true
+    end
+
+    # additonal paths: config/routes/admin.rb
+    def load_external_paths
+      @draw_paths.each do |draw_path|
+        Dir.glob("#{draw_path}/*.rb").each do |route_path|
+          instance_eval(File.read(route_path), route_path.to_s)
+        end
+      end
+    end
+
+    def append(&block)
+      @append << block
+    end
+
+    def prepend(&block)
+      @prepend << block
+    end
+
+    # Rails interface method
+    def eager_load!
+      # noop for Jets
+    end
+
+    def url_helpers(supports_path = true)
+      @url_helpers ||= named_routes.url_helpers_module
+    end
+
+    def mounted_helpers
+      # Calling url_helpers to create the mounted_helpers proxy methods
+      # IE: main_app and blorgh
+      url_helpers
+      @mounted_helpers ||= Helpers::NamedRoutes::Generated::MountedHelpers
+    end
+
+    def define_mounted_helper(name)
+      Helpers::NamedRoutes::Generated.define_mounted_helper(name, self)
+    end
+
+    # Note: Jets assigns this to a instance varialbe in the initialize method
+    # But Jets cannot do this because we currently eager load internally and
+    # that routes draw would not be called in proper order.
+    def named_routes
+      NamedRouteCollection.new(self)
+    end
+    memoize :named_routes
+
+    # Validate routes that deployable
+    def check_collision!
+      return if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+      paths = self.routes.map(&:path)
+      collision = Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Collision.new
+      collide = collision.collision?(paths)
+      raise collision.exception if collide
+    end
+
+    def one_apigw_method_for_all_routes_warning(options)
+      return unless options[:authorizer]
+      return unless Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
+      return if options[:path].starts_with?('*') # *catchall
+      return if options[:path] == '' # root
+
+      puts <<~EOL.color(:yellow)
+        WARNING: Authorizer should not be set at individual routes when using
+
+            config.cfn.build.routes == "one_apigw_method_for_all_routes"
+
+        You should only set authorizer for the root route and *catchall route.
+        The root route uses the root authorizer.
+        And all other routes uses the *catchall authorizer.
+        Docs: http://rubyonjets.com/docs/routing/authorizers/one-method/
+      EOL
+      DslEvaluator.print_code(routes_call_line) if routes_call_line
+    end
+
+    def routes_call_line
+      caller.find { |l| l.include?('config/routes.rb') }
+    end
+
+    def api_mode?
+      Jets.config.mode == 'api' || Jets.config.api_only
+    end
+
+    # Useful for creating API Gateway Resources
+    def all_paths
+      results = []
+      paths = routes.map(&:path)
+      paths.each do |p|
+        sub_paths = []
+        parts = p.split('/')
+        until parts.empty?
+          parts.pop
+          sub_path = parts.join('/')
+          sub_paths << sub_path unless sub_path == ''
+        end
+        results += sub_paths
+      end
+      @all_paths = (results + paths).sort.uniq
+    end
+
+    # Useful for RouterMatcher
+    #
+    # Precedence:
+    # Routes with wildcards are considered after routes without wildcards
+    #
+    # Routes with fewer captures are ordered first since both
+    # /posts/:post_id/comments/new and /posts/:post_id/comments/:id are equally
+    # long
+    #
+    # Routes with the same amount of captures and wildcards are orderd so that
+    # the longest path is considered first since posts/:id and posts/:id/edit
+    # can both match.
+    def ordered_routes
+      length = Proc.new { |r| [r.path.count("*"), r.path.count(":"), r.path.length * -1] }
+      routes.sort_by(&length)
+    end
+  end
+end

data/lib/jets/router/scope.rb

@@ -1,95 +1,230 @@
-module Jets
-  class Router
-    class Scope
-      include Util
+module Jets::Router
+  class Scope
+    include Util
 
-      attr_reader :options, :parent, :level
-      def initialize(options = {}, parent = nil, level = 1)
-        @options = options
-        @parent = parent
-        @level = level
-      end
+    module Macros
+      OPTION_ACCESSORS = Set.new
+      extend ActiveSupport::Concern
 
-      def root?
-        @parent.nil?
+      class_methods do
+        def option_accessor(*names)
+          names.each do |name|
+            define_method(name) do
+              @options[name]
+            end
+            define_method("#{name}=") do |value|
+              if value.nil?
+                @options.delete(name)
+              else
+                @options[name] = value
+              end
+            end
+            define_method("#{name}?") do
+              !!@options[name]
+            end
+            OPTION_ACCESSORS.add(name)
+          end
+        end
       end
 
-      def new(options={})
-        self.class.new(options, self, level + 1)
+      # Allow [] and []= notation. Though Jets does not use this internally.
+      # This is what Rails ActionDispatch::Routing::Mapper::Scope does.
+      # Helps with compatibility in case plugins use this notation.
+      def [](key)
+        if OPTION_ACCESSORS.include?(key)
+          send(key)
+        else
+          raise NoMethodError, "undefined method `#{key}' for #{self}"
+        end
       end
 
-      def full_module
-        items = walk_parents do |current, i, result|
-          mod = current.options[:module]
-          next unless mod
-          result.unshift(mod)
+      def []=(key, value)
+        if OPTION_ACCESSORS.include?(key)
+          send("#{key}=", value)
+        else
+          raise NoMethodError, "undefined method `#{key}' for #{self}"
         end
+      end
+    end
+    include Macros
 
-        items.empty? ? nil : items.join('/')
+    attr_reader :options, :parent, :level, :children
+    attr_accessor :next
+    option_accessor :from, :path, :as, :resource_name, :module, :singular_resource,
+      :controller, :defaults, :constraints, :shallow
+    def initialize(options = {}, parent = nil, level = 1)
+      @options = options
+      @parent = parent
+      @level = level
+      @children = []
+      if parent
+        parent.children << self
       end
+    end
 
-      def full_prefix
-        items = walk_parents do |current, i, result|
-          prefix = current.options[:prefix]
-          next unless prefix
+    def new(options={})
+      self.class.new(options, self, level + 1)
+    end
 
-          case current.from
-          when :resources
-            path_param = if current.options[:param]
-              ":#{current.options[:param]}"
-            else
-              resource_name = prefix.to_s.split('/').last
-              resource_name = ":#{resource_name.singularize}_id"
-            end
-            result.unshift(path_param)
-            result.unshift(prefix)
-          else # resource, namespace or general scope
-            result.unshift(prefix)
-          end
-        end
+    def virtual_controller
+      case from
+      when :member, :collection
+        parent.virtual_controller
+      when :resource
+        controller || resource_name.to_s.pluralize
+      else
+        controller || resource_name
+      end
+    end
 
-        items.empty? ? nil : items.join('/')
+    def resolved_defaults
+      result = {}
+      from_top.each do |scope|
+        result.merge!(scope.defaults) if scope.defaults
       end
+      result
+    end
 
-      def full_as
-        items = []
-        current = self
-        while current
-          items.unshift(current.options[:as]) # <= option_name
-          current = current.parent
-        end
+    def resolved_constraints
+      from_bottom.each do |scope|
+        return scope.constraints if scope.constraints
+      end
+      nil
+    end
+
+    def resolved_module
+      items = from_top.map(&:module).compact
+      items.join('/') unless items.empty?
+    end
 
-        items.compact!
-        return if items.empty?
+    def needs_controller_path?
+      return false if resource_name  # no adjustments if within resource or resources scope
 
-        items = singularize_leading(items)
-        items.join('_')
+      from.nil?
+    end
+
+    def virtual?
+      from == :member || from == :collection
+    end
+
+    def resolved_path
+      case from
+      when :resource, :resources
+        path || resource_name
+      when :namespace, :path, nil
+        path
+      when :member, :collection
+        parent.resolved_path
       end
+    end
 
-      def walk_parents
-        current, i, result = self, 0, []
-        while current
-          yield(current, i, result)
-          current = current.parent
-          i += 1
-        end
-        result
+    def parent_or_higher?(other_scope)
+      current_scope = self
+
+      while current_scope.parent && !current_scope.parent.virtual?
+        return true if current_scope.parent == other_scope
+        current_scope = current_scope.parent
       end
 
-      # singularize all except last item
-      def singularize_leading(items)
-        result = []
-        items.each_with_index do |item, index|
-          item = item.to_s
-          r = index == items.size - 1 ? item : item.singularize
-          result << r
-        end
-        result
+      false
+    end
+
+    def real_parent?(scope)
+      if scope.virtual?
+        scope.parent == parent
+      else
+        parent == scope
       end
+    end
 
-      def from
-        @options[:from]
+    def resource_descendent?(scope=self)
+      # return false
+      scope.children.each do |child|
+        return true if child.from == :resource || child.from == :resources
+        return true if resource_descendent?(child)
       end
+      false
+    end
+
+    def resource_sibling?
+      return false
+      !resource_siblings.empty?
+    end
+
+    def colliding_resource_sibling?
+      return false
+      # Don't think need to check for path because it doesn't really make sense
+      # to point 2 different resources to the same path.
+      resource_names = resource_siblings.map(&:resource_name)
+      resource_names.uniq.size != resource_names.size
+    end
+
+    def resource_siblings
+      return [] unless parent
+      parent.children.select do |c|
+        c != self &&
+        (c.from == :resource || c.from == :resources)
+      end
+    end
+
+    # At time of each_resource DSL evaluation, the routes file has not fully evaluated
+    # and the scope context is not fully available. IE: info on the children.
+    #
+    # Placeholder param allows the values to lazily replaced later with full context.
+    # We only have to replace the last segment with the placeholder.
+    # This is because previous segments are already replaced with Route::Path#path_prefixes
+    # scopes_from_top logic.
+    def param_placeholder
+      if resource_name
+        "#{resource_name.upcase}_PARAM"
+      else
+        prefix = path.to_s.gsub('/','_').upcase
+        "#{prefix}_PARAM"
+      end
+    end
+
+    def from_top
+      from_bottom.reverse
+    end
+    alias all_scopes from_top
+
+    def from_bottom
+      current_scope = self
+      scopes = []
+      previous_scope = nil # child
+      # do not include the root scope
+      while current_scope.parent
+        current_scope.next = previous_scope if previous_scope
+        scopes << current_scope
+        previous_scope = current_scope
+        current_scope = current_scope.parent
+      end
+      scopes
+    end
+
+    def any_parent_shallow?
+      from_bottom.any? do |scope|
+        scope.shallow? || scope.from == :shallow
+      end
+    end
+
+    # singularize all except last item
+    def singularize_leading(items)
+      result = []
+      items.each_with_index do |item, index|
+        item = item.to_s
+        r = index == items.size - 1 ? item : item.singularize
+        result << r
+      end
+      result
+    end
+
+    def root?
+      @parent.nil?
+    end
+
+    def to_s
+      "<Scope:#{object_id} @level=#{@level} @options=#{@options}>"
     end
   end
 end

data/lib/jets/router/state.rb

@@ -0,0 +1,67 @@
+module Jets::Router
+  class State
+    extend Memoist
+    include Jets::AwsServices
+
+    def self.save_apigw_state
+      state = Jets::Router::State.new
+      state.save("methods", Jets::Cfn::Builder::Api::Pages::Methods.pages)
+      state.save("resources", Jets::Cfn::Builder::Api::Pages::Resources.pages)
+      # To avoid API limits for calculating changed routes in next deploy
+      state.save("routes", Jets::Router.routes)
+    end
+
+    def load(filename)
+      resp = nil
+      begin
+        resp = s3.get_object(
+          bucket: Jets.aws.s3_bucket,
+          key: s3_storage_path(filename),
+        )
+      rescue Aws::S3::Errors::NoSuchBucket
+        # Allow JETS_TEMPLATES=1 jets build to work with no-bucket-yet
+        return nil
+      end
+      text = resp.body.read
+      JSON.load(text)
+    rescue Aws::S3::Errors::NoSuchKey, Aws::S3::Errors::PermanentRedirect
+    end
+    memoize :load
+
+    # Save previously deployed APIGW routes state
+    def save(filename, data)
+      body = data.respond_to?(:to_json) ? data.to_json : JSON.generate(data)
+      body = JSON.pretty_generate(JSON.parse(body)) # pretty generate
+      if ENV['JETS_API_STATE_DEBUG'] # useful with jets build --templates
+        puts "WARN: JETS_API_STATE_DEBUG=1 detected. Saving to tmp/#{filename}.json instead of S3.".color(:yellow)
+        IO.write("tmp/#{filename}.json", body)
+      else
+        s3.put_object(
+          body: body,
+          bucket: Jets.aws.s3_bucket,
+          key: s3_storage_path(filename),
+        )
+      end
+    end
+
+    # Examples:
+    #
+    #   jets/state/apigw/resources.json
+    #   jets/state/apigw/methods.json
+    #   jets/state/apigw/routes.json
+    #
+    # Fetch or loaded in:
+    #
+    #   resources.json: Jets::Cfn::Builder::Api::Pages::Resources#old_pages
+    #   methods.json:   Jets::Cfn::Builder::Api::Pages::Methods#old_pages
+    #   routes.json:    Jets::Cfn::Resource::ApiGateway::RestApi::Routes::Change::Base#deployed_routes
+    #
+    # Saved in:
+    #
+    #   Jets::Cfn::Ship#save_apigw_state
+    #
+    def s3_storage_path(filename)
+      "jets/state/apigw/#{filename}.json"
+    end
+  end
+end

data/lib/jets/router/util.rb

@@ -1,38 +1,8 @@
-class Jets::Router
+module Jets::Router
   module Util
-    # used in MethodCreator logic
-    def join(*items)
-      list = items.compact.join('_')
-      underscore(list)
-    end
-
     def underscore(str)
       return unless str
       str.to_s.gsub(/[^a-zA-Z0-9]/,'_')
     end
-
-    def get_controller_action(options)
-      if options.key?(:controller) && options.key?(:action)
-        [options[:controller], options[:action]]
-      elsif options.key?(:controller) && options.key?(:to)
-        action = options[:to].split('#').last
-        [options[:controller], action]
-      elsif options.key?(:on)
-        handle_on!(options)
-      else
-        options[:to].split('#') # controller, action
-      end
-    end
-
-    def handle_on!(options)
-      controller = @scope.options[:prefix].to_s
-      to = "#{controller}##{options[:path]}"
-      options[:to] = to
-
-      as = @options[:on] == :member ? controller.singularize : controller
-      as = "#{@options[:path]}_#{as}"
-      options[:as] = as
-      to.split('#')
-    end
   end
 end