schema-model 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dbf6656e98c4b1fb37ef7efcc4495c3fc56f39dcfd87c3e38f5caf4b3607670
-  data.tar.gz: 32583217eae45307d91662e063e447a8dcd7dbd709c60fa6757bb12a428ebfc7
+  metadata.gz: 3e515db757ac9610d21f55a046be3dd4b7c9ea089f6ee5db2d027db5857a0804
+  data.tar.gz: 734e46e76a917d70c0f170bea2b4a1bb4b784f43d00a64b7a5eb71d2d142ccfe
 SHA512:
-  metadata.gz: b23a4e93ca896b22d5bba542b5e530046cd74e0b4cab5e8b11c217efadb1f20bc87a6111bc048c7f8b62905838eee8060a27fc8847f2b4c2533b3321eb68fa7b
-  data.tar.gz: 0dc15eefe3675480d601ea8f4d04282598b6bcdd52d6b0d558d95978b1a70bfb7445c0b0c125ccdbc424806fde06c7d8dea6e3297a4ecfc55d35786425333695
+  metadata.gz: 8b068c0de3f58564b9a4ec9480cbf4792b8e865cb3cfbce67ee4f19c9410206bfff2921afa9693f634d335ade358df115f04a87e6668d6927a0b95d137fbaf51
+  data.tar.gz: 996e4ecd5e4b6ff4fc5be81ac349c5fde247781088a40907dfb368146578f57ec51c17947bdca1718289e93c7f35942c9ec4547583bb069497021402985b1dd7

data/lib/schema/array_headers.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::ArrayHeaders maps columns to schema attributes
+  module ArrayHeaders
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # adds methods to the class
+    module ClassMethods
+      def map_headers_to_attributes(headers, header_prefix = nil)
+        mapped_headers = {}
+        map_headers_to_fields(headers, mapped_headers, header_prefix)
+        map_headers_to_has_one_associations(headers, mapped_headers, header_prefix)
+        map_headers_to_has_many_associations(headers, mapped_headers)
+        mapped_headers
+      end
+
+      def get_unmapped_field_names(mapped_headers, header_prefix = nil)
+        get_field_names(mapped_headers, header_prefix, false)
+      end
+
+      def get_mapped_field_names(mapped_headers, header_prefix = nil)
+        get_field_names(mapped_headers, header_prefix, true)
+      end
+
+      def get_field_names(mapped_headers, header_prefix = nil, mapped = true)
+        fields = []
+        schema.each do |field_name, field_options|
+          case field_options[:type]
+          when :has_one,
+               :has_many
+            fields += get_model_field_names(field_name, field_options, mapped_headers, header_prefix, mapped)
+          else
+            next if skip_field?(field_name, field_options, mapped_headers, mapped)
+
+            fields << generate_field_name(field_name, field_options, header_prefix)
+          end
+        end
+        fields
+      end
+
+      private
+
+      def get_model_field_names(field_name, field_options, mapped_headers, header_prefix, mapped)
+        mapped_model = mapped_headers[field_name] || {}
+        const_get(field_options[:class_name]).get_field_names(
+          mapped_model,
+          header_prefix || field_options[:header_prefix],
+          mapped
+        )
+      end
+
+      def skip_field?(field_name, field_options, mapped_headers, mapped)
+        # skip alias fields
+        return true if field_options[:alias_of]
+
+        if mapped
+          mapped_headers[field_name].nil?
+        else
+          !mapped_headers[field_name].nil?
+        end
+      end
+
+      def generate_field_name(field_name, field_options, header_prefix)
+        field_name = field_options[:aliases].first if field_options[:aliases]
+        field_name = header_prefix + 'X' + field_name.to_s if header_prefix
+        field_name.to_s
+      end
+
+      def get_mapped_model(field_options, headers, header_prefix)
+        const_get(field_options[:class_name]).map_headers_to_attributes(headers, header_prefix)
+      end
+
+      def map_headers_to_has_one_associations(headers, mapped_headers, header_prefix)
+        schema.each do |field_name, field_options|
+          next unless field_options[:type] == :has_one
+
+          mapped_model = get_mapped_model(field_options, headers, header_prefix)
+          next if mapped_model.empty?
+
+          mapped_headers[field_name] = mapped_model
+        end
+        mapped_headers
+      end
+
+      def map_headers_to_has_many_associations(headers, mapped_headers)
+        schema.each do |field_name, field_options|
+          next unless field_options[:type] == :has_many
+          next unless field_options[:header_prefix]
+
+          mapped_model = get_mapped_model(field_options, headers, field_options[:header_prefix])
+          next if mapped_model.empty?
+
+          mapped_headers[field_name] = mapped_model
+        end
+        mapped_headers
+      end
+
+      def map_headers_to_fields(headers, mapped_headers, header_prefix)
+        schema.each do |field_name, field_options|
+          if header_prefix
+            unless (indexes = find_indexes_for_field(headers, field_options, header_prefix)).empty?
+              mapped_headers[field_options[:alias_of] || field_name] = { indexes: indexes }
+            end
+          elsif (index = headers.index(field_options[:key]))
+            mapped_headers[field_options[:alias_of] || field_name] = { index: index }
+          end
+        end
+        mapped_headers
+      end
+
+      def find_indexes_for_field(headers, field_options, header_prefix)
+        cnt = field_options[:starting_index] || 1
+        indexes = []
+        # finding all headers that look like Company1Name through CompanyXName
+        while (index = headers.index(header_prefix + cnt.to_s + field_options[:key]))
+          cnt += 1
+          indexes << index
+        end
+        indexes
+      end
+    end
+  end
+end

