sumomo 0.8.4 → 0.8.6

data/lib/sumomo/api.rb

@@ -1,117 +1,118 @@
+# frozen_string_literal: true
+
+require 'sumomo/irregular'
 
 module Sumomo
   module Stack
-
     class APIGenerator
+      extend HasIrregularlyNamedFunctions
 
       class CorsInfo
+        extend HasIrregularlyNamedFunctions
         attr_accessor :allowed_origins, :allowed_headers
 
         def apply(&block)
-            @allowed_origins = []
-            @allowed_headers = []
-            instance_eval(&block) if block
+          @allowed_origins = []
+          @allowed_headers = []
+          instance_eval(&block) if block
         end
 
-        def AllowOrigin(value)
-            @allowed_origins << value
+        defi :AllowOrigin do |value|
+          @allowed_origins << value
         end
 
-        def AllowHeader(value)
-            @allowed_headers << value
+        defi :AllowHeader do |value|
+          @allowed_headers << value
         end
       end
 
       def initialize(pretty_print: false, &block)
         @methods = {}
         @cors = CorsInfo.new
-        @script = ""
+        @script = ''
         # defaults
         @cors.apply do
-            AllowOrigin "*"
-            AllowHeader 'origin'
-            AllowHeader 'content-type'
-            AllowHeader 'accept'
-            AllowHeader 'cache-control'
-            AllowHeader 'x-requested-with'
-            AllowHeader 'if-modified-since'
+          AllowOrigin '*'
+          AllowHeader 'origin'
+          AllowHeader 'content-type'
+          AllowHeader 'accept'
+          AllowHeader 'cache-control'
+          AllowHeader 'x-requested-with'
+          AllowHeader 'if-modified-since'
         end
         @pretty_print = pretty_print
         instance_eval(&block)
       end
 
       def method_missing(name, *args, &block)
-        "#{name}".split("_").each do |meth|
-          valid_methods = ["GET", "PUT", "POST", "PATCH", "DELETE", "HEAD", "OPTIONS"]
-          if valid_methods.include?("#{meth}")
+        name.to_s.split('_').each do |meth|
+          valid_methods = %w[GET PUT POST PATCH DELETE HEAD OPTIONS]
+          if valid_methods.include?(meth.to_s)
             path = args[0]
-            @methods[path] = {} if !@methods.has_key?(path)
-            
-            @methods[path][meth] = { script: args.last, params: args.select{|arg| arg.is_a?(Symbol) && /\A[a-zA-Z\-0-9_]+\Z/.match("#{arg}") } }
+            @methods[path] = {} unless @methods.key?(path)
+
+            @methods[path][meth] = { script: args.last, params: args.select { |arg| arg.is_a?(Symbol) && /\A[a-zA-Z\-0-9_]+\Z/.match(arg.to_s) } }
           else
             super
           end
         end
       end
 
-      def CORS(&block)
+      defi :CORS do |&block|
         @cors.apply(&block)
       end
 
-      def SCRIPT(value)
+      defi :SCRIPT do |value|
         @script = value
       end
 
       def init_script
-          @script
+        @script
       end
 
       def self.combine_modules(dest)
-          orig_modules = File.join(Gem.loaded_specs['sumomo'].full_gem_path, "data", "sumomo", "api_modules", "node_modules")
+        orig_modules = File.join(Gem.loaded_specs['sumomo'].full_gem_path, 'data', 'sumomo', 'api_modules', 'node_modules')
 
-          `cp -Ra #{orig_modules}/ #{dest}/`
-          `cp -Ra node_modules/* #{dest}/`
+        `cp -Ra #{orig_modules}/ #{dest}/`
+        `cp -Ra node_modules/* #{dest}/`
       end
 
       def generate
+        pretty_print = if @pretty_print
+                         ', null, 2'
+                       else
+                         ''
+                       end
 
-        if @pretty_print
-            pretty_print = ", null, 2"
-        else
-            pretty_print = ""
-        end
-
-        result = ""
+        result = ''
 
         all_methods = @methods.clone
 
         # Generate appropriate options methods as well
 
         @methods.each do |path, resource|
