rubocop -a

Author: jasl

.rubocop.yml

@@ -17,12 +17,30 @@ Rails:
 Metrics/LineLength:
   Max: 150
 
+Metrics/MethodLength:
+  Max: 100
+
+Metrics/BlockLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Enabled: false
+
 Style/GuardClause:
   Enabled: false
 
 Style/Documentation:
   Enabled: false
 
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Naming/AccessorMethodName:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
 # Prefer assert_not over assert !
 Rails/AssertNot:
   Include:

app/models/form_core/form.rb

@@ -6,6 +6,6 @@ class Form < ApplicationRecord
 
     self.table_name = "forms"
 
-    has_many :fields
+    has_many :fields, dependent: :destroy
   end
 end

db/migrate/20170430190404_create_forms.rb

@@ -3,7 +3,7 @@
 class CreateForms < ActiveRecord::Migration[5.1]
   def change
     create_table :forms do |t|
-      t.string :name, null: false, index: {unique: true}
+      t.string :name, null: false, index: { unique: true }
       t.string :type, null: false, index: true
 
       t.timestamps

lib/form_core.rb

@@ -18,9 +18,7 @@ def virtual_model_class
     end
 
     def virtual_model_class=(klass)
-      unless klass && klass < VirtualModel
-        raise ArgumentError, "#{klass} should be sub-class of #{VirtualModel}."
-      end
+      raise ArgumentError, "#{klass} should be sub-class of #{VirtualModel}." unless klass && klass < VirtualModel
 
       @reserved_names = nil
       @virtual_model_class = klass
@@ -38,9 +36,7 @@ def virtual_model_coder_class
     end
 
     def virtual_model_coder_class=(klass)
-      unless klass && klass < Coder
-        raise ArgumentError, "#{klass} should be sub-class of #{Coder}."
-      end
+      raise ArgumentError, "#{klass} should be sub-class of #{Coder}." unless klass && klass < Coder
 
       @virtual_model_coder_class = klass
     end

lib/form_core/coder.rb

@@ -24,20 +24,20 @@ def load(_src)
 
     private
 
-    def new_or_raise_decoding_error
-      if strict?
-        raise DecodingDataCorrupted
-      else
-        object_class.new
+      def new_or_raise_decoding_error
+        if strict?
+          raise DecodingDataCorrupted
+        else
+          object_class.new
+        end
       end
-    end
 
-    def valid_attribute_names
-      object_class.attribute_names + object_class._embeds_reflections.keys
-    end
+      def valid_attribute_names
+        object_class.attribute_names + object_class._embeds_reflections.keys
+      end
 
-    def valid_attributes(hash)
-      hash.slice(*valid_attribute_names)
-    end
+      def valid_attributes(hash)
+        hash.slice(*valid_attribute_names)
+      end
   end
 end

lib/form_core/coders/hash_coder.rb

@@ -9,9 +9,7 @@ def dump(obj)
     end
 
     def load(hash)
-      if hash.nil? || !hash.respond_to?(:to_h)
-        return new_or_raise_decoding_error
-      end
+      return new_or_raise_decoding_error if hash.nil? || !hash.respond_to?(:to_h)
 
       object_class.new valid_attributes(hash)
     end

lib/form_core/coders/yaml_coder.rb

@@ -23,19 +23,15 @@ def dump(obj)
     def load(yaml)
       return object_class.new if yaml.blank?
 
-      unless yaml.is_a?(String) && /^---/.match?(yaml)
-        return new_or_raise_decoding_error
-      end
+      return new_or_raise_decoding_error unless yaml.is_a?(String) && /^---/.match?(yaml)
 
       decoded =
         if safe_mode?
           YAML.safe_load(yaml, YAMLCoder.whitelist_classes)
         else
-          YAML.load(yaml)
+          YAML.safe_load(yaml)
         end
-      unless decoded.is_a? Hash
-        return new_or_raise_decoding_error
-      end
+      return new_or_raise_decoding_error unless decoded.is_a? Hash
 
       object_class.new valid_attributes(decoded)
     end

lib/form_core/concerns/models/field.rb

@@ -8,19 +8,19 @@ module Field
       NAME_REGEX = /\A[a-z][a-z_0-9]*\z/.freeze
 
       included do
