schema-model 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e515db757ac9610d21f55a046be3dd4b7c9ea089f6ee5db2d027db5857a0804
-  data.tar.gz: 734e46e76a917d70c0f170bea2b4a1bb4b784f43d00a64b7a5eb71d2d142ccfe
+  metadata.gz: 75daea073072722da9fb5e80565a35fe6861ab6293d757a2d91b76769835c119
+  data.tar.gz: ed1036610bf036e2bf96baf3f39561cd91063ca48cecace447b80129f7409db2
 SHA512:
-  metadata.gz: 8b068c0de3f58564b9a4ec9480cbf4792b8e865cb3cfbce67ee4f19c9410206bfff2921afa9693f634d335ade358df115f04a87e6668d6927a0b95d137fbaf51
-  data.tar.gz: 996e4ecd5e4b6ff4fc5be81ac349c5fde247781088a40907dfb368146578f57ec51c17947bdca1718289e93c7f35942c9ec4547583bb069497021402985b1dd7
+  metadata.gz: 1e5475f9dc0c8b844083619584376988a8d7dabe763fd2abe67929c472093a2bb5e2a6bbb4d42cc1400cdbb5a7c8d8532bc7f3733d44fc66f4cd07b63debe365
+  data.tar.gz: 5a214b983dd1c2fbf298ddbc74667cda767ee20fb29c735e2dfc1ca4a8e44f3f1df208412b518b76314ca0c12b0d59e90ba66b7f7b2ba96a6b1f1b1793ef1ab0

data/lib/schema/associations/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Schema
+  module Associations
+    # Schema::Associations::Base common class methods between associations
+    module Base
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # no-doc
+      module ClassMethods
+        attr_accessor :schema_name
+
+        def base_schema_class=(kls)
+          @base_schema_class_name = kls.name
+        end
+
+        def base_schema_class
+          Object.const_get(@base_schema_class_name)
+        end
+
+        def schema_options
+          base_schema_class.schema[schema_name]
+        end
+      end
+    end
+  end
+end

data/lib/schema/associations/dynamic_types.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Schema
+  module Associations
+    # Schema::Associations::DynamicTypes adds support for adding dynamic types to associations
+    module DynamicTypes
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # no-doc
+      module ClassMethods
+        def add_type(type, options = {}, &block)
+          class_name = options[:class_name] || schema_dynamic_type_class_name(type)
+          kls = Class.new(self)
+          kls = base_schema_class.const_set(class_name, kls)
+          schema_add_dynamic_type(type, class_name)
+          kls.class_eval(&block) if block
+          kls
+        end
+
+        def dynamic_types
+          schema_options[:types]
+        end
+
+        def dynamic_type_names
+          dynamic_types.keys
+        end
+
+        private
+
+        def schema_dynamic_type_class_name(type)
+          ::Schema::Utils.classify_name(schema_name.to_s) +
+            'AssociationType' +
+            ::Schema::Utils.classify_name(type.to_s)
+        end
+
+        def schema_add_dynamic_type(type, class_name)
+          new_schema_options = schema_options.dup
+          new_schema_options[:types] ||= {}
+          new_schema_options[:types][type] = class_name
+          base_schema_class.add_value_to_class_method(:schema, schema_name => new_schema_options)
+          new_schema_options
+        end
+      end
+    end
+  end
+end

data/lib/schema/associations/has_many.rb

@@ -12,7 +12,7 @@ module Schema
       module ClassMethods
         # rubocop:disable Naming/PredicateName
         def has_many(name, options = {}, &block)
