aws-sdk-rails 3.6.1 → 3.13.0

data/lib/generators/aws_record/base.rb

@@ -1,217 +1,213 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 require_relative 'generated_attribute'
 require_relative 'secondary_index'
 
 module AwsRecord
-    module Generators
-      class Base < Rails::Generators::NamedBase
-        argument :attributes, type: :array, default: [], banner: "field[:type][:opts]...", desc: "Describes the fields in the model"
-        check_class_collision
-
-        class_option :disable_mutation_tracking, type: :boolean, desc: "Disables dirty tracking"
-        class_option :timestamps, type: :boolean, desc: "Adds created, updated timestamps to the model"
-        class_option :table_config, type: :hash, default: {}, banner: "primary:R-W [SecondaryIndex1:R-W]...", desc: "Declares the r/w units for the model as well as any secondary indexes", :required => true
-        class_option :gsi, type: :array, default: [], banner: "name:hkey{field_name}[,rkey{field_name},proj_type{ALL|KEYS_ONLY|INCLUDE}]...", desc: "Allows for the declaration of secondary indexes"
-        class_option :table_name, type: :string, banner: "model_table_name"
-        class_option :password_digest, type: :boolean, desc: "Whether to add a password_digest field to the model"
-
-        class_option :required, type: :string, banner: "field1...", desc: "A list of attributes that are required for an instance of the model"
-        class_option :length_validations, type: :hash, default: {}, banner: "field1:MIN-MAX...", desc: "Validations on the length of attributes in a model"
-
-        attr_accessor :primary_read_units, :primary_write_units, :gsi_rw_units, :gsis, :required_attrs, :length_validations
-
-        private
-
-        def initialize(args, *options)
-          options[0] << "--skip-table-config" if options[1][:behavior] == :revoke
-          @parse_errors = []
-
-          super
-          ensure_unique_fields
-          ensure_hkey
-          parse_gsis!
-          parse_table_config!
-          parse_validations!
-
-          if !@parse_errors.empty?
-            STDERR.puts "The following errors were encountered while trying to parse the given attributes"
-            STDERR.puts
-            STDERR.puts @parse_errors
-            STDERR.puts
-
-            abort("Please fix the errors before proceeding.")
-          end
+  module Generators
+    class Base < Rails::Generators::NamedBase
+      argument :attributes, type: :array, default: [], banner: 'field[:type][:opts]...',
+                            desc: 'Describes the fields in the model'
+      check_class_collision
+
+      class_option :disable_mutation_tracking, type: :boolean, desc: 'Disables dirty tracking'
+      class_option :timestamps, type: :boolean, desc: 'Adds created, updated timestamps to the model'
+      class_option :table_config, type: :hash, default: {}, banner: 'primary:R-W [SecondaryIndex1:R-W]...',
+                                  desc: 'Declares the r/w units for the model as well as any secondary indexes', required: true
+      class_option :gsi, type: :array, default: [],
+                         banner: 'name:hkey{field_name}[,rkey{field_name},proj_type{ALL|KEYS_ONLY|INCLUDE}]...', desc: 'Allows for the declaration of secondary indexes'
+      class_option :table_name, type: :string, banner: 'model_table_name'
+      class_option :password_digest, type: :boolean, desc: 'Whether to add a password_digest field to the model'
+
+      class_option :required, type: :string, banner: 'field1...',
+                              desc: 'A list of attributes that are required for an instance of the model'
+      class_option :length_validations, type: :hash, default: {}, banner: 'field1:MIN-MAX...',
+                                        desc: 'Validations on the length of attributes in a model'
+
+      attr_accessor :primary_read_units, :primary_write_units, :gsi_rw_units, :gsis, :required_attrs,
+                    :length_validations
+
+      private
+
+      def initialize(args, *options)
+        options[0] << '--skip-table-config' if options[1][:behavior] == :revoke
+        @parse_errors = []
+
+        super
+        ensure_unique_fields
+        ensure_hkey
+        parse_gsis!
+        parse_table_config!
+        parse_validations!
+
+        return if @parse_errors.empty?
+
+        warn 'The following errors were encountered while trying to parse the given attributes'
+        $stderr.puts
+        warn @parse_errors
+        $stderr.puts
+
+        abort('Please fix the errors before proceeding.')
+      end
+
+      def parse_attributes!
+        self.attributes = (attributes || []).map do |attr|
+          GeneratedAttribute.parse(attr)
+        rescue ArgumentError => e
+          @parse_errors << e
+          next
         end
