spyke 1.0.0

data/lib/spyke/base.rb

@@ -0,0 +1,25 @@
+require 'active_model'
+require 'spyke/associations'
+require 'spyke/attributes'
+require 'spyke/orm'
+require 'spyke/http'
+require 'spyke/scopes'
+
+module Spyke
+  class Base
+    # ActiveModel
+    include ActiveModel::Conversion
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+    extend ActiveModel::Translation
+    extend ActiveModel::Callbacks
+
+    # Spyke
+    include Associations
+    include Attributes
+    include Http
+    include Orm
+    include Scopes
+  end
+end

data/lib/spyke/collection.rb

@@ -0,0 +1,10 @@
+module Spyke
+  class Collection < ::Array
+    attr_reader :metadata
+
+    def initialize(elements, metadata = {})
+      super(elements)
+      @metadata = metadata
+    end
+  end
+end

data/lib/spyke/config.rb

@@ -0,0 +1,5 @@
+module Spyke
+  class Config
+    class_attribute :connection
+  end
+end

data/lib/spyke/exceptions.rb

@@ -0,0 +1,3 @@
+module Spyke
+  class ResourceNotFound < StandardError; end
+end

data/lib/spyke/http.rb

@@ -0,0 +1,78 @@
+require 'faraday'
+require 'spyke/config'
+require 'spyke/path'
+require 'spyke/result'
+
+module Spyke
+  module Http
+    extend ActiveSupport::Concern
+    METHODS = %i{ get post put patch delete }
+
+    included do
+    end
+
+    module ClassMethods
+      METHODS.each do |method|
+        define_method(method) do |path, params = {}|
+          new_or_collection_from_result send("#{method}_raw", path, params)
+        end
+
+        define_method("#{method}_raw") do |path, params = {}|
+          request(method, path, params)
+        end
+      end
+
+      def request(method, path, params = {})
+        response = connection.send(method) do |request|
+          if method == :get
+            request.url path.to_s, params
+          else
+            request.url path.to_s
+            request.body = params
+          end
+        end
+        Result.new_from_response(response)
+      end
+
+      def new_or_collection_from_result(result)
+        if result.data.is_a?(Array)
+          new_collection_from_result(result)
+        else
+          new_from_result(result)
+        end
+      end
+
+      def new_from_result(result)
+        new result.data if result.data
+      end
+
+      def new_collection_from_result(result)
+        Collection.new Array(result.data).map { |record| new(record) }, result.metadata
+      end
+
+      def uri(uri_template = "/#{model_name.plural}/:id")
+        @uri ||= uri_template
+      end
+
+      def connection
+        Config.connection
+      end
+    end
+
+    METHODS.each do |method|
+      define_method(method) do |action = nil, params = {}|
+        params = action if action.is_a?(Hash)
+        path = case action
+               when Symbol then uri.join(action)
+               when String then Path.new(action, attributes)
+               else uri
+               end
+        self.attributes = self.class.send("#{method}_raw", path, params).data
+      end
+    end
+
+    def uri
+      Path.new(@uri_template, attributes)
+    end
+  end
+end

data/lib/spyke/orm.rb

@@ -0,0 +1,83 @@
+module Spyke
+  module Orm
+    extend ActiveSupport::Concern
+
+    included do
+      define_model_callbacks :create, :update, :save
+
+      class_attribute :include_root
+      self.include_root = true
+
+      class_attribute :callback_methods
+      self.callback_methods = { create: :post, update: :put }.freeze
+    end
+
+    module ClassMethods
+      def include_root_in_json(value)
+        self.include_root = value
+      end
+
+      def method_for(callback, value = nil)
+        self.callback_methods = callback_methods.merge(callback => value) if value
+        callback_methods[callback]
+      end
+
+      def find(id)
+        id = strip_slug(id)
+        where(id: id).find_one || raise(ResourceNotFound)
+      end
+
+      def fetch
+        uri = new.uri
+        get_raw uri, current_scope.params.except(*uri.variables)
+      end
+
+      def create(attributes = {})
+        record = new(attributes)
+        record.save
+        record
+      end
+
+      def destroy(id = nil)
+        new(id: id).destroy
+      end
+
+      def build(attributes = {})
+        new(attributes)
+      end
+
+      def strip_slug(id)
+        id.to_s.split('-').first
+      end
+    end
+
+    def to_params
+      if include_root?
+        { self.class.model_name.param_key => attributes.except(*uri.variables) }
+      else
+        attributes.except(*uri.variables)
+      end
+    end
+
+    def persisted?
+      id?
+    end
+
+    def save
+      run_callbacks :save do
+        callback = persisted? ? :update : :create
+        run_callbacks(callback) do
+          send self.class.method_for(callback), to_params
+        end
+      end
+    end
+
+    def destroy
+      delete
+    end
+
+    def reload
+      self.attributes = self.class.find(id).attributes
+    end
+  end
+end

