roaster 0.0.1 → 0.0.2

data/lib/roaster/request.rb

@@ -0,0 +1,73 @@
+module Roaster
+  class Request
+
+    ALLOWED_OPERATIONS = [:create, :read, :update, :delete]
+
+    #TODO: Move this elsewhere (factory)
+    def self.mapping_class_from_target(target)
+      if target.relationship_name
+        mapping_class_from_name(target.relationship_name)
+      else
+        mapping_class_from_name(target.resource_name)
+      end
+    end
+
+    def self.mapping_class_from_name(name)
+      "#{name.to_s.singularize}_mapping".classify.constantize
+    end
+
+    def initialize(operation, target, resource, params, opts = {})
+      # :create, :read, :update, :delete
+      unless ALLOWED_OPERATIONS.include?(operation)
+        raise "#{operation} is not a valid operation."
+      end
+      @operation = operation
+      @resource = resource
+      @mapping_class = opts[:mapping_class] || self.class.mapping_class_from_target(target)
+      @query = Roaster::Query.new(@operation, target, @mapping_class, params)
+      #TODO: Oh snap this is confusing
+      @document = opts[:document]
+    end
+
+    def execute
+      case @operation
+      when :create
+        #TODO: - IDEA - Maybe make `new` return a fake 'relationship' object so a relationship special case wouldn't be needed
+        if @query.target.relationship_name.nil?
+          obj = @resource.new(@query)
+          parse(obj, @document)
+          @resource.save(obj)
+        else
+          @resource.create_relationship(@query, @document)
+        end
+      when :read
+        res = @resource.query(@query)
+        represent(res).to_hash
+      when :update
+        obj = @resource.find(@query)
+        links = @document.delete('links')
+        @resource.update_relationships(@query, links) if links
+        parse(obj, @document)
+        @resource.save(obj)
+      when :delete
+        @resource.delete(@query)
+      end
+    end
+
+    private
+
+    def parse(object, data)
+      rp = @mapping_class.new(object)
+      rp.from_hash(data)
+    end
+
+    def represent(data)
+      if data.respond_to?(:each)
+        @mapping_class.for_collection.prepare(data)
+      else
+        @mapping_class.prepare(data)
+      end
+    end
+
+  end
+end

data/lib/roaster/resource.rb

@@ -0,0 +1,41 @@
+module Roaster
+
+  class Resource
+
+    def initialize(adapter_class, opts = {})
+      @adapter = adapter_class.new
+      @model_class = opts[:model_class]
+    end
+
+    def new(query)
+      @adapter.new(query)
+    end
+
+    def save(model)
+      @adapter.save(model)
+      model
+    end
+
+    def delete(query)
+      @adapter.delete(query)
+    end
+
+    def create_relationship(query, document)
+      @adapter.create_relationship(query, document)
+    end
+
+    def update_relationships(query, document)
+      @adapter.update_relationship(query, document)
+    end
+
+    def find(query)
+      @adapter.find(query, model_class: @model_class)
+    end
+
+    def query(query)
+      @adapter.read(query, model_class: @model_class)
+    end
+
+  end
+
+end

data/lib/roaster/version.rb

@@ -0,0 +1,3 @@
+module Roaster
+  VERSION = '0.0.2'
+end

data/roaster.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/roaster/version', __FILE__)
+ 
+Gem::Specification.new do |gem|
+  gem.name          = 'roaster'
+  gem.authors       = ['Nicolas Albeza', 'Jérémy Lecerf']
+  gem.email         = ['n.albeza@gmail.com', 'redpist.com@gmail.com']
+  gem.description   = %q{Model/JSONAPI mapping}
+  gem.summary       = %q{Expose your models through a JSONAPI API with a simple mapping}
+  gem.homepage      = 'https://github.com/pause/roaster'
+  gem.license       = 'MIT'
+ 
+  gem.files         = `git ls-files`.split($\)
+  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.version       = Roaster::VERSION
+
+  gem.add_runtime_dependency "representable", "~> 2.0"
+  gem.add_runtime_dependency "activerecord", "~> 4.1"
+  gem.add_runtime_dependency "activesupport", "~> 4.1"
+
+  gem.add_development_dependency 'minitest', '~> 5.1'
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'factory_girl', '~> 4.4'
+  gem.add_development_dependency 'sqlite3', '~> 1.3'
+  gem.add_development_dependency 'database_cleaner', '~> 1.3'
+  gem.add_development_dependency 'byebug', '~> 3.4'
+
+end

