structish 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8edee95c617e99bb439af1073b4b79697d301c487106320c2b075b2246a5bab
+  data.tar.gz: eb452debefdf9b4d6348bb11e6b5c812bdffbe97272d33651be399a4b7d12e4b
+SHA512:
+  metadata.gz: f3ebf97ad136e4f175a5a4fbfb0bb06a8a31d3b63e01df5db44edbee439f8f43eacf4805fd262cb05cc20b51d884d5b6864b4e8b794f3d9c9a3c017b2c21c21d
+  data.tar.gz: 633f3b2c776edc67e49bc8084683e4eaf5e628c1e434631f1e2950636d941b1849c3987dd3e2a5854ff492a98b970c5e932a2b9e3e53447748515e1931a06221

data/.github/workflows/structable-rspec.yml

@@ -0,0 +1,26 @@
+env:
+  RUBY_VERSION: '2.6.6'
+
+name: Tests
+on: [push, pull_request]
+jobs:
+  rspec-test:
+    name: Rspec
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: ${{ env.RUBY_VERSION }}
+      - name: Install dependencies
+        run: |
+          gem install bundler
+          bundler install
+      - name: Run tests
+        run: bundler exec rspec
+      - name: Upload coverage results
+        uses: actions/upload-artifact@master
+        if: always()
+        with:
+          name: coverage-report
+          path: coverage

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/out/
+/Gemfile.lock

data/Gemfile

@@ -0,0 +1,15 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+group :test do
+  gem "rspec"
+  gem "simplecov", :require => false
+end
+
+group :test, :development do
+  gem "pry"
+  gem "pry-byebug"
+end

data/README.md

