commute 0.1.2 → 0.2.0.rc.1

data/.todo

@@ -0,0 +1,15 @@
+conditional sequencer (body), routing on constants
+conditional processors instead of only sequencers
+easy transforms, reactivity? When not to add a transform
+disabling
+groups of commuters (Group and delaying)
+queueing
+batching/grouping
+net/http
+stubbing
+gzip
+resourcing (commute-resourcing)
+Api::Metal
+caching
+calling processor from within commuter
+simpler sequencer internal working

data/Gemfile

@@ -3,5 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in commute.gemspec
 gemspec
 
-# Partially solves https://github.com/typhoeus/typhoeus/pull/171.
-gem 'typhoeus', :git => 'https://github.com/challengee/typhoeus.git'
+group :development do
+  gem 'dominance'
+  gem 'active_support'
+  gem 'builder'
+end

data/commute.gemspec

@@ -14,7 +14,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.version       = Commute::VERSION
 
-  s.add_dependency 'typhoeus'
+  s.add_dependency 'typhoeus', '0.5.0.rc'
+  s.add_dependency 'em-http-request'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'mocha'

data/examples/gist_api.rb

@@ -0,0 +1,71 @@
+require 'commute'
+require 'commute/common/json'
+require 'commute/common/basic_auth'
+
+class GistApi < Commute::Api
+
+  transform do |request, context|
+    if context[:auth][:username]
+      request.url = "https://api.github.com/gists"
+    else
+      request.url = "https://api.github.com/#{context[:auth][:username]}/gists"
+    end
+    request.url << "/#{context[:id]}" if context[:id]
+  end
+
+  using(:request) do
+    append Commute::Common::Json::Render.new
+    append Commute::Common::BasicAuth.new
+  end
+
+  using(:response) do
+    append Commute::Common::Json::Parse.new
+  end
+
+  def find id = nil
+    # Id for url.
+    where id: id if id
+    # Get method.
+    get
+  end
+
+  def update gist = nil
+    body(gist).patch
+  end
+
+  def create gist = nil
+    body(gist).post
+  end
+
+  private
+
+  def body gist = nil
+    with gist: gist if gist
+    transform(:gist) { |request, gist| request.body = gist }
+  end
+end
+
+ID = '46ecd83c5e13cca5a18e'
+
+api = GistApi.with auth: {
+  username: 'challengee',
+  password: 'challengeez0'
+}
+
+# gist, status = api.find(ID).run
+# p status
+
+# gist[:description] = 'cool'
+
+gist = {
+  :public => false
+  :files => {
+    "file1.txt" => {
+      :content => 'test'
+    }
+  }
+}
+
+gist, status = api.create(gist).run
+p gist
+p status

data/examples/highrise_task_api.rb

@@ -0,0 +1,59 @@
+require 'uri'
+
+require 'commute'
+
+require 'commute/aspects/url'
+require 'commute/aspects/crud'
+require 'commute/common/basic_auth'
+
+require 'active_support/core_ext/hash/conversions'
+
+class HighriseTaskApi < Commute::Api
+  include Commute::Aspect::Url
+  include Commute::Aspect::Crud
+
+  using(:request) do
+    append Proc.new { |c|
+      c.get.body = c.get.body.to_xml(root: 'task').gsub("\n", '') if c.get.body
+    }
+    append Commute::Common::BasicAuth.new
+  end
+
+  using(:response) do
+    # append Proc.new { |c|
+    #   c.get.body = Array.from_xml(c.get.body)['tasks'] if c.get.body
+    # }
+  end
+
+  url 'https://$account.highrisehq.com/$scope/tasks/$id.xml'
+
+  transform(:task) do |request, context|
+    request.body = context[:task]
+  end
+  # transform :task => :body
+
+  transform { |request| request.headers['Content-Type'] = 'application/xml' }
+
+  def update task = nil
+    super.transform { |request| request.query['reload'] = 'true' }
+  end
+end
+
+api = HighriseTaskApi.with account: 'piepetest', auth: {
+  username: '610bf60020bb861761f07feef88ba42d',
+  password: 'X'
+}
+
+task = {
+  body: 'Kmoe iets doen'
+}
+
+task, status = api.all.run
+p task.size
+p status
+
+p 'AGAIN ------------------'
+
+task, status = api.all.run
+p task.size
+p status

data/examples/pastie_api.rb

@@ -0,0 +1,18 @@
+require 'commute'
+
+class PastieApi < Commute::Api
+
+  transform(:id) do |request, id|
+    request.url = "http://pastie.org/pastes/#{id}/download"
+  end
+
+  def find id = nil
+    # Id for url.
+    where id: id if id
+    # Get method.
+    get
+  end
+end
+
+pastie, status = PastieApi.find(5119067).run.data
+# p pastie

data/lib/commute/aspects/caching.rb