-            meths = resource.map{|meth,info| meth}
+          meths = resource.map { |meth, _info| meth }
 
-            # Insert OPTIONS method if there isn't already one
-            if !all_methods[path].has_key?("OPTIONS")
-                all_methods[path]["OPTIONS"] = { script: <<-SCRIPT, params: [] }
+          # Insert OPTIONS method if there isn't already one
+          next if all_methods[path].key?('OPTIONS')
+
+          all_methods[path]['OPTIONS'] = { script: <<-SCRIPT, params: [] }
                     var headers = {}
-                    headers["Access-Control-Allow-Origin"] = #{@cors.allowed_origins.join(",").inspect}
+                    headers["Access-Control-Allow-Origin"] = #{@cors.allowed_origins.join(',').inspect}
                     headers["Access-Control-Request-Method"] = '*'
                     headers["Access-Control-Allow-Methods"] = '#{meths.join(', ')}'
-                    headers["Access-Control-Allow-Headers"] = #{@cors.allowed_headers.join(",").inspect}
+                    headers["Access-Control-Allow-Headers"] = #{@cors.allowed_headers.join(',').inspect}
 
                     respond_with({methods: #{meths.inspect}}, 200, headers)
-                SCRIPT
-            end
+          SCRIPT
         end
 
-
         all_methods.each do |path, resource|
-            resource.each do |method, method_info|
+          resource.each do |method, method_info|
+            parameter_list = method_info[:params].join(', ')
+            parameter_call_list = method_info[:params].map { |parm| "params['#{parm}']" }.join(', ')
 
-                parameter_list = method_info[:params].join(", ")
-                parameter_call_list = method_info[:params].map{|parm| "params['#{parm}']"}.join(", ")
-
-                result += <<-SCRIPT
+            result += <<-SCRIPT
 
     router.#{method.downcase}('#{path}', prepare(function (event, callback) {
 
@@ -126,7 +127,7 @@ module Sumomo
       {
         var headers = {}
         headers["Content-Type"] = "application/json; charset=utf-8"
-        headers["Access-Control-Allow-Origin"] = #{@cors.allowed_origins.join(",").inspect}
+        headers["Access-Control-Allow-Origin"] = #{@cors.allowed_origins.join(',').inspect}
 
         if (response_headers)
         {
@@ -147,141 +148,137 @@ module Sumomo
 
       var retval = function (#{parameter_list}) {
         #{method_info[:script]}
-      }( #{ parameter_call_list } );
+      }( #{parameter_call_list} );
 
     }));
 
-              SCRIPT
-            end
+            SCRIPT
           end
+        end
         result
       end
     end
 
+    def make_api(domain_name, name:, script: nil, dns: nil, cert: nil, with_statements: [], &block)
+      api = make 'AWS::ApiGateway::RestApi', name: name do
+        Name name
+      end
 
-    def make_api(domain_name, name:, script:nil, dns:nil, cert:nil, with_statements:[], &block)
-
-        api = make "AWS::ApiGateway::RestApi", name: name do
-            Name name
-        end
+      script ||= File.read(File.join(Gem.loaded_specs['sumomo'].full_gem_path, 'data', 'sumomo', 'api_modules', 'real_script.js'))
 
-        script ||= File.read(File.join(Gem.loaded_specs['sumomo'].full_gem_path, "data", "sumomo", "api_modules", "real_script.js"))
+      apigen = APIGenerator.new(&block)
+      script.sub!('// {{ ROUTES }}', apigen.generate)
+      script.gsub!('{{ SCRIPT }}', apigen.init_script)
+      script.gsub!('{{ REGION }}', @region)
+      script.gsub!('{{ BUCKET }}', @bucket_name)
+      script.gsub!('{{ STORE_PREFIX }}', 'functions/' + name)
 
-        apigen = APIGenerator.new(&block);
-        script.sub!("// {{ ROUTES }}", apigen.generate);
-        script.gsub!("{{ SCRIPT }}", apigen.init_script);
-        script.gsub!("{{ REGION }}", @region);
-        script.gsub!("{{ BUCKET }}", @bucket_name);
-        script.gsub!("{{ STORE_PREFIX }}", "functions/" + name);
+      module_dir = '.build_modules'
 
-        module_dir = ".build_modules"
+      APIGenerator.combine_modules(module_dir)
 
-        APIGenerator.combine_modules(module_dir)
+      files = Dir[File.join(module_dir, '**/*')].select { |x| File.file?(x) }.map do |x|
+        { name: x.sub(%r{^#{module_dir}/}, ''), code: File.read(x) }
+      end
 
-        files = Dir[File.join(module_dir, "**/*")].select{|x| File.file?(x)}.map do |x| 
-            { name: x.sub(/^#{module_dir}\//, ""), code: File.read(x) } 
-        end
+      files += [{ name: 'index.js', code: script }]
 
-        files += [ {name:"index.js", code:script} ]
+      fun = make_lambda(name: "#{name}Lambda#{@version_number}", files: files, with_statements: with_statements)
 
-        fun = make_lambda(name: "#{name}Lambda#{@version_number}", files:files, with_statements:with_statements)
+      resource = make 'AWS::ApiGateway::Resource', name: "#{name}Resource" do
+        ParentId api.RootResourceId
+        PathPart '{proxy+}'
+        RestApiId api
+      end
 
-        resource = make "AWS::ApiGateway::Resource", name: "#{name}Resource" do
-            ParentId api.RootResourceId
-            PathPart "{proxy+}"
-            RestApiId api
-        end
+      meth = make 'AWS::ApiGateway::Method', name: "#{name}MethodOther" do
+        RestApiId api
+        ResourceId resource
+        HttpMethod 'ANY'
+        AuthorizationType 'NONE'
+        Integration ({
+          Type: 'AWS_PROXY',
+          IntegrationHttpMethod: 'POST',
+          Uri: call('Fn::Join', '', ['arn:aws:apigateway:', ref('AWS::Region'), ':lambda:path', '/2015-03-31/functions/', fun.Arn, '/invocations'])
+        })
+      end
 
-        meth = make "AWS::ApiGateway::Method", name: "#{name}MethodOther" do
-            RestApiId api
-            ResourceId resource
-            HttpMethod "ANY"
-            AuthorizationType "NONE"
-            Integration ({
-                Type: "AWS_PROXY",
-                IntegrationHttpMethod: "POST",
-                Uri: call("Fn::Join", "", ["arn:aws:apigateway:" ,ref("AWS::Region") ,":lambda:path", "/2015-03-31/functions/", fun.Arn, "/invocations"])
-            })
-        end
+      meth2 = make 'AWS::ApiGateway::Method', name: "#{name}MethodRoot" do
+        RestApiId api
+        ResourceId api.RootResourceId
+        HttpMethod 'ANY'
+        AuthorizationType 'NONE'
+        Integration ({
+          Type: 'AWS_PROXY',
+          IntegrationHttpMethod: 'POST',
+          Uri: call('Fn::Join', '', ['arn:aws:apigateway:', ref('AWS::Region'), ':lambda:path', '/2015-03-31/functions/', fun.Arn, '/invocations'])
+        })
+      end
 
-        meth2 = make "AWS::ApiGateway::Method", name: "#{name}MethodRoot" do
-            RestApiId api
-            ResourceId api.RootResourceId
-            HttpMethod "ANY"
-            AuthorizationType "NONE"
-            Integration ({
-                Type: "AWS_PROXY",
-                IntegrationHttpMethod: "POST",
-                Uri: call("Fn::Join", "", ["arn:aws:apigateway:" ,ref("AWS::Region") ,":lambda:path", "/2015-03-31/functions/", fun.Arn, "/invocations"])
-            })
-        end
+      make 'AWS::Lambda::Permission', name: "#{name}LambdaPermission" do
+        FunctionName fun.Arn
+        Action 'lambda:InvokeFunction'
+        Principal 'apigateway.amazonaws.com'
+      end
 
-        make "AWS::Lambda::Permission", name: "#{name}LambdaPermission" do
-            FunctionName fun.Arn
-            Action "lambda:InvokeFunction"
-            Principal "apigateway.amazonaws.com"
-        end
+      deployment = make 'AWS::ApiGateway::Deployment', name: "#{name}Deployment#{@version_number}" do
+        depends_on meth
+        depends_on meth2
+        RestApiId api
+      end
 
-        deployment = make "AWS::ApiGateway::Deployment", name: "#{name}Deployment#{@version_number}" do
-            depends_on meth
-            depends_on meth2
-            RestApiId api
-        end
+      stage = make 'AWS::ApiGateway::Stage', name: "#{name}Stage" do
+        RestApiId api
+        DeploymentId deployment
+        StageName 'test'
+      end
 
-        stage = make "AWS::ApiGateway::Stage", name: "#{name}Stage" do
-            RestApiId api
-            DeploymentId deployment
-            StageName "test"
-        end
+      root_name = /(?<root_name>[^.]+\.[^.]+)$/.match(domain_name)[:root_name]
 
-        root_name = /(?<root_name>[^.]+\.[^.]+)$/.match(domain_name)[:root_name]
+      cert ||= make 'Custom::USEastCertificate', name: "#{name}Certificate" do
+        DomainName domain_name
+      end
 
-        cert ||= make "Custom::USEastCertificate", name: "#{name}Certificate" do
-            DomainName domain_name
-        end
+      domain = make 'Custom::APIDomainName', name: "#{name}DomainName" do
+        DomainName domain_name
+        CertificateArn cert
+      end
 
-        domain = make "Custom::APIDomainName", name: "#{name}DomainName" do
-            DomainName domain_name
-            CertificateArn cert
-        end
+      make 'AWS::ApiGateway::BasePathMapping', name: "#{name}BasePathMapping" do
+        BasePath '(none)'
+        DomainName domain
+        RestApiId api
+        Stage stage
+      end
 
-        make "AWS::ApiGateway::BasePathMapping", name: "#{name}BasePathMapping" do
-            BasePath "(none)"
-            DomainName domain
-            RestApiId api
-            Stage stage
+      if dns[:type] == :cloudflare
+        make 'Custom::CloudflareDNSEntry', name: "#{name}CloudFlareEntry" do
+          Key dns[:key]
+          Email dns[:email]
+          Domain root_name
+          Entry domain_name.sub(/#{root_name}$/, '').chomp('.')
+          CNAME call('Fn::Join', '', [api, '.execute-api.', ref('AWS::Region'), '.amazonaws.com'])
         end
-
-        if dns[:type] == :cloudflare
-            make "Custom::CloudflareDNSEntry", name: "#{name}CloudFlareEntry" do
-                Key dns[:key]
-                Email dns[:email]
-                Domain root_name
-                Entry domain_name.sub(/#{root_name}$/, "").chomp(".")
-                CNAME call("Fn::Join", "", [api, ".execute-api.", ref("AWS::Region"), ".amazonaws.com"])
-            end
-            domain_name
-        elsif dns[:type] == :route53
-            make "AWS::Route53::RecordSet", name: "#{name}Route53Entry" do
-                HostedZoneId dns[:hosted_zone]
-                Name domain_name
-                Type "CNAME"
-                ResourceRecords [ call("Fn::Join", "", [api, ".execute-api.", ref("AWS::Region"), ".amazonaws.com"]) ]
-            end
-            domain_name
-        else
-            call("Fn::Join", "", [api, ".execute-api.", ref("AWS::Region"), ".amazonaws.com"])
+        domain_name
+      elsif dns[:type] == :route53
+        make 'AWS::Route53::RecordSet', name: "#{name}Route53Entry" do
+          HostedZoneId dns[:hosted_zone]
+          Name domain_name
+          Type 'CNAME'
+          ResourceRecords [call('Fn::Join', '', [api, '.execute-api.', ref('AWS::Region'), '.amazonaws.com'])]
         end
-        
+        domain_name
+      else
+        call('Fn::Join', '', [api, '.execute-api.', ref('AWS::Region'), '.amazonaws.com'])
+      end
     end
 
     def cloudflare_dns(key:, email:)
-        {type: :cloudflare, key: key, email: email}
+      { type: :cloudflare, key: key, email: email }
     end
 
     def route53_dns(hosted_zone:)
-        {type: :route53, hosted_zone: hosted_zone}
+      { type: :route53, hosted_zone: hosted_zone }
     end
-
   end
 end

data/lib/sumomo/cdn.rb

@@ -1,128 +1,134 @@
+# frozen_string_literal: true
 
 module Sumomo
   module Stack
-    def make_cdn_from_dir(domain:, cert:nil, dns:nil, name:nil, dir:, low_ttl: [], lambda_assocs:{})
-
-        bucket_name = @bucket_name
-
-        name ||= make_default_resource_name("CDN")
-
-        puts "Uploading files..."
-        `aws --version`
-        `aws s3 --region #{@region} sync #{dir} "s3://#{bucket_name}/uploads/#{domain}" --size-only --delete`
-        puts "Done."
-
-        oai = make "Custom::OriginAccessIdentity"
-
-        make "AWS::S3::BucketPolicy" do
-            Bucket "#{bucket_name}"
-            PolicyDocument({
-                Version: "2008-10-17",
-                Id: "PolicyForCloudFrontPrivateContent",
-                Statement: [
-                    {
-                        Effect: "Allow",
-                        Principal: {
-                            CanonicalUser: oai.S3CanonicalUserId
-                        },
-                        Action: "s3:GetObject",
-                        Resource: "arn:aws:s3:::#{bucket_name}/uploads/#{domain}/*"
-                    }
-                ]
-            })
-        end
+    def copy_to_uploads!(from_directory, to_directory)
+      bucket_name = @bucket_name
+      location = "s3://#{bucket_name}/uploads/#{to_directory}"
 
-        viewer_policy = "allow-all"
-        if cert
-            viewer_policy = "redirect-to-https"
-        end
+      puts 'Uploading files...'
+      `aws --version`
+      `aws s3 --region #{@region} sync #{from_directory} "#{location}" --size-only --delete`
+      puts 'Done.'
 
-        cdn = make "AWS::CloudFront::Distribution", name: name do
-            DistributionConfig do
-                Origins [{
-                    Id: "originBucket",
-                    DomainName: "#{bucket_name}.s3.amazonaws.com",
-                    OriginPath: "/uploads/#{domain}",
-                    S3OriginConfig: {
-                        OriginAccessIdentity: oai
-                    }
-                }]
-
-                CacheBehaviors low_ttl.map{ |pattern|
-                    {
-                        PathPattern: pattern,
-                        ForwardedValues: {
-                            QueryString: "false",
-                            Cookies: { Forward: "none" }
-                        },
-                        TargetOriginId: "originBucket",
-                        ViewerProtocolPolicy: viewer_policy,
-                        DefaultTTL: 60,
-                        MaxTTL: 60,
-                        MinTTL: 60
-                    }
-                }.to_a
-
-                Enabled "true"
-                DefaultRootObject "index.html"
-                Aliases [ domain ]
-
-                if cert
-                    ViewerCertificate { 
-                        AcmCertificateArn cert
-                        SslSupportMethod "sni-only"
-                    }
-                else
-                    ViewerCertificate { CloudFrontDefaultCertificate "true" } 
-                end
-
-                DefaultCacheBehavior do
-                    AllowedMethods ["GET", "HEAD", "OPTIONS"]
-                    TargetOriginId "originBucket"
-                    ViewerProtocolPolicy viewer_policy
-                    ForwardedValues {
-                        QueryString "false"
-                        Cookies { Forward "none" }
-                    }
-
-                    LambdaFunctionAssociations (lambda_assocs.map do |event_type,arns|
-                        arns.map do |arn|
-                            {EventType: event_type, LambdaFunctionARN: arn}
-                        end.to_a
-                    end.flatten)
-                end
-
-                Logging do
-                    IncludeCookies "false"
-                    Bucket "#{bucket_name}.s3.amazonaws.com"
-                    Prefix "logs/#{domain}/"
-                end
+      location
+    end
+
+    def make_cdn_from_dir(domain:, cert: nil, dns: nil, name: nil, dir:, low_ttl: [], lambda_assocs: {})
+      bucket_name = @bucket_name
+
+      name ||= make_default_resource_name('CDN')
+
+      copy_to_uploads!(dir, domain)
+
+      oai = make 'Custom::OriginAccessIdentity'
+
+      make 'AWS::S3::BucketPolicy' do
+        Bucket bucket_name.to_s
+        PolicyDocument(
+          Version: '2008-10-17',
+          Id: 'PolicyForCloudFrontPrivateContent',
+          Statement: [
+            {
+              Effect: 'Allow',
+              Principal: {
+                CanonicalUser: oai.S3CanonicalUserId
+              },
+              Action: 's3:GetObject',
+              Resource: "arn:aws:s3:::#{bucket_name}/uploads/#{domain}/*"
+            }
+          ]
+        )
+      end
+
+      viewer_policy = 'allow-all'
+      viewer_policy = 'redirect-to-https' if cert
+
+      cdn = make 'AWS::CloudFront::Distribution', name: name do
+        DistributionConfig do
+          Origins [{
+            Id: 'originBucket',
+            DomainName: "#{bucket_name}.s3.amazonaws.com",
+            OriginPath: "/uploads/#{domain}",
+            S3OriginConfig: {
+              OriginAccessIdentity: oai
+            }
+          }]
+
+          CacheBehaviors low_ttl.map { |pattern|
+            {
+              PathPattern: pattern,
+              ForwardedValues: {
+                QueryString: 'false',
+                Cookies: { Forward: 'none' }
+              },
+              TargetOriginId: 'originBucket',
+              ViewerProtocolPolicy: viewer_policy,
+              DefaultTTL: 60,
+              MaxTTL: 60,
+              MinTTL: 60
+            }
+          }.to_a
+
+          Enabled 'true'
+          DefaultRootObject 'index.html'
+          Aliases [domain]
+
+          if cert
+            ViewerCertificate do
+              AcmCertificateArn cert
+              SslSupportMethod 'sni-only'
+            end
+          else
+            ViewerCertificate { CloudFrontDefaultCertificate 'true' }
+          end
+
+          DefaultCacheBehavior do
+            AllowedMethods %w[GET HEAD OPTIONS]
+            TargetOriginId 'originBucket'
+            ViewerProtocolPolicy viewer_policy
+            ForwardedValues do
+              QueryString 'false'
+              Cookies { Forward 'none' }
             end
+
+            LambdaFunctionAssociations lambda_assocs.map do |event_type, arns|
+              arns.map do |arn|
+                { EventType: event_type, LambdaFunctionARN: arn }
+              end.to_a
+            end.flatten
+          end
+
+          Logging do
+            IncludeCookies 'false'
+            Bucket "#{bucket_name}.s3.amazonaws.com"
+            Prefix "logs/#{domain}/"
+          end
         end
+      end
 
-        root_name = /(?<root_name>[^.]+\.[^.]+)$/.match(domain)[:root_name]
+      root_name = /(?<root_name>[^.]+\.[^.]+)$/.match(domain)[:root_name]
 
-        if !dns
+      if !dns
 
-        elsif dns[:type] == :cloudflare
-            make "Custom::CloudflareDNSEntry", name: "#{name}CloudFlareEntry" do
-                Key dns[:key]
-                Email dns[:email]
-                Domain root_name
-                Entry domain.sub(/#{root_name}$/, "").chomp(".")
-                CNAME cdn.DomainName
-            end
-        elsif dns[:type] == :route53
-            make "AWS::Route53::RecordSet", name: "#{name}Route53Entry" do
-                HostedZoneId dns[:hosted_zone]
-                Name domain
-                Type "CNAME"
-                ResourceRecords [ cdn.DomainName ]
-            end
+      elsif dns[:type] == :cloudflare
+        make 'Custom::CloudflareDNSEntry', name: "#{name}CloudFlareEntry" do
+          Key dns[:key]
+          Email dns[:email]
+          Domain root_name
+          Entry domain.sub(/#{root_name}$/, '').chomp('.')
+          CNAME cdn.DomainName
         end
+      elsif dns[:type] == :route53
+        make 'AWS::Route53::RecordSet', name: "#{name}Route53Entry" do
+          HostedZoneId dns[:hosted_zone]
+          Name domain
+          Type 'CNAME'
+          ResourceRecords [cdn.DomainName]
+        end
+      end
 
-        cdn
-
+      cdn
     end
   end
 end