yas 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2bc6f995a8dbaa33cabd77eb2a9488ee83e9af68
+  data.tar.gz: 9384f3846028776890fc010f4dcda77743f44812
+SHA512:
+  metadata.gz: ec347427f0a1fa5adef59b4f49d55328d0060ac6e137faf061dde08f14f7c22617c3d0594448a92dfbf8f961ea9992eae3a0c6197539c1465c09066655b4511c
+  data.tar.gz: 83e5eb5b1a739e9402d195784417a20b6fcdb27863a3fc555498a50944ded1cbc84aaf1419ce3283dd9210970b52a1a0c76b671cf152fe821836b4fa14236fd6

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.swp
+*.swo
+tags
+.yardoc
+doc

data/README.markdown

@@ -0,0 +1,127 @@
+# YAS
+
+YAS (Yet Another Schema) is an extensible hash validator for Ruby.
+Using YAS, you can enforce a specific key to be required, rename them, perform automatic type conversion, and other goodies.
+
+
+## Installation
+
+    gem install yas
+
+
+## Quick Start
+
+    require 'yas'
+
+    class MySchema < YAS::Schema
+      rename :foo => :bar
+    end
+
+    h = { bar: "value" }
+    h.validate! MySchema
+    puts h[:foo]  # "value"
+    puts h[:bar]  # nil
+
+
+## Extensions
+
+You can extend the behavior of YAS by writing your own custom extensions, but `YAS::Schema` already comes with a set of awesome default extensions that you can immediately use:
+
+* `attribute name, &block` or `key name, &block`
+
+  Declares an attribute/key with various requirements.
+
+* `rename`
+
+  Rename keys.
+
+* `migrate`
+
+  Migrate the value of a key.
+
+* `whitelist`
+
+  Provide a set of keys that you only care to see.
+
+
+### Attribute Extension
+
+The Attribute extension allows you to specify certain requirements/restrictions for a given key:
+
+    class MySchema < YAS::Schema
+      key :email do
+        required
+      end
+
+      key :first_name do
+        type String
+      end
+    end
+
+    hash = { :first_name => 'John' }
+    hash.validate! MySchema # raises YAS::ValidationError "Key 'email' is missing"
+    hash.merge!(:email => 'john@email.com')
+    hash.validate! MySchema # Success!
+
+List of directives you can use:
+
+* `required`
+
+  Sets this key as required. Will raise an error if key is missing.
+
+* `type(T)`
+
+  Sets the type of this key. Will perform type check if specified. Can be nested if type is a YAS::Schema!
+
+* `auto_convert`
+
+  Enables auto-conversion to the specified type. This gets ignored if `type` is not specified.
+
+* `default(&block)`
+
+  Runs the block to set the default value for this key, if it's missing or nil.
+
+* `validate_value(&block)`
+
+  Custom validation method to check the value of a key. This is useful in cases where you only want certain values to be stored (e.g a number between 1-10 only)
+
+
+### Rename Extension
+
+Using `rename` to rename keys. Useful to maintain hash integrity.
+
+    class UserSchema < YAS::Schema
+      rename :username => :nickname
+    end
+    hash = { :username => 'jdoe' } )
+    hash.validate!(UserSchema)
+    hash[:nickname] # 'jdoe'
+
+
+### Migrate Extension
+
+You can also migrate the values. This is useful if you have hash whose values are in the old format and you want to convert them to the new format.
+
+    class UserSchema < YAS::Schema
+      migrate :nicknames do |v|
+        v.class == String ? [v] : v
+      end
+    end
+    hash = { :nicknames => 'jdoe' }
+    hash.validate!(UserSchema)
+    hash[:nicknames] # ['jdoe']
+
+
+### Whitelist Extension
+
+Whitelist allows you to remove unneeded keys.
+
+    class UserSchema < YAS::Schema
+      whitelist :name, :address
+    end
+    hash = { :name => 'jdoe', :address => '123 Main St', :phone => '9990000000', :comment => 'JDoe is cool' }
+    hash.validate!(UserSchema)
+    hash[:name] # ['jdoe']
+    hash[:address] # ['123 Main St']
+    hash[:phone] # nil
+    hash[:comment] # nil

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/testtask'
+
+task :default => "test"
+
+Rake::TestTask.new do |t|
+  t.description = "Run tests"
+  t.name = "test"
+  t.pattern = "./test/**/*.rb"
+end
+
+desc "Build the gemfile"
+task :build do
+  `gem build yas.gemspec`
+end

