json_sti 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3624d823ce141fe74222d5ce9d2fe9dd6a07692046db37aeb18fce3a137a5b10
+  data.tar.gz: e6ecba2cb054e9dbab7d69ccba1f0b820125ad8cb8fff80480cd9c0bc12730c1
+SHA512:
+  metadata.gz: 4682108fa7c68af0dfdf92e7ce35eece47c281cf57421507ff2d5509f945d80f4fa55a299e40386544d6f862afff080eca017cbe7bed9ef8781001ea52efef52
+  data.tar.gz: 861e476792d0fd1da19f14db46aef05c8d646870a8b61eb099cfa34a330fec2e1b288043d732261765cf984e75df3d829a26ea09ed8f2b61563316139fc07449

data/lib/json_sti.rb

@@ -0,0 +1,150 @@
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+require_relative "json_sti/class_master_list"
+require_relative "json_sti/inheritable_seeder"
+
+module JsonSti
+  extend ActiveSupport::Concern
+
+  def self.initialize_single_table_arel_helpers
+    JsonSti::ClassMasterList.base_class_list.each do |receiving_class_name|
+      receiving_class = receiving_class_name.to_s.camelize.constantize
+
+      next unless ClassMasterList.relations_lookup[receiving_class_name]
+
+      ClassMasterList.relations_lookup[receiving_class_name][:relationships].each do |relationship_to_create|
+        ClassMasterList.relations_lookup[relationship_to_create][:members].each do |relationship_to_create_member|
+          creation_class = "#{relationship_to_create.to_s.camelize}::#{relationship_to_create_member.to_s.singularize.camelize}".constantize
+
+          ar_association = receiving_class.reflect_on_all_associations.detect do |association|
+            association.class_name == relationship_to_create.to_s.camelize
+          end
+
+          receiving_class.class_eval do
+            if ar_association.to_s.downcase =~ /many/
+              # create has_many helper methods for sti subtypes
+              define_method "#{relationship_to_create_member.to_s.pluralize}" do
+                self.send(relationship_to_create.to_s.pluralize).where(type: creation_class.to_s)
+              end
+
+            else
+              # create belongs_to helper methods for sti subtypes
+              define_method "#{relationship_to_create_member.to_s.singularize}" do
+                object = self.send(relationship_to_create.to_s.singularize)
+                return object.class.to_s == creation_class.to_s ? object : nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  included do
+    def self.inherited(subclass)
+      begin
+        #check to make sure if it exists, throws error and rescues with constant creation otherwise
+        subclass.to_s.split("::").last.constantize
+      rescue
+        # define subclass name as constant on global object
+        # probably smarter way to do this? Something zeitwerk?
+        Object.const_set(subclass.to_s.split("::").last, subclass)
+
+        subclass.class_eval do
+          # patch subclasses to validate based on their schema.
+          # Schemas are defined in subclasses with `define_schema`
+          validates :module_data,
+                    presence: false,
+                    json: {
+                      message: ->(errors) { errors },
+                      schema: lambda { cleaned_schema }
+                    }
+
+          # a helper similar to ARs `where` only for json fields
+          scope :jwhere, lambda { |hash| where("module_data @> ?", hash.to_json) }
+
+          def initialize(params)
+            super
+
+            self.class::SCHEMA["properties"].keys.each do |attr|
+              unless self.module_data[attr]
+                if self.class::SCHEMA["required"].include? attr
+                  self.module_data[attr] = "REQUIRED: #{self.class::SCHEMA["properties"][attr]["type"]}"
+                else
+                  self.module_data[attr] = nil
+                end
+              end
+            end
+          end
+
+          private
+
+          def cleaned_schema
+            schema = self.class::SCHEMA.to_json
+
+            hash_schema = JSON.parse(schema)
+            properties = hash_schema["properties"]
+            required = schema['required']
+
+            properties.each do |property, value|
+              unless self.module_data[property]
+                unless required.include?(property)
+                  properties.delete property
+                end
+              end
+            end
+
+            hash_schema["properties"] = properties
+            hash_schema.to_json
+          end
+        end
+      end
+
+      super
+    end
+
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    def self.define_schema(hash)
+      class_eval do
+        const_set(:SCHEMA, hash.with_indifferent_access)
+
+        json_attrs = self::SCHEMA["properties"]
+
+        class_variable_set(:@@json_attrs, self::SCHEMA["properties"])
+        class_variable_set(:@@json_required, self::SCHEMA["required"])
+
+        initialize_attr_getters(json_attrs.keys)
+        initialize_attr_setters(json_attrs.keys)
+      end
+    end
+
+    private
+
+    def self.initialize_attr_getters(attr_names)
+      # patches including classes to have getters for their json attr names
+      attr_names.each do |attr_name|
+        define_method attr_name do
+          self.module_data[attr_name]
+        end
+      end
+    end
+
+    def self.initialize_attr_setters(attr_names)
+      # patches including classes to have setters for their json attr names
+      attr_names.each do |attr_name|
+        define_method "#{attr_name}=" do |new_value|
+          self.module_data[attr_name] = new_value
+        end
+      end
+    end
+  end
+
+end
+
+loader.eager_load

