clientura 0.0.6

data/lib/clientura/client.rb

@@ -0,0 +1,143 @@
+require 'clientura/client/request'
+require 'clientura/client/endpoint'
+require 'clientura/client/middleware_function_context'
+
+module Clientura
+  module Client
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.include InstanceMethods
+    end
+
+    module ClassMethods
+      def registered_endpoints
+        @registered_endpoints ||= {}
+      end
+
+      def registered_pipes
+        @registered_pipes ||= {}
+      end
+
+      def registered_middleware
+        @registered_middleware ||= {}
+      end
+
+      [:get, :post, :put, :patch, :delete].each do |verb|
+        define_method verb do |name, path: nil|
+          register_endpoint(name, verb: verb, path: path || name.to_s)
+        end
+      end
+
+      def register_endpoint(name, verb:, path:)
+        registered_endpoints[name] = Endpoint.new verb,
+                                                  path,
+                                                  [*@middleware_context],
+                                                  [*@pipes_context]
+
+        define_method name do |args = {}|
+          call_endpoint name, args
+        end
+
+        define_method "#{name}_promise" do |args = {}|
+          Concurrent::Promise.execute { send(name, args) }
+        end
+      end
+
+      def pipe(name, callable)
+        registered_pipes[name] = callable
+      end
+
+      def middleware(name, callable)
+        registered_middleware[name] = callable
+      end
+
+      def pipe_through(*pipes)
+        pipes = pipes.map { |o| normalize_mapper o }
+
+        @pipes_context ||= []
+        @pipes_context.push(*pipes)
+        yield
+        @pipes_context.pop pipes.count
+      end
+
+      def use_middleware(*middleware)
+        middleware = middleware.map { |o| normalize_mapper o }
+
+        @middleware_context ||= []
+        @middleware_context.push(*middleware)
+        yield
+        @middleware_context.pop middleware.count
+      end
+
+      def normalize_mapper(mapper)
+        case mapper
+        when Array
+          name, *config = mapper
+          { name: name, config: config }
+        else
+          { name: mapper, config: [] }
+        end
+      end
+    end
+
+    module InstanceMethods
+      def self.included(klass)
+        define_method :registered_endpoints do
+          klass.registered_endpoints
+        end
+
+        define_method :registered_pipes do
+          klass.registered_pipes
+        end
+
+        define_method :registered_middleware do
+          klass.registered_middleware
+        end
+      end
+
+      attr_writer :config
+
+      def config
+        @config ||= {}
+      end
+
+      def save_config(args)
+        self.config = config.merge args
+      end
+
+      def call_endpoint(name_, args)
+        endpoint = registered_endpoints.fetch(name_)
+
+        path = if endpoint.path.respond_to?(:call)
+                 endpoint.path.call(args)
+               else
+                 endpoint.path
+               end
+
+        middlewares = endpoint.middleware.map do |name:, config:|
+          { callable: registered_middleware.fetch(name), config: config }
+        end
+
+        request = middlewares
+                  .reduce Request.new do |request_, callable:, config:|
+          middleware = MiddlewareFunctionContext.new(request: request_,
+                                                     client: self,
+                                                     args: args,
+                                                     callable: callable,
+                                                     config: config)
+          middleware.call
+        end
+
+        response = request.send(endpoint.verb, path)
+
+        endpoints = endpoint.pipes.map do |name:, config:|
+          -> (res) { registered_pipes.fetch(name).call(res, *config) }
+        end
+
+        endpoints.reduce response do |response_, pipe|
+          pipe.call response_
+        end
+      end
+    end
+  end
+end

data/lib/clientura/version.rb

@@ -0,0 +1,3 @@
+module Clientura
+  VERSION = File.read(File.expand_path('../../../VERSION/', __FILE__)).freeze
+end

data/lib/clientura.rb

@@ -0,0 +1,11 @@
+require 'http'
+require 'concurrent'
+require 'concurrent-edge'
+require 'active_support/core_ext/object'
+require 'active_support/json'
+
+require 'clientura/version'
+require 'clientura/client'
+
+module Clientura
+end