data/lib/spyke/path.rb

@@ -0,0 +1,28 @@
+require 'uri_template'
+
+module Spyke
+  class Path
+    def initialize(uri_template, params = {})
+      @uri_template = URITemplate.new(:colon, uri_template)
+      @params = params
+    end
+
+    def join(other_path)
+      self.class.new File.join(path, other_path.to_s), @params
+    end
+
+    def to_s
+      path
+    end
+
+    def variables
+      @variables ||= @uri_template.variables.map(&:to_sym)
+    end
+
+    private
+
+      def path
+        @uri_template.expand(@params).chomp('/')
+      end
+  end
+end

data/lib/spyke/relation.rb

@@ -0,0 +1,57 @@
+require 'spyke/exceptions'
+
+module Spyke
+  class Relation
+    include Enumerable
+
+    attr_reader :klass, :params
+    delegate :to_ary, :[], :empty?, :last, :size, :metadata, to: :find_some
+
+    def initialize(klass, options = {})
+      @klass, @options, @params = klass, options, {}
+    end
+
+    def all
+      where
+    end
+
+    def where(conditions = {})
+      @params.merge!(conditions)
+      self
+    end
+
+    def find_one
+      @find_one ||= klass.new_from_result(fetch)
+    end
+
+    def find_some
+      @find_some ||= klass.new_collection_from_result(fetch)
+    end
+
+    def each
+      find_some.each { |record| yield record }
+    end
+
+    def uri
+      @options[:uri]
+    end
+
+    private
+
+      def method_missing(name, *args, &block)
+        if klass.respond_to?(name)
+          scoping { klass.send(name, *args) }
+        else
+          super
+        end
+      end
+
+      # Keep hold of current scope while running a method on the class
+      def scoping
+        klass.current_scope = self
+        yield
+      ensure
+        klass.current_scope = nil
+      end
+  end
+end

data/lib/spyke/result.rb

@@ -0,0 +1,25 @@
+module Spyke
+  class Result
+    attr_reader :body
+
+    def self.new_from_response(response)
+      new(response.body)
+    end
+
+    def initialize(body)
+      @body = HashWithIndifferentAccess.new(body)
+    end
+
+    def data
+      body[:data]
+    end
+
+    def metadata
+      body[:metadata] || {}
+    end
+
+    def errors
+      body[:errors]
+    end
+  end
+end

data/lib/spyke/scope_registry.rb

@@ -0,0 +1,17 @@
+module Spyke
+  class ScopeRegistry
+    extend ActiveSupport::PerThreadRegistry
+
+    def initialize
+      @registry = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def value_for(scope_type, variable_name)
+      @registry[scope_type][variable_name]
+    end
+
+    def set_value_for(scope_type, variable_name, value)
+      @registry[scope_type][variable_name] = value
+    end
+  end
+end

data/lib/spyke/scopes.rb

@@ -0,0 +1,30 @@
+require 'spyke/relation'
+require 'spyke/scope_registry'
+
+module Spyke
+  module Scopes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      delegate :all, :where, to: :current_scope
+
+      def scope(name, code)
+        self.class.send :define_method, name, code
+      end
+
+      def current_scope=(scope)
+        ScopeRegistry.set_value_for(:current_scope, name, scope)
+      end
+
+      def current_scope
+        ScopeRegistry.value_for(:current_scope, name) || Relation.new(self, uri: uri)
+      end
+    end
+
+    private
+
+      def current_scope
+        self.class.current_scope
+      end
+  end
+end