+        self.attributes = attributes.compact
 
-        def parse_attributes!
+        if options['password_digest']
+          attributes << GeneratedAttribute.new('password_digest', :string_attr, digest: true)
+        end
 
-          self.attributes = (attributes || []).map do |attr|
-            begin
-              GeneratedAttribute.parse(attr)
-            rescue ArgumentError => e
-              @parse_errors << e
-              next
-            end
-          end
-          self.attributes = self.attributes.compact
+        return unless options['timestamps']
 
-          if options['password_digest']
-            self.attributes << GeneratedAttribute.new("password_digest", :string_attr, :digest => true)
-          end
+        attributes << GeneratedAttribute.parse('created:datetime:default_value{Time.now}')
+        attributes << GeneratedAttribute.parse('updated:datetime:default_value{Time.now}')
+      end
 
-          if options['timestamps']
-            self.attributes << GeneratedAttribute.parse("created:datetime:default_value{Time.now}")
-            self.attributes << GeneratedAttribute.parse("updated:datetime:default_value{Time.now}")
-          end
-        end
+      def ensure_unique_fields
+        used_names = Set.new
+        duplicate_fields = []
 
-        def ensure_unique_fields
-          used_names = Set.new
-          duplicate_fields = []
+        attributes.each do |attr|
+          duplicate_fields << [:attribute, attr.name] if used_names.include? attr.name
+          used_names.add attr.name
 
-          self.attributes.each do |attr|
+          next unless attr.options.key? :database_attribute_name
 
-            if used_names.include? attr.name
-              duplicate_fields << [:attribute, attr.name]
-            end
-            used_names.add attr.name
+          raw_db_attr_name = attr.options[:database_attribute_name].delete('"') # db attribute names are wrapped with " to make template generation easier
 
-            if attr.options.key? :database_attribute_name
-              raw_db_attr_name = attr.options[:database_attribute_name].delete('"') # db attribute names are wrapped with " to make template generation easier
+          duplicate_fields << [:database_attribute_name, raw_db_attr_name] if used_names.include? raw_db_attr_name
 
-              if used_names.include? raw_db_attr_name
-                duplicate_fields << [:database_attribute_name, raw_db_attr_name]
-              end
+          used_names.add raw_db_attr_name
+        end
 
-              used_names.add raw_db_attr_name
-            end
-          end
+        return if duplicate_fields.empty?
 
-          if !duplicate_fields.empty?
-            duplicate_fields.each do |invalid_attr|
-              @parse_errors << ArgumentError.new("Found duplicated field name: #{invalid_attr[1]}, in attribute#{invalid_attr[0]}")
-            end
-          end
+        duplicate_fields.each do |invalid_attr|
+          @parse_errors << ArgumentError.new("Found duplicated field name: #{invalid_attr[1]}, in attribute#{invalid_attr[0]}")
         end
+      end
 
-        def ensure_hkey
-          uuid_member = nil
-          hkey_member = nil
-          rkey_member = nil
-
-          self.attributes.each do |attr|
-            if attr.options.key? :hash_key
-              if hkey_member
-                @parse_errors << ArgumentError.new("Redefinition of hash_key attr: #{attr.name}, original declaration of hash_key on: #{hkey_member.name}")
-                next
-              end
-
-              hkey_member = attr
-            elsif attr.options.key? :range_key
-              if rkey_member
-                @parse_errors << ArgumentError.new("Redefinition of range_key attr: #{attr.name}, original declaration of range_key on: #{hkey_member.name}")
-                next
-              end
-
-              rkey_member = attr
-            end
+      def ensure_hkey
+        uuid_member = nil
+        hkey_member = nil
+        rkey_member = nil
 