data/lib/yas/errors.rb

@@ -0,0 +1,9 @@
+module YAS
+
+  class ValidationError < StandardError
+  end
+
+  class ExtensionError < StandardError
+  end
+
+end

data/lib/yas/ext/attribute.rb

@@ -0,0 +1,199 @@
+# Defines specific rules for keys
+#
+
+class YAS::AttributeExt
+
+  module ClassMethods
+
+    def key attr, &block
+      attr = attr.to_s.to_sym
+      new_attr = Attribute.new(attr)
+      new_attr.instance_eval &block if block
+      attributes[attr] = new_attr
+      new_attr
+    end
+    alias_method :attribute, :key
+
+
+    def attributes
+      @attributes ||= {}
+    end
+  end
+
+
+  def self.when_used schema
+    schema.extend ClassMethods
+  end
+
+
+  def self.when_schema_inherited superschema, subschema
+    superschema.attributes.each do |key, attr|
+      subschema.attributes[key] = attr
+    end
+  end
+
+
+  def self.apply schema, hash
+    schema.attributes.each do |key, attr|
+      raise YAS::ValidationError, "Key #{key} is required" if attr.required? && !hash.has_key?(key)
+      hash.has_key?(key) and
+        hash[key] = attr.validate(hash[key])
+    end
+  end
+
+
+  class Attribute
+
+    attr_reader :name
+
+    @required = false
+    @type = nil
+    @auto_convert = false
+    @default_block = nil
+    @check_value_block = nil
+
+
+    def initialize name
+      @name = name.to_s.to_sym
+    end
+
+
+    # Directive to mark this Attribute as required.
+    #
+    def required
+      @required = true
+      self
+    end
+
+
+    def required?
+      @required
+    end
+
+
+    # Directive to enforce the data type of this Attribute.
+    #
+    def type t
+      @type = t
+      self
+    end
+
+
+    # Attempts to auto convert values to the type specified by the {type}
+    # directive if the value is not of the same type.
+    # Has no effect if {type} is not specified.
+    #
+    def auto_convert
+      @auto_convert = true
+      self
+    end
+
+
+    # Directive to set the default value of this Attribute. Once specified, if
+    # this Attribute does not exist during the Document initialization, whether
+    # that's from {Document.get} or {Document#initialize}, the value of the
+    # Attribute will be set to the value returned by the block.
+    #
+    # @yield Sets the value of this Attribute to the value returned by the
+    #   block.
+    #
+    def default &block
+      @default_block = block
+      self
+    end
+
+
+    def has_default?
+      @default_block != nil
+    end
+
+
+    # Perform a validation over the value of this Attribute.
+    #
+    # @yield [v] Value of the Attribute.
+    #
+    # @example
+    #   validate_value { |v| v == "John" }
+    #
+    def validate_value &block
+      @check_value_block = block
+      self
+    end
+
+
+    # Check the default value.
+    #
+    # @param value The value of this attribute to validate.
+    #
+    def trigger_default_directive
+      @default_block.call if has_default?
+    end
+
+
+    # Check value.
+    #
+    def trigger_content_directive value
+      if @check_value_block
+        raise YAS::ValidationError, "Content validation error: #{value}" unless
+          @check_value_block.call(value)
+      end
+      value
+    end
+
+
+    # Check type.
+    #
+    def trigger_type_directive value
+      if @type
+        # Run auto-conversion first.
+        value = trigger_auto_convert_directive(value)
+
+        msg = "Type mismatch for attribute #{@name}"
+        if @type <= YAS::Schema
+          value = @type.validate(value)
+        elsif @type == TrueClass || @type == FalseClass
+          raise YAS::ValidationError, msg unless !!value == value
+        else
+          raise YAS::ValidationError, msg unless value.is_a?(@type)
+        end
+      end
+
+      value
+    end
+
+
+    # Auto convert the value
+    #
+    def trigger_auto_convert_directive value
+      if @auto_convert
+        if @type == Integer
+          value = Integer(value)
+        elsif @type == Float
+          value = Float(value)
+        elsif @type == String
+          value = String(value)
+        elsif @type == Array
+          value = Array(value)
+        elsif @type == Time && !value.is_a?(Time)
+          value = Time.parse(value)
+        elsif @type == TrueClass || @type == FalseClass
+          value = value == "1" || value == 1 || value.to_s.downcase == "true" || value == true ? true : false
+        end
+      end
+      value
+    end
+
+
+    # Validates attribute, except the required directive.
+    # First it executes the {default} directive, then {auto_convert} to type,
+    # then {type} validation, then finally the {validate} directive.
+    #
+    # @return The final value after the validation.
+    #
+    def validate value
+      value = trigger_default_directive if value.nil?
+      trigger_content_directive(trigger_type_directive(value))
+    end
+
+  end
+end

