jets 3.1.0 → 5.0.0

data/lib/jets/controller/redirection.rb

@@ -1,61 +0,0 @@
-class Jets::Controller
-  module Redirection
-    # redirect_to "/posts", :status => 301
-    # redirect_to :action=>'atom', :status => 302
-    def redirect_to(url, options={})
-      unless url.is_a?(String)
-        raise "redirect_to url parameter must be a String. Please pass in a string"
-      end
-
-      redirect_url = add_stage(url)
-      redirect_url = ensure_protocol(redirect_url)
-
-      default = {
-        headers: { "Location" => redirect_url },
-        isBase64Encoded: false,
-      }
-      if request.xhr?
-        options[:content_type] ||= "application/json"
-        options[:status] ||= 200
-        options[:body] ||= JSON.dump(success: true, location: redirect_url)
-      else
-        options[:status] ||= 302
-        options[:body] ||= ""
-      end
-      Jets.logger.info("redirect_to options #{options}")
-      options = default.merge(options)
-
-      aws_proxy = Rendering::RackRenderer.new(self, options)
-      resp = aws_proxy.render
-      # redirect is a type of rendering
-      @rendered = true
-      @rendered_data = resp
-    end
-
-    def redirect_back(fallback_location: '/')
-      location = request.headers["referer"] || fallback_location
-      redirect_to(location)
-    end
-
-    def ensure_protocol(url)
-      return url if url.starts_with?('http')
-
-      # annoying but the request payload is different with localhost/rack vs
-      # api gateway
-      # check out:
-      #   spec/fixtures/dumps/api_gateway/posts/create.json
-      #   spec/fixtures/dumps/rack/posts/create.json
-      protocol = if headers["x-forwarded-proto"] # API Gateway
-          headers["x-forwarded-proto"]
-        elsif headers["origin"] # Rack / localhost
-          URI.parse(headers["origin"]).scheme
-        else
-          "http" # fallback. Capybara / Selenium tests
-        end
-
-      raise "Invalid protocol #{protocol}" unless protocol.starts_with?('http')
-
-      "#{protocol}://#{url}"
-    end
-  end
-end

data/lib/jets/controller/rendering/rack_renderer.rb

