jets 4.0.8 → 5.0.0.beta1

data/lib/jets/overrides/rails/migration_checker.rb

@@ -1,34 +0,0 @@
-module ActiveRecord
-  module MigrationChecker
-    def prepare_test_db
-      current_config = ::ActiveRecord::Base.connection_db_config
-      all_configs = ::ActiveRecord::Base.configurations.configs_for(env_name: Jets.env)
-
-      needs_update = !all_configs.all? do |db_config|
-        ::ActiveRecord::Tasks::DatabaseTasks.schema_up_to_date?(
-          db_config.configuration_hash, 
-          ::ActiveRecord::Base.schema_format, 
-          nil
-        )
-      end
-
-      if needs_update
-        # Roundtrip to Rake to allow plugins to hook into database initialization.
-        FileUtils.cd(Jets.root) do
-          ::ActiveRecord::Base.clear_all_connections!
-          system("jets db:test:prepare")
-        end
-      end
-
-      # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
-      ::ActiveRecord::Base.establish_connection(current_config)
-
-      begin
-        check_pending!
-      rescue ::ActiveRecord::PendingMigrationError
-        puts "Migrations are pending. To resolve this issue, run:\n\n        jets db:migrate"
-        exit 1
-      end
-    end
-  end
-end

data/lib/jets/overrides/rails/rendering_helper.rb

@@ -1,27 +0,0 @@
-module Jets::RenderingHelper
-  # ensure that we always add the controller view name. So when rendering
-  # a partial:
-  #   <%= render "mypartial" %>
-  # gets turned into:
-  #   <%= render "articles/mypartial" %>
-  def render(options = {}, locals = {}, &block)
-    if options.is_a?(String) && !options.include?('/')
-      folder = _get_containing_folder(caller)
-      partial_name = options # happens to be the partial name
-      partial_name = "#{folder}/#{partial_name}"
-      options = partial_name
-    end
-
-    super(options, locals, &block)
-  end
-
-  # Ugly, going back up the caller stack to find out what view path
-  # we are in
-  def _get_containing_folder(caller_lines)
-    caller_line = caller_lines.find { |l| !l.include?('/gems/') }
-    text = caller_line.split(':').first
-    # .../fixtures/apps/demo/app/views/posts/index.html.erb
-    text.split('/')[-2] # posts
-  end
-end
-ActionView::Helpers.send(:include, Jets::RenderingHelper)

data/lib/jets/overrides/rails/url_helper.rb

@@ -1,88 +0,0 @@
-require "action_view"
-
-# hackety hack
-module Jets::UrlHelper
-  include Jets::CommonMethods
-
-  # Basic implementation of url_for to allow use helpers without routes existence
-  def url_for(options = nil) # :nodoc:
-    url = if options.is_a?(String)
-            options
-          elsif options == :back
-            _back_url
-          elsif options.respond_to?(:to_model)
-            _handle_model(options)
-          elsif options.is_a?(Array)
-            _handle_array(options)
-          else
-            raise ArgumentError, "The Jets link_to helper only supports some types of arguments. Please provided a String or an object that supports ActiveModel to link_to as the the second argument."
-          end
-
-    add_stage_name(url)
-  end
-
-  def _handle_model(record)
-    model = record.to_model
-    if model.persisted?
-      meth = model.model_name.singular_route_key + "_path"
-      send(meth, record) # Example: post_path(record)
-    else
-      meth = model.model_name.route_key + "_path"
-      send(meth) # Example: posts_path
-    end
-  end
-
-  # Convention is that the model class name is the method name. Doesnt work if user is using as.
-  def _handle_array(array)
-    contains_nil = !array.select(&:nil?).empty?
-    if contains_nil
-      raise "ERROR: You passed a nil value in the Array. #{array.inspect}."
-    end
-
-    last_persisted = nil
-    items = array.map do |x|
-      if x.is_a?(ActiveRecord::Base)
-        last_persisted = x.persisted?
-        x.persisted? ? x.model_name.singular_route_key : x.model_name.route_key
-      else
-        x
-      end
-    end
-    meth = items.join('_') + "_path"
-
-    args = array.clone
-    args.shift if args.first.is_a?(Symbol) # drop the first element if its a symbol
-    args = last_persisted ? args : args[0..-2]
-
-    # post_comment_path(post_id) - keep all args - for update
-    # post_comments_path - drop last arg - for create
-    send(meth, *args)
-  end
-
-  # for forgery protection
-  def token_tag(token = nil, form_options: {})
-    return '' unless protect_against_forgery?
-
-    hidden_field_tag 'authenticity_token', masked_authenticity_token
-  end
-
-  def masked_authenticity_token
-    @masked_authenticity_token ||= SecureRandom.hex(32)
-    session[:authenticity_token] = @masked_authenticity_token
-  end
-
-  def protect_against_forgery?
-    @_jets[:controller].class.forgery_protection_enabled?
-  end
-
-  def csrf_meta_tags
-    if protect_against_forgery?
-      html = tag("meta", name: "csrf-token", content: masked_authenticity_token).html_safe
-      html << "\n"
-      html << tag("meta", name: "csrf-param", content: "authenticity_token").html_safe
-      html
-    end
-  end
-end # UrlHelper
-
-ActionView::Helpers.send(:include, Jets::UrlHelper)