data/lib/yas/ext/migrate.rb

@@ -0,0 +1,39 @@
+# Migrate the value of a key
+#
+
+class YAS::MigrateExt
+
+  module ClassMethods
+
+    def migrate key, &block
+      migrate_keys[key] = block
+    end
+
+
+    def migrate_keys
+      @migrate_keys ||= {}
+    end
+
+  end
+
+
+  def self.when_used schema
+    schema.extend ClassMethods
+  end
+
+
+  def self.when_schema_inherited superschema, subschema
+    superschema.migrate_keys.each do |key, pr|
+      subschema.migrate_keys[key] = pr
+    end
+  end
+
+
+  def self.apply schema, hash
+    schema.migrate_keys.each do |key, pr|
+      hash.has_key?(key) and
+        hash[key] = pr.call(hash[key])
+    end
+  end
+
+end

data/lib/yas/ext/rename.rb

@@ -0,0 +1,43 @@
+# Rename keys from one to another
+#
+# Usage:
+#
+# To rename `fname` to `first_name`, and `lname` to `last_name`
+# rename :fname => :first_name, :lname => :last_name
+#
+
+class YAS::RenameExt
+
+  module ClassMethods
+    def rename map
+      smap = YAS.symbolize(map)
+      rename_keys.merge!(smap)
+    end
+
+    def rename_keys
+      @rename_keys ||= {}
+    end
+  end
+
+
+  def self.when_used schema
+    schema.extend ClassMethods
+  end
+
+
+  def self.when_schema_inherited superschema, subschema
+    superschema.rename_keys.each do |from, value|
+      subschema.rename_keys[key] = value
+    end
+  end
+
+
+  def self.apply schema, hash
+    schema.rename_keys.each do |from, to|
+      hash.has_key?(from) and
+        hash[to] = hash[from] and
+        hash.delete(from)
+    end
+  end
+
+end

data/lib/yas/ext/whitelist.rb

@@ -0,0 +1,43 @@
+# Whitelist hash to only contain a set of keys
+#
+
+class YAS::WhitelistExt
+
+  module ClassMethods
+    def whitelist *keys
+      keys = Array(keys)
+      keys.flatten!
+      keys.uniq!
+      keys.compact!
+      keys.each do |k| whitelist_keys << k; end
+      whitelist_keys.flatten!
+      whitelist_keys.uniq!
+      whitelist_keys.compact!
+    end
+
+    def whitelist_keys
+      @whitelist_keys ||= []
+    end
+  end
+
+
+  def self.when_used schema
+    schema.extend ClassMethods
+  end
+
+
+  def self.when_schema_inherited superschema, subschema
+    superschema.whitelist_keys.each do |key|
+      subschema.whitelist_keys << key
+    end
+  end
+
+
+  def self.apply schema, hash
+    hash.delete_if do |k, v|
+      !schema.whitelist_keys.include?(k)
+    end unless schema.whitelist_keys.empty?
+  end
+
+
+end

data/lib/yas/hash.rb

@@ -0,0 +1,23 @@
+class Hash
+
+  def validate schema
+    copy = Marshal.load(Marshal.dump(self))
+    schema.validate(copy) if schema.respond_to?(:validate)
+  end
+
+
+  def validate! schema
+    schema.validate(self) if schema.respond_to?(:validate)
+  end
+
+
+  def slice *keys
+    keys.flatten!
+    data = keys.inject({}) do |memo, key|
+      memo[key] = self[key] if self[key]
+      memo
+    end
+    data
+  end
+
+end

data/lib/yas/helper.rb

@@ -0,0 +1,10 @@
+module YAS
+
+  def self.symbolize hash
+    hash.inject({}) do |memo,(k,v)|
+      memo[k.to_sym] = v
+      memo
+    end
+  end
+
+end