data/lib/schema/arrays.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::Arrays maps the array to a schema model
+  module Arrays
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # adds from_array method to the class
+    module ClassMethods
+      def from_array(array, mapped_headers)
+        new.update_attributes_with_array(array, mapped_headers)
+      end
+    end
+
+    def update_attributes_with_array(array, mapped_headers, offset = nil)
+      self.class.schema.each do |_, field_options|
+        next unless (mapped_field = mapped_headers[field_options[:name]])
+
+        if offset
+          next unless mapped_field[:indexes]
+          next unless (index = mapped_field[:indexes][offset])
+        else
+          next unless (index = mapped_field[:index])
+        end
+
+        public_send(
+          field_options[:setter],
+          array[index]
+        )
+      end
+
+      update_nested_schemas_from_array(array, mapped_headers, offset)
+
+      self
+    end
+
+    def update_nested_schemas_from_array(array, mapped_headers, current_offset = nil)
+      update_nested_has_one_associations_from_array(array, mapped_headers, current_offset)
+      update_nested_has_many_associations_from_array(array, mapped_headers)
+    end
+
+    def update_nested_has_one_associations_from_array(array, mapped_headers, current_offset = nil)
+      self.class.schema.each do |_, field_options|
+        next unless field_options[:type] == :has_one
+        next unless (mapped_model = mapped_headers[field_options[:name]])
+
+        instance_variable_set(
+          field_options[:instance_variable],
+          create_schema_with_array(field_options, array, mapped_model, current_offset)
+        )
+      end
+    end
+
+    def update_nested_has_many_associations_from_array(array, mapped_headers)
+      self.class.schema.each do |_, field_options|
+        next unless field_options[:type] == :has_many
+        next unless (mapped_model = mapped_headers[field_options[:name]])
+
+        size = largest_number_of_indexes_from_map(mapped_model)
+
+        instance_variable_set(
+          field_options[:instance_variable],
+          size.times.map do |offset|
+            create_schema_with_array(field_options, array, mapped_model, offset)
+          end
+        )
+      end
+    end
+
+    def create_schema_with_array(field_options, array, mapped_model, offset)
+      self.class.const_get(field_options[:class_name]).new.update_attributes_with_array(array, mapped_model, offset)
+    end
+
+    def largest_number_of_indexes_from_map(mapped_model)
+      size = 0
+      mapped_model.each do |_, info|
+        if info[:indexes]
+          size = info[:indexes].size if info[:indexes] && info[:indexes].size > size
+        else
+          new_size = largest_number_of_indexes_from_map(info)
+          size = new_size if new_size > size
+        end
+      end
+      size
+    end
+  end
+end