data/lib/jets/overrides/rails.rb

@@ -1,6 +0,0 @@
-require "jets/overrides/rails/common_methods"
-require "jets/overrides/rails/url_helper"
-require "jets/overrides/rails/rendering_helper"
-require "jets/overrides/rails/asset_tag_helper"
-require "jets/overrides/rails/action_controller"
-require "jets/overrides/rails/migration_checker"

data/lib/jets/rack_server.rb

@@ -1,86 +0,0 @@
-module Jets
-  class RackServer
-    def self.start(options={})
-      new(options).start
-    end
-
-    def initialize(options={})
-      @options = options
-    end
-
-    def start
-      return unless File.exist?("#{rack_project}/config.ru")
-      puts "Starting additional rack server for the project under the rack subfolder..." if ENV['JETS_DEBUG']
-
-      if ENV['FOREGROUND']
-        serve
-        return
-      end
-
-      # Reaching here means we'll run the server in the background.
-      # Handle daemonzing ourselves because it keeps the stdout of the 2nd
-      # rack server. The rackup --daemonize option ends up hiding the output.
-      pid = Process.fork
-      if pid.nil?
-        # we're in the child process
-        serve
-      else
-        # we're in the parent process
-        Process.detach(pid) # dettached but still in the "foreground" since bin/rackup runs in the foreground
-      end
-    end
-
-    # Runs in the child process
-    def serve
-      # Note, looks like stopping jets server with Ctrl-C sends the TERM signal
-      # down to the sub bin/rackup command cleans up the child process fine.
-      Bundler.with_unbundled_env do
-        args = ''
-        # only forward the host option, port is always 9292 for simplicity
-        if @options[:host]
-          args << " --host #{@options[:host]}"
-        else
-          args << " --host 127.0.0.1" # using the default localhost is not starting up https://stackoverflow.com/questions/4356646/address-family-not-supported-by-protocol-family
-        end
-
-
-        command = "cd #{rack_project} && bin/rackup#{args}" # leads to the same wrapper rack scripts
-        puts "=> #{command}".color(:green)
-        system(command)
-      end
-    end
-
-    # blocks until rack server is up
-    def wait_for_socket
-      return unless Jets.rack?
-
-      retries = 0
-      max_retries = 30 # 15 seconds at a delay of 0.5s
-      delay = 0.5
-      if ENV['C9_USER'] # overrides for local testing
-        max_retries = 3
-        delay = 3
-      end
-      begin
-        server = TCPSocket.new('localhost', 9292)
-        server.close
-      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
-        puts "Unable to connect to localhost:9292. Delay for #{delay} and will try to connect again."  if ENV['JETS_DEBUG']
-        sleep(delay)
-        retries += 1
-        if retries < max_retries
-          retry
-        else
-          puts "Giving up on trying to connect to localhost:9292"
-          return false
-        end
-      end
-      puts "Connected to localhost:9292 successfully"
-      true
-    end
-
-    def rack_project
-      "#{Jets.root}/rack"
-    end
-  end
-end

data/lib/jets/resource/api_gateway/base_path/function.rb

