fried-schema 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23815d2c6643330c7882829e738c0443011ba57a
+  data.tar.gz: 758119e620df5f4a1b7f788a68332fc093142ed0
+SHA512:
+  metadata.gz: 717d5115e4e819e470e8643b3d6948cd2721bb3cb27f8225a687315bae9af01af66244a6e4778ebd0ccc48fca2ada09ed201fce8e9ae9745635771e9cc40b30c
+  data.tar.gz: 378fc6154e2968f271405a843aa3f9aefdb285033c01c66d011a712364a969a6a5aa9dc716ee61f98461532051c2ddc89e353d4ebd7ddb56652e511189037e69

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock
+.envrc
+/binstubs/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in fried-schema.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Francesco Belladonna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Fried::Schema [![Build Status][test-badge]][test-link]
+
+Struct definition with type safety
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fried-schema'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fried-schema
+
+## Usage
+
+Two modules are exposed:
+
+- `Fried::Schema::Struct`
+- `Fried::Schema::DataEntity`
+
+### Struct
+
+```ruby
+class Person
+  include Fried::Schema::Struct
+
+  # attribute_name, type_checking, default_value (optional)
+  # default value could be anything. However if it's a Proc, it will be
+  # evaluated at initialization
+  attribute :name, String, default: ""
+  attribute :born_at, Time, default: -> { Time.now }
+  attribute :age, Numeric
+end
+
+person = Person.new
+person.name = "John"
+
+person.name # => "John"
+person.born_at # => 2017-11-24 00:55:50 -0800
+person.age # => nil
+
+person.name = 123 # raises TypeError
+```
+
+### DataEntity
+
+Has all the same functionality as `Fried::Schema::Struct`, in addition to
+`#to_h` and `.build`
+
+```ruby
+class Person
+  include Fried::Schema::DataEntity
+
+  attribute :name, String, default: ""
+  attribute :born_at, Time, default: -> { Time.now }
+  attribute :age, Numeric
+end
+
+person = Person.build(name: "John", age: 123, not_present_key: "test")
+
+person.name # => "John"
+person.age # => 123
+
+person.to_h # => { name: "John", born_at: 2017-11-24 00:55:50 -0800, age: 123 }
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Fire-Dragon-DoL/fried-schema.
+
+[test-badge]: https://travis-ci.org/Fire-Dragon-DoL/fried-schema.svg?branch=master
+[test-link]: https://travis-ci.org/Fire-Dragon-DoL/fried-schema

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "fried/test/rake"
+
+include Fried::Test::Rake
+
+task default: :test

data/bin/console

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fried/schema"
+
+# 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
+
+class Foo
+  include Fried::Schema::DataEntity
+
+  attribute :name, String, default: ""
+  attribute :age, Numeric, default: 0
+  attribute :born_at, Time, default: -> { Time.now }
+end
+
+require "pry-byebug"
+Pry.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/fried-schema.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fried/schema/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "fried-schema"
+  spec.version       = Fried::Schema::VERSION
+  spec.authors       = ["Fire-Dragon-DoL"]
+  spec.email         = ["francesco.belladonna@gmail.com"]
+  spec.licenses      = ["MIT"]
+
+  spec.summary       = %q{Struct definition with type safety}
+  spec.description   = %q{Struct definition with type safety}
+  spec.homepage      = "https://github.com/Fire-Dragon-DoL/fried-schema"
+  spec.metadata      = {
+    "source_code_uri" => "https://github.com/Fire-Dragon-DoL/fried-schema"
+  }
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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_development_dependency "bundler"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-focus"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "fried-test"
+
+  spec.add_runtime_dependency "fried-core"
+  spec.add_runtime_dependency "fried-typings"
+end

data/lib/fried/schema.rb

@@ -0,0 +1,8 @@
+require "fried/schema/version"
+require "fried/schema/struct"
+require "fried/schema/data_entity"
+
+module Fried
+  module Schema
+  end
+end

data/lib/fried/schema/attribute.rb

@@ -0,0 +1,6 @@
+require "fried/core"
+
+module Fried::Schema
+  module Attribute
+  end
+end

data/lib/fried/schema/attribute/define_methods.rb

@@ -0,0 +1,39 @@
+require "fried/schema/attribute"
+require "fried/schema/attribute/define_reader"
+require "fried/schema/attribute/define_writer"
+
+module Fried::Schema::Attribute
+  # Define methods based on attributes registered in
+  # {::Fried::Schema::Definition}
+  class DefineMethods
+    attr_accessor :define_reader
+    attr_accessor :define_writer
+
+    def initialize
+      self.define_reader = ::Fried::Schema::Attribute::DefineReader.new
+      self.define_writer = ::Fried::Schema::Attribute::DefineWriter.new
+    end
+
+    def self.build
+      new.tap do |instance|
+        instance.define_reader = ::Fried::Schema::Attribute::DefineReader.build
+        instance.define_writer = ::Fried::Schema::Attribute::DefineWriter.build
+      end
+    end
+
+    def self.call(attribute_definition, klass)
+      instance = build
+      instance.(attribute_definition, klass)
+    end
+
+    # Creates methods to read/write attribute with type checking
+    # @param attribute_definition [AttributeDefinition]
+    # @param klass [Class, Module]
+    # @return [AttributeDefinition]
+    def call(attribute_definition, klass)
+      define_reader.(attribute_definition, klass)
+      define_writer.(attribute_definition, klass)
+      attribute_definition
+    end
+  end
+end

data/lib/fried/schema/attribute/define_reader.rb

@@ -0,0 +1,27 @@
+require "fried/schema/attribute"
+
+module Fried::Schema::Attribute
+  # Define reader based on attribute {Definition}
+  class DefineReader
+    def self.build
+      new
+    end
+
+    def self.call(attribute_definition, klass)
+      instance = build
+      instance.(attribute_definition, klass)
+    end
+
+    # Creates read method
+    # @param definition [Definition]
+    # @param klass [Class, Module]
+    # @return [Definition]
+    def call(definition, klass)
+      variable = definition.instance_variable
+
+      klass.instance_eval do
+        define_method(definition.reader) { instance_variable_get(variable) }
+      end
+    end
+  end
+end

data/lib/fried/schema/attribute/define_writer.rb

@@ -0,0 +1,42 @@
+require "fried/schema/attribute"
+require "fried/typings/is"
+
+module Fried::Schema::Attribute
+  # Define writer based on attribute {Definition} with type-checking
+  class DefineWriter
+    attr_accessor :is
+
+    def initialize
+      self.is = ::Fried::Typings::Is
+    end
+
+    def self.build
+      new
+    end
+
+    def self.call(attribute_definition, klass)
+      instance = build
+      instance.(attribute_definition, klass)
+    end
+
+    # Creates write method with type-checking
+    # @param definition [Definition]
+    # @param klass [Class, Module]
+    # @return [Definition]
+    def call(definition, klass)
+      is_a = is[definition.type]
+      define_writer(definition, is_a, klass)
+    end
+
+    private
+
+    def define_writer(definition, is_a, klass)
+      klass.instance_eval do
+        define_method(definition.writer) do |value|
+          value = is_a.(value)
+          instance_variable_set(definition.instance_variable, value)
+        end
+      end
+    end
+  end
+end

data/lib/fried/schema/attribute/definition.rb

@@ -0,0 +1,39 @@
+require "fried/schema/attribute"
+
+module Fried::Schema::Attribute
+  # Value-type holding definition of attribute
+  class Definition < Struct.new(:name, :type, :default)
+    # @!attribute [rw] name
+    #   A {Symbol}
+    # @!attribute [rw] type
+    #   Any {Class} or {Module}, or {::Fried::Typings::Type}
+    # @!attribute [rw] default
+    #   Any object. If a {Proc} is used, it will be evaluated during
+    #   initialization
+
+    # Attribute reader method name
+    # @return [Symbol]
+    def reader
+      name.to_sym
+    end
+
+    # Attribute writer method name
+    # @return [Symbol]
+    def writer
+      :"#{reader}="
+    end
+
+    # Attribute instance variable name (@variable)
+    # @return [Symbol]
+    def instance_variable
+      :"@#{reader}"
+    end
+
+    # Extracts content of {#default} if it's a {Proc}, otherwise just returns
+    # {#default}
+    def extract_default
+      return default.() if default.is_a?(::Proc)
+      default
+    end
+  end
+end

data/lib/fried/schema/attributes_to_hash.rb

@@ -0,0 +1,36 @@
+require "fried/core"
+require "fried/schema/get_attribute"
+
+module Fried::Schema
+  # Converts all attributes into a {Hash} of name => value
+  class AttributesToHash
+    attr_accessor :get_attribute
+
+    def initialize
+      self.get_attribute = GetAttribute.new
+    end
+
+    def self.build
+      new.tap do |instance|
+        instance.get_attribute = GetAttribute.build
+      end
+    end
+
+    def self.call(schema, obj)
+      instance = build
+      instance.(schema, obj)
+    end
+
+    # @param schema [Definition]
+    # @param obj [::Fried::Schema::Struct] an instance of a class including
+    #   {::Fried::Schema::Struct}
+    # @return [Hash{Symbol => Object}] hash of attributes key => values
+    def call(schema, obj)
+      schema.each_attribute.inject({}) do |hash, attribute|
+        value = get_attribute.(obj, attribute)
+        hash[attribute.name] = value
+        hash
+      end
+    end
+  end
+end

data/lib/fried/schema/data_entity.rb

@@ -0,0 +1,33 @@
+require "fried/core"
+require "fried/schema/struct"
+require "fried/schema/attributes_to_hash"
+require "fried/schema/hash_to_attributes"
+
+module Fried::Schema
+  # Includes {Struct} but also provide a {.build} method which initialize
+  # the object with a {Hash}, setting attributes based on keys
+  module DataEntity
+    module ClassMethods
+      def build(attributes = {})
+        new.tap do |instance|
+          schema = self.instance_variable_get(:@__fried_schema__)
+          ::Fried::Schema::HashToAttributes.(schema, attributes, instance)
+        end
+      end
+    end
+
+    # @return [Hash{Symbol => Object}] a hash containing the values of all
+    #   attribute name => value
+    def to_h
+      schema = self.class.instance_variable_get(:@__fried_schema__)
+      ::Fried::Schema::AttributesToHash.(schema, self)
+    end
+
+    def self.included(klass)
+      klass.instance_eval do
+        include ::Fried::Schema::Struct
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/fried/schema/definition.rb

@@ -0,0 +1,40 @@
+require "fried/core"
+
+module Fried::Schema
+  # Holds defined attributes for a given {Class}
+  class Definition
+    private
+
+    attr_reader :attributes
+
+    public
+
+    def initialize
+      @attributes = {}
+    end
+
+    # @param attribute_definition [Attribute::Definition]
+    # @return [Attribute::Definition]
+    def add_attribute(definition)
+      name = definition.name
+      attributes[name] = definition
+    end
+
+    # List all attributes. If no block is passed, returns an enumerator,
+    # otherwise it returns the last value returned by the block
+    # @return [Enumerator, Object]
+    def each_attribute(&block)
+      return attributes_enumerator if block.nil?
+
+      attributes_enumerator.each(&block)
+    end
+
+    private
+
+    def attributes_enumerator
+      Enumerator.new(attributes.size) do |yielder|
+        attributes.each { |_, definition| yielder << definition }
+      end
+    end
+  end
+end

data/lib/fried/schema/get_attribute.rb

@@ -0,0 +1,23 @@
+require "fried/core"
+
+module Fried::Schema
+  # Get attribute value from object
+  class GetAttribute
+    def self.build
+      new
+    end
+
+    def self.call(obj, attribute)
+      instance = build
+      instance.(obj, attribute)
+    end
+
+    # @param obj [Object] anything
+    # @param attribute [Attribute::Definition]
+    # @return [Object] value from the object attribute
+    def call(obj, attribute)
+      reader = attribute.reader
+      obj.public_send(reader)
+    end
+  end
+end

data/lib/fried/schema/hash_to_attributes.rb

@@ -0,0 +1,37 @@
+require "fried/core"
+require "fried/schema/set_attribute"
+
+module Fried::Schema
+  # Sets all attributes based on hash
+  class HashToAttributes
+    attr_accessor :set_attribute
+
+    def initialize
+      self.set_attribute = SetAttribute.new
+    end
+
+    def self.build
+      new.tap do |instance|
+        instance.set_attribute = SetAttribute.build
+      end
+    end
+
+    def self.call(schema, attributes, obj)
+      instance = build
+      instance.(schema, attributes, obj)
+    end
+
+    # @param schema [Definition]
+    # @param attributes [Hash{Symbol => Object}]
+    # @param obj [::Fried::Schema::Struct] an instance of a class including
+    #   {::Fried::Schema::Struct}
+    # @return [void]
+    def call(schema, attributes, obj)
+      schema.each_attribute do |attribute|
+        next unless attributes.has_key?(attribute.name)
+        value = attributes[attribute.name]
+        set_attribute.(obj, attribute, value)
+      end
+    end
+  end
+end

data/lib/fried/schema/set_attribute.rb

@@ -0,0 +1,24 @@
+require "fried/core"
+
+module Fried::Schema
+  # Set attribute value on object
+  class SetAttribute
+    def self.build
+      new
+    end
+
+    def self.call(obj, attribute, value)
+      instance = build
+      instance.(obj, attribute, value)
+    end
+
+    # @param obj [Object] anything
+    # @param attribute [Attribute::Definition]
+    # @param value [Object] anything
+    # @return [Object] the passed value
+    def call(obj, attribute, value)
+      writer = attribute.writer
+      obj.public_send(writer, value)
+    end
+  end
+end

data/lib/fried/schema/set_attribute_without_checks.rb

@@ -0,0 +1,24 @@
+require "fried/core"
+
+module Fried::Schema
+  # Set attribute value on object skipping type-checking
+  class SetAttributeWithoutChecks
+    def self.build
+      new
+    end
+
+    def self.call(obj, attribute, value)
+      instance = build
+      instance.(obj, attribute, value)
+    end
+
+    # @param obj [Object] anything
+    # @param attribute [Attribute::Definition]
+    # @param value [Object] anything
+    # @return [Object] the passed value
+    def call(obj, attribute, value)
+      variable = attribute.instance_variable
+      obj.instance_variable_set(variable, value)
+    end
+  end
+end

data/lib/fried/schema/set_defaults.rb

@@ -0,0 +1,35 @@
+require "fried/core"
+require "fried/schema/set_attribute_without_checks"
+
+module Fried::Schema
+  # Set defaults values for all attributes in schema definitions while
+  # ignoring type checking
+  class SetDefaults
+    attr_accessor :set_attribute_without_checks
+
+    def initialize
+      self.set_attribute_without_checks = SetAttributeWithoutChecks.new
+    end
+
+    def self.build
+      new.tap do |instance|
+        instance.set_attribute_without_checks = SetAttributeWithoutChecks.build
+      end
+    end
+
+    def self.call(schema, obj)
+      instance = build
+      instance.(schema, obj)
+    end
+
+    # @param schema [Definition]
+    # @param obj [Object]
+    # @return [void]
+    def call(schema, obj)
+      schema.each_attribute do |attribute|
+        value = attribute.extract_default
+        set_attribute_without_checks.(obj, attribute, value)
+      end
+    end
+  end
+end

data/lib/fried/schema/struct.rb

@@ -0,0 +1,47 @@
+require "fried/core"
+require "fried/schema/attribute/definition"
+require "fried/schema/attribute/define_methods"
+require "fried/schema/definition"
+require "fried/schema/set_defaults"
+
+module Fried::Schema
+  # Provides {.attribute} macro which allows to easily define type-safe
+  # accessors. The attributes are initialized with default values or with
+  # {nil} if none was provided
+  module Struct
+    module Initializer
+      def initialize
+        schema = self.class.instance_variable_get(:@__fried_schema__)
+        ::Fried::Schema::SetDefaults.(schema, self)
+      end
+    end
+
+    module ClassMethods
+      Noop = -> { nil }
+
+      # Defines an attr_accessor with given name, type checking and optional
+      # default value
+      # @param name [Symbol, String] name for attribute (attr_accessor)
+      # @param type [::Fried::Typings::Type, Class, Module] either a `Type`
+      #   from `Fried::Typings` (even a custom one) or any `Class` or `Module`
+      # @param default [Object, Proc] if an object is passed, it will be used
+      #   as default. If a {Proc} is passed, it will be evaluated during
+      #   object initialization
+      # @return [Symbol] reader method name
+      def attribute(name, type, default: Noop)
+        @__fried_schema__ ||= ::Fried::Schema::Definition.new
+        definer = ::Fried::Schema::Attribute::Definition
+        attribute_definition = definer.new(name, type, default)
+        @__fried_schema__.add_attribute(attribute_definition)
+        ::Fried::Schema::Attribute::DefineMethods.(attribute_definition, self)
+      end
+    end
+
+    def self.included(klass)
+      klass.instance_eval do
+        include Initializer
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/fried/schema/version.rb

@@ -0,0 +1,5 @@
+module Fried
+  module Schema
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: fried-schema
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Fire-Dragon-DoL
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-24 00:00:00.000000000 Z
+dependencies:
+- !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: minitest
+  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: minitest-focus
+  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: minitest-reporters
+  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: pry-byebug
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fried-test
+  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: fried-core
+  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'
+- !ruby/object:Gem::Dependency
+  name: fried-typings
+  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: Struct definition with type safety
+email:
+- francesco.belladonna@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- fried-schema.gemspec
+- lib/fried/schema.rb
+- lib/fried/schema/attribute.rb
+- lib/fried/schema/attribute/define_methods.rb
+- lib/fried/schema/attribute/define_reader.rb
+- lib/fried/schema/attribute/define_writer.rb
+- lib/fried/schema/attribute/definition.rb
+- lib/fried/schema/attributes_to_hash.rb
+- lib/fried/schema/data_entity.rb
+- lib/fried/schema/definition.rb
+- lib/fried/schema/get_attribute.rb
+- lib/fried/schema/hash_to_attributes.rb
+- lib/fried/schema/set_attribute.rb
+- lib/fried/schema/set_attribute_without_checks.rb
+- lib/fried/schema/set_defaults.rb
+- lib/fried/schema/struct.rb
+- lib/fried/schema/version.rb
+homepage: https://github.com/Fire-Dragon-DoL/fried-schema
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Fire-Dragon-DoL/fried-schema
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Struct definition with type safety
+test_files: []