jets 5.0.14 → 6.0.0.beta1

data/lib/jets/router/scope.rb

@@ -1,230 +0,0 @@
-module Jets::Router
-  class Scope
-    include Util
-
-    module Macros
-      OPTION_ACCESSORS = Set.new
-      extend ActiveSupport::Concern
-
-      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
-
-      # 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 []=(key, value)
-        if OPTION_ACCESSORS.include?(key)
-          send("#{key}=", value)
-        else
-          raise NoMethodError, "undefined method `#{key}' for #{self}"
-        end
-      end
-    end
-    include Macros
-
-    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 new(options={})
-      self.class.new(options, self, level + 1)
-    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
-
-    def resolved_defaults
-      result = {}
-      from_top.each do |scope|
-        result.merge!(scope.defaults) if scope.defaults
-      end
-      result
-    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
-
-    def needs_controller_path?
-      return false if resource_name  # no adjustments if within resource or resources scope
-
-      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 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
-
-      false
-    end
-
-    def real_parent?(scope)
-      if scope.virtual?
-        scope.parent == parent
-      else
-        parent == scope
-      end
-    end
-
-    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

@@ -1,67 +0,0 @@
-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,8 +0,0 @@
-module Jets::Router
-  module Util
-    def underscore(str)
-      return unless str
-      str.to_s.gsub(/[^a-zA-Z0-9]/,'_')
-    end
-  end
-end

data/lib/jets/router.rb

@@ -1,94 +0,0 @@
-module Jets
-  module Router
-    class Error < RuntimeError ; end
-
-    NAMED_ROUTES_METHODS = %w[index new create show edit update destroy].freeze
-
-    def has_controller?(name)
-      routes.detect { |r| r.controller_name == name }
-    end
-
-    def draw
-      drawn_route_set
-    end
-
-    @@drawn_route_set = nil
-    def drawn_route_set
-      return @@drawn_route_set if @@drawn_route_set
-
-      route_set = Jets.application.routes
-      @@drawn_route_set = route_set
-    end
-
-    def clear!
-      @@drawn_route_set = nil
-    end
-
-    def routes
-      drawn_route_set.routes
-    end
-
-    # So we can save state in s3 post deploy. Example of structure.
-    #
-    #   [
-    #     {"scope"=>{"options"=>{"as"=>"posts", "path"=>"posts", "param"=>nil, "from"=>"resources"}, "parent"=>{"options"=>{}, "parent"=>nil, "level"=>1}, "level"=>2}, "options"=>{"to"=>"posts#index", "path"=>"posts", "method"=>"get"}, "path"=>"posts", "to"=>"posts#index", "as"=>"posts"},
-    #     {"scope"=>{"options"=>{"as"=>"posts", "path"=>"posts", "param"=>nil, "from"=>"resources"}, "parent"=>{"options"=>{}, "parent"=>nil, "level"=>1}, "level"=>2}, "options"=>{"to"=>"posts#new", "path"=>"posts/new", "method"=>"get"}, "path"=>"posts/new", "to"=>"posts#new", "as"=>"new_post"},
-    #     ...
-    #   ]
-    #
-    def to_json
-      JSON.dump(routes.map(&:to_h))
-    end
-
-    # Returns all paths including subpaths.
-    # Example:
-    # Input: ["posts/:id/edit"]
-    # Output: ["posts", "posts/:id", "posts/:id/edit"]
-    def all_paths
-      drawn_route_set.all_paths
-    end
-
-    def all_routes_valid?
-      invalid_routes.empty?
-    end
-
-    def invalid_routes
-      routes.select { |r| !r.valid? }
-    end
-
-    def validate_routes!
-      return true if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
-      check_route_connected_functions
-    end
-
-    # Checks that all routes are validate and have corresponding lambda functions
-    def check_route_connected_functions
-      return true if all_routes_valid?
-
-      puts "Please double check the routes below map to valid controllers:".color(:red)
-      invalid_routes.each do |route|
-        puts "  /#{route.path} => #{route.controller_name}##{route.action_name}"
-      end
-      false
-    end
-
-    def find_route_by_event(event)
-      request = Jets::Controller::Request.new(event: event)
-      Jets::Router::Matcher.new.find_by_request(request)
-    end
-
-    def find_by_definition(definition)
-      routes.find do |route|
-        route.controller_name == definition.class_name &&
-        route.action_name == definition.meth.to_s
-      end
-    end
-
-    # Filters out internal routes
-    def no_routes?
-      routes.reject(&:internal?).empty?
-    end
-
-    extend self
-  end
-end