-        enum accessibility: {read_and_write: 0, readonly: 1, hidden: 2},
+        enum accessibility: { read_and_write: 0, readonly: 1, hidden: 2 },
              _prefix: :access
 
         serialize :validations
         serialize :options
 
         validates :name,
                   presence: true,
-                  uniqueness: {scope: :form},
-                  exclusion: {in: FormCore.reserved_names},
-                  format: {with: NAME_REGEX}
+                  uniqueness: { scope: :form },
+                  exclusion: { in: FormCore.reserved_names },
+                  format: { with: NAME_REGEX }
         validates :accessibility,
-                  inclusion: {in: accessibilities.keys.map(&:to_sym)}
+                  inclusion: { in: accessibilities.keys.map(&:to_sym) }
 
         after_initialize do
           self.validations ||= {}
@@ -54,9 +54,7 @@ def interpret_to(model, overrides: {})
         default_value = overrides.fetch(:default_value, self.default_value)
         model.attribute name, stored_type, default: default_value
 
-        if accessibility == :readonly
-          model.attr_readonly name
-        end
+        model.attr_readonly name if accessibility == :readonly
 
         interpret_validations_to model, accessibility, overrides
         interpret_extra_to model, accessibility, overrides
@@ -66,22 +64,18 @@ def interpret_to(model, overrides: {})
 
       protected
 
-      def interpret_validations_to(model, accessibility, overrides = {})
-        validations = overrides.fetch(:validations, (self.validations || {}))
-        validation_options = overrides.fetch(:validation_options) { self.options.fetch(:validation, {}) }
+        def interpret_validations_to(model, accessibility, overrides = {})
+          validations = overrides.fetch(:validations, (self.validations || {}))
+          validation_options = overrides.fetch(:validation_options) { self.options.fetch(:validation, {}) }
 
-        if accessibility == :read_and_write && validations.present?
-          model.validates name, **validations, **validation_options
+          model.validates name, **validations, **validation_options if accessibility == :read_and_write && validations.present?
         end
-      end
 
-      def interpret_extra_to(_model, _accessibility, _overrides = {}); end
+        def interpret_extra_to(_model, _accessibility, _overrides = {}); end
 
-      def check_model_validity!(model)
-        unless model.is_a?(Class) && model < ::FormCore::VirtualModel
-          raise ArgumentError, "#{model} must be a #{::FormCore::VirtualModel}'s subclass"
+        def check_model_validity!(model)
+          raise ArgumentError, "#{model} must be a #{::FormCore::VirtualModel}'s subclass" unless model.is_a?(Class) && model < ::FormCore::VirtualModel
         end
-      end
     end
   end
 end

lib/form_core/concerns/models/form.rb

@@ -11,8 +11,8 @@ module Form
         validates :name,
                   presence: true,
                   uniqueness: true,
-                  exclusion: {in: FormCore.reserved_names},
-                  format: {with: NAME_REGEX}
+                  exclusion: { in: FormCore.reserved_names },
+                  format: { with: NAME_REGEX }
       end
 
       def to_virtual_model(model_name: "Form",
@@ -38,11 +38,11 @@ def append_to_virtual_model(model,
 
       private
 
-      def check_model_validity!(model)
-        unless model.is_a?(Class) && model < ::FormCore::VirtualModel
-          raise ArgumentError, "#{model} must be a #{::FormCore::VirtualModel}'s subclass"
+        def check_model_validity!(model)
+          unless model.is_a?(Class) && model < ::FormCore::VirtualModel
+            raise ArgumentError, "#{model} must be a #{::FormCore::VirtualModel}'s subclass"
+          end
         end
-      end
     end
   end
 end

lib/form_core/virtual_model.rb

@@ -11,9 +11,7 @@ def inspect
       inspection =
         if defined?(@attributes) && @attributes
           self.class.attribute_names.collect do |name|
-            if has_attribute?(name)
-              "#{name}: #{attribute_for_inspect(name)}"
-            end
+            "#{name}: #{attribute_for_inspect(name)}" if has_attribute?(name)
           end.compact.join(", ")
         else
           "not initialized"
@@ -51,9 +49,7 @@ def coder
       end
 
       def coder=(klass)
-        unless klass && klass < Coder
-          raise ArgumentError, "#{klass} should be sub-class of #{Coder}."
-        end
+        raise ArgumentError, "#{klass} should be sub-class of #{Coder}." unless klass && klass < Coder
 
         @_coder = klass.new(self)
       end