jacoat 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b90bcea2b15f17d4e2766df1d3a8c18c50de275f
-  data.tar.gz: 4e11452c19ca00e9f38edbb110f6cb52d8f74073
+  metadata.gz: 396c87751d11cb60f85a7c3c671fe33043989aed
+  data.tar.gz: abae97ede6d6d52177f26a381ecac86f8877fdac
 SHA512:
-  metadata.gz: c0b4091682a4daaedf3c1eabf199e1a731ff78728283a26db4acdba7904f21955139f84602e7ace4af2d6d6b9da4b37cfc410be7b5f4d081a7263915cc44ed8f
-  data.tar.gz: 9fb97a37ba63348520f9157702f94b4e0fe6c214f3e41e5fd1adbaeb7b5119d203c92f9b857dc672b6914352e2fec96ca7083b8f32fa5e87171d61474efe75b5
+  metadata.gz: 25bedd6912572567f7ac48970f8fc4c47f11418a7fb533dd6aea6eb7cf783ea8bc19c58e985d9711fe84797ef04a08d3b587054d12f3923841d2624363790370
+  data.tar.gz: d4158ab50b8ff54d2c227d35e6d2ad87b3b12e3a0aa7ac8c65b0e368b9c4f740f505d9a4e361a7c505bf442abe0a64f8435d33d77e01b5b477d0910266ef52e3

data/jacoat.gemspec

@@ -21,5 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "representable", "~> 2.3"
+  spec.add_development_dependency "multi_json", "~> 1.11"
   spec.add_development_dependency "rspec"
 end

data/lib/jacoat/document.rb

@@ -11,22 +11,38 @@ require 'jacoat/document/relationship'
 
 module Jacoat
   class Document
-    attr_reader :data, :errors, :meta, :jsonapi, :links, :included
-    def initialize(arguments = {})
-      validate_arguments(arguments)
-      @has_data = true if arguments.has_key?(:data)
-      @data = Data.process(arguments[:data]) if arguments.has_key?(:data)
-      @errors = Error.new(arguments[:errors]) if arguments.has_key?(:errors)
-      @meta = Meta.new(arguments[:meta]) if arguments.has_key?(:meta) 
-      @jsonapi = Jsonapi.new(arguments[:jsonapi]) if arguments.has_key?(:jsonapi)
-      @links = Link.process(arguments[:links]) if arguments.has_key?(:links)
-      @included = Included.process(arguments[:included]) if arguments.has_key?(:included)
+    attr_reader :data
+    attr_accessor :errors, :meta, :jsonapi, :links, :included
+
+    def self.from_jsonapi(arguments)
+      document = Document.new
+      document.data = Data.from_jsonapi(arguments[:data]) if arguments.has_key?(:data)
+      
+      
+      document.errors = Error.from_jsonapi(arguments[:errors]) if arguments.has_key?(:errors)
+      document.meta = Meta.from_jsonapi(arguments[:meta]) if arguments.has_key?(:meta)
+      document.jsonapi = Jsonapi.from_jsonapi(arguments[:jsonapi]) if arguments.has_key?(:jsonapi)
+      document.links = Link.from_jsonapi(arguments[:links]) if arguments.has_key?(:links)
+      document.included = Included.from_jsonapi(arguments[:included]) if arguments.has_key?(:included)
+      document
     end
-    
-    def validate_arguments(arguments)
-      raise Invalid.new('included key without data key') if arguments.has_key?(:included) && !arguments.has_key?(:data)
-      raise Invalid.new('must contain data, errors or meta key') if !arguments.has_key?(:data) && !arguments.has_key?(:errors) && !arguments.has_key?(:meta)
-      raise Invalid.new('data and errors keys set') if arguments.has_key?(:data) && arguments.has_key?(:errors)
+
+    def data=(data)
+      @has_data = true
+      @data = data
+    end
+
+    def valid?
+      validate_arguments
+      true
+    rescue Invalid
+      return false
+    end
+
+    def validate_arguments
+      raise Invalid.new('included key without data key') if @included && !@data
+      raise Invalid.new('must contain data, errors or meta key') if !@data && !@errors && !@meta
+      raise Invalid.new('data and errors keys set') if @data && @errors
     end
     
     def to_hash

data/lib/jacoat/document/attribute.rb

@@ -1,6 +1,12 @@
 module Jacoat
   class Document
     class Attributes
+      attr_reader :hash
+
+      def self.from_jsonapi(arguments = {})
+        Attributes.new(arguments)
+      end
+
       def initialize(arguments = {})
         @hash = arguments
       end

data/lib/jacoat/document/data.rb

@@ -1,7 +1,7 @@
 module Jacoat
   class Document
     class Data
-      def self.process(arguments)
+      def self.from_jsonapi(arguments)
         data = Data.new
         if arguments.is_a?(Array)
           data.resource = create_resource_array(arguments)