@@ -1,49 +0,0 @@
-module Jets::Resource::ApiGateway::BasePath
-  class Function < Jets::Resource::Base
-    include Jets::Resource::Lambda::Function::Environment
-
-    def definition
-      {
-        base_path_function: {
-          type: "AWS::Lambda::Function",
-          properties: {
-            function_name: function_name,
-            code: {
-              s3_bucket: "!Ref S3Bucket",
-              s3_key: code_s3_key,
-            },
-            role: "!GetAtt BasePathRole.Arn",
-            handler: handler,
-            runtime: Jets.ruby_runtime,
-            timeout: 60,
-            memory_size: 1536,
-            environment: env_properties[:environment],
-            layers: layers,
-          }
-        }
-      }
-    end
-
-    def layers
-      return Jets.config.lambda.layers if Jets.config.gems.disable
-
-      ["!Ref GemLayer"] + Jets.config.lambda.layers
-    end
-
-    def function_name
-      method = "jets-base-path"
-      # need to add the deployment timestamp because or else function name collides between deploys
-      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
-      "#{Jets.config.project_namespace}-#{method}-#{timestamp}"
-    end
-
-    def handler
-      "handlers/functions/jets/base_path.lambda_handler"
-    end
-
-    def code_s3_key
-      checksum = Jets::Builders::Md5.checksums["stage/code"]
-      "jets/code/code-#{checksum}.zip" # s3_key
-    end
-  end
-end

data/lib/jets/resource/api_gateway/base_path/role.rb

@@ -1,76 +0,0 @@
-module Jets::Resource::ApiGateway::BasePath
-  class Role < Jets::Resource::Base
-    extend Memoist
-    include Jets::AwsServices
-
-    def definition
-      {
-        base_path_role: {
-          type: "AWS::IAM::Role",
-          properties: {
-            role_name: role_name,
-            path: "/",
-            assume_role_policy_document: {
-              version: "2012-10-17",
-              statement: [{
-                effect: "Allow",
-                principal: {service: ["lambda.amazonaws.com"]},
-                action: ["sts:AssumeRole"]}
-              ]
-            },
-            policies: [
-              policy_name: "#{role_name}-policy",
-              policy_document: policy_document,
-            ]
-          },
-        }
-      }
-    end
-
-    def policy_document
-      project_namespace = Jets.config.project_namespace
-      default_policy_statements = Jets::Application.default_iam_policy # Array of Hashes
-      apigateway = [{
-        action: [ "apigateway:*" ],
-        effect: "Allow",
-        resource: "arn:aws:apigateway:#{Jets.aws.region}::/restapis/*", # scoped to all restapis because this changes
-      },{
-        action: [ "apigateway:*" ],
-        effect: "Allow",
-        resource: "arn:aws:apigateway:#{Jets.aws.region}::/domainnames/*", # scoped to all restapis because this changes
-      }]
-      cloudformation = [{
-        action: ["cloudformation:DescribeStacks"],
-        effect: "Allow",
-        resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
-      }]
-
-      # Combine the statements
-      {
-        version: '2012-10-17',
-        statement: default_policy_statements + apigateway + cloudformation
-      }
-    end
-
-    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
-    def rest_api_id
-      stack_name = Jets::Names.parent_stack_name
-      return "RestApi" unless stack_exists?(stack_name)
-
-      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
-
-      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
-
-      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
-      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
-      rest_api_id = lookup(stack[:outputs], "RestApi")
-    end
-    memoize :rest_api_id
-
-    def role_name
-      # TODO: dont think we should change the role name every time but have to right now because the deployment logical id changes
-      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
-      "#{Jets.config.project_namespace}-base-path-mapping-#{timestamp}"
-    end
-  end
-end

data/lib/jets/resource/api_gateway/cors.rb