data/lib/schema/associations/has_many.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Schema
+  module Associations
+    # Schema::Associations::HasMany is used to create a list nested schema objects
+    module HasMany
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # no-doc
+      module ClassMethods
+        # rubocop:disable Naming/PredicateName
+        def has_many(name, options = {}, &block)
+          options = ::Schema::Utils.add_association_class(self, name, :has_many, options, &block)
+
+          class_eval(
+            <<~STR, __FILE__, __LINE__ + 1
+              def #{options[:getter]}
+                #{options[:instance_variable]}
+              end
+
+              def #{options[:setter]}(v)
+                if schemas = ::Schema::Utils.create_schemas(self, #{options[:class_name]}, #{name.inspect}, v)
+                  #{options[:instance_variable]} = schemas
+                end
+              end
+          STR
+          )
+
+          const_get(options[:class_name])
+        end
+        # rubocop:enable Naming/PredicateName
+      end
+    end
+  end
+end

data/lib/schema/associations/has_one.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Schema
+  module Associations
+    # Schema::Associations::HasOne is used to create a nested schema object
+    module HasOne
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # no-doc
+      module ClassMethods
+        # rubocop:disable Naming/PredicateName
+        def has_one(name, options = {}, &block)
+          options = ::Schema::Utils.add_association_class(self, name, :has_one, options, &block)
+
+          class_eval(
+            <<~STR, __FILE__, __LINE__ + 1
+              def #{options[:getter]}
+                #{options[:instance_variable]}
+              end
+
+              def #{options[:setter]}(v)
+                if schema = ::Schema::Utils.create_schema(self, #{options[:class_name]}, #{name.inspect}, v)
+                  #{options[:instance_variable]} = schema
+                end
+              end
+          STR
+          )
+
+          const_get(options[:class_name])
+        end
+        # rubocop:enable Naming/PredicateName
+      end
+    end
+  end
+end

data/lib/schema/csv_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Schema
+  # Schema::CSVParser is used to create schema models from a csv
+  class CSVParser
+    include Enumerable
+
+    def initialize(csv, schema_class, headers = nil)
+      @csv = csv
+      @schema_class = schema_class
+      @headers = headers || csv.shift
+      @mapped_headers = schema_class.map_headers_to_attributes(@headers)
+    end
+
+    def missing_fields(required_fields)
+      required_fields - get_mapped_headers(@mapped_headers)
+    end
+
+    def shift
+      return unless (row = @csv.shift)
+
+      @schema_class.from_array(row, @mapped_headers)
+    end
+
+    def each
+      while (schema = shift)
+        yield schema
+      end
+    end
+
+    def get_mapped_headers(mapped_headers)
+      indexed_headers = []
+      mapped_headers.each do |_, info|
+        if (index = info[:index])
+          indexed_headers << @headers[index]
+        elsif (indexes = info[:indexes])
+          indexed_headers += indexes.map { |i| @headers[i] }
+        else
+          indexed_headers += get_mapped_headers(info)
+        end
+      end
+      indexed_headers
+    end
+  end
+end

data/lib/schema/errors.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Schema
+  # Schema::Errors used internally for testing mainly, recommend using ActiveModel::Validations
   class Errors
     attr_reader :errors
 

data/lib/schema/model.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'inheritance-helper'
 
 module Schema
+  # Schema::Model adds schema building methods to a class
   module Model
-    def self.included base
+    def self.included(base)
       base.extend InheritanceHelper::Methods
       base.include Schema::Parsers::Common
       base.extend ClassMethods
@@ -14,11 +17,12 @@ module Schema
         name: name,
         type: type,
         getter: name.to_s.freeze,
-        setter: "#{name}=".freeze,
-        instance_variable: "@#{name}".freeze,
+        setter: "#{name}=",
+        instance_variable: "@#{name}"
       }
     end
 
+    # no-doc
     module ClassMethods
       def schema
         {}.freeze
@@ -30,36 +34,17 @@ module Schema
         }.freeze
       end
 
-      def attribute(name, type, options={})
-        if options.has_key?(:alias)
-          options[:aliases] = [options[:alias]]
-        end
+      def attribute(name, type, options = {})
+        options[:aliases] = [options[:alias]] if options.key?(:alias)
 
         options = ::Schema::Model.default_attribute_options(name, type)
-                    .merge(
-                      parser: "parse_#{type}".freeze
-                    ).merge(options)
+                                 .merge(
+                                   parser: "parse_#{type}"
+                                 ).merge(options)
 
         add_value_to_class_method(:schema, name => options)
-
-        class_eval(<<-STR
-def #{options[:getter]}
-  #{options[:instance_variable]}
-end
-
-def #{options[:setter]}(v)
-  #{options[:instance_variable]} = #{options[:parser]}(#{name.inspect}, parsing_errors, v)
-end
-STR
-        )
-
-        if options[:aliases]
-          options[:aliases].each do |alias_name|
-            add_value_to_class_method(:schema, alias_name.to_sym => options.merge(key: alias_name.to_s, alias_of: name))
-            alias_method(alias_name, options[:getter])
-            alias_method("#{alias_name}=", options[:setter])
-          end
-        end
+        add_attribute_methods(name, options)
+        add_aliases(name, options)
       end
 
       def from_hash(data)