@@ -14,9 +14,9 @@ module Jacoat
       def self.create_resource(arguments)
         return nil if arguments.nil?
         if Detector.what_is(arguments) == "resource"
-          return Resource.new(arguments)
+          return Resource.from_jsonapi(arguments)
         else
-          return ResourceIdentifier.new(arguments)
+          return ResourceIdentifier.from_jsonapi(arguments)
         end
       end
       
@@ -24,15 +24,18 @@ module Jacoat
         resources = []
         arguments.each do |resource|
           if Detector.what_is(resource) == "resource"
-            resources << Resource.new(resource)
+            resources << Resource.from_jsonapi(resource)
           else
-            resources << ResourceIdentifier.new(resource)
+            resources << ResourceIdentifier.from_jsonapi(resource)
           end
         end
         resources
       end
 
-      attr_accessor :resource      
+      attr_accessor :resource
+      def resources=(resources)
+        @resource = resources
+      end
       def resources
         @resource
       end

data/lib/jacoat/document/error.rb

@@ -1,14 +1,16 @@
 module Jacoat
   class Document
     class Error
-      attr_reader :id, :links, :status, :code, :title, :detail, :meta
-      def initialize(arguments = {})
-        @id = arguments[:id]
-        @links = Link.process(arguments[:links]) if arguments.has_key?(:links)
+      attr_accessor :id, :links, :status, :code, :title, :detail, :meta
+      def self.from_jsonapi(arguments)
+        error = Error.new
+        error.id = arguments[:id]
+        error.links = Link.from_jsonapi(arguments[:links]) if arguments.has_key?(:links)
         %w{ status code title detail }.each do |type|
-          self.instance_variable_set("@#{type}", arguments[type.to_sym]) if arguments.has_key?(type.to_sym)
+          error.instance_variable_set("@#{type}", arguments[type.to_sym]) if arguments.has_key?(type.to_sym)
         end
-        @meta = Meta.new(arguments[:meta]) if arguments.has_key?(:meta)
+        error.meta = Meta.from_jsonapi(arguments[:meta]) if arguments.has_key?(:meta)
+        error
       end
       
       def to_hash

data/lib/jacoat/document/included.rb

@@ -1,10 +1,10 @@
 module Jacoat
   class Document
     class Included
-      def self.process(arguments)
+      def self.from_jsonapi(arguments)
         resources = []
         arguments.each do |item|
-          resources << Resource.new(item)
+          resources << Resource.from_jsonapi(item)
         end
         included = Included.new
         included.resources = resources

data/lib/jacoat/document/jsonapi.rb

@@ -1,9 +1,12 @@
 module Jacoat
   class Document
     class Jsonapi
-      attr_reader :version
-      def initialize(arguments = {})
-        @version = arguments[:version]
+      attr_accessor :version
+
+      def self.from_jsonapi(arguments)
+        jsonapi = Jsonapi.new
+        jsonapi.version = arguments[:version]
+        jsonapi
       end
       
       def to_hash

data/lib/jacoat/document/link.rb

@@ -1,13 +1,14 @@
 module Jacoat
   class Document
     class Link
-      def self.process(hash)
-        Link.new(hash)
+      def self.from_jsonapi(hash)
+        link = Link.new
+        link.process_links(hash)
+        link
       end
 
-      def initialize(arguments = {})
+      def initialize
         @hash = {}
-        process_links(arguments)
       end
       
       def method_missing(m, *args)
@@ -26,18 +27,28 @@ module Jacoat
         end
         hash
       end
-      
-      private      
-        def process_links(arguments)
-          arguments.each_pair do |k, v|
-            if v.is_a?(String)
-              link = Simple.new(v)
-            else
-              link = Complex.new(v)
-            end
-            send("#{k}=", link)
+         
+      def process_links(arguments)
+        return if arguments.nil?
+        arguments.each_pair do |k, v|
+          if v.is_a?(String)
+            link = Simple.new(v)
+          else
+            link = Complex.new(v)
           end
+          send("#{k}=", link)
         end
+      end
+      
+      def add_link(title, href, options = {})
+        if options.empty?
+          link = Simple.new(href)
+        else
+          link = Complex.new(href: href, meta: options)
+        end
+        send("#{title}=", link)
+        self
+      end
       
       class Simple
         attr_reader :href
@@ -54,7 +65,7 @@ module Jacoat
         attr_reader :href, :meta
         def initialize(arguments)
           @href = arguments[:href]
-          @meta = Meta.new(arguments[:meta])
+          @meta = Meta.from_jsonapi(arguments[:meta])
         end
         
         def to_hash

data/lib/jacoat/document/meta.rb

@@ -1,9 +1,14 @@
 module Jacoat
   class Document
     class Meta