@@ -0,0 +1,37 @@
+require 'commute/common/cache'
+require 'commute/common/conditional'
+
+module Commute
+  module Aspect
+
+    # Public: Enables caching in your api by inserting
+    # cache processors in the api stack.
+    #
+    # Requires you to have a processor called request, before
+    # which the fetch processor will be inserted.
+    #
+    module Caching
+
+      def self.included api
+        # Insert a processor that fetches response from the cache.
+        api.builder.using(:request) do
+          insert Common::Cache::Fetch.new
+        end
+
+        # Insert a processor that inserts responses in the cache.
+        api.builder.using(:response) do
+          append Common::Cache::Store.new
+        end
+
+        # Wrap some phases so that they will only be executed on a miss.
+        api.builder.using do
+          [:execution, :response, :status].each do |id|
+            sequence.replace id do |processor|
+              Common::Conditional::NotTagged.new(processor, :hit)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commute/aspects/crud.rb

@@ -0,0 +1,41 @@
+module Commute
+  module Aspect
+
+    module Crud
+
+      def self.included base
+        base.builder.transform(:body) do |request, resource|
+          request.body = resource
+        end
+      end
+
+      def all
+        get.multiple
+      end
+
+      def find id = nil
+        get.where(id: id).single
+      end
+
+      def update body = nil
+        put.with(body: body).single
+      end
+
+      def create body = nil
+        post.with(body: body).single
+      end
+
+      def destroy id = nil
+        delete.where(id: id).single
+      end
+
+      def single
+        self
+      end
+
+      def multiple
+        self
+      end
+    end
+  end
+end

data/lib/commute/aspects/pagination.rb

@@ -0,0 +1,16 @@
+module Commute
+  module Aspect
+
+    module Pagination
+
+      def offset n = 0
+      end
+
+      def limit n = 1
+      end
+
+      def next limit = 0
+      end
+    end
+  end
+end

data/lib/commute/aspects/url.rb

@@ -0,0 +1,57 @@
+module Commute
+  module Aspect
+
+    module Url
+
+      def self.included base
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def url pattern
+          transform &generate(pattern)
+        end
+
+        private
+
+        def generate pattern
+          # Regex to match different parts of a URL.
+          matcher = \
+            /(?<scheme>https?):\/\/(?<host>[^\/:]+):?(?<port>\d+)?(?<path>[^\.]*)(?<extension>\..+)?/
+          # Match the pattern.
+          matched = matcher.match(pattern)
+          raise 'Invalid url: At least a host and scheme required' \
+            unless matched && matched[:host] && matched[:scheme]
+          # Collect the parts.
+          parts = {
+            scheme: matched[:scheme],
+            host: matched[:host].split('.'),
+            port: matched[:port],
+            path: matched[:path].split('/'),
+            extension: matched[:extension]
+          }
+
+          Proc.new do |request, context|
+            request.scheme = parts[:scheme]
+            request.host = fill(parts[:host], context).join '.'
+            request.path = fill(parts[:path], context).join('/') + (parts[:extension] || '')
+            request.port = matched[:port]
+          end
+        end
+
+        def fill parts, params
+          new_parts = []
+          parts.each do |part|
+            if part.start_with?('$')
+              param = params[part[1..-1].to_sym]
+              new_parts << param if param
+            else
+              new_parts << part
+            end
+          end
+          new_parts
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/basic_auth.rb

@@ -0,0 +1,20 @@
+require 'base64'
+
+module Commute
+  module Common
+
+    class BasicAuth
+      @id = :auth
+
+      def call commuter, options = {}
+        commuter.change do |request|
+          # Ruby's Base64 puts newlines at the end (and every 60 chars)...
+          # This breaks HTTP. So strip them!
+          authorization = Base64.encode64("#{options[:username]}:#{options[:password]}}").gsub "\n", ''
+          request.headers['Authorization'] = "Basic #{authorization}"
+          request
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/cache.rb

@@ -0,0 +1,43 @@
+module Commute
+  module Common
+
+    module Cache
+
+      class Success
+
+        def success?
+          true
+        end
+      end
+
+      SUCCESS = Success.new
+
+      class Fetch
+        @id = :cache
+
+        def call commuter, cache = nil
+          return unless cache
+          request = commuter.get
+          # Hit.
+          if request.method == :get && result = cache.get(request.url)
+            commuter.set [result, SUCCESS]
+            commuter.tag :hit
+            commuter.return
+          end
+        end
+      end
+
+      class Store
+        @id = :cache
+
+        def call commuter, cache = nil
+          return unless cache
+          response = commuter.get
+          if response.request.method == :get && response.body
+            cache.set response.request.url, response.body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/chemicals.rb