@@ -0,0 +1,257 @@
+# Structish
+
+Structish objects are objects which maintain all the properties and methods of their parent classes, but add customisable validations, defaults, and mutations.
+
+The concept came about when trying to create a data structure which could provide flexible validation for entries in a `Hash`; serve as a base class for inheritance so that further functions could be defined; and keep all the functionality of standard `Hash` objects.
+
+Existing gems did not quite satisfy the requirements. [Dry::Struct](https://github.com/dry-rb/dry-struct) objects were found to be too rigid for the use cases, in that they do not allow additional keys to be defined other than the explicitly defined attributes. Furthermore, the biggest drawback is that `Dry::Struct` objects *are not hashes*. We wanted to keep all the functionality of hashes so that they would be both intuitive to use and highly flexible.
+
+Other existing solutions generally fall into the `schema` pattern. Some type of schema is defined, and a method is added to the `Hash` object which allows one to validate against the schema. We still wanted a class-based inheritance system similar to `Dry::Struct`, in order to give more meaning to the objects we were creating. This in turn meant that continuous hash creation and validation would become tiresome and create less readable code.
+
+So to summarise, the problem we were trying to solve needed a data structure that:
+- Should be *rigid* enough to allow us to validate the data stored within the structure
+- Should be *flexible* enough to allow us to define our own validations and methods, as well as allow for more than just the validated data to exist within the object
+- Should be *functional* enough to still be used as a Hash (or other underlying base object)
+
+The solution is a data structure which includes the functionality of `Hashes` (or `Arrays`), flexibility of `Schema` validations, and rigidity of `Structs` - the `Structish` object. When a class inherits from `Structish::Hash` or `Structish::Array`, it gains the ability to `validate` entries in the object. Properties which can be validated include the class type, value, and presence. Custom validations can also be added by creating a class which inherits from the `Structish::Validation` class and overriding the `validate` method.
+
+Besides validating the constructor object, `Structish` objects also dynamically create accessor methods for the validated keys. So if we have `validate :foo` on the class, and an instance `obj` of that class, then we will have `obj.foo == constructor_hash[:foo]`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'structish'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install structish
+
+## Usage
+
+### Creating Structish hashes and arrays
+
+#### Class validation
+
+There are two existing `Structish` classes: `Structish::Hash` and `Structish::Array`. Both follow similar usage. The simplest example is a hash which validates the classes of the keys:
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float
+end
+
+# Validations
+MyStructishHash.new({}) -> "Structish::ValidationError: Required value foo not present"
+MyStructishHash.new({foo: "bar"}) -> "Structish::ValidationError: Class mismatch for foo -> String. Should be a Float"
+MyStructishHash.new({foo: 1.0}) -> {:foo=>1.0}
+MyStructishHash.new({foo: 1.0, bar: 2.0}) -> {:foo=>1.0, :bar=>2.0}
+
+# Dynamic method creation
+MyStructishHash.new({foo: 1.0, bar: 2.0}).foo -> 1.0
+MyStructishHash.new({foo: 1.0, bar: 2.0})[:foo] -> 1.0
+MyStructishHash.new({foo: 1.0, bar: 2.0}).bar -> "NoMethodError: undefined method `bar' for {:foo=>1.0, :bar=>2.0}:MyStructishHash"
+MyStructishHash.new({foo: 1.0, bar: 2.0})[:bar] -> 1.0
+
+# Inherited functionality
+MyStructishHash.new({foo: 1.0}).merge(bar: 2.0) -> {:foo=>1.0, :bar=>2.0}
+MyStructishHash.new({foo: 1.0}).merge(bar: 2.0).class -> MyStructishHash
+```
+
+From the above example we can see that the validation is checking two properties - presence and class. Since the `:foo` key is validated, it is by default required to create the object. If the validation conditions are not met, we get clear errors telling us what is failing the validation. This is how we introduce rigidity and struct-like behaviour into the object.
+
+We can also see that `Structish` obects are not restrictive, since any keys can be added to the constructor hash, but only the specified keys are validated. This is where the flexibility comes in.
+
+The example also shows how the dynamic accessor methods are assigned - although in the last two lines we are defining `{foo: 1.0, bar: 2.0}` as the constructor, we only get `.foo` as an accessor method. This is by design - the idea is that the validated entries will in general be expected - any other entries are extra details, and not necessary to fully describe the object.
+
+Finally we can see how `Structish` objects inherit the functionality from the parent class. Standard Ruby hash functions can be used freely with the new Structish objects, and (where applicable) we will get a new object of the same type as the object on which we are performing the operation. This is where the deep functionality comes in.
+
+Note that the required class can be an array, and will pass if the value is an instance of one of the classes in the array.
+
+When the required class is a `Array`, we can define a further requirement using the `of:` keyword to validate each element of the value array.
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, ::Array, of: Float
+end
+
+MyStructishHash.new({foo: 1.0}) -> "Structish::ValidationError: Class mismatch for foo. All values should be of type Float"
+MyStructishHash.new({foo: [1.0, "bar"]}) -> "Structish::ValidationError: Class mismatch for foo. All values should be of type Float"
+MyStructishHash.new({foo: [1.0, 2.0]}) -> {:foo=>[1.0, 2.0]}
+```
+
+#### Accessor aliasing
+
+Instead of having the accessor methods be automatically named, we can define an alias for the method.
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, alias_to: :aliased_method
+end
+
+MyStructishHash.new({foo: 1.0}).aliased_method -> 1.0
+```
+
+#### Optional attributes
+
+`Structish` object attributes can be flagged as optional. The usage should be fairly intuitive:
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, optional: true
+end
+
+MyStructishHash.new({}) -> {:foo=>nil}
+MyStructishHash.new({}).foo -> nil
+```
+
+As shown above, when an attribute is missing from the constructor hash, the key gets added to the `Structish` object, and the accessor method is defined as usual.
+
+#### Default values
+
+When an attribute is flagged as optional, a default value can be assigned to the key. Assigning a default to a non-optional (required) key does nothing - instantiating the object without a required key will still raise an error, regardless of whether a default is defined.
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, optional: true, default: 1.0
+end
+
+MyStructishHash.new({}) -> {:foo=>1.0}
+MyStructishHash.new({}).foo -> 1.0
+```
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, default: 1.0
+end
+
+MyStructishHash.new({}) -> "Structish::ValidationError: Required value foo not present"
+```
+
+A useful feature of the default option is that you can map the value from one key to the default value:
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float
+    validate :bar, Float, optional: true, default: assign(:foo)
+end
+
+MyStructishHash.new({foo: 1.0}) -> {:foo=>1.0, :bar=>1.0}
+MyStructishHash.new({foo: 1.0}).foo -> 1.0
+MyStructishHash.new({foo: 1.0}).bar -> 1.0
+```
+
+#### Type casting
+
+`Structish` validations support forced type-casting. This occurs *before* data type validation, which means that we can potentially pass in an object which is not of the required class, but force type casting so that it passes the validation:
+
+```ruby
+class StructishHashWithoutCasting < Structish::Hash
+    validate :foo, Float
+end
+
+StructishHashWithoutCasting.new({foo: "1"}) -> "Structish::ValidationError: Class mismatch for foo -> String. Should be a Float"
+
+class StructishHashWithCasting < Structish::Hash
+    validate :foo, Float, cast: true
+end
+
+StructishHashWithCasting.new({foo: "1"}) -> {:foo=>1.0}
+StructishHashWithCasting.new({foo: "1"}).foo -> 1.0
+StructishHashWithCasting.new({foo: {}}) -> "NoMethodError: undefined method `to_f' for {}:Hash"
+```
+
+For common Ruby types (specifically `String, Float, Integer, Symbol, Array, Hash`) this uses the relevant `to_x` function, namely `to_s, to_f, to_i, to_sym, to_a, to_h` respectively. For any custom classes, this will call `Klass.new(value)`.
+
+#### Specific values
+
+`Structish` objects are not limited to validating classes and presence - they can also validate specific values, using the `one_of:` key:
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, one_of: [0.0, 1.0, 2.0]
+end
+
+MyStructishHash.new({foo: 1.0}) -> {:foo=>1.0}
+MyStructishHash.new({foo: 5.0}) -> "Structish::ValidationError: Value not one of 0.0, 1.0, 2.0"
+```
+
+#### Global validations
+
+`Structable` objects allow for validations at the global level, i.e. validations that apply to every value in the object. Global validations are defined almost identically to individual validations, with the exception that they do not specify the key:
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate_all Float
+end
+
+MyStructishHash.new({foo: 1.0, bar: 2.0}) -> {:foo=>1.0, :bar=>2.0}
+MyStructishHash.new({foo: 1.0, bar: "2.0"}) -> "Structish::ValidationError: Class mismatch for bar -> String. Should be a Float"
+```
+
+The `validate_all` function can perform all the same validations as the individual validations, and can also be mixed and matched with individual validations.
+
+#### Accessor block mutations
+
+A nifty feature of `Structish` object is, within the validation, we can define a block which mutates the output of the dynamic accessor method:
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, do |num|
+        num * 2
+    end
+end
+
+MyStructishHash.new(validated_key: 5.0)[:validated_key] -> 5.0
+MyStructishHash.new(validated_key: 5.0).validated_key -> 10.0
+```
+
+It is important to realize that the mutation *only applies to the dynamically created accessor method*. We still want to allow access to the original data - the idea here is that the accessor method can perform any operations on the original value, while the hash version stores the original data.
+
+#### Function delegations
+
+Along with dynamically created accessor methods, we can create delegations, so that calling a function on the `Structish` object returns the result of calling it on the specified attribute.
+
+```ruby
+class MyStructishHash < Structish::Hash
+    validate :foo, String
+
+    delegate :downcase, :foo
+    delegate :upcase, :foo
+end
+
+MyStructishHash.new(validated_key: "HeLlo").downcase -> "hello"
+MyStructishHash.new(validated_key: "HeLlo").upcase -> "HELLO"
+```
+
+### Custom validations
+
+We can define custom validations, which may contain any logic that returns a truthy or falsey value. The validation class must inherit from `Structish::Validation` and must override the `validate` method. The accessible attribute to the class are `value` and `conditions` - `value` is the value detected for that key, and `conditions` are the conditions defined in the validation on the class.
+
+```ruby
+class PositiveNumber < Structish::Validation
+    def validate
+        value > 0
+    end
+end
+
+class MyStructishHash < Structish::Hash
+    validate :foo, Float, validation: PositiveNumber
+end
+
+MyStructishHash.new({foo: 0.0}) -> "Structish::ValidationError: Custom validation PositiveNumberStructishValidation not met"
+MyStructishHash.new({foo: 1.0}) -> {:foo=>1.0}
+```
+
+### Custom Structish data types
+
+There are four custom 'classes' available for validation:
+- `Structish::Number` passes for `Integer` or `Float`
+- `Structish::Boolean` passes for `TrueClass` or `FalseClass`
+- `Structish::Primitive` passes for `TrueClass`, `FalseClass`, `String`, `Float`, or `Integer`
+- `Structish::Any` passes for any class
+
+Although these are used like classes, they are in fact constants in the `Structish` which are given values of an array of the relevant classes (or `nil` in the case of `Structish::Any`). This is for simplicity, since the standard validations can accept arrays of classes.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "structish"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/structish.rb

@@ -0,0 +1,27 @@
+
+require 'active_support/core_ext/hash'
+
+require "structish/version"
+require "structish_object_extensions"
+require "structish/validation_error"
+require "structish/validation"
+require "structish/validations"
+require "structish/hash"
+require "structish/array"
+
+module Structish
+  Any = nil
+  Boolean = [TrueClass, FalseClass].freeze
+  Number = [Integer, Float].freeze
+  Primitive = [String, Float, Integer, TrueClass, FalseClass, Symbol].freeze
+
+  CAST_METHODS = {
+    "String" => :to_s,
+    "Float" => :to_f,
+    "Integer" => :to_i,
+    "Hash" => :to_h,
+    "Symbol" => :to_sym,
+    "Array" => :to_a
+  }.freeze
+
+end

data/lib/structish/array.rb

@@ -0,0 +1,18 @@
+module Structish
+  class Array < ::Array
+
+    include Structish::Validations
+
+    def initialize(constructor)
+      raise(ArgumentError, "Only array-like objects can be used as constructors for Structish::Array") unless constructor.class <= ::Array
+      validate_structish(constructor)
+      super(constructor)
+    end
+
+    def <<(entry)
+      super(entry)
+      validate_structish(self)
+    end
+
+  end
+end

data/lib/structish/hash.rb

@@ -0,0 +1,51 @@
+module Structish
+  class Hash < ::Hash
+
+    include Structish::Validations
+
+    def initialize(raw_constructor = {})
+      raise(ArgumentError, "Only hash-like objects can be used as constructors for Structish::Hash") unless raw_constructor.respond_to?(:to_hash)
+
+      constructor = self.class.symbolize? ? raw_constructor.symbolize_keys : raw_constructor
+      hash = constructor.to_h
+      validate_structish(hash)
+      super()
+      update(hash)
+      self.default = hash.default if hash.default
+      self.default_proc = hash.default_proc if hash.default_proc
+    end
+
+    def merge(other)
+      self.class.new(to_h.merge(other))
+    end
+
+    def merge!(other)
+      super(other)
+      validate_structish(self)
+    end
+
+    def except(*except_keys)
+      self.class.new(to_h.except(*except_keys))
+    end
+
+    def except!(*except_keys)
+      super(*except_keys)
+      validate_structish(self)
+    end
+
+    def compact
+      self.class.new(to_h.compact)
+    end
+
+    protected
+
+    def self.symbolize(sym)
+      @symbolize = sym
+    end
+
+    def self.symbolize?
+      @symbolize
+    end
+
+  end
+end

data/lib/structish/validation.rb

@@ -0,0 +1,16 @@
+module Structish
+  class Validation
+
+    attr_reader :value, :conditions, :constructor
+
+    def initialize(value, conditions, constructor)
+      @value = value
+      @conditions = conditions
+      @constructor = constructor
+    end
+
+    def validate
+      raise(NotImplementedError, "Validation conditions function must be defined")
+    end
+  end
+end

data/lib/structish/validation_error.rb

@@ -0,0 +1,8 @@
+module Structish
+  class ValidationError < RuntimeError
+    def initialize(message, klass)
+      super("#{message} in class #{klass.to_s}")
+      set_backtrace(caller)
+    end
+  end
+end

data/lib/structish/validations.rb

@@ -0,0 +1,230 @@
+module Structish
+  module Validations
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+
+      def validate_structish(constructor)
+        validate_key_restriction(constructor)
+        apply_defaults(constructor)
+        cast_values(constructor)
+        validate_constructor(constructor)
+        define_accessor_methods(constructor)
+        define_delegated_methods
+      end
+
+      def define_delegated_methods
+        self.class.delegations.each do |function, object|
+          define_singleton_method(function.to_s) { self.send(object.to_sym)&.send(function.to_sym) }
+        end
+      end
+
+      def validate_key_restriction(constructor)
+        if self.class.restrict?
+          allowed_keys = validations.map { |attribute| attribute[:key] }
+          valid = (constructor.keys - allowed_keys).empty?
+          raise(Structish::ValidationError.new("Keys are restricted to #{allowed_keys.join(", ")}", self.class)) unless valid
+        end
+      end
+
+      def apply_defaults(constructor)
+        validations.select { |v| v[:optional] }.each do |attribute|
+          key = attribute[:key]
+          default_value = if attribute[:default].is_a?(::Array) && attribute[:default].first == :other_attribute
+            constructor[attribute[:default][1]]
+          else
+            attribute[:default]
+          end
+          constructor[key] = default_value if constructor[key].nil?
+        end
+      end
+
+      def cast_values(constructor)
+        (validations + global_attributes_for(constructor)).each do |attribute|
+          key = attribute[:key]
+          if attribute[:cast] && constructor[key]
+            if attribute[:klass] == ::Array && attribute[:of]
+              constructor[key] = constructor[key].map { |v| cast_single(v, attribute[:of]) }
+            else
+              constructor[key] = cast_single(constructor[key], attribute[:klass])
+            end
+          end
+        end
+      end
+
+      def cast_single(value, klass)
+        if value.is_a?(klass)
+          value
+        else
+          if cast_method = Structish::CAST_METHODS[klass.to_s]
+            value.send(cast_method)
+          else
+            klass.new(value)
+          end
+        end
+      end
+  
+      def define_accessor_methods(constructor)
+        validations.each do |attribute|
+          if accessor = attribute[:accessor]
+            value = attribute[:proc] ? attribute[:proc].call(constructor[attribute[:key]]) : constructor[attribute[:key]]
+            instance_variable_set "@#{accessor}", value
+          end
+        end
+      end
+  
+      def validate_constructor(constructor)
+        (validations + global_attributes_for(constructor)).each do |attribute|
+          value = constructor[attribute[:key]]
+          if attribute[:optional] && value.nil?
+            true
+          else
+            validate_presence(attribute, value)
+            validate_class(attribute, value)
+            validate_one_of(attribute, value)
+            validate_custom(attribute, value, constructor)
+          end
+        end
+      end
+
+      def global_attributes_for(constructor)
+        global_attributes_hash[constructor] = begin
+          constructor_keys = constructor.keys
+          global_validations.each_with_object([]) do |validation, arr|
+            constructor_keys.each { |key| arr << validation.merge(key: key) }
+          end
+        end
+      end
+
+      def validate_presence(attribute, value)
+        raise(Structish::ValidationError.new("Required value #{attribute[:key]} not present", self.class)) unless !value.nil?
+      end
+  
+      def validate_class(attribute, value)
+        if attribute[:klass].nil?
+          return
+        elsif attribute[:of]
+          valid = if attribute[:klass] <= ::Array
+            value.class <= ::Array && value.all? { |v| v.class <= attribute[:of] }
+          elsif attribute[:klass] <= ::Hash
+            value.class <= ::Hash && value.values.all? { |v| v.class <= attribute[:of] }
+          end
+          raise(Structish::ValidationError.new("Class mismatch for #{attribute[:key]}. All values should be of type #{attribute[:of].to_s}", self.class)) unless valid
+        else
+          valid_klasses = [attribute[:klass]].flatten.compact
+          valid = valid_klasses.any? { |klass| value.class <= klass }
+          raise(Structish::ValidationError.new("Class mismatch for #{attribute[:key]} -> #{value.class}. Should be a #{valid_klasses.join(", ")}", self.class)) unless valid
+        end
+      end
+
+      def validate_one_of(attribute, value)
+        valid = attribute[:one_of] ? attribute[:one_of].include?(value) : true
+        raise(Structish::ValidationError.new("Value not one of #{attribute[:one_of].join(", ")}", self.class)) unless valid
+      end
+  
+      def validate_custom(attribute, value, constructor)
+        valid = attribute[:validation] ? attribute[:validation].new(value, attribute, constructor).validate : true
+        raise(Structish::ValidationError.new("Custom validation #{attribute[:validation].to_s} not met", self.class)) unless valid
+      end
+
+      def []=(key, value)
+        super(key, value)
+        validate_structish(self)
+      end
+
+      def global_attributes_hash
+        @global_attributes_hash ||= {}
+      end
+
+      def validations
+        @validations ||= self.class.attributes + parent_attributes(self.class)
+      end
+
+      def global_validations
+        @global_validations ||= self.class.global_validations + parent_global_validations(self.class)
+      end
+
+      def parent_attributes(klass)
+        if klass.superclass.respond_to?(:structish?) && klass.superclass.structish?
+          klass.superclass.attributes + parent_attributes(klass.superclass)
+        end || []
+      end
+
+      def parent_global_validations(klass)
+        if klass.superclass.respond_to?(:structish?) && klass.superclass.structish?
+          klass.superclass.global_validations + parent_global_validations(klass.superclass)
+        end || []
+      end
+
+    end
+
+    module ClassMethods
+
+      def structish?
+        true
+      end
+
+      def delegate(function, object)
+        delegations << [function, object]
+      end
+
+      def assign(key)
+        [:other_attribute, key]
+      end
+
+      def restrict_attributes
+        @restrict_attributes = true
+      end
+
+      def validate(key, klass = nil, kwargs = {}, &block)
+        accessor_name = kwargs[:alias_to] ? kwargs[:alias_to] : key
+        accessor = accessor_name.to_s if (accessor_name.is_a?(String) || accessor_name.is_a?(Symbol))
+        attr_reader(accessor) if accessor
+        attribute_array = kwargs[:optional] ? optional_attributes : required_attributes
+        attribute_array << attribute_hash(key, klass, kwargs.merge(accessor: accessor), block)
+      end
+
+      def validate_all(klass = nil, kwargs = {}, &block)
+        global_validations << attribute_hash(nil, klass, kwargs, block)
+      end
+
+      def attribute_hash(key, klass = nil, kwargs = {}, block)
+        {
+          key: key,
+          klass: klass,
+          proc: block,
+        }.merge(kwargs.except(:key, :klass, :proc))
+      end
+
+      def global_validations
+        @global_validations ||= []
+      end
+
+      def required_attributes
+        @required_attributes ||= []
+      end
+  
+      def optional_attributes
+        @optional_attributes ||= []
+      end
+  
+      def attributes
+        required_attributes + optional_attributes
+      end
+
+      def delegations
+        @delegations ||= []
+      end
+
+      def restrict?
+        @restrict_attributes
+      end
+
+    end
+
+  end
+end

data/lib/structish/version.rb

@@ -0,0 +1,3 @@
+module Structish
+  VERSION = "0.1.0"
+end

data/lib/structish_object_extensions.rb

@@ -0,0 +1,21 @@
+class ::Hash
+  def to_structish(structish_klass)
+    raise(ArgumentError, "Class is not a child of Structish::Hash") unless structish_klass < Structish::Hash
+    structish_klass.new(self)
+  end
+end
+
+class ::Array
+  def values
+    self.to_a
+  end
+
+  def keys
+    [*0..self.size-1]
+  end
+
+  def to_structish(structish_klass)
+    raise(ArgumentError, "Class is not a child of Structish::Array") unless structish_klass < Structish::Array
+    structish_klass.new(self)
+  end
+end

data/structish.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "structish/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "structish"
+  spec.version       = Structish::VERSION
+  spec.authors       = ["Dylan Blakemore"]
+  spec.email         = ["dylan.blakemore@gmail.com"]
+
+  spec.summary       = %q{Adding struct-like properties to Ruby Arrays and Hashes}
+  spec.description   = %q{Adds validations, function creation, function delegation,
+                          and key restrictions to arrays and hashes so that they may
+                          function similarly to Structs}
+
+  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", "~> 5.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: structish
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Blakemore
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: |-
+  Adds validations, function creation, function delegation,
+                            and key restrictions to arrays and hashes so that they may
+                            function similarly to Structs
+email:
+- dylan.blakemore@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/structable-rspec.yml"
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/structish.rb
+- lib/structish/array.rb
+- lib/structish/hash.rb
+- lib/structish/validation.rb
+- lib/structish/validation_error.rb
+- lib/structish/validations.rb
+- lib/structish/version.rb
+- lib/structish_object_extensions.rb
+- structish.gemspec
+homepage:
+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: Adding struct-like properties to Ruby Arrays and Hashes
+test_files: []