apify 0.3.0

data/lib/apify/api.rb

@@ -0,0 +1,65 @@
+module Apify
+  class Api
+    class << self
+
+      def action(method, name, &block)
+        method = method.to_sym
+        name = name.to_sym
+        if block
+          action = Apify::Action.new(method, name, &block)
+          indexed_actions[name][method] = action
+          actions << action
+        else
+          indexed_actions[name][method] or raise "Unknown API action: #{name}"
+        end
+      end
+
+      def get(name, &block)
+        action(:get, name, &block)
+      end
+
+      def post(name, &block)
+        action(:post, name, &block)
+      end
+
+      def put(name, &block)
+        action(:put, name, &block)
+      end
+
+      def delete(name, &block)
+        action(:delete, name, &block)
+      end
+
+      def actions
+        @actions ||= []
+      end
+
+      def indexed_actions
+        @indexed_actions ||= Hash.new { |hash, k| hash[k] = {} }
+      end
+
+      def draw_routes(map, options = {})
+        options[:base_path] ||= 'api'
+        options[:controller] ||= 'api'
+        indexed_actions.each do |name, methods|
+          methods.each do |method, action|
+            connect_route(map, name, method, options)
+          end
+        end
+        connect_route(map, 'docs', :get, options)
+      end
+
+      private
+
+      def connect_route(map, name, method, options)
+        options = options.dup
+        base_path = options.delete :base_path
+        map.connect(
+          base_path ? "#{base_path}/#{name}" : name,
+          options.merge(:action => name.to_s, :conditions => { :method => method })
+        )
+      end
+
+    end
+  end
+end

data/lib/apify/api_controller.rb

@@ -0,0 +1,99 @@
+module Apify
+  class ApiController < ActionController::Base
+
+    helper ApifyHelper
+
+    class << self
+
+      def authenticate(options)
+        @user = options[:user] or raise "Missing user for authentication"
+        @password = options[:password] or raise "Missing password for authentication"
+        @authenticate_condition = options[:if] || lambda { true }
+      end
+
+      def api(api)
+        @api = api
+        @api.indexed_actions.each do |name, methods|
+          define_method name do
+            if action = methods[request.method]
+              if params[:schema].present?
+                render_schema(params[:schema], action)
+              elsif params[:example].present?
+                render_example(params[:example], action)
+              else
+                respond_with_action(action)
+              end
+            else
+              render_method_not_allowed(request.method)
+            end
+          end
+        end
+        @api
+      end
+
+    end
+
+    skip_before_filter :verify_authenticity_token
+
+    before_filter :require_api_authentication
+
+    def docs
+      render 'apify/api/docs', :layout => false
+    end
+
+    def api
+      configuration(:api) || self.class.api(::Api)
+    end
+
+    def authentication_configured?
+      !!@authenticate_condition
+    end
+
+    helper_method :api, :authentication_configured? 
+
+    private
+
+    def configuration(symb)
+      self.class.instance_variable_get("@#{symb}")
+    end
+    
+    def respond_with_action(action)
+      args = params[:args].present? ? JSON.parse(params[:args]) : {}
+      exchange = action.respond(args)
+      render_api_response(exchange, "#{action.name}.json")
+    end
+
+    def render_api_response(exchange, filename)
+      # p exchange.value
+      if exchange.successful?
+        send_data exchange.value.to_json, :status => '200', :type => 'application/json', :filename => filename
+      else
+        send_data exchange.value, :status => '500', :type => 'text/plain', :filename => filename
+      end
+    end
+
+    def render_method_not_allowed(method)
+      send_data "Method not allowed: #{method}", :status => 405, :type => 'text/plain'
+    end
+
+    def render_schema(nature, action)
+      send_data JSON.pretty_generate(action.schema(nature)), :status => 200, :type => "application/schema+json", :filename => "#{action.name}.schema.json"
+    end
+
+    def render_example(nature, action)
+      send_data JSON.pretty_generate(action.example(nature)), :status => 200, :type => "application/json", :filename => "#{action.name}.example.json"
+    end
+
+    def require_api_authentication
+      condition = configuration(:authenticate_condition)
+      if condition && instance_eval(&condition)
+        authenticate_or_request_with_http_basic do |user, password|
+          required_user = configuration(:user)
+          required_password = configuration(:password)
+          required_user.present? && required_password.present? && user.strip == required_user && password.strip == required_password
+        end
+      end
+    end
+    
+  end
+end

data/lib/apify/client.rb

@@ -0,0 +1,52 @@
+module Apify
+  class Client
+
+    def initialize(options)
+      @host = options[:host] or raise "Missing :host parameter"
+      @port = options[:port]
+      @protocol = options[:protocol] || 'http'
+      @user = options[:user]
+      @password = options[:password]
+    end
+    
+    def get(*args)
+      request(:get, *args)
+    end
+    
+    def post(*args)
+      request(:post, *args)
+    end
+    
+    def put(*args)
+      request(:put, *args)
+    end
+    
+    def delete(*args)
+      request(:delete, *args)
+    end
+    
+    private
+    
+    def request(method, path, args = nil)
+      url = build_url(path)
+      args ||= {}
+      json = RestClient.send(method, url, :args => args.to_json)
+      JSON.parse(json)
+    rescue RestClient::Unauthorized => e
+      raise Apify::RequestFailed.new("Unauthorized")
+    rescue RestClient::ExceptionWithResponse => e
+      raise Apify::RequestFailed.new("API request failed with status #{e.http_code}", e.http_body)
+    end
+
+    def build_url(path)
+      url =  ""
+      url << @protocol
+      url << '://'
+      url << "#{@user}:#{@password}@" if @user
+      url << @host
+      url << ":#{@port}" if @port
+      url << path
+    end
+
+  end
+end