-            if attr.name.include? "uuid"
-              uuid_member = attr
+        attributes.each do |attr|
+          if attr.options.key? :hash_key
+            if hkey_member
+              @parse_errors << ArgumentError.new("Redefinition of hash_key attr: #{attr.name}, original declaration of hash_key on: #{hkey_member.name}")
+              next
             end
-          end
 
-          if !hkey_member
-            if uuid_member
-              uuid_member.options[:hash_key] = true
-            else
-              self.attributes.unshift GeneratedAttribute.parse("uuid:hkey")
+            hkey_member = attr
+          elsif attr.options.key? :range_key
+            if rkey_member
+              @parse_errors << ArgumentError.new("Redefinition of range_key attr: #{attr.name}, original declaration of range_key on: #{hkey_member.name}")
+              next
             end
+
+            rkey_member = attr
           end
-        end
 
-        def mutation_tracking_disabled?
-          options['disable_mutation_tracking']
+          uuid_member = attr if attr.name.include? 'uuid'
         end
 
-        def has_validations?
-          !@required_attrs.empty? || !@length_validations.empty?
+        return if hkey_member
+
+        if uuid_member
+          uuid_member.options[:hash_key] = true
+        else
+          attributes.unshift GeneratedAttribute.parse('uuid:hkey')
         end
+      end
+
+      def mutation_tracking_disabled?
+        options['disable_mutation_tracking']
+      end
 
-        def parse_table_config!
-          return unless options['table_config']
+      def has_validations?
+        !@required_attrs.empty? || !@length_validations.empty?
+      end
 
-          @primary_read_units, @primary_write_units = parse_rw_units("primary")
+      def parse_table_config!
+        return unless options['table_config']
 
-          @gsi_rw_units = @gsis.map { |idx|
-            [idx.name, parse_rw_units(idx.name)]
-          }.to_h
+        @primary_read_units, @primary_write_units = parse_rw_units('primary')
 
-          options['table_config'].each do |config, rw_units|
-            if config == "primary"
-              next
-            else
-              gsi = @gsis.select { |idx| idx.name == config}
+        @gsi_rw_units = @gsis.map do |idx|
+          [idx.name, parse_rw_units(idx.name)]
+        end.to_h
 
-              if gsi.empty?
-                @parse_errors << ArgumentError.new("Could not find a gsi declaration for #{config}")
-              end
-            end
-          end
+        options['table_config'].each_key do |config|
+          next if config == 'primary'
+
+          gsi = @gsis.select { |idx| idx.name == config }
+
+          @parse_errors << ArgumentError.new("Could not find a gsi declaration for #{config}") if gsi.empty?
         end
+      end
 
-        def parse_rw_units(name)
-          if !options['table_config'].key? name
-            @parse_errors << ArgumentError.new("Please provide a table_config definition for #{name}")
-          else
-            rw_units = options['table_config'][name]
-            return rw_units.gsub(/[,.-]/, ':').split(':').reject { |s| s.empty? }
-          end
+      def parse_rw_units(name)
+        if options['table_config'].key? name
+          rw_units = options['table_config'][name]
+          rw_units.gsub(/[,.-]/, ':').split(':').reject(&:empty?)
+        else
+          @parse_errors << ArgumentError.new("Please provide a table_config definition for #{name}")
         end
+      end
+
+      def parse_gsis!
+        @gsis = (options['gsi'] || []).map do |raw_idx|
+          idx = SecondaryIndex.parse(raw_idx)
+
+          attributes = self.attributes.select { |attr| attr.name == idx.hash_key }
+          if attributes.empty?
+            @parse_errors << ArgumentError.new("Could not find attribute #{idx.hash_key} for gsi #{idx.name} hkey")
+            next
+          end
 
