vodka 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+/*.gem
+/.bundle
+/Gemfile.lock
+
+/spec/dummy/db/*.sqlite3
+/spec/dummy/log/*
+/spec/dummy/tmp/pids/*

data/.travis.yml

@@ -0,0 +1,14 @@
+rvm:
+  - 1.9.3
+script: ./script/ci
+before_script:
+  - ./script/bundle_dummy
+  - ./script/setup_db
+  - ./script/start_server
+after_script:
+  - ./script/stop_server
+after_failure:
+  - ./script/show_logs
+notifications:
+  hipchat:
+    secure: "SUoVBD+3cNXuzHK/xiww4e2jWdo9GHz+YE09s+z0K51nPtlTy9NFaBF41O7W\nMc4sz0ZxktnVrpVvyOGmLj933uyyRjhfK9X3R6Fn/BMzWDI1S4Z2NqhKq3xy\nGpLjEAX8UPtWXR0Cs4GxTwxTM6rjIW/I/5IpM6hiwRErSBXBin0="

data/Gemfile

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

data/LICENCE

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENCE
+                        Version 2, December 2004
+
+          Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.md

@@ -0,0 +1,119 @@
+# Vodka
+Vodka makes communication easier. Always.
+
+Vodka uses [Her](https://github.com/remiprev/her) as a REST client.
+
+It currently supports ORM's on server:
+- [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord)
+- [MongoMapper](https://github.com/jnunemaker/mongomapper)
+
+Plugins:
+- [WillPaginate](https://github.com/mislav/will_paginate)
+
+It is strongly recommended *NOT* to use this gem in production (yet).
+
+## Installation
+Add this gem to both server and client application Gemfiles:
+```ruby
+# Server
+gem 'vodka', require: 'vodka/server'
+
+# Client
+gem 'vodka', require: 'vodka/client'
+```
+
+## Configuring server
+Add initializer `vodka_setup.rb` to `config/initializers`:
+
+```ruby
+Vodka::Server.configure do |c|
+  c.secret = 'whatever'
+end
+```
+
+Add vodka namespaced resources to your `config/routes.rb`
+```ruby
+namespace :vodka do
+  resources :articles do
+    collection { get :best }
+    resources :comments do
+      member { put :approve }
+    end
+  end
+end
+```
+
+Create controllers in `app/controllers/vodka`
+```ruby
+# articles_controller.rb
+class ArticlesController < VodkaController
+  def best
+    respond_with_collection(Article.best)
+  end
+end
+
+# comments_controller.rb
+class CommentsController < Vodka::Server::VodkaController
+  def approve
+    vodka_response.success = resource.approve
+    respond_with_resource
+  end
+end
+```
+
+Modify your models:
+```ruby
+# article.rb
+class Article < ActiveRecord::Base
+  has_many :comments
+  scope :best, ->{ where('rating > 100') }
+  validates_presence_of :title, :body
+
+  # Defines fields and actions that would be used in :as_json method
+  present_with :id, :title, :body, :created_at
+end
+
+# comment.rb
+class Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :user
+  validates_presence_of :body
+
+  # Defines fields and actions that would be used in :as_json method
+  present_with :id, :body, :author_name, :created_at
+
+  def approve
+    update_attributes(status: 'approved')
+  end
+
+  def author_name
+    [user.first_name, user.last_name].join(' ')
+  end
+end
+```
+
+## Configuring client
+Add initializer `vodka_setup.rb` to `config/initializers`:
+
+```ruby
+Vodka::Client.configure do |c|
+  c.api_url = 'https://api.myproject.org/vodka'
+  c.secret = 'whatever' # Same as server's
+end
+Vodka::Client.configure_her!
+```
+
+## Usage
+After all the configuration is done, you can use your Her-applied models with all the new possibilities.
+
+Vodka adds some convinient methods to client and supports them on server:
+- `.create!` (throws exception on error)
+- `.paginate` (same as `.all`, for WillPaginate compatibility)
+- `.where` (supports chaining the way you expect)
+- `#update_attribute`
+- `#update_attribute!` (throws exception on error)
+- `#update_attributes`
+- `#update_attributes!` (throws exception on error)
+- `#destroy!` (throws exception on error)
+- `#delete` (acts as `#destroy`)
+- `#delete!` (acts as `#destroy!`)

data/lib/party.rb

@@ -0,0 +1,9 @@
+require 'i18n'
+require 'vodka/client'
+require './spec/client/article'
+
+Vodka::Client.configure do |c|
+  c.api_url = 'http://0.0.0.0:3000/vodka'
+  c.secret = 'whatever'
+end
+Vodka::Client.configure_her!

data/lib/vodka/client/exceptions/exception.rb

@@ -0,0 +1,6 @@
+module Vodka
+  module Client
+    class Exception < ::Exception
+    end
+  end
+end

data/lib/vodka/client/exceptions/failed_action_exception.rb

@@ -0,0 +1,6 @@
+module Vodka
+  module Client
+    class FailedActionException < ::Exception
+    end
+  end
+end

data/lib/vodka/client/exceptions/forbidden_exception.rb

@@ -0,0 +1,11 @@
+module Vodka
+  module Client
+    class ForbiddenException < ::Exception
+      MESSAGE = '403 Forbidden'
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+  end
+end

data/lib/vodka/client/exceptions/not_found_exception.rb

@@ -0,0 +1,11 @@
+module Vodka
+  module Client
+    class NotFoundException < ::Exception
+      MESSAGE = '404 Not Found'
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+  end
+end

data/lib/vodka/client/exceptions/resource_exception.rb

@@ -0,0 +1,6 @@
+module Vodka
+  module Client
+    class ResourceException < ::Exception
+    end
+  end
+end

data/lib/vodka/client/middleware/error_aware.rb

@@ -0,0 +1,21 @@
+module Vodka
+  module Client
+    module Middleware
+      class ErrorAware < Faraday::Response::Middleware
+        def on_complete(env)
+          env[:body] = MultiJson.load(env[:body]) unless env[:body].is_a?(Hash)
+          return unless env[:body][:errors].present? && env[:body][:errors][:vodka_error].present?
+
+          case env[:body][:errors][:vodka_error]
+          when ForbiddenException::MESSAGE
+            raise ForbiddenException.new
+          when NotFoundException::MESSAGE
+            raise NotFoundException.new
+          else
+            raise Exception.new(env[:body][:errors][:vodka_error])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vodka/client/middleware/signed_request.rb

@@ -0,0 +1,34 @@
+module Vodka
+  module Client
+    module Middleware
+      class SignedRequest < Faraday::Middleware
+        attr_reader :app, :env
+
+        def initialize(app, options = {})
+          @app = app
+        end
+
+        def call(_env)
+          @env = _env
+
+          env[:request_headers]['X-Request-Id'] = request_id
+          env[:request_headers]['X-Request-Signature'] = request_signature
+          env[:request_headers]['X-Response-Locale'] = I18n.locale.to_s if defined?(I18n)
+
+          @app.call(env)
+        end
+
+        def request_id
+          @request_id ||= [Time.now.to_i, (rand * 100_000_000).to_i].join(?_)
+        end
+
+        def request_signature
+          Digest::SHA512.hexdigest([
+            env[:url].scheme, env[:url].host, env[:url].port, env[:url].path,
+            request_id, Vodka::Client.config.secret
+          ].join)
+        end
+      end
+    end
+  end
+end

data/lib/vodka/client.rb

@@ -0,0 +1,16 @@
+require 'vodka'
+require 'vodka/client/exceptions/exception'
+require 'vodka/client/exceptions/failed_action_exception'
+require 'vodka/client/exceptions/forbidden_exception'
+require 'vodka/client/exceptions/not_found_exception'
+require 'vodka/client/exceptions/resource_exception'
+require 'vodka/client/middleware/signed_request'
+require 'vodka/client/middleware/error_aware'
+require 'vodka/her/extensions/extended_orm'
+require 'vodka/her/extensions/will_paginate'
+
+module Vodka
+  module Client
+    extend Configurable
+  end
+end

data/lib/vodka/configuration.rb

@@ -0,0 +1,25 @@
+module Vodka
+  class Configuration
+    attr_accessor :secret, :api_url
+  end
+
+  module Configurable
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config if block_given?
+    end
+
+    def configure_her!
+      ::Her::API.setup(url: Vodka::Client.config.api_url) do |c|
+        c.use Vodka::Client::Middleware::ErrorAware
+        c.use Vodka::Client::Middleware::SignedRequest
+        c.use Faraday::Request::UrlEncoded
+        c.use ::Her::Middleware::SecondLevelParseJSON
+        c.use Faraday::Adapter::NetHttp
+      end
+    end
+  end
+end

data/lib/vodka/her/extensions/extended_orm.rb

@@ -0,0 +1,92 @@
+module Vodka
+  module Her
+    module Extensions
+      module ExtendedOrm
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def create!(*args)
+            resource = create(*args)
+            unless resource.errors.empty?
+              error = [resource.errors.keys.first, resource.errors.values.first].join(' ')
+              raise Vodka::Client::ResourceException.new(error)
+            end
+
+            resource
+          end
+
+          def first
+            resources = all(vodka_special_action: 'first')
+            resource = resources.first
+            resource.errors = resources.errors
+            resource.metadata = resources.metadata
+            resource
+          end
+
+          def last
+            resources = all(vodka_special_action: 'last')
+            resource = resources.first
+            resource.errors = resources.errors
+            resource.metadata = resources.metadata
+            resource
+          end
+
+          def where(*args)
+            @where_conditions ||= []
+            @where_conditions << args
+            self
+          end
+
+          def all(params = {})
+            unless @where_conditions.nil?
+              params[:vodka_special_where] = MultiJson.dump(@where_conditions)
+              @where_conditions = nil
+            end
+            super(params)
+          end
+        end
+
+        def update_attributes(params)
+          params.each do |attribute, value|
+            send(:"#{attribute}=", value)
+          end
+          save
+        end
+
+        def update_attributes!(params)
+          update_attributes(params)
+          unless errors.empty?
+            error = [errors.keys.first, errors.values.first].join(' ')
+            raise Vodka::Client::ResourceException.new(error)
+          end
+
+          self
+        end
+
+        def update_attribute(attribute, value)
+          update_attributes(attribute => value)
+        end
+
+        def update_attribute!(attribute, value)
+          update_attributes!(attribute => value)
+        end
+
+        def destroy!
+          destroy
+          raise Vodka::Client::FailedActionException.new('Destroy failed') if metadata[:vodka_action_success] == false
+          self
+        end
+
+        def delete
+          destroy
+        end
+
+        def delete!
+          destroy!
+        end
+      end
+    end
+  end
+end
+
+Her::Model.send(:include, Vodka::Her::Extensions::ExtendedOrm)

data/lib/vodka/her/extensions/will_paginate.rb

@@ -0,0 +1,32 @@
+module Vodka
+  module Her
+    module Extensions
+      module WillPaginate
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def paginate(params)
+            response = all(params)
+            PaginatedCollection.new(response, response.metadata, response.errors)
+          end
+        end
+      end
+
+      class PaginatedCollection < ::Her::Collection
+        def current_page
+          metadata[:page].to_i
+        end
+
+        def per_page
+          metadata[:per_page].to_i
+        end
+
+        def total_entries
+          metadata[:total].to_i
+        end
+      end
+    end
+  end
+end
+
+Her::Model.send(:include, Vodka::Her::Extensions::WillPaginate)

data/lib/vodka/server/controllers/vodka_controller.rb

@@ -0,0 +1,32 @@
+require 'action_controller' unless defined?(::ActionController)
+
+module Vodka
+  module Server
+    class VodkaController < ::ActionController::Base
+      include Handlers::Scaffold
+      include Handlers::Resource
+      include Handlers::Response
+
+      before_filter :fix_params_names, :set_locale
+      before_filter :handle_not_found, only: [:show, :update, :destroy]
+
+    private
+
+      def set_locale
+        return unless defined?(I18n)
+        locale = request.headers['X-Response-Locale']
+        I18n.locale = locale if locale.present? && locale.to_sym.in?(I18n.available_locales)
+      end
+
+      def fix_params_names
+        params[:password] = params.delete(:buzzword) unless params[:buzzword].nil?
+      end
+
+      def handle_not_found
+        not_found if resource.nil? && vodka_response.success == false
+      end
+    end
+  end
+end
+
+VodkaController = Vodka::Server::VodkaController

data/lib/vodka/server/handlers/resource.rb

@@ -0,0 +1,36 @@
+module Vodka
+  module Server
+    module Handlers
+      module Resource
+      private
+
+        def resource
+          @resource ||= extract_resource
+        end
+
+        def extract_resource
+          return unless params.has_key?(:id)
+
+          new_resource = resource_class.find_by_id(params[:id])
+          vodka_response.success = false if new_resource.nil?
+
+          new_resource
+        end
+
+        def filtered_params
+          params.slice(*resource_class.accessible_attributes.to_a)
+        end
+
+        # Resource magick
+
+        def resource_name
+          self.class.name.demodulize.underscore.gsub('_controller', '').singularize
+        end
+
+        def resource_class
+          resource_name.camelcase.constantize
+        end
+      end
+    end
+  end
+end

data/lib/vodka/server/handlers/response.rb

@@ -0,0 +1,34 @@
+module Vodka
+  module Server
+    module Handlers
+      module Response
+
+        def vodka_response
+          @vodka_response ||= Vodka::Server::Response.new
+        end
+
+      private
+
+        def respond_with_resource(custom_resource = nil)
+          vodka_response.data = custom_resource || resource
+          respond!
+        end
+
+        def respond_with_collection(resources)
+          vodka_response.data = resources
+          respond!
+        end
+
+        def respond!
+          return render text: vodka_response.json, status: vodka_response.code, content_type: 'application/json'
+        end
+
+        def not_found
+          vodka_response.errors[:vodka_error] = '404 Not Found'
+          vodka_response.code = 404
+          respond!
+        end
+      end
+    end
+  end
+end

data/lib/vodka/server/handlers/scaffold.rb

@@ -0,0 +1,63 @@
+module Vodka
+  module Server
+    module Handlers
+      module Scaffold
+        def index
+          if params[:vodka_special_action] == 'first'
+            resources = [resource_class.first]
+          elsif params[:vodka_special_action] == 'last'
+            resources = [resource_class.last]
+          elsif params[:vodka_special_where].present?
+            resources = vodka_special_where
+          elsif params[:page].present? && defined?(::WillPaginate)
+            resources = vodka_special_paginate
+          else
+            resources = resource_class.all
+          end
+
+          respond_with_collection(resources)
+        end
+
+        def show
+          respond_with_resource
+        end
+
+        def create
+          respond_with_resource(resource_class.create(filtered_params))
+        end
+
+        def update
+          vodka_response.success = resource.update_attributes(filtered_params)
+          respond_with_resource
+        end
+
+        def destroy
+          resource.destroy
+          vodka_response.success = resource.destroyed?
+          respond_with_resource
+        end
+
+      private
+
+        def vodka_special_where
+          relation = resource_class
+          conditions = MultiJson.load(params[:vodka_special_where])
+          conditions.each do |condition|
+            if condition.is_a?(Hash)
+              relation = relation.where(condition)
+            else
+              relation = relation.where(*condition)
+            end
+          end
+          relation.all
+        end
+
+        def vodka_special_paginate
+          data = resource_class.paginate(page: params[:page], per_page: params[:per_page]).all
+          vodka_response.metadata = { page: data.current_page, per_page: data.per_page, total: resource_class.count }
+          data
+        end
+      end
+    end
+  end
+end

data/lib/vodka/server/middleware/signed_request.rb

@@ -0,0 +1,39 @@
+module Vodka
+  module Server
+    module Middleware
+      class SignedRequest
+        attr_reader :app, :env, :request
+
+        def initialize(app, options = {})
+          @app, @options = app, options
+        end
+
+        def call(env)
+          @env = env
+          @request = Rack::Request.new(env)
+
+          request_signature_valid? ? app.call(env) : forbidden
+        end
+
+        def request_signature_valid?
+          env['HTTP_X_REQUEST_SIGNATURE'] == request_signature
+        end
+
+        def request_signature
+          Digest::SHA512.hexdigest([
+            request.scheme, request.host, request.port, request.path,
+            env['HTTP_X_REQUEST_ID'], Vodka::Server.config.secret
+          ].join)
+        end
+
+        def forbidden
+          [
+            403,
+            { 'Content-Type' => 'application/json; charset=utf-8' },
+            ['{"data":null,"errors":{"vodka_error":"403 Forbidden"},"metadata":{}}']
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/vodka/server/plugins/presentable.rb

@@ -0,0 +1,20 @@
+module Vodka
+  module Server
+    module Plugins
+      module Presentable
+        def present_with(*methods)
+          define_method 'present_vodka' do
+            json = Hash[methods.map{ |method| [method, send(method)] }]
+            json[:errors] = errors.messages
+            json[:metadata] = {}
+            json
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, Vodka::Server::Plugins::Presentable) if defined?(ActiveRecord)
+MongoMapper::Document.send(:extend, Vodka::Server::Plugins::Presentable) if defined?(MongoMapper)
+MongoMapper::EmbeddedDocument.send(:extend, Vodka::Server::Plugins::Presentable) if defined?(MongoMapper)

data/lib/vodka/server/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails' unless defined?(::Rails)
+
+module Vodka
+  module Server
+    class Railtie < ::Rails::Railtie
+      initializer 'vodka.inject_middleware' do |app|
+        app.config.middleware.use 'Vodka::Server::Middleware::SignedRequest'
+      end
+    end
+  end
+end