@@ -1,61 +0,0 @@
-module Jets::Resource::ApiGateway
-  # Might be weird inheriting from Method because Method has Method#cors also
-  # but Cors is essentially a Method class.
-  class Cors < Method
-    def definition
-      {
-        cors_logical_id => {
-          type: "AWS::ApiGateway::Method",
-
-          properties: {
-            resource_id: "!Ref #{resource_id}",
-            rest_api_id: "!Ref #{RestApi.logical_id}",
-            authorization_type: cors_authorization_type,
-            http_method: "OPTIONS",
-            method_responses: [{
-              status_code: '200',
-              response_parameters: response_parameters(true),
-              response_models: {},
-            }],
-            request_parameters: {},
-            integration: {
-              type: "MOCK",
-              request_templates: {
-                "application/json": "{statusCode:200}",
-              },
-              integration_responses: [{
-                status_code: '200',
-                response_parameters: response_parameters,
-                response_templates: {
-                  "application/json": '',
-                },
-              }] # closes integration_responses
-            } # closes integration
-          } # closes properties
-        } # closes logical id
-      } # closes definition
-    end
-
-    def response_parameters(method_response=false)
-      cors_headers.map do |k,v|
-        k = "method.response.header.#{k}"
-        v = method_response ? true : "'#{v}'" # surround value with single quotes
-        [k,v]
-      end.to_h
-    end
-
-    # Always the pre-flight headers in this case
-    def cors_headers
-      rack = Jets::Controller::Middleware::Cors.new(Jets.application)
-      rack.cors_headers(true)
-    end
-
-    def cors_authorization_type
-      Jets.config.api.cors_authorization_type || "NONE"
-    end
-
-    def cors_logical_id
-      "#{resource_logical_id}_cors_api_method"
-    end
-  end
-end

data/lib/jets/resource/api_gateway/method.rb

@@ -1,102 +0,0 @@
-# Converts a Jets::Route to a CloudFormation Jets::Resource::ApiGateway::Method resource
-module Jets::Resource::ApiGateway
-  class Method < Jets::Resource::Base
-    include Authorization
-
-    # also delegate permission for a method
-    delegate :permission, to: :resource
-
-    # route - Jets::Route
-    def initialize(route)
-      @route = route
-    end
-
-    def definition
-      {
-        method_logical_id => {
-          type: "AWS::ApiGateway::Method",
-          properties: props
-        }
-      }
-    end
-
-    def props
-      props = {
-        resource_id: "!Ref #{resource_id}",
-        rest_api_id: "!Ref #{RestApi.logical_id}",
-        http_method: @route.method,
-        request_parameters: {},
-        authorization_type: authorization_type,
-        api_key_required: api_key_required?,
-        integration: {
-          integration_http_method: "POST",
-          type: "AWS_PROXY",
-          uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${{namespace}LambdaFunction.Arn}/invocations"
-        },
-        method_responses: []
-      }
-      props[:authorizer_id] = authorizer_id if authorizer_id
-      props[:authorization_scopes] = authorization_scopes if authorization_scopes
-
-      props
-    end
-
-    def method_logical_id
-      # https://stackoverflow.com/questions/6104240/how-do-i-strip-non-alphanumeric-characters-from-a-string-and-keep-spaces
-      # Add path to the logical id to allow 2 different paths to be connected to the same controller action.
-      # Example:
-      #
-      #   root "jets/public#show"
-      #   any "*catchall", to: "jets/public#show"
-      #
-      # Without the path in the logical id, the logical id would be ShowApiMethod for both routes and only the
-      # last one would be created in the CloudFormation template.
-      path = @route.path.gsub('*','')
-              .gsub(/[^0-9a-z]/i, ' ')
-              .gsub(/\s+/, '_')
-      path = nil if path == ''
-      http_verb = @route.method.downcase
-      [path, "{namespace}_#{http_verb}_api_method"].compact.join('_')
-    end
-
-    def replacements
-      # mimic task to grab replacements, we want the namespace to be the lambda function's namespace
-      resources = [definition]
-      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
-               resources: resources)
-      task.replacements
-    end
-
-    def cors
-      Cors.new(@route)
-    end
-    memoize :cors
-
-  private
-
-    def controller_klass
-      @controller_klass ||= "#{controller_name}_controller".camelize.constantize
-    end
-
-    def controller_name
-      @controller_name ||= @route.to.split('#').first
-    end
-
-    def resource_id
-      @route.path == '' ?
-       "RootResourceId" :
-       Jets::Resource.truncate_id(resource_logical_id.camelize, "ApiResource")
-    end
-
-    # Example: Posts
-    def resource_logical_id
-      camelized_path.underscore
-    end
-
-    def camelized_path
-      path = @route.path
-      path = "homepage" if path == ''
-      path.gsub('/','_').gsub(':','').gsub('*','').gsub('.','').camelize
-    end
-  end
-end