data/test/activerecord_adapter_test.rb

@@ -0,0 +1,124 @@
+require 'minitest/autorun'
+
+require 'roaster/query'
+require 'roaster/adapters/active_record'
+
+require_relative 'test_helper'
+require_relative 'models/album'
+#require_relative 'models/namespaced/model'
+
+class ActiveRecordAdapterTest < MiniTest::Test
+
+  def setup
+    super
+    @adapter = Roaster::Adapters::ActiveRecord.new
+    @album_mapping = AlbumMapping
+    @albums_target = Roaster::Query::Target.new(:albums)
+  end
+
+  def test_interface
+    assert @adapter.respond_to?(:new)
+    assert @adapter.respond_to?(:save)
+    assert @adapter.respond_to?(:find)
+    assert @adapter.respond_to?(:read)
+    assert @adapter.respond_to?(:delete)
+  end
+
+  def test_mapping_class_from_resource_name
+    mc = Roaster::Adapters::ActiveRecord.model_class_from_resource_name(:albums)
+    assert_equal Album, mc
+  end
+
+  def test_simple_model_for
+    model = @adapter.send(:model_for, :albums)
+    assert_equal model, Album
+  end
+
+  def test_custom_model_for
+    model = @adapter.send(:model_for, Album)
+    assert_equal model, Album
+  end
+
+  def test_new
+    query = build_query(:create)
+    model_instance = @adapter.new(query)
+    assert_kind_of Album, model_instance
+  end
+
+  def test_save
+    title = 'Serial Smokers'
+    query = build_query(:create)
+    model_instance = @adapter.new(query)
+    model_instance.send(:title=, title)
+    @adapter.save(model_instance)
+
+    new_album = Album.last
+    assert_equal model_instance, new_album
+    assert_equal title, new_album.title
+  end
+
+  def test_find
+    ref_album = FactoryGirl.create(:album)
+    target = Roaster::Query::Target.new(:albums, ref_album.id)
+    #TODO: API problems (why do i need a full query here ?!)!
+    query = build_query(:update, target)
+    album = @adapter.find(query)
+
+    assert_equal album, ref_album
+  end
+
+  private
+
+  def call_adapter_method(method,
+                          target,
+                          params = {})
+    query = Roaster::Query.new(method, target, @mapping, params)
+    @adapter.send(method, query)
+  end
+
+  def build_query(operation, target = @albums_target, mapping = @album_mapping, params = {})
+    Roaster::Query.new(:create, @albums_target, @album_mapping, params)
+  end
+
+  def test_new
+    query = build_query(:create)
+    model_instance = @adapter.new(query)
+    assert_kind_of Album, model_instance
+  end
+
+  def test_save
+    title = 'Serial Smokers'
+    query = build_query(:create)
+    model_instance = @adapter.new(query)
+    model_instance.send(:title=, title)
+    @adapter.save(model_instance)
+
+    new_album = Album.last
+    assert_equal model_instance, new_album
+    assert_equal title, new_album.title
+  end
+
+  def test_find
+    ref_album = FactoryGirl.create(:album)
+    target = Roaster::Query::Target.new(:albums, ref_album.id)
+    #TODO: API problems (why do i need a full query here ?!)!
+    query = build_query(:update, target)
+    album = @adapter.find(query)
+
+    assert_equal album, ref_album
+  end
+
+  private
+
+  def call_adapter_method(method,
+                          target,
+                          params = {})
+    query = Roaster::Query.new(method, target, @mapping, params)
+    @adapter.send(method, query)
+  end
+
+  def build_query(operation, target = @albums_target, mapping = @album_mapping, params = {})
+    Roaster::Query.new(:create, @albums_target, @album_mapping, params)
+  end
+
+end