@@ -73,20 +58,32 @@ STR
         include mod
       end
 
-      def schema_base_class=(kls)
-        config = schema_config.dup
-        config[:schema_base_class] = kls
-        redefine_class_method(:schema_config, config.freeze)
+      def add_attribute_methods(name, options)
+        class_eval(
+          <<~STR, __FILE__, __LINE__ + 1
+            def #{options[:getter]}
+              #{options[:instance_variable]}
+            end
+
+            def #{options[:setter]}(v)
+              #{options[:instance_variable]} = #{options[:parser]}(#{name.inspect}, parsing_errors, v)
+            end
+        STR
+        )
       end
 
-      def set_schema_base_class_to_superclass
-        self.schema_base_class = superclass
+      def add_aliases(name, options)
+        options[:aliases]&.each do |alias_name|
+          add_value_to_class_method(:schema, alias_name.to_sym => options.merge(key: alias_name.to_s, alias_of: name))
+          alias_method(alias_name, options[:getter])
+          alias_method("#{alias_name}=", options[:setter])
+        end
       end
     end
 
     def update_attributes(data)
       self.class.schema.each do |field_name, field_options|
-        next if ! data.has_key?(field_options[:key]) && ! data.has_key?(field_name)
+        next if !data.key?(field_options[:key]) && !data.key?(field_name)
 
         public_send(
           field_options[:setter],
@@ -97,13 +94,12 @@ STR
       self
     end
 
-    def as_json(opts={})
-      self.class.schema.inject({}) do |memo, (field_name, field_options)|
+    def as_json(opts = {})
+      self.class.schema.each_with_object({}) do |(field_name, field_options), memo|
         unless field_options[:alias_of]
           value = public_send(field_options[:getter])
-          memo[field_name] = value if ! value.nil? || opts[:include_nils]
+          memo[field_name] = value if !value.nil? || opts[:include_nils]
         end
-        memo
       end
     end
 

data/lib/schema/parsers/common.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 require 'time'
 
 module Schema
   module Parsers
+    # Schema::Parsers::Common are parser methods for basic types
     module Common
-      INTEGER_REGEX = /^(?:[1-9]\d*|0)$/
-      FLOAT_REGEX = /^(?:[1-9]\d*|0)(?:\.\d+)?$/
-      BOOLEAN_REGEX = /^(?:1|t|true|on|y|yes)$/i
+      INTEGER_REGEX = /^(?:[1-9]\d*|0)$/.freeze
+      FLOAT_REGEX = /^(?:[1-9]\d*|0)(?:\.\d+)?$/.freeze
+      BOOLEAN_REGEX = /^(?:1|t|true|on|y|yes)$/i.freeze
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def parse_integer(field_name, parsing_errors, value)
         case value
         when Integer
@@ -19,9 +23,7 @@ module Schema
             nil
           end
         when Float
-          if (value % 1) > 0.0
-            parsing_errors.add(field_name, :incompatable)
-          end
+          parsing_errors.add(field_name, :incompatable) if (value % 1) > 0.0
           value.to_i
         when nil
           nil
@@ -30,6 +32,7 @@ module Schema
           nil
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def parse_string(field_name, parsing_errors, value)
         case value
@@ -126,4 +129,3 @@ module Schema
     end
   end
 end
-

data/lib/schema/utils.rb

@@ -1,31 +1,31 @@
+# frozen_string_literal: true
+
 module Schema
+  # Schema::Utils is a collection of common utility methods used in this gem
   module Utils
-    extend self
+    module_function
 
-    def classify_name(prefix, name)
-      prefix + name.gsub(/[^\da-z_-]/, '').gsub(/(^.|[_|-].)/) { |m| m[-1].upcase }
+    def classify_name(name)
+      name.gsub(/[^\da-z_-]/, '').gsub(/(^.|[_|-].)/) { |m| m[-1].upcase }
     end
 
-    def create_schema_class(base_schema_class, class_name_prefix, name, &block)
-      schema_config = base_schema_class.schema_config
-      kls = Class.new(schema_config[:schema_base_class] || Object) do
-        include ::Schema::Model
-      end
-
-      class_name = classify_name(class_name_prefix, name.to_s)
+    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)
 
-      # make sure additional schema classes use this base class
-      kls.schema_base_class = schema_config[:schema_base_class] if schema_config[:schema_base_class]
+      include_schema_modules(kls, base_schema_class.schema_config) if base_class == Object
+
+      kls.class_eval(&block) if block
 
