conglomerate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9008dac9ea7c50dfb488faa1eb897070f62499f4
+  data.tar.gz: f4260d896b2b80ca6e5581fb79eb08d212914f27
+SHA512:
+  metadata.gz: e8a62475f4429d00aa29ab15dcc08affc5bf18444f57e50e2efa37c892111de6b173008f4504bf3ddd76931e3999a7450cbdce972b7f9bba2185dbacf5c24c82
+  data.tar.gz: e4dc81daac27fed5f17bdc1b3796a1f638c164bffe02a30f9cc13bdb66bb4e785c22aa8dc5e797793d4d4fff48d4f7004855a51cd656f0ff640cfa71ce63db25

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TeamSnap
+
+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,39 @@
+# Conglomerate
+
+[![Gem Version](https://badge.fury.io/rb/conglomerate.png)](http://badge.fury.io/rb/conglomerate)
+[![Code Climate](https://codeclimate.com/github/teamsnap/conglomerate.png)](https://codeclimate.com/github/teamsnap/conglomerate)
+[![Coverage Status](https://coveralls.io/repos/teamsnap/conglomerate/badge.png?branch=master)](https://coveralls.io/r/teamsnap/conglomerate?branch=master)
+[![Dependency Status](https://gemnasium.com/teamsnap/conglomerate.png)](https://gemnasium.com/teamsnap/conglomerate)
+[![License](http://img.shields.io/license/MIT.png?color=green)](http://opensource.org/licenses/MIT)
+
+A library to serialize Ruby objects into collection+json.
+
+![conglomerate](http://i.imgur.com/QkKZ0ru.jpg)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'conglomerate'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install conglomerate
+
+## Usage
+
+```ruby
+# TODO
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/teamsnap/conglomerate/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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/conglomerate.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "conglomerate/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "conglomerate"
+  spec.version       = Conglomerate::VERSION
+  spec.authors       = ["Shane Emmons"]
+  spec.email         = ["oss@teamsnap.com"]
+  spec.summary       = "A library to serialize Ruby objects into collection+json"
+  spec.description   = "A library to serialize Ruby objects into collection+json"
+  spec.homepage      = "https://github.com/teamsnap/conglomerate"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+end

data/lib/conglomerate.rb

@@ -0,0 +1,11 @@
+require_relative "conglomerate/serializer"
+
+module Conglomerate
+  def self.serializer
+    Module.new do
+      def self.included(descendant)
+        descendant.send(:include, ::Conglomerate::Serializer)
+      end
+    end
+  end
+end

data/lib/conglomerate/serializer.rb

@@ -0,0 +1,200 @@
+module Conglomerate
+  module Serializer
+    def self.included(descendant)
+      descendant.extend(ClassMethods)
+    end
+
+    def initialize(objects, context: nil)
+      self.objects = [*objects].compact
+      self.context = context
+    end
+
+    def serialize
+      {
+        "collection" => actions.inject({}) do |collection, action|
+          send("apply_#{action}", collection)
+        end
+      }
+    end
+
+    private
+
+    attr_accessor :objects, :context
+
+    def actions
+      [:version, :href, :queries, :items, :template, :links]
+    end
+
+    def apply_version(collection)
+      collection.merge({"version" => "1.0"})
+    end
+
+    def apply_href(collection, proc: self.class._href, object: nil)
+      if object
+        collection.merge({"href" => context.instance_exec(object, &proc)})
+      else
+        collection.merge({"href" => context.instance_eval(&proc)})
+      end
+    end
+
+    def apply_data(collection, data: [], object: nil)
+      data = data.map do |name|
+        {"name" => name.to_s, "value" => object.nil? ? "" : object.send(name)}
+      end
+
+      if data.empty?
+        collection
+      else
+        collection.merge({"data" => data})
+      end
+    end
+
+    def apply_queries(collection)
+      queries = self.class._queries.map do |query|
+        build_query(query[:rel], query[:data], query[:block])
+      end
+
+      if queries.empty?
+        collection
+      else
+        collection.merge({"queries" => queries})
+      end
+    end
+
+    def apply_items(collection)
+      items = objects.map do |object|
+        item = {}
+
+        if self.class._item_href
+          item = apply_href(
+            item, :proc => self.class._item_href, :object => object
+          )
+        end
+
+        names = self.class._attributes.map { |attr| attr[:name] }
+        item = apply_data(item, :data => names, :object => object)
+
+        links = self.class._attributes
+          .select { |attr| attr[:block] }
+
+        if links.empty?
+          item.empty? ? nil : item
+        else
+          apply_links(item, :links => links, :object => object)
+        end
+      end
+
+      if items.compact.empty?
+        collection
+      else
+        collection.merge({"items" => items})
+      end
+    end
+
+    def apply_template(collection)
+      attrs = self.class._attributes
+        .select { |attr| attr[:template] }
+        .map { |attr| attr[:name] }
+
+      if attrs.empty?
+        collection
+      else
+        collection.merge({"template" => apply_data({}, :data => attrs)})
+      end
+    end
+
+    def apply_links(collection, links: self.class._links, object: nil)
+      if object && !links.empty?
+        links = links.map do |link|
+          if object.send(link[:name])
+            build_item_link(
+              link[:rel], :proc => link[:block], :object => object
+            )
+          else
+            nil
+          end
+        end.compact.reject { |link| link["href"].nil? }
+
+        if links.empty?
+          collection
+        else
+          collection.merge({"links" => links})
+        end
+      elsif !links.empty?
+        collection.merge(
+          {
+            "links" => links.map do |link|
+              {
+                "rel" => link[:rel].to_s,
+                "href" => context.instance_eval(&link[:block])
+              }
+            end.reject { |link| link["href"].nil? }
+          }
+        )
+      else
+        collection
+      end
+    end
+
+    def build_query(rel, data, block)
+      query = {"rel" => rel.to_s}
+      query = apply_href(query, :proc => block)
+      apply_data(query, :data => data)
+    end
+
+    def build_item_link(rel, proc: nil, object: nil)
+      link = {"rel" => rel.to_s}
+      apply_href(link, :proc => proc, :object => object)
+    end
+
+    module ClassMethods
+      def href(&block)
+        self._href = block
+      end
+
+      def item_href(&block)
+        self._item_href = block
+      end
+
+      def query(rel, data: [], &block)
+        self._queries = self._queries << {
+          :rel => rel, :data => [*data], :block => block
+        }
+      end
+
+      def attribute(name, template: false, rel: nil, &block)
+        self._attributes = self._attributes << {
+          :name => name, :template => template, :rel => rel, :block => block
+        }
+      end
+
+      def link(rel, &block)
+        self._links = self._links << {
+          :rel => rel, :block => block
+        }
+      end
+
+      attr_writer :_href, :_item_href, :_queries, :_attributes, :_links
+
+      def _href
+        @_href || Proc.new { request.original_url }
+      end
+
+      def _item_href
+        @_item_href || nil
+      end
+
+      def _queries
+        @_queries || []
+      end
+
+      def _attributes
+        @_attributes || []
+      end
+
+      def _links
+        @_links || []
+      end
+    end
+  end
+end

data/lib/conglomerate/version.rb

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

data/spec/conglomerate_spec.rb

@@ -0,0 +1,215 @@
+require_relative "spec_helper"
+require_relative "../lib/conglomerate"
+
+class ConglomerateTestSerializer
+  include Conglomerate.serializer
+
+  href { test_url }
+  item_href { |item| item_url(item.id) }
+
+  attribute :description, :template => true
+  attribute :id
+  attribute :event_id, :rel => :event do |item|
+    event_url(item.event_id)
+  end
+  attribute :roster_id, :rel => :roster do |item|
+    roster_url(item.roster_id)
+  end
+  attribute :team_ids, :rel => :teams do |item|
+    team_url(item.team_ids.join(","))
+  end
+
+  link :events do
+    events_url
+  end
+
+  query :search, :data => :id do
+    search_items_url
+  end
+end
+
+class ConglomerateExtraTestSerializer
+  include Conglomerate.serializer
+
+  attribute :id
+end
+
+class ConglomerateNullSerializer
+  include Conglomerate.serializer
+end
+
+describe Conglomerate do
+  let(:object) do
+    double(
+      "Object",
+      :id => 1,
+      :description => "Tasty Burgers",
+      :event_id => 2,
+      :roster_id => nil,
+      :team_ids => [1,2]
+    )
+  end
+
+  let(:context) do
+    request = double("Request", :original_url => "https://example.com/items")
+    double(
+      "Context",
+      :request => request,
+      :search_items_url => "https://example.com/items/search",
+    ).tap do |context|
+      allow(context).to receive(:item_url).with(1) {
+        "https://example.com/items/1"
+      }
+      allow(context).to receive(:event_url).with(2) {
+        "https://example.com/events/2"
+      }
+      allow(context).to receive(:events_url) {
+        "https://example.com/events"
+      }
+      allow(context).to receive(:team_url).with("1,2") {
+        "https://example.com/teams/1,2"
+      }
+      allow(context).to receive(:test_url) { "abc" }
+    end
+  end
+
+  let(:test_serializer) do
+    ConglomerateTestSerializer.new(object, :context => context).serialize
+  end
+
+  let(:extra_test_serializer) do
+    ConglomerateExtraTestSerializer.new(object, :context => context).serialize
+  end
+
+  let(:null_serializer) do
+    ConglomerateNullSerializer.new(object, :context => context).serialize
+  end
+
+  let(:test_collection) { test_serializer["collection"] }
+
+  let(:extra_test_collection) { extra_test_serializer["collection"] }
+
+  let(:null_collection) { null_serializer["collection"] }
+
+  describe "#version" do
+    it "sets version to 1.0" do
+      expect(null_collection["version"]).to eq("1.0")
+      expect(test_collection["version"]).to eq("1.0")
+    end
+  end
+
+  describe "#href" do
+    it "in context, uses the block to set the collection href" do
+      expect(test_collection["href"]).to eq("abc")
+    end
+
+    it "uses 'request.original_url' if preset 'rails_current_url' used" do
+      expect(extra_test_collection["href"]).to eq("https://example.com/items")
+    end
+  end
+
+  describe "#query" do
+    it "doesn't include any query templates if none are provided" do
+      expect(null_collection.keys).to_not include("queries")
+    end
+
+    it "adds a query template to the collection" do
+      expect(test_collection["queries"]).to match_array(
+        [
+          {
+            "href" => "https://example.com/items/search",
+            "rel" => "search",
+            "data" => [
+              {"name" => "id", "value" => ""}
+            ]
+          }
+        ]
+      )
+    end
+  end
+
+  describe "#attribute(s)" do
+    context "items" do
+      it "skips items if there are no attributes" do
+        expect(null_collection.keys).to_not include("items")
+      end
+
+      it "doesn't have an items array if items is empty" do
+        test_serializer = ConglomerateTestSerializer
+        .new(nil, :context => context)
+        .serialize
+        test_collection = test_serializer["collection"]
+        expect(test_collection.keys).to_not include("items")
+      end
+
+      it "includes an items array if attributes and objects present" do
+        expect(test_collection["items"]).to eq(
+          [
+            {
+              "href" => "https://example.com/items/1",
+              "data" => [
+                {"name" => "description", "value" => "Tasty Burgers"},
+                {"name" => "id", "value" => 1},
+                {"name" => "event_id", "value" => 2},
+                {"name" => "roster_id", "value" => nil},
+                {"name" => "team_ids", "value" => [1,2]}
+              ],
+              "links" => [
+                {"rel" => "event", "href" => "https://example.com/events/2"},
+                {"rel" => "teams", "href" => "https://example.com/teams/1,2"}
+              ]
+            }
+          ]
+        )
+      end
+
+      it "doesn't include links if there are none" do
+        expect(extra_test_collection["items"]).to eq(
+          [
+            {
+              "data" => [
+                {"name" => "id", "value" => 1}
+              ]
+            }
+          ]
+        )
+      end
+    end
+
+    context "template" do
+      it "skips template if there are no attributes for a template" do
+        expect(null_collection.keys).to_not include("template")
+      end
+
+      it "includes a valid template if attributes have them" do
+        expect(test_collection["template"]["data"]).to match_array(
+          [
+            {"name" => "description", "value" => ""}
+          ]
+        )
+      end
+    end
+  end
+
+  describe "#link" do
+    it "skips links if there are none present" do
+      expect(null_collection.keys).to_not include("links")
+    end
+
+    it "adds links if they are present" do
+      expect(test_collection["links"]).to match_array(
+        [
+          {"rel" => "events", "href" => "https://example.com/events"}
+        ]
+      )
+    end
+  end
+
+  describe "#item_link" do
+    it "adds links if they are present" do
+      expect(test_collection["items"][0]["links"]).to include(
+        {"rel" => "teams", "href" => "https://example.com/teams/1,2"}
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.order = "random"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: conglomerate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane Emmons
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+description: A library to serialize Ruby objects into collection+json
+email:
+- oss@teamsnap.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- conglomerate.gemspec
+- lib/conglomerate.rb
+- lib/conglomerate/serializer.rb
+- lib/conglomerate/version.rb
+- spec/conglomerate_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/teamsnap/conglomerate
+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.0
+signing_key: 
+specification_version: 4
+summary: A library to serialize Ruby objects into collection+json
+test_files:
+- spec/conglomerate_spec.rb
+- spec/spec_helper.rb