data/lib/json_sti/class_master_list.rb

@@ -0,0 +1,77 @@
+module JsonSti
+  class ClassMasterList
+    def self.sti_base_class_list
+      # a list of STI base classes which have their own tables
+      @@sti_base_class_list ||= build_sti_base_class_list
+    end
+
+    def self.relations_lookup
+      # a lookup table including the subclasses of each baseclasses
+      # and what relationships each STI class has to other STI classes
+      @@relations_lookup ||= build_relations_lookup
+    end
+
+    def self.base_class_list
+      # a list of STI base classes which have their own tables
+      @@base_class_list ||= build_base_class_list
+    end
+
+    private
+
+    def self.build_sti_base_class_list
+      ObjectSpace.
+        each_object(Class).
+        select { |klass| klass.included_modules.include? JsonSti }.
+        map(&:to_s).
+        reject { |klass| klass.include?("::") }.
+        map(&:underscore).
+        map(&:to_sym)
+    end
+
+    def self.build_base_class_list
+      models = ActiveRecord::Base.
+        descendants.
+        map(&:name).
+        reject { |klass| klass.include?("::") }.
+        reject { |klass| klass.include?("HABTM") }.
+        reject { |klass| klass.include?("WP") }.
+        map(&:underscore).
+        map(&:to_sym).
+        tap { |models| models.delete :application_record}
+    end
+
+    def self.build_relations_lookup
+      @@relations_lookup = {}
+
+      base_class_list.each do |class_name|
+        @@relations_lookup[class_name] = {}
+        build_relation_list_for_class(class_name)
+        build_members_list_for_class(class_name)
+      end
+
+      @@relations_lookup
+    end
+
+    def self.build_relation_list_for_class(class_name)
+        klass = class_name.to_s.camelize.constantize
+        associations = klass.reflect_on_all_associations
+
+        relation_list = associations.map(&:class_name).
+          map(&:to_s).
+          map(&:underscore).
+          map(&:to_sym)
+
+        @@relations_lookup[class_name][:relationships] = (relation_list & JsonSti::ClassMasterList.sti_base_class_list)
+    end
+
+    def self.build_members_list_for_class(class_name)
+        klass = class_name.to_s.camelize.constantize
+        members = klass.descendants.map(&:to_s).
+          map{ |descendant| descendant.gsub("#{class_name.to_s.camelize}::", "") }.
+          map(&:underscore).
+          map(&:to_sym)
+
+        @@relations_lookup[class_name][:members] = members
+    end
+  end
+end

data/lib/json_sti/inheritable_seeder.rb