data/spec/clientura/adequate_spec.rb

@@ -0,0 +1,204 @@
+describe 'Ability to use this for solving real world problems' do
+  # Purpose of this spec is to define some real world use cases in a clean and
+  # readable manner to serve as an example of usage.
+
+  subject { instance }
+
+  let(:instance) { client_class.new(client_config) }
+  let(:client_config) { { uri: 'http://localhost:3001/real_world/' } }
+  let(:client_class) do
+    Class.new do
+      include Clientura::Client
+
+      middleware :configurable_uri, -> { update(:uri) { client.config[:uri] } }
+      middleware :header_with_token, -> { headers AuthToken: client.config[:token] }
+      middleware :pass_all_as_query_string, -> { update(:params) { args } }
+      middleware :namespace, -> (namespace) { update(:uri) { |uri| URI.join uri, namespace } }
+      middleware :bad_middleware, -> { raise 'Some Exception' }
+      middleware :slow_middleware, -> { sleep 0.1; self }
+
+      pipe :body_retriever, -> (res) { res.body.to_s }
+      pipe :parser, -> (res, parser) { parser.parse res }
+      pipe :answer_header, -> (res) { res.headers['Answer'] }
+      pipe :data_retriever, -> (res) { res['data'] }
+
+      use_middleware :configurable_uri do
+        get :root, path: '/'
+
+        use_middleware :header_with_token do
+          get :pass_token
+        end
+
+        pipe_through :body_retriever do
+          get :get_some, path: 'some'
+          put :put_some, path: 'some'
+          patch :patch_some, path: 'some'
+          post :post_some, path: 'some'
+          delete :delete_some, path: 'some'
+
+          pipe_through [:parser, JSON] do
+            get :parse_response
+
+            pipe_through :data_retriever do
+              get :comments, path: -> (params) { "comments/#{params[:id]}" }
+              get :users, path: -> (params) { "users/#{params[:id]}" }
+              get :attachments, path: -> (params) { "attachments/#{params[:id]}" }
+            end
+          end
+
+          use_middleware :pass_all_as_query_string do
+            get :pass_query_string
+          end
+        end
+
+        use_middleware [:namespace, 'namespace/'] do
+          get :namespaced
+        end
+
+        pipe_through :answer_header do
+          get :get_answer_header
+        end
+      end
+
+      use_middleware :bad_middleware do
+        get :raise_some_exception
+      end
+
+      use_middleware :slow_middleware, :bad_middleware do
+        get :slowly_raise_some_exception
+      end
+
+      def initialize(uri:, token: nil)
+        save_config uri: uri, token: token
+      end
+    end
+  end
+
+  describe 'My wish to see this at least working' do
+    subject { super().root.status }
+
+    it { should eq 200 }
+  end
+
+  describe 'My desire to use different verbs' do
+    describe 'GET' do
+      subject { super().get_some }
+
+      it { should eq 'get' }
+    end
+
+    describe 'POST' do
+      subject { super().post_some }
+
+      it { should eq 'post' }
+    end
+
+    describe 'PUT' do
+      subject { super().put_some }
+
+      it { should eq 'put' }
+    end
+
+    describe 'PATCH' do
+      subject { super().patch_some }
+
+      it { should eq 'patch' }
+    end
+
+    describe 'DELETE' do
+      subject { super().delete_some }
+
+      it { should eq 'delete' }
+    end
+  end
+
+  describe 'My desire to see some exceptions' do
+    subject { -> { instance.raise_some_exception } }
+
+    it { should raise_error 'Some Exception' }
+  end
+
+  describe 'My desire to work with promise' do
+    context 'when no errors raised' do
+      subject { super().root_promise }
+
+      it { should be_pending }
+
+      it 'has correct value' do
+        expect(subject.value.status).to eq 200
+      end
+
+      context 'when awaited' do
+        before { subject.value }
+
+        it 'fulfills' do
+          expect(subject).to be_fulfilled
+        end
+      end
+    end
+
+    context 'when error raised' do
+      subject { super().slowly_raise_some_exception_promise }
+
+      it { should be_pending }
+
+      it 'has nil value' do
+        expect(subject.value).to be nil
+      end
+
+      context 'when awaited' do
+        before { subject.value }
+
+        it 'rejects' do
+          expect(subject).to be_rejected
+        end
+
+        it 'has correct message' do
+          expect(subject.reason.message).to eq 'Some Exception'
+        end
+      end
+    end
+  end
+
+  describe 'My desire to pass some token in header' do
+    subject { super().pass_token.status }
+
+    let(:client_config) { super().merge token: token }
+
+    context 'when token is bad' do
+      let(:token) { 'Bad token!' }
+
+      it { should eq 403 }
+    end
+
+    context 'when token is good' do
+      let(:token) { 'Secret' }
+
+      it { should eq 200 }
+    end
+  end
+
+  describe 'My desire to parse response' do
+    subject { super().parse_response }
+
+    it { should eq 'data' => 'Awesome!' }
+  end
+
+  describe 'My desire to pass query string' do
+    subject { super().pass_query_string echo: 'Awesome!' }
+
+    it { should eq 'Awesome!' }
+  end
+
+  describe 'My desire to get response header' do
+    subject { super().get_answer_header }
+
+    it { should eq 'Awesome!' }
+  end
+
+  describe 'My desire to namespace routes' do
+    subject { super().namespaced.status }
+
+    it { should eq 200 }
+  end
+end