-        def parse_gsis!
-          @gsis = (options['gsi'] || []).map do |raw_idx|
-            begin
-              idx = SecondaryIndex.parse(raw_idx)
-
-              attributes = self.attributes.select { |attr| attr.name == idx.hash_key}
-              if attributes.empty?
-                @parse_errors << ArgumentError.new("Could not find attribute #{idx.hash_key} for gsi #{idx.name} hkey")
-                next
-              end
-
-              if idx.range_key
-                attributes = self.attributes.select { |attr| attr.name == idx.range_key}
-                if attributes.empty?
-                  @parse_errors << ArgumentError.new("Could not find attribute #{idx.range_key} for gsi #{idx.name} rkey")
-                  next
-                end
-              end
-
-              idx
-            rescue ArgumentError => e
-              @parse_errors << e
+          if idx.range_key
+            attributes = self.attributes.select { |attr| attr.name == idx.range_key }
+            if attributes.empty?
+              @parse_errors << ArgumentError.new("Could not find attribute #{idx.range_key} for gsi #{idx.name} rkey")
               next
             end
           end
 
-          @gsis = @gsis.compact
+          idx
+        rescue ArgumentError => e
+          @parse_errors << e
+          next
         end
 
-        def parse_validations!
-          @required_attrs = options['required'] ? options['required'].split(',') : []
-          @required_attrs.each do |val_attr|
-            @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if !self.attributes.any? { |attr| attr.name == val_attr }
-          end
+        @gsis = @gsis.compact
+      end
 
-          @length_validations = options['length_validations'].map do |val_attr, bounds|
-            @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if !self.attributes.any? { |attr| attr.name == val_attr }
+      def parse_validations!
+        @required_attrs = options['required'] ? options['required'].split(',') : []
+        @required_attrs.each do |val_attr|
+          @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if attributes.none? do |attr|
+                                                                                                       attr.name == val_attr
+                                                                                                     end
+        end
 
-            bounds = bounds.gsub(/[,.-]/, ':').split(':').reject { |s| s.empty? }
-            [val_attr, "#{bounds[0]}..#{bounds[1]}"]
-          end
-          @length_validations = @length_validations.to_h
+        @length_validations = options['length_validations'].map do |val_attr, bounds|
+          @parse_errors << ArgumentError.new("No such field #{val_attr} in required validations") if attributes.none? do |attr|
+                                                                                                       attr.name == val_attr
+                                                                                                     end
+
+          bounds = bounds.gsub(/[,.-]/, ':').split(':').reject(&:empty?)
+          [val_attr, "#{bounds[0]}..#{bounds[1]}"]
         end
+        @length_validations = @length_validations.to_h
       end
     end
   end
+end

data/lib/generators/aws_record/generated_attribute.rb

@@ -1,28 +1,31 @@
+# frozen_string_literal: true
+
 module AwsRecord
   module Generators
     class GeneratedAttribute
-
-      OPTS = %w(hkey rkey persist_nil db_attr_name ddb_type default_value)
-      INVALID_HKEY_TYPES = %i(map_attr list_attr numeric_set_attr string_set_attr)
+      OPTS = %w[hkey rkey persist_nil db_attr_name ddb_type default_value].freeze
+      INVALID_HKEY_TYPES = %i[map_attr list_attr numeric_set_attr string_set_attr].freeze
       attr_reader :name, :type
       attr_accessor :options
 
       def field_type
         case @type
-          when :integer_attr then :number_field
-          when :date_attr then :date_select
-          when :datetime_attr then :datetime_select
-          when :boolean_attr then :check_box
-          else :text_field
+        when :integer_attr then :number_field
+        when :date_attr then :date_select
+        when :datetime_attr then :datetime_select
+        when :boolean_attr then :check_box
+        else :text_field
         end
       end
 
       class << self
-
         def parse(field_definition)
           name, type, opts = field_definition.split(':')
-          type = "string" if not type
-          type, opts = "string", type if OPTS.any? { |opt| type.include? opt }
+          type ||= 'string'
+          if OPTS.any? { |opt| type.include? opt }
+            opts = type
+            type = 'string'
+          end
 
           opts = opts.split(',') if opts
           type, opts = parse_type_and_options(name, type, opts)
