skemata 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6713230674986ff5f3405c68207d6949d504da6
+  data.tar.gz: 4ab2b8dec03973c1b955f753f40a0f252b3ff2fe
+SHA512:
+  metadata.gz: 04bb556c6667236d33a94c9d9bf946458d1d402104c01d5eb8fbfbac8960f3132345ed9779004302faac87b9d824101f3e410f0edd16e2fe9557eb3ebe9426e2
+  data.tar.gz: 0bf7afd80d1a4f2efbafc434500967470e8a5dae4b2aeed1116f8ff8c8d6f7b7af13160988f2de6a8b0bd8afb5e6239db46e75b5ba0a6cfa022c416a6502074f

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,6 @@
+/.bundle
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--require skemata
+--colour --format documentation

data/.rubocop.yml

@@ -0,0 +1,21 @@
+AllCops:
+  DisplayCopNames: true
+  Exclude: 
+    - Gemfile
+    - Guardfile
+    - Rakefile
+    - ./vendor/**/*
+    - ./spec/**/*
+    - ./kagu/**/*
+
+Style/Documentation:
+  Enabled: false
+
+Lint/Debugger:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+2.4.0

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "skemata Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2017-04-12
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'kramdown'
+end

data/Guardfile

@@ -0,0 +1,75 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end
+
+guard :rubocop, cli: %w(-a) do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 MyBankTracker
+
+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/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2017 
+
+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,159 @@
+# skemata
+
+A lightweight schema.org object DSL written in Ruby. This library is currently under active development and is missing many features, including validation. See the [contributing](#contributing) section for more information. 
+
+[![Code Climate](https://codeclimate.com/github/mybanktracker/skemata.png)](https://codeclimate.com/github/mybanktracker/skemata) ![CircleCI](https://circleci.com/gh/mybanktracker/skemata.svg?style=shield&circle-token=11b5d953bf45ab8237fe2eb5091a2c320c358417) [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/mybanktracker/skemata/master)
+
+
+
+## Getting Started
+Developed against MRI 2.4.0
+
+Add the following line to your `Gemfile`:
+```ruby
+gem 'skemata'
+```
+
+...or this to your `*.gemspec`:
+```ruby
+gem.add_dependency 'skemata'
+```
+
+...and then `bundle`
+
+## Basic Usage
+Invoke `Skemata.draw` with a [schema.org](http://schema.org/docs/schemas.html) type and a PORO that you wish to serialize. If an attribute isn't present, it will default to `null`. Provide a block to an attribute key to draw a child object. That's it!
+
+```ruby
+require 'skemata'
+
+schema_json = Skemata.draw :Thing, Dog.last do
+  name
+  description
+  # You can also provide any kind of Ruby PORO for attribute values as long as they are serializable!
+  some_custom_attribute_not_in_the_object 'woop woop'
+end
+```
+
+`schema_json` looks like this: 
+```json
+{
+  "@type": "Product",
+  "@context": "https://schema.org",
+  "name": "Fido",
+  "description": "Cute and adorable!",
+  "some_custom_attribute_not_in_the_object": "woop woop"
+}
+```
+
+## Advanced Usage
+
+### Defining attributes explicitly
+
+- `different_key :attribute_name_on_object` can be used to specify a different field name in the output JSON (for presentation), while `:attribute_name_on_object` will be the attribute that is retrieved from the object being serialized. 
+
+```ruby
+car = OpenStruct.new(
+  brand: 'Mercedes-Benz',
+  model: 'E550',
+  next_model_up: OpenStruct.new(brand: 'Mercedes-Benz', model: 'E63 AMG')
+)
+
+car_json = Skemata.draw :Vehicle, car do
+  brand_name :brand
+  model
+  next_model_up :Vehicle, :next_model_up do 
+    model
+  end
+end
+```
+
+`car_json` looks like this:
+
+```json
+{
+  "@type": "Vehicle",
+  "@context": "https://schema.org",
+  "brand_name": "Mercedes-Benz",
+  "model": "E550",
+  "next_model_up": {
+    "@type": "Vehicle",
+    "model": "E63 AMG"
+  }
+}
+```
+
+### Resolving attributes implicitly
+After defining a few objects, it may become apparent that a lot of the schema entries for keys may match attributes on your objects. Skemata can infer field names by using the schema object type or the field name. 
+
+#### Fields
+- `attribute_name` is short for `attribute_name :attribute_name`. If these two match, the `:attribute_name` symbol does not need to be specified.
+
+#### Objects
+```ruby
+object_key :Type, :attribute_key do 
+  # attributes
+end
+```
+
+Shown above is the explicit way to specify a new child object with `object_key` under the parent (`:attribute_key` is the key containing another object to serialize in the block provided), with type `:Type`. It has happened frequently that either the `object_key` or `:Type` are actually fields in objects that we wish to serialize. The DSL will attempt to resolve both `object_key` and `:Type` by seeing if the `root_object` has either attribute before falling back on the explicit definition of `:attribute_key` if present. 
+
+##### Even less explicit!
+If you know that the `root_object` has an attribute with the same name as `:type`, you do not need to provide any other arguments (other than the block).
+
+```ruby
+object_key :type do 
+  # attributes
+end
+```
+
+### Hashes
+Specify attributes as Hash keys.
+
+```ruby
+Skemata.draw :Foo, { bar: 'baz' } do
+  bar
+  bar_with_another_name :bar
+end
+```
+
+```json
+{"@type":"Foo","@context":"https://schema.org","bar":"baz","bar_with_another_name":"baz"}
+```
+
+### Distant attributes
+Sometimes it is necessary to retrieve attributes from relational data (e.g. an `ActiveRecord` model) without serializing the whole object as a new child. Assuming a `Student` model with a `Parent` that has a `name` field. 
+
+```ruby
+Skemata.draw :Person, Student.last do
+  parent_name nested(:parent, :name)
+end
+```
+
+```json
+{"@type":"Person","@context":"https://schema.org","parent_name":"Some Name"}
+```
+
+#### Applying transformations
+If this was not already apparent, since we effectively fold into one object for presentation, you can use any method that each successive object will respond to. Using the previous example, it would be valid to do this:
+
+```ruby
+nested(:parent, :name, :upcase)
+```
+
+## Contributing
+This library is being built incrementally with features that are of immediate need. That being said, there is a plan to build:
+- schema.org type validations
+- Mapping support
+	- Define a map for a certain object type and automatically marshal those objects without explicitly drawing it each time
+
+### How to contribute
+- Fork
+- Make a new branch
+- Write tests / ensure there are no linting errors
+- Pull request
+
+## Credits
+Copyright (c) [David Stancu](https://davidstancu.me), contributors, MBTMedia LLC 2017.
+
+[MIT License](https://github.com/mybanktracker/skemata/blob/master/LICENSE.txt)

data/Rakefile

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => e
+  abort e.message
+end
+
+require 'rake'
+
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard

data/lib/skemata.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'skemata/version'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Skemata
+  extend ActiveSupport::Autoload
+
+  autoload :DSL
+  autoload :Node
+
+  def self.draw(type, root_object, &block)
+    DSL.draw({ type: type, root_object: root_object }, &block)
+  end
+end

data/lib/skemata/dsl.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Skemata
+  class DSL
+    # Make a new type
+    class NodeMethodChain < Array; end
+
+    class << self
+      #
+      # Draw a schema.org node. Creates a new DSL class for each child node.
+      # @param opts = {} [Hash] Options hash
+      #   root_object (required): Object you wish to serialize
+      #   type        (required): schema.org type
+      #   is_root     (optional): Is this the top level object
+      # @param &block [Block] DSL schema definition
+      #
+      # @return [String] schema.org JSON structure
+      def draw(opts = {}, &block)
+        dsl = new(Node.new(opts))
+        dsl.instance_eval(&block)
+        opts.fetch(:is_root, true) ? dsl.node.data.to_json : dsl.node.data
+      end
+    end
+
+    #
+    # Prepares DSL instance by assigning Node
+    # @param node [Node] Data object
+    #
+    # @return [DSL] A DSL class.
+    def initialize(node)
+      raise(
+        ArgumentError, 'DSL must be provided with a Skemata::Node type!'
+      ) unless node.is_a?(Node)
+
+      @node = node
+    end
+
+    # rubocop:disable Style/MethodMissing
+    # TODO: special token so we can define respond_to_missing?
+    def method_missing(name, *args, &block)
+      node.decorate(name, *args, &block)
+    end
+    # rubocop:enable Style/MethodMissing
+
+    #
+    # Delegator to NodeMethodChain.new
+    # @param *args [varargs]
+    #
+    # @return [NodeMethodChain]
+    def nested(*args)
+      NodeMethodChain.new(args)
+    end
+
+    attr_reader :node
+  end
+end

data/lib/skemata/node.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Skemata
+  class Node
+    ALLOWED_OPTS = %i[type root_object].freeze
+    #
+    # Prepares internal data hash and assigns locals
+    # @param opts = {} [Hash] See Skemata::DSL.draw for valid
+    #                         opts
+    #
+    # @return [Node] A Node class.
+    def initialize(opts = {})
+      ALLOWED_OPTS.each { |o| instance_variable_set("@#{o}", opts[o]) }
+      @data = { '@type' => type }
+      @data['@context'] = 'https://schema.org' if opts.fetch(:is_root, true)
+    end
+
+    #
+    # Decorate the node with a new property (as delegated by method_missing)
+    #
+    # @param name [Symbol] Key name
+    # @param *args [Array] Varargs for attributes describing key
+    # @param &block [Proc] Body for a child node, if present
+    #
+    def decorate(name, *args, &block)
+      # Draw another node
+      return route_block(name, *args, &block) if block.present?
+      # Or populate the hash
+      data[attify_token(name)] = extract(args.first || name.to_sym)
+    end
+
+    attr_reader :data
+
+    private
+
+    attr_reader :root_object, :type
+
+    RESERVED_SCHEMA_TOKENS = %w[id type context].freeze
+    #
+    # Interpolate @ into string of reserved schema.org names
+    # @param token [String] Key
+    #
+    # @return [String]
+    def attify_token(token)
+      RESERVED_SCHEMA_TOKENS.include?(token) ? "@#{token}" : token
+    end
+
+    #
+    # Driver for #fetch_property. If passed a NodeMethodChain (Array), fold
+    # the chain of methods until the final value. If passed a Symbol,
+    # just extract that single method.
+    #
+    # @param property [Symbol|NodeMethodChain] Propert(ies) to extract
+    #
+    # @return [Object] Serializable value
+    def extract(property)
+      case property
+      when DSL::NodeMethodChain
+        property.inject(root_object, &method(:fetch_property))
+      when Symbol
+        fetch_property(root_object, property)
+      else property
+      end
+    rescue NoMethodError, ArgumentError
+      nil
+    end
+
+    #
+    # Extract property from object, if Hash, look up via #[]
+    #
+    # @param object [Object] Object to serialize
+    # @param property [Symbol] Accessor signature
+    #
+    # @return [Object] Serializable value
+    def fetch_property(object, property)
+      object.send(object.is_a?(Hash) ? :fetch : :send, property)
+    end
+
+    def find_property(*props)
+      props.inject(nil) do |m, e|
+        next m if m.present?
+        extract(e.to_s.underscore.to_sym)
+      end
+    end
+
+    #
+    # Draw a new schema.org node and merge it into the current serializable
+    # hash.
+    #
+    # @param token [String] Name of DSL / Hash entry
+    # @param type [String] schema.org type
+    # @param property [Object] Anything, but if symbol,
+    #   will extract from #root_object
+    # @param &block [Block] DSL definition
+    #
+    # @return [Hash] Hash#merge! return value with new node
+    def internal_draw(token, type, property, &block)
+      property = root_object.send(property) if property.is_a?(Symbol)
+      data.merge!(
+        token.to_s => DSL.draw(
+          { type: type, root_object: property, is_root: false },
+          &block
+        )
+      ) if property.present?
+    end
+
+    #
+    # If a schema entry is passed a block, extract the child's root_object
+    # attribute and draw a new node. Attempts to infer the attribute name.
+    #
+    # The token is the schema definition key (e.g. a function invocation),
+    # the type is the schema.org object type, and the last key is the explicit
+    # attribute on the current node's root object. If only the token is
+    # provided, or if both the token and the type are provided, we try to
+    # extract an attribute with either of those names before falling back to
+    # null.
+    #
+    # @param token [String] Invoked method name in DSL.draw block body
+    # @param *args [Array] Contains [type, token]
+    # @param &block [Block] The DSL definition of the child object
+    #
+    # @return [Hash] A copy of the data hash as returned by Hash#merge!
+    def route_block(token, *args, &block)
+      type, prop = args.shift(2)
+
+      # Explicitly defined property
+      child_root = extract(prop) if prop.is_a?(Symbol)
+
+      # Hash key / token is type
+      child_root = extract(token.titleize.to_sym) if type.nil? && prop.nil?
+
+      # If we still have no data, fold to the first present
+      # property by using token and type as keys
+      child_root = find_property(token, type) unless child_root.present?
+
+      internal_draw(token, type, child_root, &block)
+    end
+  end
+end

data/lib/skemata/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Skemata
+  VERSION = '0.0.1'
+end

data/skemata.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skemata/version'
+
+# rubocop:disable Metrics/BlockLength
+Gem::Specification.new do |gem|
+  gem.name          = 'skemata'
+  gem.version       = Skemata::VERSION
+  gem.summary       = 'A DSL designed to draft JSON-LD schema.org objects.'
+  gem.description   = gem.summary
+  gem.license       = 'MIT'
+  gem.authors       = ['David Stancu']
+  gem.email         = 'dstancu@nyu.edu'
+  gem.homepage      = 'https://rubygems.org/gems/skemata'
+
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+
+  `git submodule --quiet foreach --recursive pwd`
+    .split($INPUT_RECORD_SEPARATOR).each do |submodule|
+      submodule.sub!("#{Dir.pwd}/", '')
+
+      Dir.chdir(submodule) do
+        `git ls-files`.split($INPUT_RECORD_SEPARATOR).map do |subpath|
+          gem.files << File.join(submodule, subpath)
+        end
+      end
+    end
+
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'activesupport'
+
+  gem.add_development_dependency 'bundler', '~> 1.10'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rubocop'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'rubocop'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  gem.add_development_dependency 'yard', '~> 0.8'
+end
+# rubocop:enable Metrics/BlockLength

data/spec/dsl_spec.rb

@@ -0,0 +1,118 @@
+require 'json'
+require 'ostruct'
+
+describe Skemata::DSL do
+  let(:cat) do 
+    OpenStruct.new(
+      name: 'Dr. Snuggles',
+      age: 10,
+      occupation: 'Sleep expert'
+    )
+  end
+
+  let(:opts) do 
+    { root_object: cat, type: :Animal }
+  end
+
+  let(:schema_definition) do
+    described_class.draw(opts) do 
+      name
+      age
+      occupation
+    end
+  end
+
+  let(:result) { JSON.parse(schema_definition) }
+
+  context '.draw' do
+    it 'should produce JSON with the correct attributes' do
+      expect(result).to eql(
+        { "@type" => opts[:type].to_s,
+          "@context" => "https://schema.org",
+          "name" => cat.name,
+          "age" => cat.age,
+          "occupation" => cat.occupation } 
+      )
+    end
+
+    context 'with a hash and primitive object attributes' do 
+      let(:opts) { { root_object: { foo: 'bar'}, type: 'Baz' } }
+      let(:schema_definition) do 
+        described_class.draw(opts) do
+          foo
+          not_a_thing 'except it is now'
+        end
+      end
+
+      it 'should produce a valid schema' do
+        expect(result).to eql(
+          { "@type" => opts[:type].to_s,
+            "@context" => "https://schema.org",
+            "foo" => "bar",
+            "not_a_thing" => "except it is now" }
+        )
+      end
+    end
+
+    context 'with nesting' do 
+      context 'n-ary distant properties' do  
+        before { cat.toy = OpenStruct.new(color: 'red') }
+
+        let(:schema_definition) do 
+          described_class.draw(opts) do 
+            name
+            age
+            toy_color nested :toy, :color
+            occupation
+          end
+        end
+
+        it 'should produce a valid schema' do
+          expect(result).to eql(
+            { "@type" => opts[:type].to_s,
+              "@context" => "https://schema.org",
+              "name" => cat.name,
+              "age" => cat.age,
+              "toy_color" => cat.toy.color,
+              "occupation" => cat.occupation }
+          )
+        end
+      end
+
+      context 'child objects' do
+        before do 
+          cat.best_friend = OpenStruct.new(
+            name: 'Garfield',
+            age: 8,
+            occupation: 'Lasagna expert, likes playing with yarn'
+          )
+        end
+
+        let(:schema_definition) do 
+          described_class.draw(opts) do 
+            name
+            age
+            occupation
+
+            best_friend :Animal do 
+              name
+              age
+              occupation
+            end
+          end
+        end
+
+        it 'should produce a valid schema' do 
+          expect(result['best_friend']).to eql(
+            { "@type" => opts[:type].to_s,
+              "name" => cat.best_friend.name,
+              "age" => cat.best_friend.age,
+              "occupation" => cat.best_friend.occupation }
+          )
+
+          expect(result['best_friend']).to_not have_key('@context')
+        end
+      end
+    end
+  end
+end

data/spec/schemata_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'skemata'
+
+describe Skemata do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).to_not be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+require 'skemata/version'
+
+include Skemata

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: skemata
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Stancu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: guard
+  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: guard-rubocop
+  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: guard-rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: A DSL designed to draft JSON-LD schema.org objects.
+email: dstancu@nyu.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- Guardfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/skemata.rb
+- lib/skemata/dsl.rb
+- lib/skemata/node.rb
+- lib/skemata/version.rb
+- skemata.gemspec
+- spec/dsl_spec.rb
+- spec/schemata_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/skemata
+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.6.8
+signing_key: 
+specification_version: 4
+summary: A DSL designed to draft JSON-LD schema.org objects.
+test_files:
+- spec/dsl_spec.rb
+- spec/schemata_spec.rb
+- spec/spec_helper.rb