@@ -0,0 +1,39 @@
+require 'chemicals'
+
+module Commute
+  module Common
+    class Chemicals
+      @id = :chemicals
+
+      def initialize root = nil
+        @root = root
+        @cache = {}
+      end
+
+      def call commuter, path
+        # Build the path to the template.
+        path = if @root
+          "#{@root}/#{path}.xml"
+        else
+          "#{path}.xml"
+        end
+        # Create/Cache the Template.
+        template = if @cache[path]
+          @cache[path]
+        else
+          ::Chemicals::Template.new(IO.read(path)).tap do |t|
+            @cache[path] = t
+          end
+        end
+        # Use the template to parse/render.
+        if commuter.get.body
+          if commuter.get.body.kind_of?(String) && !commuter.get.body.strip.empty?
+            commuter.get.body = template.parse(commuter.get.body)
+          elsif !commuter.get.body.kind_of?(String)
+            commuter.get.body = template.render(commuter.get.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/conditional.rb

@@ -0,0 +1,27 @@
+require 'commute/core/commuter'
+
+module Commute
+  module Common
+    module Conditional
+
+      class Tagged
+
+        def initialize processor, *tags
+          @processor = processor
+          @tags = tags
+        end
+
+        def call commuter
+          @processor.call unless @tags.any? { |tag| commuter.tagged? tag }
+        end
+      end
+
+      class NotTagged < Tagged
+
+        def call commuter
+          @processor.call commuter if @tags.all? { |tag| !commuter.tagged? tag }
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/em-synchrony_adapter.rb

@@ -0,0 +1,29 @@
+require "em-synchrony"
+require "em-synchrony/em-http"
+
+require 'commute/common/em_http_request_adapter'
+
+module Commute
+  module Common
+
+    # Public: Adapter that uses em-synchrony (with em-http-request).
+    #
+    # Requires use of em-synchrony and thus Eventmachine.
+    #
+    class EmSynchronyAdapter < EmHttpRequestAdapter
+      @id = :adapter
+
+      # Internal: Make a request through em-synchrony.
+      def call commuter, options = {}
+        # Create a native em-http request.
+        em_request = to_request commuter.get
+
+        # Create a Commute response.
+        response = to_response em_request.response_header, em_request.response
+        response.request = commuter.get
+        # Set it on the commuter.
+        commuter.set response
+      end
+    end
+  end
+end

data/lib/commute/common/em_http_request_adapter.rb

@@ -0,0 +1,57 @@
+require 'em-http-request'
+
+require 'commute/core/response'
+
+module Commute
+  module Common
+
+    # Public: Adapter that uses em-http-request, an Eventmachine based
+    # HTTP client, as a underlaying commute engine.
+    #
+    # This requires all the commute requests to be made within the
+    # Eventmachine loop.
+    #
+    class EmHttpRequestAdapter
+      @id = :adapter
+
+      # Internal: Make a request through Eventmachine.
+      def call commuter, options = {}
+        # Commuter delay for async processing.
+        commuter.delay do |&done|
+          # Create a native em-http request.
+          em_request = to_request commuter.get
+
+          # Set the callback.
+          em_request.callback do
+            # Create a Commute response.
+            response = to_response em_request.response_header, em_request.response
+            response.request = request
+            # Set it on the commuter.
+            commuter.set response
+            # Async call finished.
+            done.call
+          end
+        end
+      end
+
+      protected
+
+      # Internal: Converts a Commute requests into an em-http request.
+      def to_request request
+        EventMachine::HttpRequest.new(request.url).send request.method, \
+          query: request.query,
+          head: request.headers,
+          body: request.body
+      end
+
+      # Internal: Converts an em-http response into a Commute response.
+      # Note: trims whitespace bodies.
+      def to_response em_response_header, em_response
+        Commute::Response.new.tap do |response|
+          response.code = em_response_header.status
+          response.body = em_response unless em_response.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/json.rb

@@ -0,0 +1,28 @@
+require 'multi_json'
+
+module Commute
+  module Common
+
+    module Json
+      class Parse
+
+        OPTIONS = {
+          symbolize_keys: true
+        }
+
+        def call c, options = {}
+          response = c.get
+          response.body =  MultiJson.load response.body, OPTIONS.merge(options)
+        end
+      end
+
+      class Render
+
+        def call c, options = {}
+          request = c.get
+          request.body =  MultiJson.dump request.body
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/typhoeus_adapter.rb

@@ -0,0 +1,40 @@
+require 'typhoeus'
+
+require 'commute/core/response'
+
+module Commute
+  module Common
+
+    # Internal: Adapter that uses Typhoeus to make requests.
+    #
+    # Compatibility:
+    #
+    #   TODO
+    #
+    class TyphoeusAdapter
+      @id = :adapter
+
+      def call commuter, options = {}
+        commuter.change do |request|
+          # puts request.inspect
+          # Build a Typhoeus request from this request.
+          typhoeus_request = Typhoeus::Request.new request.url, \
+            method: request.method,
+            body: request.body.to_s,
+            params: request.query || {},
+            headers: request.headers
+          # Run the request.
+          hydra = Typhoeus::Hydra.new
+          hydra.queue typhoeus_request
+          hydra.run
+          typhoeus_response = typhoeus_request.response
+          # Build a Commute response.
+          Response.new(request).tap do |response|
+            response.code = typhoeus_response.code
+            response.body = typhoeus_response.body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/commute/common/xml.rb

@@ -0,0 +1,7 @@
+module Commute
+  module Common
+
+    class Xml
+    end
+  end
+end

data/lib/commute/configuration.rb

@@ -0,0 +1,8 @@
+module Commute
+
+  class Configuration
+    class << self
+      attr_accessor :adapter
+    end
+  end
+end