schema-model 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3dbf6656e98c4b1fb37ef7efcc4495c3fc56f39dcfd87c3e38f5caf4b3607670
+  data.tar.gz: 32583217eae45307d91662e063e447a8dcd7dbd709c60fa6757bb12a428ebfc7
+SHA512:
+  metadata.gz: b23a4e93ca896b22d5bba542b5e530046cd74e0b4cab5e8b11c217efadb1f20bc87a6111bc048c7f8b62905838eee8060a27fc8847f2b4c2533b3321eb68fa7b
+  data.tar.gz: 0dc15eefe3675480d601ea8f4d04282598b6bcdd52d6b0d558d95978b1a70bfb7445c0b0c125ccdbc424806fde06c7d8dea6e3297a4ecfc55d35786425333695

data/lib/schema/errors.rb

@@ -0,0 +1,25 @@
+module Schema
+  class Errors
+    attr_reader :errors
+
+    EMPTY_ARRAY = [].freeze
+
+    def initialize
+      @errors = {}
+    end
+
+    def [](name)
+      @errors[name] || EMPTY_ARRAY
+    end
+
+    def add(name, error)
+      @errors[name] ||= []
+      @errors[name] << error
+    end
+    alias []= add
+
+    def empty?
+      @errors.empty?
+    end
+  end
+end

data/lib/schema/model.rb

@@ -0,0 +1,119 @@
+require 'inheritance-helper'
+
+module Schema
+  module Model
+    def self.included base
+      base.extend InheritanceHelper::Methods
+      base.include Schema::Parsers::Common
+      base.extend ClassMethods
+    end
+
+    def self.default_attribute_options(name, type)
+      {
+        key: name.to_s.freeze,
+        name: name,
+        type: type,
+        getter: name.to_s.freeze,
+        setter: "#{name}=".freeze,
+        instance_variable: "@#{name}".freeze,
+      }
+    end
+
+    module ClassMethods
+      def schema
+        {}.freeze
+      end
+
+      def schema_config
+        {
+          schema_includes: []
+        }.freeze
+      end
+
+      def attribute(name, type, options={})
+        if options.has_key?(:alias)
+          options[:aliases] = [options[:alias]]
+        end
+
+        options = ::Schema::Model.default_attribute_options(name, type)
+                    .merge(
+                      parser: "parse_#{type}".freeze
+                    ).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
+      end
+
+      def from_hash(data)
+        new.update_attributes(data)
+      end
+
+      def schema_include(mod)
+        config = schema_config.dup
+        config[:schema_includes] = config[:schema_includes] + [mod]
+        redefine_class_method(:schema_config, config.freeze)
+        include mod
+      end
+
+      def schema_base_class=(kls)
+        config = schema_config.dup
+        config[:schema_base_class] = kls
+        redefine_class_method(:schema_config, config.freeze)
+      end
+
+      def set_schema_base_class_to_superclass
+        self.schema_base_class = superclass
+      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)
+
+        public_send(
+          field_options[:setter],
+          data[field_options[:key]] || data[field_name.to_sym]
+        )
+      end
+
+      self
+    end
+
+    def as_json(opts={})
+      self.class.schema.inject({}) do |memo, (field_name, field_options)|
+        unless field_options[:alias_of]
+          value = public_send(field_options[:getter])
+          memo[field_name] = value if ! value.nil? || opts[:include_nils]
+        end
+        memo
+      end
+    end
+
+    def to_hash
+      as_json(include_nils: true)
+    end
+    alias to_h to_hash
+
+    def parsing_errors
+      @parsing_errors ||= ::Schema::Errors.new
+    end
+  end
+end

data/lib/schema/parsers/common.rb

@@ -0,0 +1,129 @@
+require 'time'
+
+module Schema
+  module Parsers
+    module Common
+      INTEGER_REGEX = /^(?:[1-9]\d*|0)$/
+      FLOAT_REGEX = /^(?:[1-9]\d*|0)(?:\.\d+)?$/
+      BOOLEAN_REGEX = /^(?:1|t|true|on|y|yes)$/i
+
+      def parse_integer(field_name, parsing_errors, value)
+        case value
+        when Integer
+          value
+        when String
+          if INTEGER_REGEX.match?(value)
+            Integer(value)
+          else
+            parsing_errors.add(field_name, :invalid)
+            nil
+          end
+        when Float
+          if (value % 1) > 0.0
+            parsing_errors.add(field_name, :incompatable)
+          end
+          value.to_i
+        when nil
+          nil
+        else
+          parsing_errors.add(field_name, :unhandled_type)
+          nil
+        end
+      end
+
+      def parse_string(field_name, parsing_errors, value)
+        case value
+        when String
+          value
+        when Hash, Array
+          parsing_errors.add(field_name, :incompatable)
+          nil
+        when nil
+          nil
+        else
+          String(value)
+        end
+      end
+
+      def parse_float(field_name, parsing_errors, value)
+        case value
+        when Float
+          value
+        when Integer
+          value.to_f
+        when String
+          if FLOAT_REGEX.match?(value)
+            Float(value)
+          else
+            parsing_errors.add(field_name, :invalid)
+            nil
+          end
+        when nil
+          nil
+        else
+          parsing_errors.add(field_name, :unhandled_type)
+          nil
+        end
+      end
+
+      def parse_time(field_name, parsing_errors, value)
+        case value
+        when Time
+          value
+        when Date
+          value.to_time
+        when String
+          begin
+            Time.xmlschema(value)
+          rescue ArgumentError
+            parsing_errors.add(field_name, :invalid)
+            nil
+          end
+        when nil
+          nil
+        else
+          parsing_errors.add(field_name, :unhandled_type)
+          nil
+        end
+      end
+
+      def parse_date(field_name, parsing_errors, value)
+        case value
+        when Date
+          value
+        when Time
+          value.to_date
+        when String
+          begin
+            Date.parse(value)
+          rescue ArgumentError
+            parsing_errors.add(field_name, :invalid)
+            nil
+          end
+        when nil
+          nil
+        else
+          parsing_errors.add(field_name, :unhandled_type)
+          nil
+        end
+      end
+
+      def parse_boolean(field_name, parsing_errors, value)
+        case value
+        when TrueClass, FalseClass
+          value
+        when Integer, Float
+          value != 0
+        when String
+          BOOLEAN_REGEX.match?(value)
+        when nil
+          nil
+        else
+          parsing_errors.add(field_name, :unhandled_type)
+          nil
+        end
+      end
+    end
+  end
+end
+

data/lib/schema/relation/has_many.rb

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,37 @@
+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

data/lib/schema/utils.rb

@@ -0,0 +1,55 @@
+module Schema
+  module Utils
+    extend self
+
+    def classify_name(prefix, name)
+      prefix + 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)
+      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]
+
+      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)
+      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
+      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?
+        base_schema.parsing_errors.add(schema_name, :incompatable)
+        nil
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/schema.rb

@@ -0,0 +1,14 @@
+module Schema
+  autoload :Errors, 'schema/errors'
+  autoload :Model, 'schema/model'
+  autoload :Utils, 'schema/utils'
+
+  module Parsers
+    autoload :Common, 'schema/parsers/common'
+  end
+
+  module Relation
+    autoload :HasMany, 'schema/relation/has_many'
+    autoload :HasOne, 'schema/relation/has_one'
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: schema-model
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doug Youch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: inheritance-helper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy way to create models from payloads
+email: dougyouch@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/schema.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: []
+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: Schema Model
+test_files: []