data/lib/yas/schema.rb

@@ -0,0 +1,46 @@
+class YAS::SchemaBase
+
+  def self.use ext
+    raise YAS::ExtensionError, "Duplicate Extension" if exts.any? { |e| e == ext }
+    raise YAS::ExtensionError, "Wrong Extension Format" unless ext.respond_to?(:apply) && ext.respond_to?(:when_used)
+    exts << ext
+    ext.when_used(self)
+  end
+
+
+  def self.exts
+    @exts ||= []
+  end
+
+
+  def self.validate hash
+    exts.each do |ext|
+      ext.apply(self, hash)
+    end
+    hash
+  end
+
+
+  def self.inspect
+    exts.inspect
+  end
+
+
+  # Inherited hook to inherit all extensions.
+  def self.inherited subclass
+    exts.each do |ext|
+      subclass.use(ext)
+      ext.when_schema_inherited(self, subclass) if ext.respond_to?(:when_schema_inherited)
+    end
+  end
+
+end
+
+class YAS::Schema < YAS::SchemaBase
+
+  use YAS::RenameExt
+  use YAS::WhitelistExt
+  use YAS::MigrateExt
+  use YAS::AttributeExt
+
+end

data/lib/yas/version.rb

@@ -0,0 +1,5 @@
+module YAS
+  GEM_NAME = "yas"
+  NAME = "YAS"
+  VERSION = "0.1.0"
+end

data/lib/yas.rb

@@ -0,0 +1,15 @@
+require 'securerandom'
+require 'json'
+require 'time'
+
+require 'yas/version'
+require 'yas/errors'
+require 'yas/helper'
+
+require 'yas/ext/rename'
+require 'yas/ext/attribute'
+require 'yas/ext/migrate'
+require 'yas/ext/whitelist'
+
+require 'yas/schema'
+require 'yas/hash'

data/test/ext/test_attribute.rb