@@ -34,65 +37,71 @@ module AwsRecord
         private
 
         def validate_opt_combs(name, type, opts)
-          if opts
-              is_hkey = opts.key?(:hash_key)
-              is_rkey = opts.key?(:range_key)
+          return unless opts
+
+          is_hkey = opts.key?(:hash_key)
+          is_rkey = opts.key?(:range_key)
 
-              raise ArgumentError.new("Field #{name} cannot be a range key and hash key simultaneously") if is_hkey && is_rkey
-              raise ArgumentError.new("Field #{name} cannot be a hash key and be of type #{type}") if is_hkey and INVALID_HKEY_TYPES.include? type
+          if is_hkey && is_rkey
+            raise ArgumentError,
+                  "Field #{name} cannot be a range key and hash key simultaneously"
           end
+          return unless is_hkey && INVALID_HKEY_TYPES.include?(type)
+
+          raise ArgumentError,
+                "Field #{name} cannot be a hash key and be of type #{type}"
         end
 
         def parse_type_and_options(name, type, opts)
-          opts = [] if not opts
-          return parse_type(name, type), opts.map { |opt| parse_option(name, opt) }.to_h
+          opts ||= []
+          [parse_type(name, type), opts.map { |opt| parse_option(name, opt) }.to_h]
         end
 
         def parse_option(name, opt)
           case opt
 
-          when "hkey"
-            return :hash_key, true
-          when "rkey"
-            return :range_key, true
-          when "persist_nil"
-            return :persist_nil, true
+          when 'hkey'
+            [:hash_key, true]
+          when 'rkey'
+            [:range_key, true]
+          when 'persist_nil'
+            [:persist_nil, true]
           when /db_attr_name\{(\w+)\}/
-            return :database_attribute_name, '"' + $1 + '"'
+            [:database_attribute_name, "\"#{::Regexp.last_match(1)}\""]
           when /ddb_type\{(S|N|B|BOOL|SS|NS|BS|M|L)\}/i
-            return :dynamodb_type, '"' + $1.upcase + '"'
+            [:dynamodb_type, "\"#{::Regexp.last_match(1).upcase}\""]
           when /default_value\{(.+)\}/
-            return :default_value, $1
+            [:default_value, ::Regexp.last_match(1)]
           else
-            raise ArgumentError.new("You provided an invalid option for #{name}: #{opt}")
+            raise ArgumentError, "You provided an invalid option for #{name}: #{opt}"
           end
         end
 
         def parse_type(name, type)
           case type.downcase
 
-          when "bool", "boolean"
+          when 'bool', 'boolean'
             :boolean_attr
-          when "date"
+          when 'date'
             :date_attr
-          when "datetime"
+          when 'datetime'
             :datetime_attr
-          when "float"
+          when 'float'
             :float_attr
-          when "int", "integer"
+          when 'int', 'integer'
             :integer_attr
-          when "list"
+          when 'list'
             :list_attr
-          when "map"
+          when 'map'
             :map_attr
-          when "num_set", "numeric_set", "nset"
+          when 'num_set', 'numeric_set', 'nset'
             :numeric_set_attr
-          when "string_set", "s_set", "sset"
+          when 'string_set', 's_set', 'sset'
             :string_set_attr
-          when "string"
+          when 'string'
             :string_attr
           else
-            raise ArgumentError.new("Invalid type for #{name}: #{type}")
+            raise ArgumentError, "Invalid type for #{name}: #{type}"
           end
         end
       end
@@ -114,8 +123,8 @@ module AwsRecord
       end
 
       def column_name
-        if @name == "password_digest"
-          "password"
+        if @name == 'password_digest'
+          'password'
         else
           @name
         end

data/lib/generators/aws_record/model/model_generator.rb

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
+
 require_relative '../base'
 
 module AwsRecord
   module Generators
     class ModelGenerator < Base
       def initialize(args, *options)
