roaster 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c5d9e2dda820c1034845165adfecaeb04cde982
-  data.tar.gz: 54ac2421861352302f4cca29696e670265fc80a3
+  metadata.gz: 55772cb368935448bd887e970762e0fe89537916
+  data.tar.gz: 9ced0c2bae78911a674888ccdbf985631d7778fc
 SHA512:
-  metadata.gz: 013558aebabc2120eaeda249f159b97238232045dce1b5bd875611402dc974b0733ff6d29e1b763b056b9d7a4d6bd2cb4abe9940c961f69d730bc713640c6be6
-  data.tar.gz: 291636ebc5544f8f7333e1933988f731b6b877f35c2a77813e08677e02b0d86ab82f1d24cca83dc4180746ea77cf9552a23fcecdd01cb05c2446a3563f18dbf4
+  metadata.gz: 86eb522d00e4912a98a1c59d2a897fb16cd4d28379c617a8271d969b037b9ad1514669930ce2d30493244cfc06e41019313898e9f399ed3c7ae748afd4129e4f
+  data.tar.gz: cdf43f96e7f5d40707961f97953a878a153e147c7baae2363fdc2464dc39a39b832c0f4598f50c40947a905556229ab67ab23bf68972f77e7208292759073a71

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'awesome_print'

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    roaster (0.0.1)
+      activerecord (~> 4.1.0)
+      activesupport (~> 4.1.0)
+      representable (~> 2.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (4.1.5)
+      activesupport (= 4.1.5)
+      builder (~> 3.1)
+    activerecord (4.1.5)
+      activemodel (= 4.1.5)
+      activesupport (= 4.1.5)
+      arel (~> 5.0.0)
+    activesupport (4.1.5)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    arel (5.0.1.20140414130214)
+    awesome_print (1.2.0)
+    builder (3.2.2)
+    byebug (3.4.0)
+      columnize (~> 0.8)
+      debugger-linecache (~> 1.2)
+      slop (~> 3.6)
+    columnize (0.8.9)
+    database_cleaner (1.3.0)
+    debugger-linecache (1.2.0)
+    factory_girl (4.4.0)
+      activesupport (>= 3.0.0)
+    i18n (0.6.11)
+    json (1.8.1)
+    mini_portile (0.6.0)
+    minitest (5.4.1)
+    multi_json (1.10.1)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    rake (10.3.2)
+    representable (2.0.4)
+      multi_json
+      nokogiri
+      uber (~> 0.0.7)
+    slop (3.6.0)
+    sqlite3 (1.3.9)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    uber (0.0.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  byebug
+  database_cleaner (~> 1.3)
+  factory_girl (~> 4.4)
+  minitest (~> 5.1)
+  rake (~> 10.3)
+  roaster!
+  sqlite3 (~> 1.3)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.pattern = "test/*_test.rb"
+end

data/STUFF

@@ -0,0 +1,105 @@
+WOOT:
+  - How to handle this case (different relationship resource type/name (author != people)):
+  POST /articles/1/links/author
+  {
+    "people": "12"
+  }
+  => Resource type and name are two different things !
+
+  - How to handle HABTM vs regular to_many ?
+
+WARNING: Ruby code for illustration purposes, NOT CORRECTNESS
+
+CREATE RESOURCE:
+  POST /albums
+  {
+    albums: {
+      title: "Animals"
+    }
+  }
+  Album.new(title: 'Animals').save!
+  INSERT INTO `albums` (`title`) VALUES ('Animals');
+
+DELETE RESOURCE:
+  DELETE /albums/1
+  album = Album.find(1)
+  album.destroy
+  DELETE FROM `album` WHERE `album`.`id` = 1
+
+GET TO_ONE RELATIONSHIP:
+  GET /albums/1/links/band
+  album = Album.find(1)
+  album.band
+  SELECT `albums`.* FROM `albums`  WHERE `albums`.`id` = 1 LIMIT 1;
+  SELECT `bands`.* FROM `bands`  WHERE `bands`.`id` = #{album.band_id} LIMIT 1;
+
+CREATE/REPLACE TO_ONE RELATIONSHIP:
+  POST /albums/1/links/band
+  {
+    bands: "2"
+  }
+  album = Album.find(1)
+  album.band = Band.find(2)
+  UPDATE `albums` SET `band_id` = 2 WHERE `albums`.`id` = 1
+
+REPLACE TO_ONE RELATIONSHIP (equivalent to ADD/REPLACE above):
+  PUT /albums/1
+  {
+    "articles": {
+      "can_update_other_properties_too": true,
+      "links": {
+        "band": "42"
+      }
+    }
+  }
+  album = Album.find(1)
+  album.update_attributes(attr)
+  album.band = Band.find(42)
+  UPDATE `albums` SET `attr` = attr WHERE `albums`.`id` = 1
+  UPDATE `albums` SET `band_id` = 42 WHERE `albums`.`id` = 1
+
+DELETE TO_ONE RELATIONSHIP:
+  DELETE /albums/1/links/band
+  album = Album.find(1)
+  album.band = nil (.clear instead ?)
+  UPDATE `albums` SET `band_id` = NULL WHERE `albums`.`id` = 1
+
+GET TO_MANY RELATIONSHIP:
+  GET /albums/1/links/tracks
+  album = Album.find(1)
+  album.tracks
+  SELECT `tracks`.* FROM `tracks`  WHERE `tracks`.`album_id` = 1;
+
+CREATE/ADD TO_MANY RELATIONSHIPS:
+  POST /album/1/links/tracks
+  {
+    tracks: ['1', '2']
+  }
+  album = Album.find(1)
+  album.tracks << tracks
+  UPDATE `tracks` SET `album_id` = 1 WHERE `tracks`.`id` = 1
+  UPDATE `tracks` SET `album_id` = 1 WHERE `tracks`.`id` = 2
+
+REPLACE TO_MANY RELATIONSHIP (equivalent to ADD/REPLACE above):
+  PUT /albums/1
+  {
+    "articles": {
+      "can_update_other_properties_too": true,
+      "links": {
+        // This can be an empty array (remove all)
+        "tracks": ["3", "5"]
+      }
+    }
+  }
+  album = Album.find(1)
+  album.update_attributes(attr)
+  album.tracks = tracks
+  UPDATE `tracks` SET `tracks`.`album_id` = NULL WHERE `tracks`.`album_id` = 1 AND `tracks`.`id` IN (#{previous_track_ids})
+  UPDATE `tracks` SET `album_id` = 1 WHERE `tracks`.`id` = 3
+  UPDATE `tracks` SET `album_id` = 1 WHERE `tracks`.`id` = 5 
+
+DELETE TO_MANY RELATIONSHIPS:
+  DELETE /albums/1/links/tracks/3,4
+  album = Album.find(1)
+  album.tracks.where(id: [3, 4]).destroy_all
+  UPDATE `blog_post_pictures` SET `blog_post_pictures`.`post_id` = NULL WHERE `blog_post_pictures`.`id` IN (3, 4)

data/lib/roaster.rb

@@ -0,0 +1,12 @@
+require 'representable'
+require 'representable/json'
+
+require 'roaster/adapters/active_record'
+require 'roaster/decorator'
+require 'roaster/json_api'
+require 'roaster/query'
+require 'roaster/request'
+require 'roaster/version'
+
+module Roaster
+end

data/lib/roaster/adapters/active_record.rb

@@ -0,0 +1,116 @@
+require 'active_record'
+
+module Roaster
+  module Adapters
+
+    class ActiveRecord
+
+      def self.model_class_from_resource_name(resource_name)
+        "#{resource_name.to_s.singularize}".classify.constantize
+      end
+
+      def new(query, model_class: nil)
+        model = model_for(model_class || query.target.resource_name)
+        model.new
+      end
+
+      #TODO: HAX, rethink data path for POST/PUT requests from the start
+      #TODO: #save! not good if we want to delay adapter request execution
+      def save(model)
+        model.save!
+      end
+
+      #TODO: Please refactor me, i'm ugly
+      def _change_relationship(query, rel_name, rel_ids, replace: false)
+        model = model_for(query.target.resource_name)
+        object = model.find(query.target.resource_ids.first)
+        rel_model = rel_name.to_s.classify.constantize
+        rel_meta = model.reflect_on_association(rel_name)
+        rel_object = rel_model.find(rel_ids)
+        case rel_meta.macro
+        when :has_many
+          object.send(rel_name).clear if replace === true
+          object.send(rel_name).push(rel_object)
+        when :belongs_to
+          object.send("#{rel_name}=", rel_object)
+        else
+          raise "#{rel_meta.macro} relationship not implemented"
+        end
+        self.save(object)
+      end
+
+      #TODO:
+      # Document key isn't always rel_name, it's rel_name's resource type
+      #   ( not accessible here right now :-( )
+      def create_relationship(query, document)
+        rel_name = query.target.relationship_name
+        rel_ids = document[rel_name.to_s.pluralize]
+        _change_relationship(query, rel_name, rel_ids)
+      end
+
+      def update_relationship(query, document)
+        document.each do |rel_name, rel_ids|
+          _change_relationship(query, rel_name.to_sym, rel_ids, replace: true)
+        end
+      end
+
+      def find(query, model_class: nil)
+        raise 'No ID provided' if query.target.resource_ids.empty?
+        scope_for(query.target, model_class).first
+      end
+
+      def read(query, model_class: nil)
+        q = scope_for(query.target, model_class)
+        query.includes.each do |i|
+          q = q.include(i)
+        end
+        query.filters.each_pair do |k, v|
+          q = q.where(k => v)
+        end
+        query.sorting.each do |resource_name, criteria|
+          criteria.each do |field, direction|
+            q = q.order(model_for(resource_name).arel_table[field].send(direction))
+          end
+        end
+        q
+      end
+
+      def delete(query)
+        q = scope_for(query.target)
+        q.destroy_all
+        q
+      end
+
+      private
+
+      def resource_for(resource_name, id = nil)
+      end
+
+      def model_for(model_class_or_name)
+        if model_class_or_name.kind_of?(::ActiveRecord::Base)
+          model_class_or_name
+        else
+          self.class.model_class_from_resource_name(model_class_or_name)
+        end
+      end
+
+      #TODO: Handle ALL, none should be the default: maybe not ?
+      # Move resource stuff into resource_for
+      def scope_for(target, model_class_or_name = nil)
+        model_class = model_for(model_class_or_name || target.resource_name)
+        scope = model_class.all
+        unless target.resource_ids.empty?
+          scope = scope.where(id: target.resource_ids)
+        end
+        if target.relationship_name
+          raise "Cannot apply relationship #{target.relationship_name} to nil object" if scope.count == 0
+          raise "Cannot apply relationship #{target.relationship_name} to more than one object" if scope.count > 1
+          scope = scope.first.send(target.relationship_name)
+        end
+        scope
+      end
+
+    end
+
+  end
+end

data/lib/roaster/decorator.rb

@@ -0,0 +1,65 @@
+require 'representable/decorator'
+
+
+module Roaster
+
+  class Decorator < Representable::Decorator
+
+    def resource_name
+      if defined? @@overloaded_resource_name
+        @@overloaded_resource_name
+      else
+        self.class.to_s.gsub(/Mapping\Z/, '').underscore.pluralize
+      end
+    end
+
+
+    class << self
+
+      def can_filter_by(*attrs)
+        representable_attrs[:_filterable_attributes] ||= []
+        representable_attrs[:_filterable_attributes].push(*attrs.map(&:to_sym)).uniq!
+      end
+
+      def filterable_attributes
+        representable_attrs[:_filterable_attributes] ||= []
+        representable_attrs[:_filterable_attributes]
+      end
+
+      #TODO: Disallow sorting directly by relationship (need relationship field)
+      def can_sort_by(*attrs)
+        representable_attrs[:_sortable_attributes] ||= []
+        sort_keys = attrs.map do |option|
+          if option.class == Hash
+            { option.first[0].to_sym => option.first[1].map(&:to_sym) }
+          else
+            option.to_sym
+          end
+        end
+        representable_attrs[:_sortable_attributes].push(*sort_keys).uniq!
+      end
+
+      def sortable_attributes
+        representable_attrs[:_sortable_attributes] ||= []
+        representable_attrs[:_sortable_attributes]
+      end
+
+      def can_include(*attrs)
+        representable_attrs[:_includeable_attributes] ||= []
+        representable_attrs[:_includeable_attributes].push(*attrs.map(&:to_sym)).uniq!
+      end
+
+      def includeable_attributes
+        representable_attrs[:_includeable_attributes] ||= []
+        representable_attrs[:_includeable_attributes]
+      end
+
+      def resource_name(name)
+        @@overloaded_resource_name = name
+      end
+
+    end
+
+  end
+
+end

data/lib/roaster/json_api.rb

@@ -0,0 +1,13 @@
+require 'roaster/decorator'
+require 'representable/json'
+
+module Roaster
+  module JsonApi
+    class Mapping < ::Roaster::Decorator
+      include Representable::Hash
+      def to_hash(options={})
+        super options
+      end
+    end
+  end
+end

data/lib/roaster/query.rb

@@ -0,0 +1,144 @@
+module Roaster
+
+  # Query represents the operation performed on the target, and its parameters 
+  class Query
+
+    # Target represents the resource(s) scope on which is executed the query
+    class Target
+
+      attr_accessor :resource_name, :resource_ids, :relationship_name, :relationship_ids
+
+      def initialize(resource_name,
+                     resource_ids = [],
+                     relationship_name = nil,
+                     relationship_ids = [])
+        @resource_name = resource_name
+        @resource_ids = Array(resource_ids)
+        @relationship_name = relationship_name
+        @relationship_ids = Array(relationship_ids)
+      end
+
+    end
+
+    #TODO: This is not validating includes it seems (HARD VALIDATE EVERYTHING, raise is your FRIEND)
+    attr_accessor :page, :page_size, :includes, :fields, :filters,
+                  :target,
+                  :sorting,
+                  :operation
+
+    #TODO: Move in config class
+    DEFAULT_PAGE_SIZE = 10
+    OPERATIONS = [:create, :read, :update, :delete]
+
+    def initialize(operation, target, mapping, params = {})
+      raise "Invalid operation: #{operation}" unless OPERATIONS.include?(operation)
+      params.symbolize_keys! if params.respond_to?(:symbolize_keys!)
+
+      @operation = operation
+      @target = target
+      @page = params[:page] ? params[:page].to_i : 1
+      @page_size = params[:page_size] ? params[:page_size].to_i : DEFAULT_PAGE_SIZE
+      @includes = includes_from_params(params, mapping)
+      @fields = fields_from_params(params, mapping)
+      @filters = filters_from_params(params, mapping)
+      @sorting = sorting_from_params(params, mapping)
+      #VALIDATE THIS (TARGET) ! omgz =D
+      @mapping = mapping
+    end
+
+    def default_page_size?
+      @page_size == DEFAULT_PAGE_SIZE
+    end
+
+    def filters_as_url_params
+      @filters.sort.map { |k,v| map_filter_ids(k,v) }.join('&')
+    end
+
+    def sorting_as_url_params
+      sorting_values = sorting.map { |k, v| v == :asc ? k : "-#{k}" }.join(',')
+      "sort=#{sorting_values}"
+    end
+
+    private
+
+    def includes_from_params(params, mapping)
+      return [] unless params[:include] && params[:include].respond_to?(:split)
+      includes = params[:include].split(',').map(&:to_sym)
+      includes.select do |i|
+        mapping.includeable_attributes.include?(i)
+      end
+    end
+
+    def parse_fieldset(fields)
+      fields.to_s.split(',').collect do |field|
+        field.downcase.to_sym
+      end
+    end
+
+    def fields_from_params(params, mapping)
+      return {} if params[:fields].blank?
+      if params[:fields].class == Hash
+        Hash[params[:fields].collect do |resource_name, fieldset|
+            [resource_name.downcase.to_sym, parse_fieldset(fieldset)]
+          end
+        ]
+      else
+        {@target.resource_name => parse_fieldset(params[:fields])}
+      end
+    end
+
+    def filters_from_params(params, mapping)
+      filters = {}
+      mapping.filterable_attributes.each do |filter|
+        filters[filter] = params[filter] if params[filter]
+      end
+      filters
+    end
+
+    def parse_sort_criteria(criteria)
+      sorting_parameters = {}
+      criteria.to_s.split(',').each do |sort_value|
+        sort_order = sort_value[0] == '-' ? :desc : :asc
+        sort_value = sort_value.gsub(/\A\-/, '').downcase.to_sym
+        sorting_parameters[sort_value] = sort_order
+      end
+      sorting_parameters
+    end
+
+    def validate_sorting_parameters(sort, mapping)
+    end
+
+    def sorting_from_params(params, mapping)
+      return {} if params[:sort].blank? || mapping.sortable_attributes.blank?
+      if params[:sort].class == Hash
+        sorting_parameters = {}
+        params[:sort].each do |sorting_resource|
+          sorting_parameters[sorting_resource[0].to_sym] = parse_sort_criteria sorting_resource[1]
+        end
+        sorting_parameters
+      else
+        {@target.resource_name => parse_sort_criteria(params[:sort])}
+      end
+    end
+
+    def map_filter_ids(key,value)
+      case value
+      when Hash
+        value.map { |k,v| map_filter_ids(k,v) }
+      else
+         "#{key}=#{value.join(',')}"
+      end
+    end
+
+    def query_to_array(value)
+      case value
+        when String
+          value.split(',')
+        when Hash
+          value.each { |k, v| value[k] = query_to_array(v) }
+        else
+          value
+      end
+    end
+  end
+end