@@ -0,0 +1,200 @@
+require './test/helper.rb'
+
+class TestAttribute < Minitest::Test
+
+  Attribute = YAS::AttributeExt::Attribute
+
+  def test_required
+    attr = Attribute.new(:batman).required
+    assert_equal true, attr.required?
+  end
+
+
+  def test_type
+    attr = Attribute.new(:batman).type(String)
+    assert_equal "hello", attr.validate("hello")
+    assert_raises YAS::ValidationError do
+      attr.validate(1)
+    end
+  end
+
+
+  def test_auto_convert_integer
+    attr = Attribute.new(:batman).type(Integer).auto_convert
+    assert_equal 1000, attr.validate(1000)
+    assert_equal 1000, attr.validate("1000")
+  end
+
+
+  def test_auto_convert_float
+    attr = Attribute.new(:batman).type(Float).auto_convert
+    assert_equal 1000.01, attr.validate(1000.01)
+    assert_equal 1000.01, attr.validate("1000.01")
+  end
+
+
+  def test_auto_convert_string
+    attr = Attribute.new(:batman).type(String).auto_convert
+    assert_equal "hello", attr.validate("hello")
+    assert_equal "1", attr.validate(1)
+  end
+
+
+  def test_auto_convert_array
+    attr = Attribute.new(:batman).type(Array).auto_convert
+    assert_equal ["hello"], attr.validate(["hello"])
+    assert_equal [1], attr.validate(1)
+  end
+
+
+  def test_auto_convert_time
+    attr = Attribute.new(:batman).type(Time).auto_convert
+    time = attr.validate("2014/7/14")
+    assert time.is_a?(Time)
+    assert_equal 2014, time.year
+    assert_equal 7, time.month
+    assert_equal 14, time.day
+
+    time = attr.validate(Time.now.utc)
+    assert time
+  end
+
+
+  def test_auto_convert_boolean
+    attr = Attribute.new(:batman).type(TrueClass).auto_convert
+    assert_equal false, attr.validate("false")
+    assert_equal false, attr.validate("123")
+    assert_equal true, attr.validate(1)
+    assert_equal true, attr.validate("true")
+    assert_equal true, attr.validate("1")
+    assert_equal false, attr.validate(0)
+    assert_equal false, attr.validate(nil)
+  end
+
+
+  def test_default
+    attr = Attribute.new(:batman).default { "John" }
+    assert_equal "John", attr.validate(nil)
+  end
+
+
+  def test_has_default
+    attr = Attribute.new(:batman).default { "John" }
+    assert_equal true, attr.has_default?
+
+    no_default_attr = Attribute.new(:batman)
+    assert_equal false, no_default_attr.has_default?
+  end
+
+
+  def test_content
+    attr = Attribute.new(:batman).validate_value { |v| v == "John" }
+    assert_raises YAS::ValidationError do
+      attr.validate("Jim")
+    end
+    attr.validate("John")
+  end
+
+
+  def test_all
+    attr = Attribute.new(:batman)
+      .required
+      .type(Integer)
+      .default { 0 }
+      .validate_value { |v| v >= 0 }
+
+    assert_equal true, attr.required?
+    assert_equal 0, attr.validate(nil)
+    assert_equal 100, attr.validate(100)
+    assert_raises YAS::ValidationError do
+      attr.validate(-100)
+    end
+  end
+
+
+  def test_validate_maintain_value_if_type_not_specified
+    attr = Attribute.new(:batman)
+    [true, false, :symbol, 1, 0, -1, 10.0, "string", 1293.1, 0x90, Time.now, nil].each do |v|
+      assert_equal v, attr.validate(v)
+    end
+  end
+
+end
+
+
+class AttributeSchema < YAS::Schema
+
+  key :name do
+    required
+    type String
+    auto_convert
+    default { "joe" }
+    validate_value { |v| v.length < 10 }
+  end
+
+  key :number do
+    required
+    type Integer
+    auto_convert
+  end
+
+end
+
+
+class NestedAttributeSchema < YAS::Schema
+
+  key :personal_info do
+    required
+    type AttributeSchema
+  end
+
+end
+
+
+class TestAttributeExt < Minitest::Test
+
+  def test_attribute_ext
+    hash = {
+      name: "someone",
+      number: 10,
+    }
+    hash.validate! AttributeSchema
+    assert_equal "someone", hash[:name]
+  end
+
+
+  def test_attribute_ext_validate_value
+    hash = {
+      name: "someone with long name",
+      number: 99,
+    }
+    assert_raises YAS::ValidationError do
+      hash.validate! AttributeSchema
+    end
+  end
+
+
+  def test_attribute_ext_autoconvert_and_nil_attribute
+    hash = {
+      name: nil,
+      number: "10"
+    }
+    hash.validate! AttributeSchema
+    assert_equal 10, hash[:number]
+    assert_equal "joe", hash[:name]
+  end
+
+
+  def test_nested_attribute_schema
+    hash = {
+      personal_info: {
+        name: nil,
+        number: "10"
+      }
+    }
+    hash.validate! NestedAttributeSchema
+    assert_equal 10, hash[:personal_info][:number]
+    assert_equal "joe", hash[:personal_info][:name]
+  end
+
+end

data/test/ext/test_migrate.rb

@@ -0,0 +1,22 @@
+require './test/helper.rb'
+
+
+class MigrateSchema < YAS::Schema
+  migrate :names do |v|
+    v = Array(v) if !v.is_a?(Array)
+    v
+  end
+end
+
+
+class TestMigrateExt < Minitest::Test
+
+  def test_migrate_ext
+    hash = {
+      names: "john"
+    }
+    hash.validate! MigrateSchema
+    assert_equal ["john"], hash[:names]
+  end
+
+end

data/test/ext/test_rename.rb

@@ -0,0 +1,22 @@
+require './test/helper.rb'
+
+class RenameSchema < YAS::Schema
+  rename :addr => :address
+end
+
+
+class TestRenameExt < Minitest::Test
+
+  def test_rename_ext
+    hash = {
+      addr: "Some address",
+      untouched: "Nothing"
+    }
+    hash.validate! RenameSchema
+    assert_equal "Some address", hash[:address]
+    assert_equal "Nothing", hash[:untouched]
+    assert_nil hash[:addr]
+    assert_equal 2, hash.length
+  end
+
+end

data/test/ext/test_whitelist.rb