@@ -0,0 +1,125 @@
+module JsonSti
+  class InheritableSeeder
+    def self.seed!(num_to_create=3)
+      relations_lookup = JsonSti::ClassMasterList.relations_lookup
+
+      relations_lookup.each do |type, info|
+        info[:members].each do |member|
+          klass = "#{type.to_s.camelize}::#{member.to_s.camelize}".constantize
+          instance = klass.create
+
+          if !instance.valid?
+            skip_sub_object_creation = self.fix_errors_on_instance_and_determine_next_step(instance)
+            next if skip_sub_object_creation
+          end
+
+          p "Created a #{klass.to_s}"
+
+          info[:relationships].each do |relationship|
+            relations_lookup[relationship][:members].each do |relation_member|
+              self.create_relationship_for_instance(instance, relationship, relation_member, num_to_create)
+            end
+          end
+        end
+      end
+    end
+
+    def self.populate_attrs_for_instance!(instance, only_required=false)
+      klass = instance.class
+      json_attrs = klass.class_variable_get(:@@json_attrs)
+      return if json_attrs.blank?
+
+      attrs = only_required ? klass.class_variable_get(:@@json_required) : klass.class_variable_get(:@@json_attrs).keys
+
+      return if attrs.blank?
+
+      attrs.each do |attr|
+        type  = json_attrs[attr].values
+        case type.first
+          when "string"
+            if type[1] && type[1] == "date"
+              new_val = Faker::Date.between(from: 10.days.ago, to: Date.today)
+            elsif type[1] && type[1] == "time"
+              new_val = Faker::Time.between(from: DateTime.now - 1, to: DateTime.now)
+            else
+              new_val = Faker::Marketing.buzzwords
+            end
+          when "boolean"
+            new_val = [true, false].sample
+          when "integer"
+            new_val = Integer(Faker::Number.within(range: 0..99))
+          when "number"
+            new_val = Faker::Number.decimal(l_digits:2, r_digits: 3)
+        end
+
+        instance.send((attr.to_s + "="), new_val)
+      end
+
+      instance.save!
+
+      instance
+    end
+
+    def self.generate_valid_instance_of_class!(klass, only_required=false)
+      populate_attrs_for_instance!(klass.new, only_required)
+    end
+
+    private
+
+    def self.create_relationship_for_instance(instance, relationship_type, relation_member, num_to_create)
+      p "Creating a #{relation_member} for a #{instance.class}"
+
+      num_to_create.times do |n|
+        ar_association = instance.class.reflect_on_all_associations.detect do |association|
+          association.class_name == relationship_type.to_s.camelize
+        end
+
+        if ar_association.to_s.downcase =~ /many/
+          relation_name = relation_member.to_s.pluralize
+          sub_instance = instance.send(relation_name).create
+        else
+          klass_to_create = "#{relationship_type.to_s.camelize}::#{relation_member.to_s.camelize}".constantize
+          sub_instance = generate_valid_instance_of_class!(klass_to_create)
+
+          sub_instance_rel_id = sub_instance.class.to_s.split("::").first.underscore + "_id="
+          instance.send(sub_instance_rel_id, sub_instance.id)
+        end
+
+        JsonSti::InheritableSeeder.populate_attrs_for_instance!(sub_instance)
+      end
+    end
+
+    def self.fix_errors_on_instance_and_determine_next_step(instance)
+      klass = instance.class
+      skip_sub_object_creation = false
+
+      instance.errors.messages.each do |error_key, error_value|
+        if error_key == :module_data
+          JsonSti::InheritableSeeder.populate_attrs_for_instance!(instance)
+
+        elsif error_value.include? "must exist"
+          fix_belongs_to_based_errors_for_instance(instance, error_key)
+          skip_sub_object_creation = true
+
+        else
+          p "============================="
+          p "There was an unhandled error on instance creation: #{error_key} : #{error_value.first}"
+          p "============================="
+          skip_sub_object_creation = true
+        end
+      end
+
+      skip_sub_object_creation
+    end
+
+    def self.fix_belongs_to_based_errors_for_instance(instance, error_key)
+      valid_sub_type = ClassMasterList.relations_lookup[error_key][:members].sample.to_s
+      sub_type_klass = "#{error_key.to_s.camelize}::#{valid_sub_type.camelize}".constantize
+
+      p "creating #{sub_type_klass.to_s} belongs to for #{instance.class.to_s}"
+      new_sub_instance = instance.send("#{error_key}=", sub_type_klass.create)
+
+      JsonSti::InheritableSeeder.populate_attrs_for_instance!(new_sub_instance)
+    end
+  end
+end

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: json_sti
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Max
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.77'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.77'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord_json_validator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+description: A common argument against STI in rails is that the tables eventually
+  get cluttered with class specific columns. By keeping all subtype specific attrs
+  in json, you completely avoid table bloat while keeping all the advantages of AR
+  and a relational database
+email: andrew.max89@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json_sti.rb
+- lib/json_sti/class_master_list.rb
+- lib/json_sti/inheritable_seeder.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A scheme for single table inheritance with ActiveRecord which puts all class
+  specific attributes in a json blob, and allows validations
+test_files: []