data/lib/apify/errors.rb

@@ -0,0 +1,12 @@
+module Apify
+  class RequestFailed < StandardError
+
+    attr_reader :response_body
+
+    def initialize(message, response_body = nil)
+      super(message)
+      @response_body = response_body
+    end
+
+  end
+end

data/lib/apify/exchange.rb

@@ -0,0 +1,53 @@
+
+module Apify
+  class Exchange
+
+    attr_reader :args, :value
+
+    def initialize
+      @value = nil
+      @error = false
+      @args = nil
+    end
+
+    def successful?
+      not @error
+    end
+
+    def respond(args, action)
+      logging_errors do
+        @args = args
+        validate(@args, action.schema(:args), 'Invalid request args')
+        @value = instance_eval(&action.responder) || {}
+        validate(@value, action.schema(:value), 'Invalid response value')
+      end
+      successful?
+    end
+
+    private
+
+    attr_writer :value
+
+    def validate(object, schema, message_prefix)
+      JSON::Schema.validate(object, schema) if schema
+    rescue JSON::Schema::ValueError => e
+      raise "#{message_prefix}: #{e.message}"
+    end
+
+    def logging_errors(&block)
+      block.call
+    rescue Exception => e
+      @error = true
+      @value = e.message
+    end
+    
+    def sql_datetime(time)
+      time.present? ? time.strftime("%Y-%m-%d %H:%M:%S") : nil
+    end
+
+    def sql_date(date)
+      date.present? ? date.strftime("%Y-%m-%d") : nil
+    end
+
+  end
+end

data/lib/apify/schema_helper.rb

@@ -0,0 +1,56 @@
+module Apify
+  module SchemaHelper
+
+    def optional(schema)
+      schema.merge('optional' => true)
+    end
+    
+    def object(properties = nil)
+      { 'type' => 'object' }.tap do |schema|
+        schema['properties'] = properties if properties
+      end
+    end
+
+    def array(items = nil)
+      { 'type' => 'array' }.tap do |schema|
+        schema['items'] = items if items
+      end
+    end
+
+    def string
+      { 'type' => 'string' }
+    end
+
+    def boolean
+      { 'type' => 'boolean' }
+    end
+
+    def enum(schema, allowed_values)
+      schema.merge('enum' => allowed_values)
+    end
+
+    def number
+      { 'type' => 'number' }
+    end
+
+    def integer
+      { 'type' => 'integer' }
+    end
+
+    def sql_date
+      { 'type' => 'string',
+        'pattern' => Patterns::SQL_DATE.source }
+    end
+
+    def sql_datetime
+      { 'type' => 'string',
+        'pattern' => Patterns::SQL_DATETIME.source }
+    end
+
+    def email
+      { 'type' => 'string',
+        'pattern' => Patterns::EMAIL.source }
+    end
+
+  end
+end

data/spec/apify/action_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Apify::Action do
+
+  describe '#uid' do
+
+    it "should return a string uniquely describing the action within an API" do
+      action = Apify::Action.new(:post, :hello_world) {}
+      action.uid.should == 'post_hello_world'
+    end
+
+  end
+
+  describe '#example' do
+
+    it "should return an example for a JSON object matching the schema" do
+      action = Apify::Action.new(:post, :hello_world) do
+        schema :value do
+          object(
+            'string_property' => string,
+            'integer_property' => integer
+          )
+        end
+      end
+
+      action.example(:value).should == {
+        'string_property' => 'string',
+        'integer_property' => 123
+      }
+
+    end
+
+  end
+
+end

data/spec/apify/client_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Apify::Client do
+
+  it "raise an exception if authorization is missing" do
+    client = Apify::Client.new(:host => 'host')
+    stub_http_request(:get, 'http://host/api').to_return(:status => 401, :body => 'the body')
+    expect { client.get '/api' }.to raise_error(Apify::RequestFailed)
+  end
+
+  it "raise an exception if there is a server error" do
+    client = Apify::Client.new(:host => 'host')
+    stub_http_request(:get, 'http://host/api').to_return(:status => 500, :body => 'the body')
+    expect { client.get '/api' }.to raise_error(Apify::RequestFailed)
+  end
+
+  it "should return the parsed JSON object if the request went through" do
+    client = Apify::Client.new(:host => 'host')
+    stub_http_request(:get, 'http://host/api').to_return(:status => 200, :body => '{ "key": "value" }')
+    client.get('/api').should == { 'key' => 'value' }
+  end
+
+end
+

data/spec/app_root/app/controllers/api_controller.rb

@@ -0,0 +1,8 @@
+class ApiController < Apify::ApiController
+
+  attr_accessor :skip_authentication
+
+  api Api
+  authenticate :user => 'user', :password => 'password', :if => lambda { !skip_authentication }
+
+end

data/spec/app_root/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+
+end

data/spec/app_root/app/models/api.rb

@@ -0,0 +1,42 @@
+class Api < Apify::Api
+
+  post :ping do
+    respond do
+      { 'message' => 'pong' }
+    end
+  end
+
+  post :fail do
+    respond do
+      raise "error message"
+    end
+  end
+
+  post :echo_args do
+    respond do
+      args
+    end
+  end
+
+  post :with_args_schema do
+    schema :args do
+      { "type" => "object",
+        "properties" => {
+          "string_arg" => string
+      }}
+    end
+  end
+
+  post :with_value_schema do
+    schema :value do
+      { "type" => "object",
+        "properties" => {
+          "string_value" => string
+      }}
+    end
+    respond do
+      args
+    end
+  end
+
+end