data/lib/jets/resource/api_gateway/rest_api/routes/change.rb

@@ -1,16 +0,0 @@
-# Detects route changes
-class Jets::Resource::ApiGateway::RestApi::Routes
-  class Change
-    include Jets::AwsServices
-
-    def changed?
-      return false unless parent_stack_exists?
-
-      MediaTypes.changed? || To.changed? || Variable.changed? || Page.changed? || ENV['JETS_REPLACE_API']
-    end
-
-    def parent_stack_exists?
-      stack_exists?(Jets::Names.parent_stack_name)
-    end
-  end
-end

data/lib/jets/resource/base.rb

@@ -1,28 +0,0 @@
-# Classes that inherit from this method should NOT define and override:
-#
-#   logical_id
-#   type
-#   properties
-#   attributes
-#
-# These are computed methods that derive their values from the resource definition itself.
-# Overriding these methods will remove the computed logical which handles things
-# like camelizing and replacements.
-#
-# The implementation of these methods are in `Jets::Resource`.
-class Jets::Resource
-  class Base
-    extend Memoist
-    delegate :logical_id, :type, :properties, :attributes, :parameters, :outputs,
-             to: :resource
-
-    def resource
-      Jets::Resource.new(definition, replacements)
-    end
-    memoize :resource
-
-    def replacements
-      @replacements || {}
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_deployment.rb

@@ -1,58 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiDeployment < Base
-    def definition
-      {
-        deployment_id => {
-          type: "AWS::CloudFormation::Stack",
-          properties: {
-            template_url: template_url,
-            parameters: parameters,
-          },
-          depends_on: depends_on,
-        }
-      }
-    end
-
-    def parameters
-      p = {
-        GemLayer: "!Ref GemLayer",
-        IamRole: "!GetAtt IamRole.Arn",
-        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
-        S3Bucket: "!Ref S3Bucket",
-      }
-      p[:DomainName] = "!GetAtt ApiGateway.Outputs.DomainName" if Jets.custom_domain?
-      p[:BasePath] = Jets.config.domain.base_path unless Jets.config.domain.base_path.nil?
-      p
-    end
-
-    def depends_on
-      expression = "#{Jets::Names.template_path_prefix}-*_controller*"
-      controller_logical_ids = []
-      Dir.glob(expression).each do |path|
-        next unless File.file?(path)
-
-        # map the path to a camelized logical_id. Example:
-        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
-        #   PostsController
-        regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
-        controller_name = path.sub(regexp, '').sub('.yml', '')
-        controller_logical_id = controller_name.underscore.camelize
-        controller_logical_ids << controller_logical_id
-      end
-      controller_logical_ids
-    end
-
-    def deployment_id
-      Jets::Resource::ApiGateway::Deployment.logical_id
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-deployment.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_gateway.rb

@@ -1,23 +0,0 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
-  class ApiGateway < Base
-    def definition
-      {
-        api_gateway: {
-          type: "AWS::CloudFormation::Stack",
-          properties: {
-            template_url: template_url,
-          }
-        }
-      }
-    end
-
-    def template_filename
-      "#{Jets.config.project_namespace}-api-gateway.yml"
-    end
-  end
-end

data/lib/jets/resource/child_stack/api_resource/page.rb

@@ -1,20 +0,0 @@
-class Jets::Resource::ChildStack::ApiResource
-  # Find the ApiResource Page that contains the AWS::ApiGateway::Resource
-  # Returns: logical id of ApiResource Page
-  class Page
-    def self.logical_id(parameter)
-      expression = "#{Jets::Names.template_path_prefix}-api-resources-*"
-      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
-      template_paths = Dir.glob(expression).sort.to_a
-      found_template = template_paths.detect do |path|
-        next unless File.file?(path)
-
-        template = Jets::Cfn::BuiltTemplate.get(path)
-        template['Outputs'].keys.include?(parameter)
-      end
-      md = found_template.match(/-(api-resources-\d+)/)
-
-      md[1].underscore.camelize # IE: ApiResources1
-    end
-  end
-end