@@ -1,267 +0,0 @@
-require "rack/utils"
-
-# Special renderer.  All the other renderers lead here
-module Jets::Controller::Rendering
-  class RackRenderer
-    delegate :request, :event, :headers, to: :controller
-    attr_reader :controller
-    def initialize(controller, options={})
-      @controller = controller
-      @options = options
-    end
-
-    # Example response:
-    #
-    #   [200, {"my-header" = > "value" }, "my body" ]
-    #
-    # Returns rack triplet
-    def render
-      # we do some normalization here
-      status = normalize_status_code(@options[:status])
-
-      base64 = normalized_base64_option(@options)
-
-      headers = @options[:headers] || {}
-      set_content_type!(status, headers)
-      # x-jets-base64 to convert this Rack triplet to a API Gateway hash structure later
-      headers["x-jets-base64"] = base64 ? 'yes' : 'no' # headers values must be Strings
-
-      if drop_content_info?(status)
-        body = StringIO.new
-      else
-        # Rails rendering does heavy lifting
-        # _prefixes provided by jets/overrides/rails/action_controller.rb
-        ActionController::Base._prefixes = @controller.controller_paths
-        renderer = ActionController::Base.renderer.new(renderer_options)
-        clear_view_cache
-        body = renderer.render(render_options)
-        body = StringIO.new(body)
-      end
-
-      [status, headers, body] # triplet
-    end
-
-    # default options:
-    #   https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/renderer.rb#L41-L47
-    def renderer_options
-      options = {
-        # script_name: "", # unfortunately doesnt seem to effect relative_url_root like desired
-        # input: ""
-      }
-
-      origin = headers["origin"]
-      if origin
-        uri = URI.parse(origin)
-        options[:https] = uri.scheme == "https"
-      end
-
-      # Important to not use rack_headers as local variable instead of headers.
-      # headers is a method that gets deleted to controller.headers and using it
-      # seems to cause issues.
-      rack_headers = rackify_headers(headers)
-      options.merge!(rack_headers)
-
-      # Note @options[:method] uses @options vs options on purpose
-      @options[:method] = event["httpMethod"].downcase if event["httpMethod"]
-
-      # This is how we pass parameters to actionpack. IE: params to the view.
-      # This is because renderer_options is actually the env that is passed to the rack request.
-      options.merge!("action_dispatch.request.path_parameters" => @controller.path_parameters)
-      options.merge!("action_dispatch.request.query_parameters" => @controller.query_parameters)
-      options.merge!("action_dispatch.request.request_parameters" => @controller.request_parameters)
-      options
-    end
-
-    def render_options
-      # normalize the template option
-      template = @options[:template]
-      if template and !template.include?('/')
-        template = "#{template_namespace}/#{template}"
-      end
-      template ||= default_template_name
-      # ready to override @options[:template]
-      @options[:template] = template if @options[:template]
-
-      render_options = {
-        template: template, # weird: template needs to be set no matter because it
-          # sets the name which is used in lookup_context.rb:209:in `normalize_name'
-        layout: @options[:layout],
-        assigns: controller_instance_variables,
-        # prefixes: ["posts"],
-      }
-      types = %w[json inline plain file xml body action].map(&:to_sym)
-      types.each do |type|
-        render_options[type] = @options[type] if @options[type]
-      end
-
-      render_options
-    end
-
-    # Example: posts/index
-    def default_template_name
-      "#{template_namespace}/#{@controller.meth}"
-    end
-
-    # PostsController => "posts" is the namespace
-    def template_namespace
-      @controller.class.to_s.sub('Controller','').underscore
-    end
-
-    # Takes headers and adds HTTP_ to front of the keys because that is what rack
-    # does to the headers passed from a request. This seems to be the standard
-    # when testing with curl and inspecting the headers in a Rack app.  Example:
-    # https://gist.github.com/tongueroo/94f22f6c261c8999e4f4f776547e2ee3
-    #
-    # This is useful for:
-    #
-    #   ActionController::Base.renderer.new(renderer_options)
-    #
-    # renderer_options are rack normalized headers.
-    #
-    # Example input (from api gateway)
-    #
-    #   {"host"=>"localhost:8888",
-    #   "user-agent"=>"curl/7.53.1",
-    #   "accept"=>"*/*",
-    #   "version"=>"HTTP/1.1",
-    #   "x-amzn-trace-id"=>"Root=1-5bde5b19-61d0d4ab4659144f8f69e38f"}
-    #
-    # Example output:
-    #
-    #   {"HTTP_HOST"=>"localhost:8888",
-    #   "HTTP_USER_AGENT"=>"curl/7.53.1",
-    #   "HTTP_ACCEPT"=>"*/*",
-    #   "HTTP_VERSION"=>"HTTP/1.1",
-    #   "HTTP_X_AMZN_TRACE_ID"=>"Root=1-5bde5b19-61d0d4ab4659144f8f69e38f"}
-    #
-    def rackify_headers(headers)
-      results = {}
-      headers.each do |k,v|
-        rack_key = 'HTTP_' + k.gsub('-','_').upcase
-        results[rack_key] = v
-      end
-      results
-    end
-
-    # Pass controller instance variables from jets-based controller to ActionView scope
-    def controller_instance_variables
-      instance_vars = @controller.instance_variables.inject({}) do |vars, v|
-        k = v.to_s.sub(/^@/,'') # @var => var
-        vars[k] = @controller.instance_variable_get(v)
-        vars
-      end
-      instance_vars[:event] = event
-      # jets internal variables
-      # So ActionView has access back to the jets controller
-      instance_vars[:_jets] = { controller: @controller }
-      instance_vars
-    end
-
-    def clear_view_cache
-      ActionView::LookupContext::DetailsKey.clear if Jets.env.development?
-    end
-
-  private
-    # From jets/controller/response.rb
-    def drop_content_info?(status)
-      status.to_i / 100 == 1 or drop_body?(status)
-    end
-
-    DROP_BODY_RESPONSES = [204, 304]
-    def drop_body?(status)
-      DROP_BODY_RESPONSES.include?(status.to_i)
-    end
-
-    # maps:
-    #   :continue => 100
-    #   :success => 200
-    #   etc
-    def normalize_status_code(code)
-      status_code = if code.is_a?(Symbol)
-                      Rack::Utils::SYMBOL_TO_STATUS_CODE[code]
-                    else
-                      code
-                    end
-
-      # API Gateway requires status to be String but local rack is okay with either
-      # Note, ELB though requires status to be an Integer. We'll later in rack/adapter.rb
-      # adjust status to an Integer if request is coming from an ELB.
-      (status_code || 200).to_s
-    end
-
-    def set_content_type!(status, headers)
-      if drop_content_info?(status)
-        headers.delete "Content-Length"
-        headers.delete "Content-Type"
-      else
-        headers["Content-Type"] = @options[:content_type] ||
-                                  headers['content-type'] || # Mega Mode (Rails)
-                                  headers['Content-Type'] || # Just in case
-                                  Jets::Controller::DEFAULT_CONTENT_TYPE
-      end
-    end
-
-    def normalized_base64_option(options)
-      base64 = @options[:base64] if options.key?(:base64)
-      base64 = @options[:isBase64Encoded] if options.key?(:isBase64Encoded)
-      base64
-    end
-
-    class << self
-      def setup!
-        require "action_controller"
-        require "jets/overrides/rails"
-
-        # Load helpers
-        # Assign local variable because scope in the `:action_view do` block changes
-        app_helper_classes = find_app_helper_classes
-        ActiveSupport.on_load :action_view do
-          include Jets::Router::Helpers # internal routes helpers
-          include ApplicationHelper  # include first
-          app_helper_classes.each do |helper_class|
-            include helper_class
-          end
-        end
-
-        ActionController::Base.append_view_path("#{Jets.root}/app/views")
-
-        setup_webpacker if Jets.webpacker?
-      end
-
-      # Does not include ApplicationHelper, will include ApplicationHelper explicitly first.
-      def find_app_helper_classes
-        internal_path = File.expand_path("../../internal", File.dirname(__FILE__))
-        internal_classes = find_app_helper_classes_from(internal_path)
-        app_classes = find_app_helper_classes_from(Jets.root)
-        (internal_classes + app_classes).uniq
-      end
-
-      def find_app_helper_classes_from(project_root)
-        klasses = []
-        expression = "#{project_root}/app/helpers/**/*"
-        Dir.glob(expression).each do |path|
-          next unless File.file?(path)
-          class_name = path.sub("#{project_root}/app/helpers/","").sub(/\.rb/,'')
-
-          unless class_name == "application_helper"
-            klasses << class_name.camelize.constantize # autoload
-          end
-        end
-        klasses
-      end
-
-      def setup_webpacker
-        require 'webpacker'
-        require 'webpacker/helper'
-
-        ActiveSupport.on_load :action_controller do
-          ActionController::Base.helper Webpacker::Helper
-        end
-
-        ActiveSupport.on_load :action_view do
-          include Webpacker::Helper
-        end
-      end
-    end
-  end
-end