data/spec/clientura/client_spec.rb

@@ -0,0 +1,175 @@
+describe Clientura::Client do
+  subject { client }
+
+  let(:uri) { 'http://localhost:3001' }
+  let(:client) { klass.new(uri: uri, token: 'InitializationToken') }
+  let(:klass) do
+    Class.new do
+      include Clientura::Client
+
+      middleware :static_token, -> (token) { headers(Token: token) }
+      middleware :init_token, -> { headers(token: client.config[:token]) }
+      middleware :token_passer, -> { headers(token: args[:token]) }
+      middleware :send_as_json, -> { update(:json) { args } }
+      middleware :pass_as_query, -> { update(:params) { |p| p.merge args } }
+      middleware :configurable_uri, lambda {
+        update(:uri) { |uri| URI.join client.config[:uri], uri }
+      }
+
+      pipe :body_retriever, -> (res) { res.body.to_s }
+      pipe :parser, -> (res, parser) { parser.parse res }
+      pipe :data_retriever, -> (res) { res['data'] }
+
+      use_middleware :configurable_uri do
+        pipe_through :body_retriever do
+          get :resource_raw, path: 'res'
+
+          pipe_through [:parser, JSON] do
+            get :root, path: '/'
+            get :resource, path: 'res'
+            get :name
+            get :echo_argument, path: -> (params) { "echo_argument/#{params[:argument]}" }
+
+            use_middleware :pass_as_query do
+              get :echo_param
+            end
+          end
+        end
+
+        pipe_through :body_retriever, [:parser, JSON] do
+          use_middleware [:static_token, 'StaticToken'] do
+            get :try_static_token, path: 'echo_header'
+          end
+
+          use_middleware [:static_token, 'Token'] do
+            get :echo_header_const, path: 'echo_header'
+          end
+
+          use_middleware :token_passer do
+            get :try_token_passer, path: 'echo_header'
+            get :echo_header
+          end
+
+          use_middleware :init_token do
+            get :try_init_token, path: 'echo_header'
+          end
+
+          get :configurable_uri_resource, path: 'res'
+
+          use_middleware :send_as_json do
+            post :send_json, path: 'data'
+          end
+        end
+      end
+
+      use_middleware :configurable_uri do
+        pipe_through :body_retriever, [:parser, JSON], :data_retriever do
+          use_middleware :send_as_json do
+            post :sum
+          end
+
+          get :comments, path: -> (params) { "comments/#{params[:id]}" }
+          get :users, path: -> (params) { "users/#{params[:id]}" }
+          get :tags, path: -> (params) { "tags/#{params[:id]}" }
+
+          use_middleware :pass_as_query do
+            get :left_operand
+            get :right_operand
+          end
+        end
+      end
+
+      def initialize(uri:, token:)
+        save_config uri: URI.parse(uri), token: token
+      end
+    end
+  end
+
+  describe '#root' do
+    subject { client.root }
+
+    it { should eq 'data' => 'root' }
+  end
+
+  describe '#resource' do
+    subject { client.resource }
+
+    it { should eq 'data' => 'resource' }
+  end
+
+  describe '#name' do
+    subject { client.name }
+
+    it { should eq 'data' => 'name' }
+  end
+
+  describe '#echo_argument' do
+    subject { client.echo_argument argument: 'Argument' }
+
+    it { should eq 'data' => 'Argument' }
+  end
+
+  describe '#echo_param' do
+    subject { client.echo_param param: 'Param' }
+
+    it { should eq 'data' => 'Param' }
+  end
+
+  describe '#echo_header' do
+    subject { client.echo_header token: 'Token' }
+
+    it { should eq 'data' => 'Token' }
+  end
+
+  describe '#echo_header_const' do
+    subject { client.echo_header_const }
+
+    it { should eq 'data' => 'Token' }
+  end
+
+  describe '#resource_raw' do
+    subject { client.resource_raw }
+
+    it { should eq JSON.dump data: 'resource' }
+  end
+
+  describe 'try_static_token' do
+    subject { client.try_static_token }
+
+    it { should eq 'data' => 'StaticToken' }
+  end
+
+  describe 'try_token_passer' do
+    subject { client.try_token_passer token: 'PassedToken' }
+
+    it { should eq 'data' => 'PassedToken' }
+  end
+
+  describe 'try_init_token' do
+    subject { client.try_init_token }
+
+    it { should eq 'data' => 'InitializationToken' }
+  end
+
+  describe 'configurable_uri_resource' do
+    subject { client.configurable_uri_resource }
+
+    it { should eq 'data' => 'resource' }
+  end
+
+  describe '#send_json' do
+    subject { client.send_json json_data: { foo: :bar } }
+
+    it { should eq 'data' => { 'foo' => 'bar' } }
+  end
+
+  describe '#sum' do
+    subject { client.sum sum: sum }
+
+    let(:sum) { client.left_operand(key: 'Secret') + client.right_operand(key: 'Secret') }
+
+    it { should eq true }
+  end
+
+  # it('__run_server__', :focus) { binding.pry }
+end