data/lib/jets/ruby_version_check.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.7.0") && RUBY_ENGINE == "ruby"
-  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
-  abort <<-end_message
-
-    Jets 5 requires Ruby 2.7.0 or newer.
-
-    You're running
-      #{desc}
-
-    Please upgrade to Ruby 2.7.0 or newer to continue.
-
-  end_message
-end

data/lib/jets/rule/base.rb

@@ -1,20 +0,0 @@
-require 'json'
-
-# Base public methods get turned into Lambda functions.
-#
-# Jets::Rule::Base < Jets::Lambda::Functions
-# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
-# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
-module Jets::Rule
-  class Base < Jets::Lambda::Functions
-    include Dsl
-    prepend Jets::ExceptionReporting::Process
-
-    class << self
-      def process(event, context, meth)
-        job = new(event, context, meth)
-        job.send(meth)
-      end
-    end
-  end
-end

data/lib/jets/rule/dsl.rb

@@ -1,109 +0,0 @@
-# Jets::Rule::Base < Jets::Lambda::Functions
-# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
-# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
-#
-# Implements:
-#
-#   default_associated_resource_definition
-#
-module Jets::Rule::Dsl
-  extend ActiveSupport::Concern
-
-  included do
-    class << self
-      def rule_namespace(value=nil)
-        if value.nil?
-          @rule_namespace # getter
-        else
-          @rule_namespace = value # # setter
-        end
-      end
-
-      # Allows for different types of values. Examples:
-      #
-      # String: scope "AWS::EC2::SecurityGroup"
-      # Array:  scope ["AWS::EC2::SecurityGroup"]
-      # Hash:   scope {"ComplianceResourceTypes" => ["AWS::EC2::SecurityGroup"]}
-      def scope(value)
-        scope = case value
-          when String
-            {ComplianceResourceTypes: [value]}
-          when Array
-            {ComplianceResourceTypes: value}
-          else # default to hash
-            value
-          end
-        associated_properties(Scope: scope)
-      end
-
-      # Convenience method that set properties. List based on https://amzn.to/2oSph1P
-      # Not all properties are included because some properties are not meant to be set
-      # directly. For example, function_name is a calculated setting by Jets.
-      ASSOCIATED_PROPERTIES = %W[
-        config_rule_name
-        description
-        input_parameters
-        maximum_execution_frequency
-      ]
-      define_associated_properties(ASSOCIATED_PROPERTIES)
-      alias_method :desc, :description
-
-      def default_associated_resource_definition(meth)
-        config_rule_definition(meth)
-      end
-
-      def config_rule_definition(meth)
-        resource = Jets::Cfn::Resource::Config::ConfigRule.new(self, meth, associated_properties)
-        resource.definition # returns a definition to be added by associated_resources
-      end
-
-      def managed_rule(name)
-        name = name.to_s
-        managed_rule = Jets::Cfn::Resource::Config::ManagedRule.new(self, name, associated_properties)
-        resource(managed_rule.definition) # Sets @associated_resources
-
-        # The key to not register the task to all_tasks to avoid creating a Lambda function.
-        # Instead we store it in all_managed_rules.
-        register_managed_rule(name, managed_rule.definition)
-      end
-
-      # Creates a task but registers it to all_managed_rules instead of all_tasks
-      # because we do not want Lambda functions to be created.
-      def register_managed_rule(name, definition)
-        # Mimic task to grab base_replacements, namely namespace.
-        # Do not actually use the task to create a Lambda function for managed rules.
-        # Only using the task for base_replacements.
-        resources = [definition]
-        meth = name
-        task = Jets::Lambda::Definition.new(self.name, meth,
-                 resources: resources,
-                 replacements: replacements(meth))
-        all_managed_rules[name] = { definition: definition, replacements: task.replacements }
-        clear_properties
-      end
-
-      # Override lambda/dsl.rb to add config_rule_name also
-      def replacements(meth)
-        name_without_rule = self.name.underscore.gsub(/_rule$/,'')
-        config_rule_name = "#{name_without_rule}_#{meth}".dasherize
-        {
-          config_rule_name: config_rule_name
-        }
-      end
-
-      # AWS managed rules are not actual Lambda functions and require their own storage.
-      def all_managed_rules
-        @all_managed_rules ||= ActiveSupport::OrderedHash.new
-      end
-
-      def managed_rules
-        all_managed_rules.values
-      end
-
-      # Override Lambda::Dsl.build? to account for possible managed_rules
-      def build?
-        !definitions.empty? || !managed_rules.empty?
-      end
-    end
-  end
-end