@@ -0,0 +1,25 @@
+require './test/helper.rb'
+
+
+class WhitelistSchema < YAS::Schema
+  whitelist :first_name, :last_name, :address
+end
+
+
+class TestWhitelistExt < Minitest::Test
+
+  def test_whitelist_ext
+    hash = {
+      first_name: "john",
+      last_name: "doe",
+      address: "123 Main St",
+      invalid: "will get removed",
+    }
+    hash.validate! WhitelistSchema
+    assert_equal "john", hash[:first_name]
+    assert_equal "doe", hash[:last_name]
+    assert_equal "123 Main St", hash[:address]
+    assert_nil hash[:invalid]
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+require './lib/yas.rb'
+
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'mocha/mini_test'
+

data/test/test_schema.rb

@@ -0,0 +1,97 @@
+require './test/helper.rb'
+
+
+class MigrateSchema < YAS::Schema
+  migrate :names do |v|
+    v = Array(v) if !v.is_a?(Array)
+    v
+  end
+end
+
+
+class InheritedSchema < MigrateSchema
+  rename :book => :books
+end
+
+
+class ComplexSchema < MigrateSchema
+
+  whitelist :name, :contact_name, :contact_email, :redirect_uris, :active
+
+  attribute :name do
+    required
+    type String
+  end
+
+  attribute :contact_name do
+    required
+    type String
+  end
+
+  rename :email => :contact_email
+  attribute :contact_email do
+    required
+    type String
+  end
+
+  rename :redirect_uri => :redirect_uris
+  attribute :redirect_uris do
+    required
+    type Array
+    auto_convert
+  end
+  migrate :redirect_uris do |v|
+    v = Array(v) if !v.is_a?(Array)
+    v
+  end
+
+  attribute :active do
+    required
+    type TrueClass
+    auto_convert
+    default { true }
+  end
+
+end
+
+
+class TestSchema < Minitest::Test
+
+  def test_validate_not_bang_does_not_overwrite_original
+    hash = {
+      names: "john",
+    }
+    result = hash.validate MigrateSchema
+    assert_equal ["john"], result[:names]
+    assert_equal "john", hash[:names]
+  end
+
+  def test_inherited_schema_should_inherit_extensions
+    hash = {
+      names: "john",
+      book: "Dolly",
+    }
+    hash.validate! InheritedSchema
+    assert_equal ["john"], hash[:names]
+    assert_equal "Dolly", hash[:books]
+    assert_nil hash[:book]
+  end
+
+  def test_complex_schema
+    hash = {
+      name: "john",
+      contact_name: "someone else",
+      email: "jdoe@example.com",
+      redirect_uri: "jdoe.com",
+      active: 1,
+    }
+    hash.validate! ComplexSchema
+    assert_equal "john", hash[:name]
+    assert_equal "someone else", hash[:contact_name]
+    assert_equal "jdoe@example.com", hash[:contact_email]
+    assert_nil hash[:email]
+    assert_equal ["jdoe.com"], hash[:redirect_uris]
+    assert_equal true, hash[:active]
+  end
+
+end

data/yas.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'yas/version'
+
+Gem::Specification.new do |s|
+  s.name = "#{YAS::GEM_NAME}"
+  s.version = YAS::VERSION
+  s.authors = ["Albert Tedja"]
+  s.email = "nicho_tedja@yahoo.com"
+  s.homepage = "https://github.com/atedja/yahs"
+  s.summary = "Yet Another Schema for Ruby."
+  s.description = "#{YAS::NAME} is a Ruby hash schema and validator."
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '~> 2.0'
+  s.add_development_dependency 'minitest',  '~> 5.3'
+  s.add_development_dependency 'mocha', '~> 1.1'
+  s.add_development_dependency 'rake', '~> 10.3'
+
+  s.license = "Apache"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: yas
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Albert Tedja
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+description: YAS is a Ruby hash schema and validator.
+email: nicho_tedja@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.markdown
+- Rakefile
+- lib/yas.rb
+- lib/yas/errors.rb
+- lib/yas/ext/attribute.rb
+- lib/yas/ext/migrate.rb
+- lib/yas/ext/rename.rb
+- lib/yas/ext/whitelist.rb
+- lib/yas/hash.rb
+- lib/yas/helper.rb
+- lib/yas/schema.rb
+- lib/yas/version.rb
+- test/ext/test_attribute.rb
+- test/ext/test_migrate.rb
+- test/ext/test_rename.rb
+- test/ext/test_whitelist.rb
+- test/helper.rb
+- test/test_schema.rb
+- yas.gemspec
+homepage: https://github.com/atedja/yahs
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Yet Another Schema for Ruby.
+test_files: []
+has_rdoc: