spyke 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22e34d4a8e27855f8532e9f079990487350e0ecf
+  data.tar.gz: 93c623d72dd7699be86e9bfa8f3f0c09911a748f
+SHA512:
+  metadata.gz: a294370b263e09eb49836d5c338835388e9a8c5471633b4565afdf1c3c3c902b9f3a867d05fc356814e488638aee7b94b73eeee2767d9e8b8a4cbc06d78d757d
+  data.tar.gz: 9e8aa1d7d557d57877e0e87177ef75069e87988a059097015f73d97e631fa484e981112d5dcd4e9a00b6198374cd9dfbd90274042b9c61955cf633fae64ce8fc

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spyke.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jens Balvig
+
+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,84 @@
+# Spyke
+
+Spyke allows you to interact with remote REST services in an ActiveRecord-like manner.
+
+It basically ~~rips off~~ takes inspiration from :innocent: [Her](https://github.com/remiprev/her), a gem which we sadly had to abandon as it showed significant performance problems and maintenance seemed to had gone stale. 
+
+We therefore made Spyke which adds a few fixes/features that we needed for our projects:
+
+- Fast handling of even large amounts of JSON
+- Proper support for scopes
+- Ability to define custom URIs for associations
+- Googlable name! :)
+
+## Configuration
+
+Add this line to your application's Gemfile:
+
+    gem 'spyke'
+
+Like Her, Spyke uses Faraday to handle requests and expects a hash in the following format:
+
+```ruby
+{ result: { id: 1, name: 'Bob' }, metadata: {} }
+```
+
+The simplest possible configuration that can work is something like this:
+
+```ruby
+# config/initializers/spyke.rb
+
+class JSONParser < Faraday::Response::Middleware
+  def parse(body)
+    json = MultiJson.load(body, symbolize_keys: true)
+    {
+      data: json[:result],
+      metadata: json[:metadata]
+    }
+  end
+end
+
+Spyke::Config.connection = Faraday.new(url: 'http://api.com') do |c|
+  c.use JSONParser
+  c.use Faraday::Adapter::NetHttp
+end
+```
+
+## Usage
+
+Adding a class and inheriting from `Spyke::Base` will allow you to interact with the remote service:
+
+```ruby
+class User < Spyke::Base
+  has_many :posts
+end
+
+user = User.find(3) # => GET http://api.com/users/3
+user.posts # => find embedded in user or GET http://api.com/users/3/posts
+```
+
+### Custom URIs
+
+You can specify custom URIs on both the class and association level:
+
+```ruby
+class User < Spyke::Base
+  uri '/v1/users/:id'
+  
+  has_one :image, uri: nil
+  has_many :posts, uri: '/posts/for_user/:user_id'
+end
+
+class Post < Spyke::Base
+end
+
+user = User.find(3) # => GET http://api.com/v1/users/3
+user.image # Will only use embedded JSON and never call out to api
+user.posts # => GET http://api.com/posts/for_user/3
+Post.find(4) # => GET http://api.com/posts/4
+```
+
+## Contributing
+
+If possible please take a look at the tests marked "wishlisted"! 
+These are features/fixes we want to implement but haven't gotten around to doing yet :)

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+end

data/lib/spyke.rb

@@ -0,0 +1,6 @@
+require 'active_support/core_ext'
+require 'spyke/base'
+require 'spyke/version'
+
+module Spyke
+end

data/lib/spyke/associations.rb

@@ -0,0 +1,55 @@
+require 'spyke/associations/association'
+require 'spyke/associations/has_many'
+require 'spyke/associations/has_one'
+require 'spyke/associations/belongs_to'
+
+module Spyke
+  module Associations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :associations
+      self.associations = {}.freeze
+    end
+
+    module ClassMethods
+      def has_many(name, options = {})
+        self.associations = associations.merge(name => options.merge(type: HasMany))
+
+        define_method "#{name.to_s.singularize}_ids=" do |ids|
+          attributes[name] = []
+          ids.reject(&:blank?).each { |id| association(name).build(id: id) }
+        end
+
+        define_method "#{name.to_s.singularize}_ids" do
+          association(name).map(&:id)
+        end
+      end
+
+      def has_one(name, options = {})
+        self.associations = associations.merge(name => options.merge(type: HasOne))
+        define_method "build_#{name}" do |attributes = nil|
+          association(name).build(attributes)
+        end
+      end
+
+      def belongs_to(name, options = {})
+        self.associations = associations.merge(name => options.merge(type: BelongsTo))
+      end
+
+      def accepts_nested_attributes_for(*names)
+        names.each do |association_name|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{association_name}_attributes=(association_attributes)
+              association(:#{association_name}).assign_nested_attributes(association_attributes)
+            end
+          RUBY
+        end
+      end
+
+      def reflect_on_association(name)
+        Relation.new(name.to_s.classify.constantize) # Just enough to support nested_form gem
+      end
+    end
+  end
+end

data/lib/spyke/associations/association.rb

@@ -0,0 +1,62 @@
+require 'spyke/relation'
+require 'spyke/result'
+
+module Spyke
+  module Associations
+    class Association < Relation
+      attr_reader :parent, :name
+
+      def initialize(parent, name, options = {})
+        super (options[:class_name] || name.to_s).classify.constantize, options
+        @parent, @name = parent, name
+      end
+
+      def load
+        find_one # Override for plural associations that return an association object
+      end
+
+      def assign_nested_attributes(attributes)
+        parent.attributes[name] = new(attributes).attributes
+      end
+
+      def create(attributes = {})
+        add_to_parent super
+      end
+
+      def new(*args)
+        add_to_parent super
+      end
+
+      def build(*args)
+        new(*args)
+      end
+
+      private
+
+        def add_to_parent(record)
+          parent.attributes[name] = record.attributes
+          record
+        end
+
+        def foreign_key
+          (@options[:foreign_key] || "#{parent.class.model_name.param_key}_id").to_sym
+        end
+
+        def fetch
+          fetch_embedded || super
+        end
+
+        def fetch_embedded
+          if embedded_attributes
+            Result.new(data: embedded_attributes)
+          elsif !uri
+            Result.new(data: nil)
+          end
+        end
+
+        def embedded_attributes
+          parent.attributes[name]
+        end
+    end
+  end
+end

data/lib/spyke/associations/belongs_to.rb

@@ -0,0 +1,11 @@
+module Spyke
+  module Associations
+    class BelongsTo < Association
+      def initialize(*args)
+        super
+        @options.reverse_merge!(uri: "/#{klass.model_name.plural}/:id", foreign_key: "#{klass.model_name.param_key}_id")
+        @params[:id] = parent.try(foreign_key)
+      end
+    end
+  end
+end

data/lib/spyke/associations/has_many.rb

@@ -0,0 +1,39 @@
+module Spyke
+  module Associations
+    class HasMany < Association
+      def initialize(*args)
+        super
+        @options.reverse_merge!(uri: "/#{parent.class.model_name.plural}/:#{foreign_key}/#{klass.model_name.plural}/:id")
+        @params[foreign_key] = parent.id
+      end
+
+      def load
+        self
+      end
+
+      def assign_nested_attributes(collection)
+        collection = collection.values if collection.is_a?(Hash)
+
+        collection.each do |attributes|
+          if existing = find_existing_attributes(attributes.with_indifferent_access[:id])
+            existing.merge!(attributes)
+          else
+            build(attributes)
+          end
+        end
+      end
+
+      private
+
+        def find_existing_attributes(id)
+          embedded_attributes.to_a.find { |attr| attr[:id] && attr[:id].to_s == id.to_s }
+        end
+
+        def add_to_parent(record)
+          parent.attributes[name] ||= []
+          parent.attributes[name] << record.attributes
+          record
+        end
+    end
+  end
+end

data/lib/spyke/associations/has_one.rb

@@ -0,0 +1,11 @@
+module Spyke
+  module Associations
+    class HasOne < Association
+      def initialize(*args)
+        super
+        @options.reverse_merge!(uri: "/#{parent.class.model_name.plural}/:#{foreign_key}/#{klass.model_name.singular}")
+        @params[foreign_key] = parent.id
+      end
+    end
+  end
+end

data/lib/spyke/attributes.rb

@@ -0,0 +1,130 @@
+require 'spyke/collection'
+
+module Spyke
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :attributes
+    end
+
+    module ClassMethods
+      def attributes(*args)
+        args.each do |attr|
+          define_method attr do
+            attribute(attr)
+          end
+        end
+      end
+    end
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+      @uri_template = current_scope.uri
+    end
+
+    def attributes=(new_attributes)
+      @attributes ||= current_scope.params.with_indifferent_access
+      use_setters parse(new_attributes) if new_attributes
+    end
+
+    def id
+      attributes[:id]
+    end
+
+    def id=(value)
+      attributes[:id] = value if value.present?
+    end
+
+    def ==(other)
+      other.is_a?(Spyke::Base) && id == other.id
+    end
+
+    def inspect
+      "#<#{self.class}(#{uri}) id: #{id.inspect} #{inspect_attributes}>"
+    end
+
+    private
+
+      def default_attributes
+        self.class.default_attributes
+      end
+
+      def parse(attributes)
+        attributes.each_with_object({}) do |(key, value), parameters|
+          parameters[key] = parse_value(value)
+        end
+      end
+
+      def parse_value(value)
+        case
+        when value.is_a?(Spyke::Base)         then parse(value.attributes)
+        when value.is_a?(Hash)                then parse(value)
+        when value.is_a?(Array)               then value.map { |v| parse_value(v) }
+        when value.respond_to?(:content_type) then Faraday::UploadIO.new(value.path, value.content_type)
+        else value
+        end
+      end
+
+      def use_setters(attributes)
+        attributes.each do |key, value|
+          send "#{key}=", value
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        case
+        when association?(name) then association(name).load
+        when attribute?(name)   then attribute(name)
+        when predicate?(name)   then predicate(name)
+        when setter?(name)      then set_attribute(name, args.first)
+        else super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        association?(name) || attribute?(name) || predicate?(name) || super
+      end
+
+      def association?(name)
+        associations.has_key?(name)
+      end
+
+      def association(name)
+        options = associations[name]
+        options[:type].new(self, name, options)
+      end
+
+      def attribute?(name)
+        attributes.has_key?(name)
+      end
+
+      def attribute(name)
+        attributes[name]
+      end
+
+      def predicate?(name)
+        name.to_s.end_with?('?')
+      end
+
+      def predicate(name)
+        !!attribute(depredicate(name))
+      end
+
+      def depredicate(name)
+        name.to_s.chomp('?').to_sym
+      end
+
+      def setter?(name)
+        name.to_s.end_with?('=')
+      end
+
+      def set_attribute(name, value)
+        attributes[name.to_s.chomp('=')] = value
+      end
+
+      def inspect_attributes
+        attributes.except(:id).map { |k, v| "#{k}: #{v.inspect}" }.join(' ')
+      end
+  end
+end