data/test/decorator_test.rb

@@ -0,0 +1,10 @@
+require 'minitest/autorun'
+
+require 'roaster/decorator'
+
+require_relative 'test_helper'
+
+class QueryTest < MiniTest::Test
+
+
+end

data/test/factories/album.rb

@@ -0,0 +1,25 @@
+require_relative './band'
+
+FactoryGirl.define do
+  factory :album do
+    title 'Album Title'
+    band
+
+    factory :pink_floyd_albums do
+      association :band, factory: :pink_floyd
+
+      factory :animals_album do
+        title 'Animals'
+      end
+
+      factory :the_wall_album do
+        title 'The Wall'
+      end
+
+      factory :meddle_album do
+        title 'Meddle'
+      end
+    end
+
+  end
+end

data/test/factories/band.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  factory :band do
+    name 'Band Name'
+
+    factory :pink_floyd do
+      name 'Pink Floyd'
+    end
+  end
+end

data/test/factories/track.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :track do
+    title 'Track Title'
+  end
+end

data/test/mappings/album.rb

@@ -0,0 +1,19 @@
+require 'roaster/json_api'
+
+class AlbumMapping < Roaster::JsonApi::Mapping
+
+  property :title
+  #property :created_at
+
+  # TODO: auto include included mapping
+  # Aiming: Nested sparse fieldsets authorizations and default behaviour for sort
+  can_include :band, :tracks
+
+  can_filter_by :band, :title
+
+  can_sort_by :band, :title, :created_at, band: [:name]
+
+  # resource_name 'test_lautre'
+
+  collection_representer class: Album
+end

data/test/mappings/band.rb

@@ -0,0 +1,6 @@
+require 'roaster/json_api'
+
+class BandMapping < Roaster::JsonApi::Mapping
+
+  property :name
+end

data/test/mappings/track.rb

@@ -0,0 +1,8 @@
+require 'roaster/json_api'
+
+class TrackMapping < Roaster::JsonApi::Mapping
+
+  property :title
+
+end
+ 

data/test/models/album.rb

@@ -0,0 +1,14 @@
+require 'active_model'
+require 'active_record'
+
+ActiveRecord::Migration.class_eval do
+  create_table :albums do |t|
+    t.string  :title
+    t.belongs_to :band
+  end
+end
+
+class Album < ActiveRecord::Base
+  belongs_to :band
+  has_many :tracks
+end

data/test/models/band.rb

@@ -0,0 +1,11 @@
+require 'active_model'
+require 'active_record'
+
+ActiveRecord::Migration.class_eval do
+  create_table :bands do |t|
+    t.string  :name
+  end
+end
+
+class Band < ActiveRecord::Base
+end

data/test/models/namespaced/model.rb

@@ -0,0 +1,4 @@
+module Namespaced
+  class Model < ActiveRecord::Base
+  end
+end

data/test/models/track.rb

@@ -0,0 +1,13 @@
+require 'active_model'
+require 'active_record'
+
+ActiveRecord::Migration.class_eval do
+  create_table :tracks do |t|
+    t.string  :title
+    t.belongs_to :album
+  end
+end
+
+class Track < ActiveRecord::Base
+  belongs_to :album
+end

data/test/query_target_test.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+
+require 'roaster/query'
+
+require_relative 'test_helper'
+
+class QueryTargetTest < MiniTest::Test
+
+  def setup
+    super
+  end
+
+  def test_defaults
+    target = Roaster::Query::Target.new(:albums)
+    assert_equal target.resource_name, :albums
+    assert_equal target.resource_ids, []
+    assert_equal target.relationship_name, nil
+    assert_equal target.relationship_ids, []
+  end
+
+  def test_init
+    target = Roaster::Query::Target.new(:albums, 1, :tracks, [2, 3])
+    assert_equal target.resource_name, :albums
+    assert_equal target.resource_ids, [1]
+    assert_equal target.relationship_name, :tracks
+    assert_equal target.relationship_ids, [2, 3]
+  end
+
+end