+      def self.from_jsonapi(arguments)
+        meta = Meta.new
+        meta.process_meta(arguments)
+        meta
+      end
+
       def initialize(arguments = {})
         @hash = {}
-        process_meta(arguments)
       end
       
       def method_missing(m, *args)
@@ -19,12 +24,11 @@ module Jacoat
         @hash
       end
       
-      private
-        def process_meta(arguments)
-          arguments.each_pair do |k, v|
-            send("#{k}=", v)
-          end
+      def process_meta(arguments)
+        arguments.each_pair do |k, v|
+          send("#{k}=", v)
         end
+      end
     end
   end
 end

data/lib/jacoat/document/relationship.rb

@@ -1,19 +1,19 @@
 module Jacoat
   class Document
     class Relationship
-      attr_reader :id, :type, :data, :links
-      def self.process(hash)
+      attr_accessor :id, :type, :data, :links
+      def self.from_jsonapi(hash)
         relationships = []
         hash.each_pair do |k, v|
-          relationships << Document::Relationship.new(k, v)
+          relationship = Document::Relationship.new(k)
+          relationship.process_jsonapi(v)
+          relationships << relationship
         end
         relationships
       end
 
-      def initialize(type, body)
+      def initialize(type)
         @type = type.to_s
-        process_data(body[:data]) if body.has_key?(:data)
-        process_body(body[:links]) if body.has_key?(:links)
       end
       
       def to_hash
@@ -24,13 +24,19 @@ module Jacoat
         hash
       end
       
+      def process_jsonapi(hash)
+        process_data(hash[:data]) if hash.has_key?(:data)
+        process_body(hash[:links]) if hash.has_key?(:links)
+        self
+      end
+
       private
         def process_data(data)
-          @data = Document::ResourceIdentifier.process(data)
+          @data = Document::ResourceIdentifier.from_jsonapi(data)
         end
 
         def process_body(links)
-          @links = Document::Link.process(links)
+          @links = Document::Link.from_jsonapi(links)
         end
 
         def data_to_hash

data/lib/jacoat/document/resource.rb

@@ -1,19 +1,25 @@
 module Jacoat
   class Document
     class Resource
-      attr_reader :id, :type, :attributes, :links, :relationships
-      def initialize(arguments)
-        @id = arguments[:id]
-        @type = arguments[:type]
-        @attributes = Document::Attributes.new(arguments[:attributes])
-        create_relationships(arguments[:relationships]) if arguments.has_key?(:relationships)
-        @links = Link.process(arguments[:links]) if arguments.has_key?(:links)
+      attr_accessor :id, :type, :attributes, :links, :relationships
+
+      def self.from_jsonapi(arguments)
+        resource = Resource.new(arguments[:id], arguments[:type])
+        resource.attributes = Document::Attributes.from_jsonapi(arguments[:attributes])
+        resource.create_relationships(arguments[:relationships]) if arguments.has_key?(:relationships)
+        resource.links = Link.from_jsonapi(arguments[:links]) if arguments.has_key?(:links)
+        resource
+      end
+
+      def initialize(id, type)
+        @id = id
+        @type = type
       end
       
       def create_relationships(hash)
         @relationships = []
         hash.each_pair do |k, v|
-          @relationships << Document::Relationship.new(k, v)
+          @relationships << Document::Relationship.new(k).process_jsonapi(v)
         end
       end
       

data/lib/jacoat/document/resource_identifier.rb

@@ -1,29 +1,33 @@
 module Jacoat
   class Document
     class ResourceIdentifier
-      attr_reader :id, :type, :relationships
-      def self.process(body)
+      attr_accessor :id, :type, :relationships
+      def self.from_jsonapi(body)
         if body.is_a?(Array)
           resources = []
           body.each do |item|
-            resources << ResourceIdentifier.new(item)
+            resources << ResourceIdentifier.new(item[:id], item[:type]).process_jsonapi(item)
           end
         else
-          resources = ResourceIdentifier.new(body)
+          resources = ResourceIdentifier.new(body[:id], body[:type]).process_jsonapi(body)
         end
         resources
       end
 
-      def initialize(arguments)
-        @id = arguments[:id]
-        @type = arguments[:type]
+      def initialize(id, type)
+        @id = id
+        @type = type
+      end
+      
+      def process_jsonapi(arguments)
         create_relationships(arguments[:relationships]) if arguments.has_key?(:relationships)
+        self
       end
 
       def create_relationships(hash)
         @relationships = []
         hash.each_pair do |k, v|
-          @relationships << Document::Relationship.new(k, v)
+          @relationships << Document::Relationship.new(k).process_jsonapi(v)
         end
       end
       

data/lib/jacoat/representable.rb