data/lib/jets/secrets.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "tempfile"
-require "active_support/message_encryptor"
-
-module Jets
-  # Greatly inspired by Ara T. Howard's magnificent sekrets gem. 😘
-  class Secrets # :nodoc:
-    class MissingKeyError < RuntimeError
-      def initialize
-        super(<<-end_of_message.squish)
-          Missing encryption key to decrypt secrets with.
-          Ask your team for your master key and put it in ENV["JETS_MASTER_KEY"]
-        end_of_message
-      end
-    end
-
-    @cipher = "aes-128-gcm"
-    @root = File # Wonky, but ensures `join` uses the current directory.
-
-    class << self
-      attr_writer :root
-
-      def parse(paths, env:)
-        paths.each_with_object(Hash.new) do |path, all_secrets|
-          require "erb"
-
-          source = ERB.new(preprocess(path)).result
-          secrets = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(source) : YAML.load(source)
-          secrets ||= {}
-
-          all_secrets.merge!(secrets["shared"].deep_symbolize_keys) if secrets["shared"]
-          all_secrets.merge!(secrets[env].deep_symbolize_keys) if secrets[env]
-        end
-      end
-
-      def key
-        ENV["JETS_MASTER_KEY"] || read_key_file || handle_missing_key
-      end
-
-      def encrypt(data)
-        encryptor.encrypt_and_sign(data)
-      end
-
-      def decrypt(data)
-        encryptor.decrypt_and_verify(data)
-      end
-
-      def read
-        decrypt(IO.binread(path))
-      end
-
-      def write(contents)
-        IO.binwrite("#{path}.tmp", encrypt(contents))
-        FileUtils.mv("#{path}.tmp", path)
-      end
-
-      def read_for_editing(&block)
-        writing(read, &block)
-      end
-
-      private
-        def handle_missing_key
-          raise MissingKeyError
-        end
-
-        def read_key_file
-          if File.exist?(key_path)
-            IO.binread(key_path).strip
-          end
-        end
-
-        def key_path
-          @root.join("config", "secrets.yml.key")
-        end
-
-        def path
-          @root.join("config", "secrets.yml.enc").to_s
-        end
-
-        def preprocess(path)
-          if path.end_with?(".enc")
-            decrypt(IO.binread(path))
-          else
-            IO.read(path)
-          end
-        end
-
-        def writing(contents)
-          file_name = "#{File.basename(path)}.#{Process.pid}"
-
-          Tempfile.create(["", "-" + file_name]) do |tmp_file|
-            tmp_path = Pathname.new(tmp_file)
-            tmp_path.binwrite contents
-
-            yield tmp_path
-
-            updated_contents = tmp_path.binread
-
-            write(updated_contents) if updated_contents != contents
-          end
-        end
-
-        def encryptor
-          @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: @cipher)
-        end
-    end
-  end
-end

data/lib/jets/spec_helpers/controllers/params.rb

@@ -1,8 +0,0 @@
-module Jets::SpecHelpers::Controllers
-  class Params
-    attr_accessor :path_params, :body_params, :query_params
-    def initialize(path_params={}, body_params={}, query_params={})
-      @path_params, @body_params, @query_params = path_params, body_params, query_params
-    end
-  end
-end