jets_bb_fork 0.0.4

data/lib/jets/resource/sns/topic_policy.rb

@@ -0,0 +1,40 @@
+# CloudFormation SNS TopicPolicy docs: https://amzn.to/2SBMq9v
+module Jets::Resource::Sns
+  class TopicPolicy < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        policy_logical_id => {
+          type: "AWS::SNS::TopicPolicy",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      {
+        policy_document: {
+          version: "2012-10-17",
+          statement: {
+            effect: "Allow",
+            principal: { service: "s3.amazonaws.com"},
+            action: "sns:Publish",
+            resource: "*", # TODO: figure out good syntax to limit easily
+            # Condition:
+            #   ArnLike:
+            #     aws:SourceArn: arn:aws:s3:::aa-test-95872017
+          }
+        },
+        topics: ["!Ref {namespace}SnsTopic"],
+      }.deep_merge(@props)
+    end
+
+    def policy_logical_id
+      "{namespace}_sns_topic_policy"
+    end
+  end
+end

data/lib/jets/resource/sqs/queue.rb

@@ -0,0 +1,21 @@
+# CloudFormation SQS Queue docs: https://amzn.to/2MVWk0j
+module Jets::Resource::Sqs
+  class Queue < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        queue_logical_id => {
+          type: "AWS::SQS::Queue",
+          properties: @props,
+        }
+      }
+    end
+
+    def queue_logical_id
+      "{namespace}_sqs_queue"
+    end
+  end
+end

data/lib/jets/resource/standardizer.rb

@@ -0,0 +1,42 @@
+class Jets::Resource
+  class Standardizer
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def template
+      camelize(standarize(@definition))
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    def standarize(definition)
+      first, second, third, _ = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form
+        logical_id, attributes = first, second
+        attributes.delete(:properties) if attributes[:properties].nil? || attributes[:properties].empty?
+        { logical_id => attributes }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id, type = first, second
+        { logical_id => {
+            type: type
+        }}
+      elsif definition.size == 3 && (second.is_a?(String) || second.is_a?(NilClass))# short form
+        logical_id, type, properties = first, second, third
+        template = { logical_id => {
+                       type: type
+                    }}
+        attributes = template.values.first
+        attributes[:properties] = properties unless properties.empty?
+        template
+      else # Dont understand this form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

data/lib/jets/route.rb