@@ -0,0 +1,147 @@
+require 'multi_json'
+require 'representable/json'
+require 'representable/hash_methods'
+require 'jacoat/representable/has_one'
+
+module Jacoat
+  module Representable
+    attr_accessor :type
+    
+    def self.included(base)
+      base.class_eval do
+        include ::Representable
+        include ::Representable::JSON
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def type(type)
+        representable_attrs[:_type] = type.to_s
+      end
+      
+      def links
+      end
+      
+      def link(link, &block)
+        representable_attrs[:_link] = {} if representable_attrs[:_link].nil?
+        representable_attrs[:_link][link] = block if block_given?
+      end
+      
+      def has_one(name, options = {}, &block)
+        add_relationship(name, :_has_one, options, block)
+      end
+      
+      def has_many(name, options = {}, &block)
+        add_relationship(name, :_has_many, options, block)
+      end
+      
+      def relationships
+      end
+
+      private
+      def add_relationship(object, type, options, block)
+        representable_attrs[type] = {} unless representable_attrs.has_key?(type)
+        rel = HasOne.new
+        rel.options = options
+        rel.instance_eval(&block)
+        representable_attrs[type][object] = rel
+      end
+    end
+    
+    module InstanceMethods
+      def from_hash(hash, options={})
+        hash = from_document(hash)
+        super(hash, options.merge(:only_body => true))
+      end
+
+      def to_hash(options={})
+        res = super(options.merge(:only_body => true))
+        to_document(res, options)
+      end
+      
+      private
+      def from_document(hash)
+        document = Jacoat::Document.from_jsonapi(symbolize_keys(hash))
+        attributes = document.data.resource.attributes.hash
+        attributes = from_document_set_relationships(hash, attributes)
+        stringify_keys(attributes)
+      end
+      
+      def from_document_set_relationships(hash, attributes)
+        representable_attrs[:_has_one].each_key do |k|
+          attributes["#{k}_id"] = hash["data"]["relationships"][k.to_s]["data"]["id"].to_i
+        end
+        attributes
+      end
+      
+      def to_document(hash, options = {})
+        document = Jacoat::Document.new
+        document.data = generate_resource(hash)
+        document.data.relationships = relationship_array(hash)
+        document.links = generate_links(hash)
+        document.to_hash
+      end
+      
+      def generate_links(hash)
+        lk = Jacoat::Document::Link.new
+        @representable_attrs[:_link].each_pair do |link, block|
+          href = represented.instance_eval(&@representable_attrs[:_link][link.to_sym])
+          lk.add_link(link.to_s, href)
+        end
+        lk
+      end
+      
+      def generate_resource(hash)
+        id = hash.delete("id")
+        res = Jacoat::Document::Resource.new(id, representable_attrs[:_type])
+        res.attributes = Jacoat::Document::Attributes.new(hash)
+        res
+      end
+      
+      def relationship_array(hash)
+        relationships = []
+        @representable_attrs[:_has_one].each_pair do |item, object|
+          rel = Jacoat::Document::Relationship.new(item.to_s)
+          object.links.each_pair do |k, block|
+            href = represented.instance_eval(&block)
+            rel.links = Jacoat::Document::Link.new.add_link(k.to_s, href)
+          end
+          relationships.push(rel)
+        end
+        relationships
+      end
+
+      def symbolize_keys(hash)
+        hash.inject({}){|result, (key, value)|
+          new_key = case key
+                    when String then key.to_sym
+                    else key
+                    end
+          new_value = case value
+                      when Hash then symbolize_keys(value)
+                      else value
+                      end
+          result[new_key] = new_value
+          result
+        }
+      end
+      
+      def stringify_keys(hash)
+        hash.inject({}){|result, (key, value)|
+          new_key = case key
+                    when Symbol then key.to_s
+                    else key
+                    end
+          new_value = case value
+                      when Hash then symbolize_keys(value)
+                      else value
+                      end
+          result[new_key] = new_value
+          result
+        }
+      end
+    end
+  end
+end

data/lib/jacoat/representable/has_one.rb

@@ -0,0 +1,12 @@
+module Jacoat
+  module Representable
+    class HasOne
+      attr_accessor :links, :options
+      
+      def link(link, &block)
+        @links = {} if @links.nil?
+        @links[link] = block
+      end
+    end
+  end
+end

data/lib/jacoat/version.rb

@@ -1,3 +1,3 @@
 module Jacoat
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jacoat
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Celso Fernandes
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2015-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: representable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +111,8 @@ files:
 - lib/jacoat/document/relationship.rb
 - lib/jacoat/document/resource.rb
 - lib/jacoat/document/resource_identifier.rb
+- lib/jacoat/representable.rb
+- lib/jacoat/representable/has_one.rb
 - lib/jacoat/version.rb
 homepage: http://github.com/fernandes/jacoat
 licenses:
@@ -104,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Your JSON-API Coat in Ruby