+      kls
+    end
+
+    def include_schema_modules(kls, schema_config)
+      kls.include ::Schema::Model
       schema_config[:schema_includes].each do |mod|
         kls.schema_include(mod)
       end
-
-      kls.class_eval(&block)
-
-      return kls, class_name
     end
 
     def create_schema(base_schema, schema_class, schema_name, data)
@@ -33,23 +33,36 @@ module Schema
         schema = schema_class.from_hash(data)
         base_schema.parsing_errors.add(schema_name, :invalid) unless schema.parsing_errors.empty?
         schema
-      elsif ! data.nil?
+      elsif !data.nil?
         base_schema.parsing_errors.add(schema_name, :incompatable)
         nil
-      else
-        nil
       end
     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?
+      elsif !list.nil?
         base_schema.parsing_errors.add(schema_name, :incompatable)
         nil
-      else
-        nil
       end
     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)
+    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
+    end
   end
 end

data/lib/schema.rb

@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
+# Schema is a series of tools for transforming data into models
 module Schema
+  autoload :ArrayHeaders, 'schema/array_headers'
+  autoload :Arrays, 'schema/arrays'
+  autoload :CSVParser, 'schema/csv_parser'
   autoload :Errors, 'schema/errors'
+  autoload :CSVParser, 'schema/csv_parser'
   autoload :Model, 'schema/model'
   autoload :Utils, 'schema/utils'
 
+  # Schema::Parsers are used to convert values into the correct data type
   module Parsers
     autoload :Common, 'schema/parsers/common'
   end
 
-  module Relation
-    autoload :HasMany, 'schema/relation/has_many'
-    autoload :HasOne, 'schema/relation/has_one'
+  # Schema::Associations mange the associations between schema models
+  module Associations
+    autoload :HasMany, 'schema/associations/has_many'
+    autoload :HasOne, 'schema/associations/has_one'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema-model
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Doug Youch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-21 00:00:00.000000000 Z
+date: 2019-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inheritance-helper
@@ -31,14 +31,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/schema.rb
+- lib/schema/array_headers.rb
+- lib/schema/arrays.rb
+- lib/schema/associations/has_many.rb
+- lib/schema/associations/has_one.rb
+- lib/schema/csv_parser.rb
 - lib/schema/errors.rb
 - lib/schema/model.rb
 - lib/schema/parsers/common.rb
-- lib/schema/relation/has_many.rb
-- lib/schema/relation/has_one.rb
 - lib/schema/utils.rb
 homepage: https://github.com/dougyouch/schema
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []

data/lib/schema/relation/has_many.rb

@@ -1,37 +0,0 @@
-module Schema
-  module Relation
-    module HasMany
-      def self.included base
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def has_many(name, options={}, &block)
-          _, class_name = ::Schema::Utils.create_schema_class(self, 'SchemaHasMany', name, &block)
-
-          options = ::Schema::Model.default_attribute_options(name, :has_many)
-                      .merge(
-                        class_name: class_name
-                      ).merge(options)
-
-          add_value_to_class_method(:schema, name => options)
-
-          class_eval(<<-STR
-def #{options[:getter]}
-  #{options[:instance_variable]}
-end
-
-def #{options[:setter]}(v)
-  if schemas = ::Schema::Utils.create_schemas(self, #{options[:class_name]}, #{name.inspect}, v)
-    #{options[:instance_variable]} = schemas
-  end
-end
-STR
-                    )
-
-          const_get(class_name)
-        end
-      end
-    end
-  end
-end

data/lib/schema/relation/has_one.rb

@@ -1,37 +0,0 @@
-module Schema
-  module Relation
-    module HasOne
-      def self.included base
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def has_one(name, options={}, &block)
-          _, class_name = ::Schema::Utils.create_schema_class(self, 'SchemaHasOne', name, &block)
-
-          options = ::Schema::Model.default_attribute_options(name, :has_one)
-                      .merge(
-                        class_name: class_name
-                      ).merge(options)
-
-          add_value_to_class_method(:schema, name => options)
-
-          class_eval(<<-STR
-def #{options[:getter]}
-  #{options[:instance_variable]}
-end
-
-def #{options[:setter]}(v)
-  if schema = ::Schema::Utils.create_schema(self, #{options[:class_name]}, #{name.inspect}, v)
-    #{options[:instance_variable]} = schema
-  end
-end
-STR
-                    )
-
-          const_get(class_name)
-        end
-      end
-    end
-  end
-end