-        self.class.source_root File.expand_path('../templates', __FILE__)
+        self.class.source_root File.expand_path('templates', __dir__)
         super
       end
 
       def create_model
-        template "model.rb", File.join("app/models", class_path, "#{file_name}.rb")
+        template 'model.erb', File.join('app/models', class_path, "#{file_name}.rb")
       end
 
       def create_table_config
-        template "table_config.rb", File.join("db/table_config", class_path, "#{file_name}_config.rb") if options["table_config"]
-      end
+        return unless options['table_config']
 
+        template 'table_config.erb',
+                 File.join('db/table_config', class_path, "#{file_name}_config.rb")
+      end
     end
   end
 end

data/lib/generators/aws_record/secondary_index.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module AwsRecord
   module Generators
     class SecondaryIndex
-
-      PROJ_TYPES = %w(ALL KEYS_ONLY INCLUDE)
+      PROJ_TYPES = %w[ALL KEYS_ONLY INCLUDE].freeze
       attr_reader :name, :hash_key, :range_key, :projection_type
 
       class << self
@@ -15,45 +16,50 @@ module AwsRecord
         end
 
         private
-          def parse_raw_options(raw_opts)
-            raw_opts = [] if not raw_opts
-            raw_opts.map { |opt| get_option_value(opt) }.to_h
-          end
 
-          def get_option_value(raw_option)
-            case raw_option
-
-            when /hkey\{(\w+)\}/
-              return :hash_key, $1
-            when /rkey\{(\w+)\}/
-              return :range_key, $1
-            when /proj_type\{(\w+)\}/
-              return :projection_type, $1
-            else
-              raise ArgumentError.new("Invalid option for secondary index #{raw_option}")
-            end
+        def parse_raw_options(raw_opts)
+          raw_opts ||= []
+          raw_opts.map { |opt| get_option_value(opt) }.to_h
+        end
+
+        def get_option_value(raw_option)
+          case raw_option
+
+          when /hkey\{(\w+)\}/
+            [:hash_key, ::Regexp.last_match(1)]
+          when /rkey\{(\w+)\}/
+            [:range_key, ::Regexp.last_match(1)]
+          when /proj_type\{(\w+)\}/
+            [:projection_type, ::Regexp.last_match(1)]
+          else
+            raise ArgumentError, "Invalid option for secondary index #{raw_option}"
           end
+        end
       end
 
       def initialize(name, opts)
-        raise ArgumentError.new("You must provide a name") if not name
-        raise ArgumentError.new("You must provide a hash key") if not opts[:hash_key]
+        raise ArgumentError, 'You must provide a name' unless name
+        raise ArgumentError, 'You must provide a hash key' unless opts[:hash_key]
 
         if opts.key? :projection_type
-          raise ArgumentError.new("Invalid projection type #{opts[:projection_type]}") if not PROJ_TYPES.include? opts[:projection_type]
-          raise NotImplementedError.new("ALL is the only projection type currently supported") if opts[:projection_type] != "ALL"
+          unless PROJ_TYPES.include? opts[:projection_type]
+            raise ArgumentError, "Invalid projection type #{opts[:projection_type]}"
+          end
+          if opts[:projection_type] != 'ALL'
+            raise NotImplementedError, 'ALL is the only projection type currently supported'
+          end
         else
-          opts[:projection_type] = "ALL"
+          opts[:projection_type] = 'ALL'
         end
 
         if opts[:hash_key] == opts[:range_key]
-          raise ArgumentError.new("#{opts[:hash_key]} cannot be both the rkey and hkey for gsi #{name}")
+          raise ArgumentError, "#{opts[:hash_key]} cannot be both the rkey and hkey for gsi #{name}"
         end
 
         @name = name
         @hash_key = opts[:hash_key]
         @range_key = opts[:range_key]
-        @projection_type = '"' + "#{opts[:projection_type]}" + '"'
+        @projection_type = "\"#{opts[:projection_type]}\""
       end
     end
   end