-          options = ::Schema::Utils.add_association_class(self, name, :has_many, options, &block)
+          options = ::Schema::Utils.add_association_class(self, name, :has_many, options)
 
           class_eval(
             <<~STR, __FILE__, __LINE__ + 1
@@ -20,15 +20,19 @@ module Schema
                 #{options[:instance_variable]}
               end
 
+              def #{name}_schema_creator
+                @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
+              end
+
               def #{options[:setter]}(v)
-                if schemas = ::Schema::Utils.create_schemas(self, #{options[:class_name]}, #{name.inspect}, v)
-                  #{options[:instance_variable]} = schemas
-                end
+                #{options[:instance_variable]} = #{name}_schema_creator.create_schemas(self, v)
               end
           STR
           )
 
-          const_get(options[:class_name])
+          kls = const_get(options[:class_name])
+          kls.class_eval(&block) if block
+          kls
         end
         # rubocop:enable Naming/PredicateName
       end

data/lib/schema/associations/has_one.rb

@@ -12,7 +12,7 @@ module Schema
       module ClassMethods
         # rubocop:disable Naming/PredicateName
         def has_one(name, options = {}, &block)
-          options = ::Schema::Utils.add_association_class(self, name, :has_one, options, &block)
+          options = ::Schema::Utils.add_association_class(self, name, :has_one, options)
 
           class_eval(
             <<~STR, __FILE__, __LINE__ + 1
@@ -20,15 +20,19 @@ module Schema
                 #{options[:instance_variable]}
               end
 
+              def #{name}_schema_creator
+                @#{name}_schema_creator ||= ::Schema::Associations::SchemaCreator.new(self, #{name.inspect})
+              end
+
               def #{options[:setter]}(v)
-                if schema = ::Schema::Utils.create_schema(self, #{options[:class_name]}, #{name.inspect}, v)
-                  #{options[:instance_variable]} = schema
-                end
+                #{options[:instance_variable]} = #{name}_schema_creator.create_schema(self, v)
               end
           STR
           )
 
-          const_get(options[:class_name])
+          kls = const_get(options[:class_name])
+          kls.class_eval(&block) if block
+          kls
         end
         # rubocop:enable Naming/PredicateName
       end

data/lib/schema/associations/schema_creator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Schema
+  module Associations
+    # Schema::Associations::SchemaCreator is used to create schema objects for associations
+    class SchemaCreator
+      def initialize(base_schema, name)
+        options = base_schema.class.schema[name]
+        @schema_name = name
+        @schema_class = base_schema.class.const_get(options[:class_name])
+        @aliases = options[:aliases] || []
+        @type_field = options[:type_field]
+        @external_type_field = options[:external_type_field]
+        @types = options[:types]
+        @ignorecase = !options[:type_ignorecase].nil?
+      end
+
+      def create_schema(base_schema, data, error_name = nil)
+        if data.is_a?(Hash)
+          unless (schema_class = get_schema_class(base_schema, data))
+            add_parsing_error(base_schema, error_name, :unknown)
+            return nil
+          end
+          schema = schema_class.from_hash(data)
+          add_parsing_error(base_schema, error_name, :invalid) unless schema.parsing_errors.empty?
+          schema
+        elsif !data.nil?
+          add_parsing_error(base_schema, error_name, :incompatable)
+          nil
+        end
+      end
+
+      def create_schemas(base_schema, list)
+        if list.is_a?(Array)
+          list.each_with_index.map { |data, idx| create_schema(base_schema, data, "#{@schema_name}:#{idx}") }
+        elsif !list.nil?
+          add_parsing_error(base_schema, @schema_name, :incompatable)
+          nil
+        end
+      end
+
+      def get_schema_class(base_schema, data)
+        if dynamic?
+          get_dynamic_schema_class(base_schema, data)
+        else
+          @schema_class
+        end
+      end
+
+      def dynamic?
+        !@type_field.nil? || !@external_type_field.nil?
+      end
+
+      def get_dynamic_schema_class(base_schema, data)
+        type = get_dynamic_type(base_schema, data)
+        type = type.to_s.downcase if @ignorecase
+        @types.each do |name, class_name|
+          name = name.downcase if @ignorecase
+          return base_schema.class.const_get(class_name) if name == type
+        end
+        nil
+      end
+
+      def get_dynamic_type(base_schema, data)
+        if @type_field
+          type_fields.each do |name|
+            type = data[name]
+            return type if type
+          end
+          nil
+        elsif @external_type_field
+          base_schema.public_send(@external_type_field)
+        end
+      end
+
+      def type_fields
+        @type_fields ||= [
+          @type_field,
+          @type_field.to_s
+        ] + @aliases
+      end
+
+      def add_parsing_error(base_schema, error_name, error_msg)
+        base_schema.parsing_errors.add(error_name || @schema_name, error_msg)
+      end
+    end
+  end
+end

data/lib/schema/parsers/array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Schema
+  module Parsers
+    # Schema::Parsers::Array adds the array type to schemas
+    module Array
+      def parse_array(field_name, parsing_errors, value)
+        case value
+        when ::Array
+          value
+        when String
+          schema_options = self.class.schema[field_name]
+          if (data = Array.parse_string_array(self, field_name, parsing_errors, value, schema_options))
+            return data
+          end
+
+          parsing_errors.add(field_name, :incompatable)
+          nil
+        else
+          parsing_errors.add(field_name, :incompatable)
+          nil
+        end
+      end
+
+      def self.parse_string_array(model, field_name, parsing_errors, value, schema_options)
+        return nil unless (separator = schema_options[:separator])
+
+        convert_array_values(model, field_name, parsing_errors, value.split(separator), schema_options)
+      end
+
+      def self.convert_array_values(model, field_name, parsing_errors, data, schema_options)
+        return data unless (data_type = schema_options[:data_type])
+
+        parser_method = "parse_#{data_type}"
+        data.each_with_index.map do |datum, idx|
+          model.send(parser_method, "#{field_name}:#{idx}", parsing_errors, datum)
+        end
+      end
+    end
+  end
+end

data/lib/schema/parsers/common.rb

@@ -38,7 +38,7 @@ module Schema
         case value
         when String
           value
-        when Hash, Array
+        when ::Hash, ::Array
           parsing_errors.add(field_name, :incompatable)
           nil
         when nil

data/lib/schema/parsers/hash.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Schema
+  module Parsers
+    # Schema::Parsers::Hash adds the hash type to schemas
+    module Hash
+      def parse_hash(field_name, parsing_errors, value)
+        case value
+        when ::Hash
+          value
+        else
+          parsing_errors.add(field_name, :incompatable)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/schema/parsers/json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'json'
+
+module Schema
+  module Parsers
+    # Schema::Parsers::Json parse the string as json
+    module Json
+      def parse_json(field_name, parsing_errors, value)
+        case value
+        when String
+          begin
+            ::JSON.parse(value)
+          rescue ::JSON::ParserError
+            parsing_errors.add(field_name, :invalid)
+            nil
+          end
+        else
+          parsing_errors.add(field_name, :incompatable)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/schema/utils.rb

@@ -9,15 +9,11 @@ module Schema
       name.gsub(/[^\da-z_-]/, '').gsub(/(^.|[_|-].)/) { |m| m[-1].upcase }
     end
 
-    def create_schema_class(base_schema_class, class_name, base_class, &block)
-      kls = Class.new(base_class)
-      base_schema_class.const_set(class_name, kls)
-      kls = base_schema_class.const_get(class_name)
-
-      include_schema_modules(kls, base_schema_class.schema_config) if base_class == Object
-
-      kls.class_eval(&block) if block
-
+    def create_schema_class(base_schema_class, schema_name, options)
+      base_schema_class.add_value_to_class_method(:schema, schema_name => options)
+      kls = Class.new(options[:base_class] || Object)
+      kls = base_schema_class.const_set(options[:class_name], kls)
+      include_schema_modules(kls, base_schema_class.schema_config) unless options[:base_class]
       kls
     end
 
@@ -28,41 +24,33 @@ module Schema
       end
     end
 
-    def create_schema(base_schema, schema_class, schema_name, data)
-      if data.is_a?(Hash)
-        schema = schema_class.from_hash(data)
-        base_schema.parsing_errors.add(schema_name, :invalid) unless schema.parsing_errors.empty?
-        schema
-      elsif !data.nil?
-        base_schema.parsing_errors.add(schema_name, :incompatable)
-        nil
-      end
+    def association_options(schema_name, schema_type, options)
+      options[:class_name] ||= 'Schema' + classify_name(schema_type.to_s) + classify_name(schema_name.to_s)
+      ::Schema::Model.default_attribute_options(schema_name, schema_type).merge(options)
     end
 
-    def create_schemas(base_schema, schema_class, schema_name, list)
-      if list.is_a?(Array)
-        list.each_with_index.map { |data, idx| create_schema(base_schema, schema_class, "#{idx}:#{schema_name}", data) }
-      elsif !list.nil?
-        base_schema.parsing_errors.add(schema_name, :incompatable)
-        nil
-      end
+    def add_association_class(base_schema_class, schema_name, schema_type, options)
+      options = ::Schema::Utils.association_options(schema_name, schema_type, options)
+      kls = ::Schema::Utils.create_schema_class(
+        base_schema_class,
+        schema_name,
+        options
+      )
+      add_association_defaults(kls, base_schema_class, schema_name)
+      add_association_dynamic_types(kls, options)
+      options
     end
 
-    def association_options(name, type, options)
-      options[:class_name] ||= 'Schema' + classify_name(type.to_s) + classify_name(name.to_s)
-      ::Schema::Model.default_attribute_options(name, type).merge(options)
+    def add_association_defaults(kls, base_schema_class, schema_name)
+      kls.include ::Schema::Associations::Base
+      kls.base_schema_class = base_schema_class
+      kls.schema_name = schema_name
     end
 
-    def add_association_class(base_schema_class, name, type, options, &block)
-      options = ::Schema::Utils.association_options(name, type, options)
-      ::Schema::Utils.create_schema_class(
-        base_schema_class,
-        options[:class_name],
-        options[:base_class] || Object,
-        &block
-      )
-      base_schema_class.add_value_to_class_method(:schema, name => options)
-      options
+    def add_association_dynamic_types(kls, options)
+      return if !options[:type_field] && !options[:external_type_field]
+
+      kls.include ::Schema::Associations::DynamicTypes
     end
   end
 end

data/lib/schema.rb

@@ -12,12 +12,18 @@ module Schema
 
   # Schema::Parsers are used to convert values into the correct data type
   module Parsers
+    autoload :Array, 'schema/parsers/array'
     autoload :Common, 'schema/parsers/common'
+    autoload :Hash, 'schema/parsers/hash'
+    autoload :Json, 'schema/parsers/json'
   end
 
   # Schema::Associations mange the associations between schema models
   module Associations
+    autoload :Base, 'schema/associations/base'
+    autoload :DynamicTypes, 'schema/associations/dynamic_types'
     autoload :HasMany, 'schema/associations/has_many'
     autoload :HasOne, 'schema/associations/has_one'
+    autoload :SchemaCreator, 'schema/associations/schema_creator'
   end
 end

data/lib/schema_validator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# SchemaValidator validates nested schemas
+class SchemaValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add(attribute, options.fetch(:message, :invalid)) if value && !value.valid?
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Doug Youch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-29 00:00:00.000000000 Z
+date: 2019-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inheritance-helper
@@ -33,13 +33,20 @@ files:
 - lib/schema.rb
 - lib/schema/array_headers.rb
 - lib/schema/arrays.rb
+- lib/schema/associations/base.rb
+- lib/schema/associations/dynamic_types.rb
 - lib/schema/associations/has_many.rb
 - lib/schema/associations/has_one.rb
+- lib/schema/associations/schema_creator.rb
 - lib/schema/csv_parser.rb
 - lib/schema/errors.rb
 - lib/schema/model.rb
+- lib/schema/parsers/array.rb
 - lib/schema/parsers/common.rb
+- lib/schema/parsers/hash.rb
+- lib/schema/parsers/json.rb
 - lib/schema/utils.rb
+- lib/schema_validator.rb
 homepage: https://github.com/dougyouch/schema
 licenses:
 - MIT
@@ -59,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Schema Model