data/lib/spyke/version.rb

@@ -0,0 +1,3 @@
+module Spyke
+  VERSION = '1.0.0'
+end

data/spyke.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spyke/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spyke"
+  spec.version       = Spyke::VERSION
+  spec.authors       = ["Jens Balvig"]
+  spec.email         = ["jens@balvig.com"]
+  spec.summary       = %q{Interact with REST services in an ActiveRecord-like manner}
+  spec.description   = %q{Interact with REST services in an ActiveRecord-like manner}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "activesupport"
+  spec.add_dependency "activemodel"
+  spec.add_dependency "faraday"
+  spec.add_dependency "uri_template"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "faraday_middleware"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-line"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "webmock"
+end

data/test/associations_test.rb

@@ -0,0 +1,282 @@
+require 'test_helper'
+
+module Spyke
+  class AssociationsTest < MiniTest::Test
+    def test_association_independence
+      assert_kind_of Associations::HasMany, Recipe.new.groups
+      assert_raises NoMethodError do
+        Recipe.new.recipes
+      end
+    end
+
+    def test_initializing_with_has_many_association
+      group = Group.new(ingredients: [Ingredient.new(title: 'Water'), Ingredient.new(title: 'Flour')])
+      assert_equal %w{ Water Flour }, group.ingredients.map(&:title)
+      assert_equal({ 'group' => { 'ingredients' => [{ 'title' => 'Water' }, { 'title' => 'Flour' }] } }, group.to_params)
+    end
+
+    def test_initializing_with_has_one_association
+      recipe = Recipe.new(image: Image.new(url: 'bob.jpg'))
+      assert_equal 'bob.jpg', recipe.image.url
+    end
+
+    def test_initializing_with_blank_has_one_association
+      recipe = Recipe.new(image: Image.new)
+      assert_kind_of Image, recipe.image
+    end
+
+    def test_embedded_associations
+      stub_request(:get, 'http://sushi.com/recipes/1').to_return_json(data: { groups: [{ id: 1, name: 'Fish' }] })
+
+      recipe = Recipe.find(1)
+
+      assert_equal %w{ Fish }, recipe.groups.map(&:name)
+    end
+
+    def test_nested_embedded_associtations
+      json = { data: { groups: [{ ingredients: [{ id: 1, name: 'Fish' }] }, { ingredients: [] }] } }
+      stub_request(:get, 'http://sushi.com/recipes/1').to_return_json(json)
+
+      recipe = Recipe.find(1)
+
+      assert_equal %w{ Fish }, recipe.ingredients.map(&:name)
+    end
+
+    def test_singular_associtations
+      stub_request(:get, 'http://sushi.com/recipes/1').to_return_json(data: { image: { url: 'bob.jpg' } })
+
+      recipe = Recipe.find(1)
+
+      assert_equal 'bob.jpg', recipe.image.url
+    end
+
+    def test_unloaded_has_many_association
+      endpoint = stub_request(:get, 'http://sushi.com/recipes/1/groups?public=true').to_return_json(data: [{ id: 1 }])
+
+      groups = Recipe.new(id: 1).groups.where(public: true).to_a
+
+      assert_equal 1, groups.first.id
+      assert_requested endpoint
+    end
+
+    def test_unloaded_has_one_association
+      endpoint = stub_request(:get, 'http://sushi.com/recipes/1/image').to_return_json(data: { url: 'bob.jpg' })
+
+      image = Recipe.new(id: 1).image
+
+      assert_equal 'bob.jpg', image.url
+      assert_requested endpoint
+    end
+
+    def test_array_like_behavior
+      stub_request(:get, 'http://sushi.com/recipes/1/groups').to_return_json(data: [{ name: 'Fish' }, { name: 'Fruit' }, { name: 'Bread' }])
+
+      recipe = Recipe.new(id: 1)
+
+      assert_equal %w{ Fish Fruit }, recipe.groups[0..1].map(&:name)
+      assert_equal 'Bread', recipe.groups.last.name
+      assert_equal 'Fish', recipe.groups.first.name
+    end
+
+    def test_nil_has_one_association
+      stub_request(:get, 'http://sushi.com/recipes/1/image')
+
+      image = Recipe.new(id: 1).image
+
+      assert_nil image
+    end
+
+    def test_unloaded_belongs_to_association
+      endpoint = stub_request(:get, 'http://sushi.com/users/1')
+
+      recipe = Recipe.new(user_id: 1)
+      recipe.user
+
+      assert_requested endpoint
+    end
+
+    def test_scopes_on_assocations
+      endpoint = stub_request(:get, 'http://sushi.com/users/1/recipes?page=2')
+
+      User.new(id: 1).recipes.page(2).to_a
+
+      assert_requested endpoint
+    end
+
+    def test_build_has_many_association
+      recipe = Recipe.new(id: 1)
+      recipe.groups.build
+      assert_equal 1, recipe.groups.first.recipe_id
+    end
+
+    def test_new_has_many_association
+      recipe = Recipe.new(id: 1)
+      recipe.groups.new
+      assert_equal 1, recipe.groups.first.recipe_id
+    end
+
+    def test_deep_build_has_many_association
+      recipe = Recipe.new(id: 1)
+      recipe.groups.build(ingredients: [Ingredient.new(name: 'Salt')])
+
+      assert_equal %w{ Salt }, recipe.ingredients.map(&:name)
+      assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => 1, 'ingredients' => [{ 'name' => 'Salt' }] }] } }, recipe.to_params)
+    end
+
+    def test_deep_build_has_many_association_with_scope
+      recipe = User.new(id: 1).recipes.published.build
+
+      assert_equal({ 'recipe' => { 'status' => 'published' } }, recipe.to_params)
+    end
+
+    def test_build_association_with_ids
+      user = User.new(id: 1, recipes: [{ id: 1 }])
+      user.recipe_ids = ['', 2]
+
+      assert_equal [2], user.recipes.map(&:id)
+      assert_equal({ 'user' => { 'recipes' => [{ 'user_id' => 1, 'id' => 2 }] } }, user.to_params)
+    end
+
+    def test_converting_association_to_ids
+      stub_request(:get, 'http://sushi.com/users/1/recipes').to_return_json(data: [{ id: 2 }])
+      user = User.new(id: 1)
+      assert_equal [2], user.recipe_ids
+    end
+
+    def test_build_has_one_association
+      recipe = Recipe.new(id: 1)
+      image = recipe.build_image
+      assert_equal 1, image.recipe_id
+      assert_equal 1, recipe.image.recipe_id
+    end
+
+    def test_custom_class_name
+      stub_request(:get, 'http://sushi.com/recipes/1').to_return_json(data: { background_image: { url: 'bob.jpg' } })
+
+      recipe = Recipe.find(1)
+
+      assert_equal 'bob.jpg', recipe.background_image.url
+      assert_equal Image, recipe.background_image.class
+    end
+
+    def test_cached_result
+      endpoint_1 = stub_request(:get, 'http://sushi.com/recipes/1/groups?per_page=3')
+      endpoint_2 = stub_request(:get, 'http://sushi.com/recipes/1/groups')
+
+      recipe = Recipe.new(id: 1)
+      groups = recipe.groups.where(per_page: 3)
+      groups.any?
+      groups.to_a
+      assert_requested endpoint_1, times: 1
+
+      recipe.groups.to_a
+      assert_requested endpoint_2, times: 1
+    end
+
+    def test_custom_uri_template
+      endpoint = stub_request(:get, 'http://sushi.com/recipes/1/alternates/recipe')
+      Recipe.new(id: 1).alternate
+      assert_requested endpoint
+    end
+
+    def test_create_association
+      endpoint = stub_request(:post, 'http://sushi.com/recipes/1/groups').with(body: { group: { title: 'Topping' } }).to_return_json(data: { title: 'Topping', id: 1, recipe_id: 1 })
+
+      recipe = Recipe.new(id: 1)
+      group = recipe.groups.create(title: 'Topping')
+
+      assert_equal 'Topping', group.title
+      assert_equal 1, group.id
+      assert_equal 'Topping', recipe.groups.last.title
+      assert_equal 1, recipe.groups.last.id
+      assert_requested endpoint
+    end
+
+    def test_create_association_with_no_params
+      endpoint = stub_request(:post, 'http://sushi.com/recipes/1/groups').with(body: { group: {} })
+
+      Recipe.new(id: 1).groups.create
+
+      assert_requested endpoint
+    end
+
+    def test_create_scoped_association
+      endpoint = stub_request(:post, 'http://sushi.com/users/1/recipes').with(body: { recipe: { title: 'Sushi', status: 'published' } })
+
+      User.new(id: 1).recipes.published.create(title: 'Sushi')
+
+      assert_requested endpoint
+    end
+
+    def test_save_association
+      endpoint = stub_request(:post, 'http://sushi.com/recipes/1/groups').with(body: { group: { title: 'Topping' } }).to_return_json(data: { title: 'Topping', recipe_id: 1 })
+
+      group = Recipe.new(id: 1).groups.build(title: 'Topping')
+      group.save
+
+      assert_equal 'Topping', group.title
+      assert_requested endpoint
+    end
+
+    def test_nested_attributes_has_one
+      recipe = Recipe.new(image_attributes: { file: 'bob.jpg' })
+      assert_equal 'bob.jpg', recipe.image.file
+    end
+
+    def test_nested_attributes_belongs_to
+      recipe = Recipe.new(user_attributes: { name: 'Bob' })
+      assert_equal 'Bob', recipe.user.name
+    end
+
+    def test_nested_attributes_has_many
+      recipe = Recipe.new(groups_attributes: [{ title: 'starter' }, { title: 'sauce' }])
+      assert_equal %w{ starter sauce }, recipe.groups.map(&:title)
+    end
+
+    def test_nested_attributes_overwriting_existing
+      recipe = Recipe.new(groups_attributes: [{ title: 'starter' }, { title: 'sauce' }])
+      recipe.attributes = { groups_attributes: [{ title: 'flavor' }] }
+      assert_equal %w{ starter sauce flavor }, recipe.groups.map(&:title)
+    end
+
+    def test_nested_attributes_merging_with_existing
+      recipe = Recipe.new(groups_attributes: [{ id: 1, title: 'starter', description: 'nice' }, { id: 2, title: 'sauce', description: 'spicy' }])
+      recipe.attributes = { groups_attributes: [{ 'id' => '2', 'title' => 'flavor' }] }
+      assert_equal %w{ starter flavor }, recipe.groups.map(&:title)
+      assert_equal %w{ nice spicy }, recipe.groups.map(&:description)
+    end
+
+    def test_deeply_nested_attributes
+      params = { groups_attributes: [{ id: 1, ingredient_attributes: [{ id: 1, title: 'fish' }]}] }
+      recipe = Recipe.new(params)
+      recipe.attributes = params
+      assert_equal 1, recipe.groups.size
+    end
+
+    def test_nested_attributes_has_many_using_hash_syntax
+      recipe = Recipe.new(groups_attributes: { '0' => { title: 'starter' }, '1' => { title: 'sauce' } })
+      assert_equal %w{ starter sauce }, recipe.groups.map(&:title)
+    end
+
+    def test_nested_nested_attributes
+      recipe = Recipe.new(groups_attributes: { '0' => { ingredients_attributes: { '0' => { name: 'Salt' } } } })
+      assert_equal %w{ Salt }, recipe.ingredients.map(&:name)
+    end
+
+    def test_reflect_on_association
+      assert_equal Group, Recipe.reflect_on_association(:group).klass
+      skip 'wishlisted'
+      assert_equal Recipe, Recipe.reflect_on_association(:alternate).klass
+    end
+
+    def test_embed_only_singular_associations
+      assert_nil Recipe.new.background_image
+      assert_equal 'photo.jpg', Recipe.new(background_image: { url: 'photo.jpg' }).background_image.url
+    end
+
+    def test_embed_only_plural_associations
+      assert_equal [], Group.new.ingredients.to_a
+      assert_equal [1], Group.new(ingredients: [{ id: 1 }]).ingredients.map(&:id)
+    end
+  end
+end