@@ -0,0 +1,166 @@
+# route = Jets::Route.new(
+#   path: "posts",
+#   method: :get,
+#   to: "posts#index",
+# )
+class Jets::Route
+  CAPTURE_REGEX = "([^/]*)" # as string
+
+  def initialize(options)
+    @options = options
+  end
+
+  # IE: standard: posts/:id/edit
+  #     api_gateway: posts/{id}/edit
+  def path(format=:jets)
+    case format
+    when :api_gateway
+      api_gateway_format(@options[:path])
+    when :raw
+      @options[:path]
+    else # jets format
+      ensure_jets_format(@options[:path])
+    end
+  end
+
+  def method
+    @options[:method].to_s.upcase
+  end
+
+  # IE: posts#index
+  def to
+    @options[:to]
+  end
+
+  def internal?
+    !!@options[:internal]
+  end
+
+  def homepage?
+    path == ''
+  end
+
+  # IE: PostsController
+  def controller_name
+    to.sub(/#.*/,'').camelize + "Controller"
+  end
+
+  # IE: index
+  def action_name
+    to.sub(/.*#/,'')
+  end
+
+  # Checks to see if the corresponding controller exists. Useful to validate routes
+  # before deploying to CloudFormation and then rolling back.
+  def valid?
+    controller_class = begin
+      controller_name.constantize
+    rescue NameError
+      return false
+    end
+    controller_class.lambda_functions.include?(action_name.to_sym)
+  end
+
+  # Extracts the path parameters from the actual path
+  # Only supports extracting 1 parameter. So:
+  #
+  #   actual_path: posts/tung/edit
+  #   route.path: posts/:id/edit
+  #
+  # Returns:
+  #    { id: "tung" }
+  def extract_parameters(actual_path)
+    if path.include?(':')
+      extract_parameters_capture(actual_path)
+    elsif path.include?('*')
+      extract_parameters_proxy(actual_path)
+    else
+      # Lambda AWS_PROXY sets null to the input request when there are no path parmeters
+      nil
+    end
+  end
+
+  def extract_parameters_proxy(actual_path)
+    # changes path to a string used for a regexp
+    # others/*proxy => others\/(.*)
+    # nested/others/*proxy => nested/others\/(.*)
+    if path.include?('/')
+      leading_path = path.split('/')[0..-2].join('/') # drop last segment
+      # leading_path: nested/others
+      # capture everything after the leading_path as the value
+      regexp = Regexp.new("#{leading_path}/(.*)")
+      value = actual_path.match(regexp)[1]
+    else
+      value = actual_path
+    end
+
+    # the last segment without the '*' is the key
+    proxy_segment = path.split('/').last # last segment is the proxy segment
+    # proxy_segment: *proxy
+    key = proxy_segment.sub('*','')
+
+    { key => value }
+  end
+
+  def extract_parameters_capture(actual_path)
+    # changes path to a string used for a regexp
+    # posts/:id/edit => posts\/(.*)\/edit
+    labels = []
+    regexp_string = path.split('/').map do |s|
+                      if s.start_with?(':')
+                        labels << s.delete_prefix(':')
+                        CAPTURE_REGEX
+                      else
+                        s
+                      end
+                    end.join('\/')
+    # make sure beginning and end of the string matches
+    regexp_string = "^#{regexp_string}$"
+    regexp = Regexp.new(regexp_string)
+
+    values = regexp.match(actual_path).captures
+    labels.map do |next_label|
+      [next_label, values.delete_at(0)]
+    end.to_h
+  end
+
+  def authorization_type
+    @options[:authorization_type]
+  end
+
+private
+  def ensure_jets_format(path)
+    path.split('/').map do |s|
+      if s =~ /^\{/ and s =~ /\+\}$/
+        s.sub(/^\{/, '*').sub(/\+\}$/,'') # {proxy+} => *proxy
+      elsif s =~ /^\{/ and s =~ /\}$/
+        s.sub('{',':').sub(/\}$/,'') # {id} => :id
+      else
+        s
+      end
+    end.join('/')
+  end
+
+  def api_gateway_format(path)
+    path.split('/')
+      .map {|s| transform_capture(s) }
+      .map {|s| transform_proxy(s) }
+      .join('/')
+  end
+
+  def transform_capture(text)
+    if text.starts_with?(':')
+      text = text.sub(':','')
+      text = "{#{text}}"
+    end
+    text
+  end
+
+  def transform_proxy(text)
+    if text.starts_with?('*')
+      text = text.sub('*','')
+      text = "{#{text}+}"
+    end
+    text
+  end
+end

data/lib/jets/router.rb

@@ -0,0 +1,177 @@
+require 'text-table'
+
+module Jets
+  class Router
+    attr_reader :routes
+    def initialize
+      @routes = []
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+      check_collision!
+    end
+
+    # Validate routes that deployable
+    def check_collision!
+      paths = self.routes.map(&:path)
+      collision = Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
+      collide = collision.collision?(paths)
+      raise collision.exception if collide
+    end
+
+    # Methods supported by API Gateway
+    %w[any delete get head options patch post put].each do |method_name|
+      define_method method_name do |path, options|
+        create_route(options.merge(path: path, method: __method__))
+      end
+    end
+
+    def create_route(options)
+      # Currently only using scope to add namespace
+      # TODO: Can use it to add additional things like authorization_type
+      # Would be good to add authorization_type at the controller level also
+      options[:path] = add_namespace(options[:path])
+      @routes << Route.new(options)
+    end
+
+    def add_namespace(path)
+      return path unless @scope
+      ns = @scope.full_namespace
+      return path unless ns
+      "#{ns}/#{path}"
+    end
+
+    def namespace(ns, &block)
+      scope(namespace: ns, &block)
+    end
+
+    def scope(options={})
+      root_level = @scope.nil?
+      @scope = root_level ? Scope.new(options) : @scope.new(options)
+      yield
+    ensure
+      @scope = @scope.parent if @scope
+    end
+
+    # resources macro expands to all the routes
+    def resources(name)
+      get "#{name}", to: "#{name}#index"
+      get "#{name}/new", to: "#{name}#new" unless api_mode?
+      get "#{name}/:id", to: "#{name}#show"
+      post "#{name}", to: "#{name}#create"
+      get "#{name}/:id/edit", to: "#{name}#edit" unless api_mode?
+      put "#{name}/:id", to: "#{name}#update"
+      post "#{name}/:id", to: "#{name}#update" # for binary uploads
+      patch "#{name}/:id", to: "#{name}#update"
+      delete "#{name}/:id", to: "#{name}#delete"
+    end
+
+    def api_mode?
+      if Jets.config.key?(:api_mode) || Jets.config.key?(:api_generator)
+        puts <<~EOL.color(:yellow)
+          DEPRECATED: Jets.config.api_generator
+          Instead, please update your config/application.rb to use:
+            Jets.config.mode = 'api'
+          You can also run:
+            jets upgrade
+        EOL
+      end
+      api_mode = Jets.config.mode == 'api' || Jets.config.api_mode || Jets.config.api_generator
+      api_mode
+    end
+
+    # root "posts#index"
+    def root(to, options={})
+      default = {path: '', to: to, method: :get, root: true}
+      options = default.merge(options)
+      @routes << Route.new(options)
+    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:
+    # 1. Routes with no captures get highest precedence: posts/new
+    # 2. Then consider the routes with captures: post/:id
+    # 3. Last consider the routes with wildcards: *catchall
+    #
+    # Within these 2 groups we consider the routes with the longest path first
+    # since posts/:id and posts/:id/edit can both match.
+    def ordered_routes
+      length = Proc.new { |r| r.path.length * -1 }
+      capture_routes = routes.select { |r| r.path.include?(':') }.sort_by(&length)
+      wildcard_routes = routes.select { |r| r.path.include?('*') }.sort_by(&length)
+      simple_routes = (routes - capture_routes - wildcard_routes).sort_by(&length)
+      simple_routes + capture_routes + wildcard_routes
+    end
+
+    def self.has_controller?(name)
+      routes.detect { |r| r.controller_name == name }
+    end
+
+    # Class methods
+    def self.draw
+      drawn_router
+    end
+
+    @@drawn_router = nil
+    def self.drawn_router
+      return @@drawn_router if @@drawn_router
+
+      router = Jets.application.routes
+      @@drawn_router = router
+    end
+
+    def self.clear!
+      @@drawn_router = nil
+    end
+
+    def self.routes
+      drawn_router.routes
+    end
+
+    # Returns all paths including subpaths.
+    # Example:
+    # Input: ["posts/:id/edit"]
+    # Output: ["posts", "posts/:id", "posts/:id/edit"]
+    def self.all_paths
+      drawn_router.all_paths
+    end
+
+    def self.routes_help
+      return "Your routes table is empty." if routes.empty?
+
+      table = Text::Table.new
+      table.head = %w[Verb Path Controller#action]
+      routes.each do |route|
+        table.rows << [route.method, route.path, route.to]
+      end
+      table
+    end
+
+    def self.all_routes_valid
+      invalid_routes.empty?
+    end
+
+    def self.invalid_routes
+      routes.select { |r| !r.valid? }
+    end
+  end
+end