data/spec/clientura_spec.rb

@@ -0,0 +1,9 @@
+# require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Clientura do
+  describe Clientura::VERSION do
+    subject { described_class }
+
+    it { should_not be_blank }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+require 'simplecov'
+require 'codeclimate-test-reporter'
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_profile 'test_frameworks'
+end
+
+ENV['COVERAGE'] && SimpleCov.start do
+  add_filter '/.rvm/'
+end
+
+CodeClimate::TestReporter.start
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'bundler'
+Bundler.require(:test)
+require 'clientura'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  # config.expose_current_running_example_as :example
+  config.raise_errors_for_deprecations!
+  config.run_all_when_everything_filtered = true
+  config.filter_run focus: true
+  # config.mock_with :rspec
+  # config.use_transactional_fixtures = false
+
+  config.order = :rand
+
+  config.before(:suite) do |_example|
+    pid = Process.fork do
+      Rack::Handler::Thin.run TestServer, Port: 3001
+      # trap(:INT) { Rack::Handler::WEBrick.shutdown }
+      # Rack::Handler::WEBrick.run TestServer.new,
+      #                            Port: 3001,
+      #                            Logger: WEBrick::Log.new('/dev/null'),
+      #                            AccessLog: []
+      exit
+    end
+
+    at_exit do
+      Process.kill('INT', pid)
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+        # ignore this error...I think it means the child process has already exited.
+      end
+    end
+
+    sleep 1
+  end
+end