data/lib/jets/controller/rendering.rb

@@ -1,96 +0,0 @@
-class Jets::Controller
-  module Rendering
-    include Redirection
-
-    def ensure_render
-      return @rendered_data if @rendered
-
-      # defaults to rendering templates
-      RackRenderer.new(self, managed_options).render
-    end
-
-    # Many different ways to render:
-    #
-    #  render "articles/index", layout: "application"
-    #  render :new
-    #  render template: "articles/index", layout: "application"
-    #  render json: {my: "data"}
-    #  render text: "plain text"
-    def render(options={}, rest={})
-      raise "DoubleRenderError" if @rendered
-
-      if options.is_a?(Symbol) or options.is_a?(String)
-        options = normalize_options(options, rest)
-      end
-
-      options.reverse_merge!(managed_options)
-      adjust_content_type!(options)
-
-      @rendered_data = RackRenderer.new(self, options).render
-
-      @rendered = true
-      @rendered_data
-    end
-
-    def adjust_content_type!(options)
-      return if options.key?(:content_type)
-
-      if options.key?(:json)
-        options[:content_type] = "application/json"
-      elsif options.key?(:xml)
-        options[:content_type] = "application/xml"
-      end
-    end
-
-    def managed_options
-      layout = self.class.layout.nil? ? default_layout : self.class.layout
-      options = { layout: layout }
-      options[:headers] = response.headers unless response.headers.empty?
-      options
-    end
-
-    def default_layout
-      application_layout_exist = !Dir.glob("#{Jets.root}/app/views/layouts/application*").empty?
-      "application" if application_layout_exist
-    end
-
-    # Can normalize the options when it is a String or a Symbol
-    # Also set defaults here like the layout.
-    # Ensure options is a Hash, not a String or Symbol.
-    def normalize_options(options, rest)
-      template = options.to_s
-      rest.merge(template: template)
-    end
-
-    # Example usage:
-    #
-    #   render json: {success: true, location: add_stage(posts_path)}
-    #
-    def add_stage(url)
-      return url unless actual_host
-
-      uri = URI.parse(url)
-      # if no location.host, we been provided a relative host
-      if !uri.host && actual_host
-        url = "/#{url}" unless url.starts_with?('/')
-        url = Jets::Controller::Stage.add(actual_host, url)
-        actual_host + url
-      else
-        url
-      end
-    end
-
-    def url_for(url)
-      add_stage(url)
-    end
-
-    # Actual host can be headers["origin"] when cloudfront is in front.
-    # Remember to set custom header "origin" header in cloudfront distribution.
-    # Can also override with Jets.config.app.domain.
-    # The actual_host value is used by redirect_to.
-    def actual_host
-      Jets.config.app.domain || headers["origin"] || headers["host"]
-    end
-
-  end
-end

data/lib/jets/controller/stage.rb

@@ -1,34 +0,0 @@
-class Jets::Controller
-  class Stage
-    def initialize(host, url)
-      @host, @url = host, url
-    end
-
-    def add
-      return @url unless add_stage?
-
-      stage_name = Jets::Resource::ApiGateway::Deployment.stage_name
-      stage_name_with_slashes = "/#{stage_name}/" # use to prevent stage name being added twice if url_for is called twice on the same string
-      @url.include?(stage_name_with_slashes) ? @url : "/#{stage_name}#{@url}"
-    end
-
-    def add_stage?
-      return false if on_cloud9?
-      @host.include?("amazonaws.com") && @url.starts_with?('/')
-    end
-
-    def on_cloud9?
-      self.class.on_cloud9?(@host)
-    end
-
-    class << self
-      def add(host, url)
-        new(host, url).add
-      end
-
-      def on_cloud9?(host)
-        !!(host =~ /cloud9\..*\.amazonaws\.com/)
-      end
-    end
-  end
-end

data/lib/jets/controller.rb

@@ -1,3 +0,0 @@
-class Jets::Controller
-  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
-end

data/lib/jets/db.rb

@@ -1,15 +0,0 @@
-module Jets::Db ; end
-
-# Thanks: https://makandracards.com/makandra/42521-detecting-if-a-ruby-gem-is-loaded
-if File.exist?("#{Jets.root}/config/database.yml")
-  require "active_record"
-  specs = Gem.loaded_specs
-  require "mysql2" if specs.key?('mysql2')
-  require "pg" if specs.key?('pg')
-end
-
-if File.exist?("#{Jets.root}/config/dynamodb.yml")
-  specs = Gem.loaded_specs
-  specs.key?('dynomite')
-  require "dynomite" if specs.key?('dynomite')
-end

data/lib/jets/generator/templates/erb/controller/view.html.erb

@@ -1,2 +0,0 @@
-<h1><%= class_name %>#<%= @action %></h1>
-<p>Find me in <%= @path %></p>

data/lib/jets/generator/templates/erb/scaffold/index.html.erb

@@ -1,29 +0,0 @@
-<h1><%= plural_table_name.titleize %></h1>
-
-<table>
-  <thead>
-    <tr>
-<% attributes.reject(&:password_digest?).each do |attribute| -%>
-      <th><%= attribute.human_name %></th>
-<% end -%>
-      <th colspan="3"></th>
-    </tr>
-  </thead>
-
-  <tbody>
-    <%% @<%= plural_table_name %>.each do |<%= singular_table_name %>| %>
-      <tr class="jets-element-to-delete">
-<% attributes.reject(&:password_digest?).each do |attribute| -%>
-        <td><%%= <%= singular_table_name %>.<%= attribute.column_name %> %></td>
-<% end -%>
-        <td><%%= link_to 'Show', <%= model_resource_name %> %></td>
-        <td><%%= link_to 'Edit', edit_<%= singular_route_name %>_path(<%= singular_table_name %>) %></td>
-        <td><%%= link_to 'Destroy', <%= model_resource_name %>, method: :delete, data: { confirm: 'Are you sure?' } %></td>
-      </tr>
-    <%% end %>
-  </tbody>
-</table>
-
-<br>
-
-<%%= link_to 'New <%= singular_table_name.titleize %>', new_<%= singular_route_name %>_path %>

data/lib/jets/generator/templates/rails/controller/controller.rb

@@ -1,13 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= class_name %>Controller < ApplicationController
-<% actions.each do |action| -%>
-  def <%= action %>
-  end
-<%= "\n" unless action == actions.last -%>
-<% end -%>
-end
-<% end -%>

data/lib/jets/generator/templates/rails/helper/helper.rb

@@ -1,4 +0,0 @@
-<% module_namespacing do -%>
-module <%= class_name %>Helper
-end
-<% end -%>

data/lib/jets/generator/templates/rails/scaffold_controller/controller.rb

@@ -1,67 +0,0 @@
-<% if namespaced? -%>
-require_dependency "<%= namespaced_path %>/application_controller"
-
-<% end -%>
-<% module_namespacing do -%>
-class <%= controller_class_name %>Controller < ApplicationController
-  before_action :set_<%= singular_table_name %>, only: [:show, :edit, :update, :delete]
-
-  # GET <%= route_url %>
-  def index
-    @<%= plural_table_name %> = <%= orm_class.all(class_name) %>
-  end
-
-  # GET <%= route_url %>/1
-  def show
-  end
-
-  # GET <%= route_url %>/new
-  def new
-    @<%= singular_table_name %> = <%= orm_class.build(class_name) %>
-  end
-
-  # GET <%= route_url %>/1/edit
-  def edit
-  end
-
-  # POST <%= route_url %>
-  def create
-    @<%= singular_table_name %> = <%= orm_class.build(class_name, "#{singular_table_name}_params") %>
-
-    if @<%= orm_instance.save %>
-      redirect_to <%= singular_table_name %>_path(@<%= singular_table_name %>)
-    else
-      render :new
-    end
-  end
-
-  # PUT <%= route_url %>/1
-  def update
-    if @<%= orm_instance.update("#{singular_table_name}_params") %>
-      redirect_to <%= singular_table_name %>_path(@<%= singular_table_name %>)
-    else
-      render :edit
-    end
-  end
-
-  # DELETE <%= route_url %>/1
-  def delete
-    @<%= orm_instance.destroy %>
-    redirect_to <%= table_name %>_path
-  end
-
-private
-  # Use callbacks to share common setup or constraints between actions.
-  def set_<%= singular_table_name %>
-    @<%= singular_table_name %> = <%= orm_class.find(class_name, "params[:id]") %>
-  end
-
-  def <%= "#{singular_table_name}_params" %>
-    <%- if attributes_names.empty? -%>
-    params.fetch(:<%= singular_table_name %>, {})
-    <%- else -%>
-    params.require(:<%= singular_table_name %>).permit(<%= attributes_names.map { |name| ":#{name}" }.join(', ') %>)
-    <%- end -%>
-  end
-end
-<% end -%>