schemad 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42533ea7f5721acf5f2bcc3c10a10322b61d6e76
+  data.tar.gz: d24a50de59c6ce8d81d5c5466f19b993e05bfe06
+SHA512:
+  metadata.gz: 9cced2f7ca522ac55286b5c34e7ab1539a342c16c97831cbeb838987f1885790dd81d2bc73a80f4783d166ef5bbc0258a5fc61cf8fab9c97befe6c812dd9f1a6
+  data.tar.gz: c828d9d9c9c0ab5e7df1d50613ec45c63f7d13f91ac5cb7db404a896f2158b63a9270580ba3b41707c3a46020ae586d898c53e462a3b69a97db3a3c02b3a2998

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in schemad.gemspec
+gemspec
+
+group :test do
+  gem 'rspec-given'
+  gem 'flexmock'
+  gem 'timecop'
+
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Luke van der Hoeven
+
+MIT License
+
+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,327 @@
+# Schemad
+
+Schemad is a simple metagem to aid integrating legacy or third-party datasets into other projects. It's especially geared towards unifying multiple datasets into consistent data structures for ease of and consistency in use.
+
+This gem has two main parts: Normalizers and Entities.
+
+## Normalizers
+
+Normalizers are the translators between different datasets. They take misshaped data and help mold it into a consistent form before turning them into objects for general use. 
+
+For example, let's say I want to pull commit data from [GitHub](https://github.com) and [BitBucket](https://bitbucket.org) and do something with the two datasets. Let's look at the API for both and the kind of data they return for a commit object.
+
+### GitHub Commit API
+> [Source](https://developer.github.com/v3/git/commits/)
+
+```json
+{
+  "sha": "7638417db6d59f3c431d3e1f261cc637155684cd",
+  "url": "https://api.github.com/repos/octocat/Hello-World/git/commits/7638417db6d59f3c431d3e1f261cc637155684cd",
+  "author": {
+    "date": "2010-04-10T14:10:01-07:00",
+    "name": "Scott Chacon",
+    "email": "schacon@gmail.com"
+  },
+  "committer": {
+    "date": "2010-04-10T14:10:01-07:00",
+    "name": "Scott Chacon",
+    "email": "schacon@gmail.com"
+  },
+  "message": "added readme, because im a good github citizen\n",
+  "tree": {
+    "url": "https://api.github.com/repos/octocat/Hello-World/git/trees/691272480426f78a0138979dd3ce63b77f706feb",
+    "sha": "691272480426f78a0138979dd3ce63b77f706feb"
+  },
+  "parents": [
+    {
+      "url": "https://api.github.com/repos/octocat/Hello-World/git/commits/1acc419d4d6a9ce985db7be48c6349a0475975b5",
+      "sha": "1acc419d4d6a9ce985db7be48c6349a0475975b5"
+    }
+  ]
+}
+```
+
+### BitBucket Commit API
+> [Source](https://confluence.atlassian.com/display/BITBUCKET/commits+or+commit+Resource#commitsorcommitResource-GETanindividualcommit)
+
+```json
+{
+    hash: "61d9e64348f9da407e62f64726337fd3bb24b466",
+    links: {
+        self: {
+            href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/commit/61d9e64348f9da407e62f64726337fd3bb24b466"
+        },
+        comments: {
+            href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/commit/61d9e64348f9da407e62f64726337fd3bb24b466/comments"
+        },
+        patch: {
+            href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/patch/61d9e64348f9da407e62f64726337fd3bb24b466"
+        },
+        html: {
+            href: "https://api.bitbucket.org/atlassian/atlassian-rest/commits/61d9e64348f9da407e62f64726337fd3bb24b466"
+        },
+        diff: {
+            href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/diff/61d9e64348f9da407e62f64726337fd3bb24b466"
+        },
+        approve: {
+            href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/commit/61d9e64348f9da407e62f64726337fd3bb24b466/approve"
+        }
+    },
+    repository: {
+        links: {
+            self: {
+                href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest"
+            },
+            avatar: {
+                href: "https://d3oaxc4q5k2d6q.cloudfront.net/m/bf1e763db20f/img/language-avatars/java_16.png"
+            }
+        },
+        full_name: "atlassian/atlassian-rest",
+        name: "atlassian-rest"
+    },
+    author: {
+        raw: "Joseph Walton <jwalton@atlassian.com>",
+        user: {
+            username: "jwalton",
+            display_name: "Joseph Walton",
+            links: {
+                self: {
+                    href: "https://api.bitbucket.org/2.0/users/jwalton"
+                },
+                avatar: {
+                    href: "https://secure.gravatar.com/avatar/8e6e91101e3ed8a332dbebfdf59a3cef?d=https%3A%2F%2Fd3oaxc4q5k2d6q.cloudfront.net%2Fm%2Fbf1e763db20f%2Fimg%2Fdefault_avatar%2F32%2Fuser_blue.png&s=32"
+                }
+            }
+        }
+    },
+    participants: [{
+        role: "PARTICIPANT",
+        user: {
+            username: "evzijst",
+            display_name: "Erik van Zijst",
+            links: {
+                self: {
+                    href: "https://api.bitbucket.org/2.0/users/evzijst"
+                },
+                avatar: {
+                    href: "https://secure.gravatar.com/avatar/f6bcbb4e3f665e74455bd8c0b4b3afba?d=https%3A%2F%2Fd3oaxc4q5k2d6q.cloudfront.net%2Fm%2Fbf1e763db20f%2Fimg%2Fdefault_avatar%2F32%2Fuser_blue.png&s=32"
+                }
+            }
+        },
+        approved: false
+    }],
+    parents: [{
+        hash: "59721f593b020123a75424285845325126f56e2e",
+        links: {
+            self: {
+                href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/commit/59721f593b020123a75424285845325126f56e2e"
+            }
+        }
+    }, {
+        hash: "56c49d8b2ae3a094fa7ba5a1251d6dd2c7c66993",
+        links: {
+            self: {
+                href: "https://api.bitbucket.org/2.0/repositories/atlassian/atlassian-rest/commit/56c49d8b2ae3a094fa7ba5a1251d6dd2c7c66993"
+            }
+        }
+    }],
+    date: "2013-10-21T07:21:51+00:00",
+    message: "Merge remote-tracking branch 'origin/rest-2.8.x' "
+}
+```
+
+Obviously, mining the two datasets for a bunch of commits will require a lot of parsing to unify the two data structures presented here.
+
+In step the Normalizers. For this example ee'd create two separate normalizers for these datasets, one for GH, one for BB:
+
+```ruby
+class GitHubNormalizer < Schemad::Normalizer
+  normalize :id, key: :sha
+  normalize :url, key: :url
+  normalize :committer, key: "committer/name"
+  normalize :created_date, key: "committer/date"
+  normalize :comment, key: :message
+end
+```
+
+We could obviously also include additional data if we wanted. Notice you can use either symbols or strings as keys. If you want to do a deep traversal (more than one level), you will need to use strings with a "/" delimited path.
+
+Now for BitBucket:
+
+```ruby
+class BitBucketNormalizer < Schemad::Normalizer
+  normalize :id, key: :hash
+  normalize :url, key: "links/self/href"
+  normalize :committer, key: "author/user/display_name"
+  normalize :created_date, key: :date
+  normalize :comment, key: :message
+end
+```
+
+Sweet. So now when we get the json from the API, all we need to do with these classes is:
+
+```ruby
+raw_json = some_http_get("https://api.github.com/path/to/my/commit")
+github_data = JSON.parse(raw_json)
+
+parsed = GitHubNormalizer.new.normalize(github_data)
+```
+
+And we should then have a plain hash much like the following: 
+
+```ruby
+{
+  id: "7638417db6d59f3c431d3e1f261cc637155684cd",
+  url: "https://api.github.com/repos/octocat/Hello-World/git/commits/7638417db6d59f3c431d3e1f261cc637155684cd",
+  committer: "Scott Chacon",
+  created_date: "2010-04-10T14:10:01-07:00",
+  comment: "added readme, because im a good github citizen\n"
+}
+```
+
+Our BitBucket normalizer would work the same way, we'd just use it to run through data harvested by our BitBucket requests.
+
+Two things of mention: First, the normalizers can also be passed a block to perform additional data manipulation. For example, assume we wanted to harvest an email field. GitHub provides this to us directly to use:
+
+```ruby
+class GitHubNormalizer < Schemad::Normalizer
+  # ... other normalizers
+  normalize :email, key: "committer/email"
+end
+```
+
+However, BitBucket does not directly. It's wrapped within the "raw" field in the author hash. So we can provide additional modifiers to get this:
+
+```ruby
+class BitBucketNormalizer < Schemad::Normalizer
+  # ... other normalizers
+  normalize :email, key: "author/raw" do |value|
+    value.match(/\A[\w|\s]+<(.+)>\z/).captures.first
+  end
+end
+```
+
+Now the normalizer will use the raw field and pick out the email using a regex matcher. Now you might be tempted to use the normalizer blocks to manipulate the fields into ruby types, as the normalizers do not attempt to parse the data types. You'll notice in the above examples that date strings are left as strings through the normalization. This brings us to our second thing to note: Normalizers _only parse data into consistent structures_. They are not responsible for type casting. This is intentional and brings us to the role of the Entity.
+
+## Entities
+
+Entities provide consistent [value objects](http://martinfowler.com/bliki/ValueObject.html) that allow for easily transporting the data to functionality that uses the data. Entities are very limited in functionality and are mainly meant to provide a more ruby-ish means of accessing the data. We _could_ pass around the normalized hashes, but typically, we rubyists like having method access to our data: 
+
+```ruby
+commit.comment        # "added readme, because im a good github citizen\n"
+commit.id             # "7638417db6d59f3c431d3e1f261cc637155684cd"
+comment.created_date  # A time object!
+```
+
+So this is what Entities provide. 
+
+```ruby
+class Commit < Schemad::Entity
+  attribute :id
+  attribute :committer
+  attribute :comment
+  attribute :created_date, type: :date_time
+  attribute :email
+  attribute :url
+end
+```
+
+Note that the default attribute type (if not provided) is a string (`:string`). Currently supported types are
+
+- :string
+- :time, :date, :date_time (all the same in our case)
+- :integer
+- :boolean
+
+New types are easy to create, more on this in a moment.
+
+To instantiate these new class, we use the `from_data` method to ensure parsing with the output from the normalizer step above:
+
+```ruby
+raw_json = some_http_get("https://api.github.com/path/to/my/commit")
+github_data = JSON.parse(raw_json)
+
+parsed = GitHubNormalizer.new.normalize(github_data)
+
+commit = Commit.from_data(parsed)
+
+commit.comment        # "added readme, because im a good github citizen\n"
+commit.id             # "7638417db6d59f3c431d3e1f261cc637155684cd"
+comment.created_date  # A time object!
+```
+
+You don't have to use the normalizers to use the `from_data` method. It can be any consistently formatted hash. The keys **must** be accessible by symbol however (use a hash with all symbols as keys or an ActiveSupport/Hashie/other [HashWithIndifferentAccess](http://api.rubyonrails.org/classes/ActiveSupport/HashWithIndifferentAccess.html) implementation).
+
+In fact, both normalizer and entity can be used independent of one another if one or the other isn't required for your use. Just include the library you want: 
+
+```ruby
+require 'schemad/type_handler'
+require 'schemad/normalizer'
+require 'schemad/entity'
+
+# or to get all...
+require 'schemad'
+```
+
+## Type Handlers
+
+On a side note, we have a number of very simple type handlers, you can see them all in the various type definitions [type_handler](https://github.com/plukevdh/schemad/tree/master/lib/schemad/types).
+
+It is _also_ possible to use these however you want in your own classes, but there are far more complete and complex type handlers elsewhere. If you find these types unsatisfactory or wish to use additional types, you can easily define your own.
+
+```ruby
+class YouMomHandler < Schemad::AbstractHandler
+  handle :your_mom
+
+  def parse(value)
+    "Your Mom"
+  end
+end
+
+# register this handler
+Schemad::TypeHandler.register YourMomHandler
+
+# alternatively...
+YourMomHandler.register_with Schemad::TypeHandler
+```
+
+Now when you want to have your entity turn anything into your mother, simply add the type `:your_mom` to the attribute definition.
+
+```ruby
+class Commit < Schemad::Entity
+  # ...
+  attribute :comment, type: :your_mom
+end
+
+commit = Commit.from_data(parsed)
+
+commit.comment        # "Your Mom"
+```
+
+## Notes
+
+[Hashie](https://github.com/intridea/hashie) is probably a better idea than this gem. But I couldn't find a decent way to combine the [DeepFetch](https://github.com/intridea/hashie#deepfetch) functionality with the [Dash](https://github.com/intridea/hashie#dash)/[Trash](https://github.com/intridea/hashie#trash) functionality. This is also likely much ligher weight and therefore about half as meta.
+
+Be warned, this is a lot of crazy metacode and it's _mostly_ recommended you don't use this for real. Mostly. But it is awesome.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'schemad'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install schemad
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/schemad/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+

data/lib/schemad/abstract_handler.rb

@@ -0,0 +1,16 @@
+module Schemad
+	class AbstractHandler
+		def self.register_with(with)
+			with.register self
+		end
+
+    def self.handle(*types)
+      @types ||= []
+      @types.concat types
+    end
+
+    def self.handles
+      @types
+    end
+	end
+end

data/lib/schemad/entity.rb

@@ -0,0 +1,74 @@
+require 'schemad/extensions'
+require 'schemad/type_handler'
+
+module Schemad
+  class Entity
+    extend Schemad::Extensions
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@attributes, [])
+    end
+
+    def self.attribute(name, args={}, &block)
+      attr_accessor name
+
+      define_parser_for(name, args, &block)
+
+      @attributes << name
+    end
+
+    # expect data hash to have symbol keys at this point
+    # normalizer should standardize this
+    def self.from_data(data)
+      obj = new
+
+      @attributes.each do |key|
+        value = obj.send "parse_#{key}", data
+        obj.send "#{key}=", value
+      end
+
+      obj
+    end
+
+    def attribute_names
+      self.class.instance_variable_get(:@attributes)
+    end
+
+    def to_hash
+      hash = {}
+      attribute_names.each do |key|
+        hash[key] = send key
+      end
+
+      hash
+    end
+    alias_method :attributes, :to_hash
+
+    private
+
+    def self.define_parser_for(name, args, &block)
+      define_method "parse_#{name}" do |data|
+        value = data[name]
+        value ||= get_default(args[:default])
+
+        self.send "#{name}=", coerce_to_type(value, args[:type])
+      end
+
+      define_method "#{name}?" do
+        !!send(name)
+      end if args[:type] == :boolean
+    end
+
+    def get_default(default_provider)
+      return default_provider unless default_provider.is_a? Proc
+      default_provider.call
+    end
+
+    def coerce_to_type(value, type)
+      type ||= :string
+
+      handler = TypeHandler.new type
+      handler.parse(value)
+    end
+  end
+end

data/lib/schemad/extensions.rb

@@ -0,0 +1,39 @@
+require 'active_support/inflector'
+require 'active_support/concern'
+require 'active_support/core_ext/hash'
+require 'active_support/hash_with_indifferent_access'
+
+module Schemad
+  module Extensions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def base_class_name
+        name.demodulize
+      end
+    end
+
+    def base_class_name
+      self.class.base_class_name
+    end
+
+    private
+    # TODO: decide if I still want this method around. modifies repos
+    # def add_behavior(repo, additions)
+    #   repo.extend additions
+    # end
+
+    def constantize(string)
+      string.to_s.constantize
+    end
+
+    def classify(string)
+      string = "nil" if string.nil?
+      string.to_s.classify
+    end
+
+    def indifferent_hash(hash)
+      ActiveSupport::HashWithIndifferentAccess.new hash
+    end
+  end
+end

data/lib/schemad/normalizer.rb

@@ -0,0 +1,93 @@
+require 'schemad/extensions'
+
+module Schemad
+  class Normalizer
+    include Schemad::Extensions
+
+    DELIMITER = "/"
+
+    InvalidPath = Class.new(Exception)
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@normalizers, {})
+      subclass.instance_variable_set(:@allowed_attributes, [])
+    end
+
+    def self.include_fields(fields)
+      @allowed_attributes.concat fields
+    end
+
+    def self.normalize(name, args={}, &block)
+      lookup = args[:key] || name
+      method_name = normalizer_method_name(name)
+
+      @normalizers[lookup] = name
+      @allowed_attributes << lookup
+
+      define_method method_name do |data|
+        value = find_value lookup, data
+        return value unless block_given?
+
+        yield value
+      end
+    end
+
+    def normalize(data)
+      normalized = {}
+
+      allowed_attributes.each do |key|
+        to_key = normalizers[key]
+
+        if to_key
+          normalized[to_key] = self.send normalizer_method_name(to_key), data
+        else
+          normalized[key_from_path(key)] = find_value(key, data)
+        end
+      end
+
+      normalized
+    end
+
+    def normalizers
+      self.class.instance_variable_get(:@normalizers)
+    end
+
+    def allowed_attributes
+      self.class.instance_variable_get(:@allowed_attributes)
+    end
+
+    private
+    def path_steps(key)
+      key.to_s.split(DELIMITER)
+    end
+
+    def key_from_path(path)
+      path_steps(path).last.to_sym
+    end
+
+    def find_value(key, data)
+      begin
+        search_data path_steps(key), indifferent_hash(data)
+      rescue InvalidPath => e
+        # rethrow with more info
+        raise e, "Can't find value for \"#{key}\""
+      end
+    end
+
+    def search_data(steps, data)
+      step = steps.shift
+      return data unless step
+      raise InvalidPath if data.nil?
+
+      search_data steps, data[step]
+    end
+
+    def self.normalizer_method_name(field)
+      "normalize_#{field}".to_sym
+    end
+
+    def normalizer_method_name(field)
+      self.class.normalizer_method_name(field)
+    end
+  end
+end

data/lib/schemad/type_handler.rb

@@ -0,0 +1,34 @@
+require 'time'
+require 'schemad/extensions'
+
+module Schemad
+  class TypeHandler
+    include Extensions
+    extend Forwardable
+
+    UnknownHandler = Class.new(Exception)
+
+    def self.register(handler)
+      @types ||= {}
+
+      handler.handles.each do |type|
+        @types[type] = handler
+      end
+    end
+
+    def initialize(type=:string)
+      handler = handlers[type]
+
+      raise UnknownHandler, "No known handlers for #{classify(type)}" if handler.nil?
+
+      @handler = handler.new
+    end
+
+    def_delegators :@handler, :parse
+
+    private
+    def handlers
+      self.class.instance_variable_get(:@types) || {}
+    end
+  end
+end

data/lib/schemad/types/boolean_handler.rb

@@ -0,0 +1,13 @@
+module Schemad
+  class BooleanHandler < AbstractHandler
+    VALID_TRUTHS = ["true", true, "t", "T", "1", 1, "TRUE"]
+
+    handle :boolean, :bool
+
+    def parse(value)
+      VALID_TRUTHS.include? value
+    end
+  end
+end
+
+Schemad::BooleanHandler.register_with Schemad::TypeHandler

data/lib/schemad/types/integer_handler.rb

@@ -0,0 +1,16 @@
+module Schemad
+	class IntegerHandler < AbstractHandler
+    handle :integer
+
+    def parse(value)
+      case value
+      when TrueClass, FalseClass
+        value ? 1 : 0
+      else
+        value.to_i rescue nil
+      end
+    end
+  end
+end
+
+Schemad::IntegerHandler.register_with Schemad::TypeHandler

data/lib/schemad/types/string_handler.rb

@@ -0,0 +1,11 @@
+module Schemad
+	class StringHandler < AbstractHandler
+    handle :string
+
+    def parse(value)
+      value.to_s
+    end
+  end
+end
+
+Schemad::StringHandler.register_with Schemad::TypeHandler

data/lib/schemad/types/time_handler.rb

@@ -0,0 +1,19 @@
+module Schemad
+  class TimeHandler < AbstractHandler
+    handle :time, :date, :date_time
+
+    def parse(value)
+      return value.to_time if value.respond_to?(:to_time)
+
+      begin
+        Time.at(value)
+      rescue TypeError => e
+        Time.parse(value)
+      rescue ArgumentError => e
+        nil
+      end
+    end
+  end
+end
+
+Schemad::TimeHandler.register_with Schemad::TypeHandler

data/lib/schemad/version.rb

@@ -0,0 +1,3 @@
+module Schemad
+  VERSION = "1.0.0"
+end

data/lib/schemad.rb

@@ -0,0 +1,7 @@
+require "schemad/version"
+
+require 'schemad/type_handler'
+require 'schemad/normalizer'
+require 'schemad/entity'
+
+module Schemad ; end

data/schemad.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schemad/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "schemad"
+  spec.version       = Schemad::VERSION
+  spec.authors       = ["Luke van der Hoeven"]
+  spec.email         = ["hungerandthirst@gmail.com"]
+  spec.summary       = %q{Simple schema DSL for services}
+  spec.description   = %q{
+    This gem allows easy attribute definition, type casting and special handling
+    of data returned from a service of some kind. It's meant to be incredibly general
+    purpose. Maybe this is a bad idea...
+  }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 4.1"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/spec/entity_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'timecop'
+require 'schemad/entity'
+
+require_relative 'fixtures/demo_class'
+
+describe Schemad::Entity do
+  before { Timecop.freeze }
+  after { Timecop.return }
+
+  Given(:normal_data) {{
+    world: "coordinates",
+    cool: true,
+    roads: 5,
+    beasts: "1337"
+  }}
+
+  context "#from_data" do
+    Given(:ent) { Ent.from_data(normal_data) }
+
+    Then { ent.attribute_names.should == [:forest, :roads, :beasts, :world, :cool, :created]}
+
+    context "defaults or nil get used when no data" do
+
+      Then { ent.forest.should == "Green" }
+      And { ent.cool.should be_true }
+      And { ent.created.should eq(Time.now) }
+      And { ent.roads.should == 5 }
+      And { ent.world.should == "coordinates" }
+    end
+
+    context "parses types" do
+      Then { ent.beasts.should == 1337 }
+    end
+
+    context "defines #? method for bools" do
+      Then { ent.should be_cool }
+    end
+
+    context "assumes string if no type given" do
+      Then { ent.world.should be_a(String) }
+    end
+
+    context "can get all params as a hash" do
+      When(:hash) { ent.to_hash }
+      Then { hash.should == {
+        forest: "Green",
+        roads: 5,
+        beasts: 1337,
+        world: "coordinates",
+        cool: true,
+        created: Time.now
+      }}
+    end
+  end
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'schemad/extensions'
+
+class Demo
+  class Foo
+    class Bar
+      include Schemad::Extensions
+    end
+  end
+end
+
+describe Schemad::Extensions do
+  Given(:ext) { Demo::Foo::Bar.new }
+
+  context "base class name getter" do
+    When(:class_base) { Demo::Foo::Bar.base_class_name }
+    Then { class_base.should == "Bar" }
+  end
+
+  context "instance method for base class" do
+    When(:base) { ext.base_class_name }
+    Then { base.should == "Bar" }
+  end
+
+  context "constantizer" do
+    When(:const) { ext.send :constantize, "Demo::Foo::Bar" }
+    Then { const.should == Demo::Foo::Bar }
+  end
+
+  context "classifier" do
+    When(:classy) { ext.send :classify, "demo_foo_bar" }
+    Then { classy.should == "DemoFooBar" }
+  end
+
+  context "indifferent hash wrapper" do
+    When(:converted) { ext.send :indifferent_hash, {one: 1, "two" => 2, "Three and Four" => 34} }
+    Then { converted["one"].should == 1 }
+    And { converted[:two].should == 2 }
+    And { converted["Three and Four"].should == 34 }
+  end
+end

data/spec/fixtures/demo_class.rb

@@ -0,0 +1,8 @@
+class Ent < Schemad::Entity
+  attribute :forest, type: :string, default: "Green"
+  attribute :roads, type: :integer
+  attribute :beasts, type: :integer
+  attribute :world
+  attribute :cool, type: :boolean
+  attribute :created, type: :date_time, default: -> { Time.now }
+end

data/spec/normalizer_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'schemad/normalizer'
+
+class Demalizer < Schemad::Normalizer
+  normalize :world, key: "Middle Earth" do |val|
+    val.upcase
+  end
+  normalize :roads do |val|
+    val * 10
+  end
+end
+
+describe Schemad::Normalizer do
+  Given(:data) {{
+    "Middle Earth" => "coordinates",
+    cool: "true",
+    roads: 5,
+    "beasts" => "1337"
+  }}
+
+  Given(:normalizer) { Demalizer.new }
+
+  context "normalization" do
+    When(:normalized) { normalizer.normalize(data) }
+
+    context "maps specified keys" do
+      Then { normalized[:world].should == "COORDINATES" }
+      And { normalized[:roads].should == 50 }
+    end
+
+    context "does not pass through unspecified keys" do
+      Then { normalized[:cool].should be_nil }
+      And { normalized[:beasts].should be_nil }
+    end
+  end
+
+  context "additional fields" do
+    Given { normalizer.class.include_fields [:beasts, :cool] }
+    When(:normalized) { normalizer.normalize(data) }
+
+    context "can be specified" do
+      Then { normalized[:cool].should == "true" }
+      And { normalized[:beasts].should == "1337" }
+    end
+
+    context "converts all keys to symbols" do
+      Then { normalized[:cool].should_not be_nil }
+      And { normalized[:beasts].should_not be_nil }
+      And { normalized["Middle Earth"].should be_nil }
+    end
+  end
+
+  context "can mine nested properties" do
+    class BucketNormalizer < Schemad::Normalizer
+      normalize :answer_to_the_universe, key: "useless_root"
+      normalize :username, key: "author/user/username"
+      normalize :avatar_url, key: "author/user/links/avatar/href"
+      normalize :email, key: "author/raw" do |value|
+        value.match(/\A[\w|\s]+<(.+)>\z/).captures.first
+      end
+    end
+
+    class BadNormalizer < Schemad::Normalizer
+      # missing the "links" part of the path
+      normalize :avatar_url, key: "author/user/avatar/href"
+    end
+
+    Given(:data) {
+    { useless_root: 42,
+      author: {
+        raw: "Joseph Walton <jwalton@atlassian.com>",
+        user: {
+          username: "jwalton",
+          display_name: "Joseph Walton",
+          links: {
+            self: {
+              href: "https://api.bitbucket.org/2.0/users/jwalton"
+            },
+            avatar: {
+              href: "funk_blue.png"
+            }
+          }
+          }
+      }
+    } }
+
+    context "parses paths" do
+      Given(:normalizer) { BucketNormalizer.new }
+      When(:results) { normalizer.normalize(data) }
+      Then { results[:username].should == "jwalton" }
+      And { results[:avatar_url].should == "funk_blue.png" }
+      And { results[:email].should == "jwalton@atlassian.com" }
+      And { results[:answer_to_the_universe].should == 42 }
+    end
+
+    context "bad path throws exception" do
+      Given(:normalizer) { BadNormalizer.new }
+      When(:results) { normalizer.normalize(data) }
+      Then { expect(results).to have_failed(Schemad::Normalizer::InvalidPath, /author\/user\/avatar\/href/) }
+    end
+
+    context "can allow fields from nested data" do
+      Given { BucketNormalizer.include_fields ["author/user/display_name"] }
+      Given(:normalizer) { BucketNormalizer.new }
+      When(:results) { normalizer.normalize(data) }
+      Then { results[:display_name].should == "Joseph Walton" }
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# $LOAD_PATH.unshift "../lib"
+
+require 'rspec/given'
+require 'pry'

data/spec/type_handler_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+require 'schemad/type_handler'
+require 'schemad/abstract_handler'
+
+require 'schemad/types/boolean_handler'
+require 'schemad/types/string_handler'
+require 'schemad/types/time_handler'
+require 'schemad/types/integer_handler'
+
+describe Schemad::TypeHandler do
+
+  context "rejects unknown types" do
+    When(:typer) { Schemad::TypeHandler.new(:fake_type) }
+    Then { expect(typer).to have_failed(Schemad::TypeHandler::UnknownHandler, /No known handlers for FakeType/) }
+  end
+
+  context "defaults to string type" do
+    When(:typer) { Schemad::TypeHandler.new }
+    Then { expect(typer.instance_variable_get(:@handler)).to be_a(Schemad::StringHandler) }
+  end
+
+  context "can register custom handlers" do
+    class YouMomHandler < Schemad::AbstractHandler
+      handle :your_mom
+
+      def parse(value)
+        "Your Mom"
+      end
+    end
+
+    Given { Schemad::TypeHandler.register(YouMomHandler) }
+    Given(:typer) { Schemad::TypeHandler.new(:your_mom) }
+    When(:parsed) { typer.parse("Good vs. Evil") }
+    Then { parsed.should == "Your Mom" }
+  end
+
+  context "can handle bools" do
+    Given(:bool_handler) { Schemad::TypeHandler.new(:boolean) }
+
+    context "knows trues" do
+      Schemad::BooleanHandler::VALID_TRUTHS.each do |val|
+        When(:parsed) { bool_handler.parse(val) }
+        Then { parsed.should be_true }
+      end
+    end
+
+    context "rejects falses" do
+      [42, "Hello World", nil, String].each do |val|
+        When(:parsed) { bool_handler.parse(val) }
+        Then { parsed.should be_false }
+      end
+    end
+  end
+
+  context "can parse integers" do
+    Given(:int_handler) { Schemad::TypeHandler.new(:integer) }
+
+    context "true to 1" do
+      When(:result) { int_handler.parse(true) }
+      Then { result.should eq(1) }
+    end
+
+    context "false to 0" do
+      When(:result) { int_handler.parse(false) }
+      Then { result.should eq(0) }
+    end
+
+    context "strings to numbers" do
+      When(:result) { int_handler.parse("42") }
+      Then { result.should == 42 }
+    end
+
+    context "odd strings to 0" do
+      When(:result) { int_handler.parse("sneeze") }
+      Then { result.should == 0 }
+    end
+
+    context "nil for unknown items" do
+      When(:result) { int_handler.parse(String) }
+      Then { result.should == nil }
+    end
+  end
+
+  context "can parse dates" do
+    Given(:date_handler) { Schemad::TypeHandler.new(:date_time) }
+    Given(:time) { DateTime.now.to_time }
+
+    context "knows unix time" do
+      When(:result) { date_handler.parse(time.to_i) }
+      Then { result.to_i.should == time.to_i }
+    end
+
+    context "knows iso8601 time" do
+      When(:result) { date_handler.parse(time.iso8601) }
+      Then { result.to_i.should == time.to_i }
+    end
+
+    context "knows ruby date format time" do
+      When(:result) { date_handler.parse(time.to_s) }
+      Then { result.to_i.should == time.to_i }
+    end
+
+    context "knows ruby date object" do
+      Given(:date) { Date.today }
+      When(:result) { date_handler.parse(date) }
+      Then { result.should be_a(Time) }
+      And { result.to_i.should == date.to_time.to_i }
+    end
+
+    context "knows ruby time objects" do
+      Given(:time) { Time.now }
+      When(:result) { date_handler.parse(time) }
+      Then { result.should be_a(Time) }
+      Then { result.to_i.should == time.to_i }
+    end
+
+    context "knows ruby time objects" do
+      Given(:date_time) { DateTime.now }
+      When(:result) { date_handler.parse(date_time) }
+      Then { result.should be_a(Time) }
+      Then { result.to_i.should == date_time.to_time.to_i }
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: schemad
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Luke van der Hoeven
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+description: "\n    This gem allows easy attribute definition, type casting and special
+  handling\n    of data returned from a service of some kind. It's meant to be incredibly
+  general\n    purpose. Maybe this is a bad idea...\n  "
+email:
+- hungerandthirst@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/schemad.rb
+- lib/schemad/abstract_handler.rb
+- lib/schemad/entity.rb
+- lib/schemad/extensions.rb
+- lib/schemad/normalizer.rb
+- lib/schemad/type_handler.rb
+- lib/schemad/types/boolean_handler.rb
+- lib/schemad/types/integer_handler.rb
+- lib/schemad/types/string_handler.rb
+- lib/schemad/types/time_handler.rb
+- lib/schemad/version.rb
+- schemad.gemspec
+- spec/entity_spec.rb
+- spec/extensions_spec.rb
+- spec/fixtures/demo_class.rb
+- spec/normalizer_spec.rb
+- spec/spec_helper.rb
+- spec/type_handler_spec.rb
+homepage: ''
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple schema DSL for services
+test_files:
+- spec/entity_spec.rb
+- spec/extensions_spec.rb
+- spec/fixtures/demo_class.rb
+- spec/normalizer_spec.rb
+- spec/spec_helper.rb
+- spec/type_handler_spec.rb