jsender 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e4c38c81ff6bb317e2715c8df12d0c983c83a96
-  data.tar.gz: e6df08c2c1f7fefb0b45cb5e6f7b51f36157638c
+  metadata.gz: d54b8d2efe09a714ff7297af5afe424b569460ba
+  data.tar.gz: 2200fa05c6037642b3230290968326d35ea34ae7
 SHA512:
-  metadata.gz: 8c72f304dd65b6eddd5fe69c4aa0649b972d6be0bb4f10def994f78e86054aca0125fdb8c6d33be030a5ecf998523efcc2d45b2bdce3f21ae7e4188a9b99ea34
-  data.tar.gz: bc9f62329360394a99a6a5c71fc5119d6c7715d4f88e3cb3e554100c1b95588dee4e0fd01c1f5d3857c2bda5ac9330f49dd3247435952929c25fc493e142218f
+  metadata.gz: a12515fd684d1502c917f289a55d65e9fc0dc87f11f13127711fea0f099385059bfc4d5f3f253d166a559086c7c814c125d279fc4f56c2eee8cd792cd6aedd65
+  data.tar.gz: 4e47367fdc446fc5f3da1063580942b4fe82775e1ba3c32e8f127bc122c5654ddabe66014fa3ab77e4c3c30c6d0014a81ed0f14407dc25ba07a3eda46b0dafe5

data/README.md

@@ -19,81 +19,81 @@ gem 'jsender'
 
 And then execute:
 
-    $ bundle
+```bash
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install jsender
+```bash
+gem install jsender
+```
 
 ## Usage
-### Returns Ruby Hash
-
-```
-  Jsender.success
-  => {"status"=>"success", "data"=>{"result"=>nil, "notifications"=>["success"]}}
+### Returns JSON
 
-  Jsender.success('happy day')
-  => {"status"=>"success", "data"=>{"result"=>nil, "notifications"=>["happy day"]}}
+Basic usage without any parameters yielding default json encoded jsend format:
 
-  result = Jsender.success_data({ 'a' => 'A', 'b' => 'B' })
-  => {"status"=>"success", "data"=>{"a"=>"A", "b"=>"B", "notifications"=>["success"]}}
-  Jsender.has_data?(result, 'b')
-  => true
+```ruby
+Jsender::Json.success
+ => "{\"status\":\"success\",\"data\":null}"
 
-  result = Jsender.success('some data for you', ['d', 'a', 't', 'a'])
-  => {"status"=>"success", "data"=>{"result"=>["d", "a", "t", "a"], "notifications"=>["some data for you"]}}
-  Jsender.has_data?(result, 'result')
-  => true
-  Jsender.notifications_include?(result, 'ata fo')
-  => true
+Jsender::Json.failure
+ => "{\"status\":\"fail\",\"data\":{\"message\":\"A failure has occurred\"}}"
 
-  Jsender.error
-  => {"status"=>"error", "message"=>nil}
+Jsender::Json.error
+ => "{\"status\":\"error\",\"message\":\"An error has occurred\"}"
+```
 
-  Jsender.error('something went wrong')
-  => {"status"=>"error", "message"=>"something went wrong"}
+Or with parameters yielding the correct json encoded jsend format:
 
-  Jsender.failure
-  => {"status"=>"fail", "data"=>{"result"=>nil, "notifications"=>["fail"]}}
+```ruby
+Jsender::Json.success(data: {'key' => 'value'})
+ => "{\"status\":\"success\",\"data\":{\"key\":\"value\"}}"
 
-  Jsender.failure('a failure occurred')
-  => {"status"=>"fail", "data"=>{"result"=>nil, "notifications"=>["a failure occurred"]}}
+Jsender::Json.failure(message: 'custom message')
+ => "{\"status\":\"fail\",\"data\":{\"message\":\"custom message\"}}"
 
-  Jsender.failure('a failure occurred', ['d', 'a', 't', 'a'])
-  => {"status"=>"fail", "data"=>{"result"=>["d", "a", "t", "a"], "notifications"=>["a failure occurred"]}}
+Jsender::Json.error(message: 'custom message')
+ => "{\"status\":\"error\",\"message\":\"custom message\"}"
 ```
 
-### Returns JSON
-
-```
-  Jsender.success_json
-  => "{\"status\":\"success\", \"data\": null}"
+### Returns Rack Response Tuple
 
-  Jsender.success_json({:key1 => 'value1'})
-  => "{\"status\":\"success\",\"data\":{\"key1\":\"value1\"}}"
+Basic usage without any parameters yielding default json encoded jsend format in a Rack tuple:
 
-  Jsender.fail_json
-  => "{\"status\": \"fail\", \"data\": null}"
+```ruby
+Jsender::Rack.success
+ => [200, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>nil}, "{\"status\":\"success\",\"data\":null}"]
 
-  Jsender.fail_json({:key1 => "value1"})
-  => "{\"status\":\"fail\",\"data\":{\"key1\":\"value1\"}}"
+Jsender::Rack.failure
+ => [400, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>nil}, "{\"status\":\"fail\",\"data\":{\"message\":\"A failure has occurred\"}}"]
 
-  Jsender.error_json
-  => ArgumentError, 'Missing required argument message'
+Jsender::Rack.error
+=> [500, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>nil}, "{\"status\":\"error\",\"message\":\"An error has occurred\"}"]
+```
 
-  Jsender.error_json('My little error')
-  => "{\"status\":\"error\", \"message\":\"My little error\"}"
+Or with parameters yielding the correct json encoded jsend format in a Rack tuple for use in controllers (including Sinatra):
 
-  Jsender.error_json('Another little error', 401)
-  => "{\"status\":\"error\",\"message\":\"Another little error\",\"code\":401}"
+```ruby
+Jsender::Rack.success(data: {'key' => 'value'}, code: 201, flow_id: '123')
+ => [201, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>"123"}, "{\"status\":\"success\",\"data\":{\"key\":\"value\"}}"]
 
-  Jsender.error_json('Another little error', 401, {:key1 => 'cause of another little error'})
-  => "{\"status\":\"error\",\"message\":\"Another little error\",\"code\":401,\"data\":{\"key1\":\"cause of another little error\"}}"
+ Jsender::Rack.failure(message: 'some custom failure message', code: 201, flow_id: '123')
+ => [201, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>"123"}, "{\"status\":\"fail\",\"data\":{\"message\":\"some custom failure message\"}}"]
 
-  Jsender.error_json('Another little error', {:key1 => 'cause of another little error'})
-  => "{\"status\":\"error\",\"message\":\"Another little error\",\"data\":{\"key1\":\"cause of another little error\"}}"
+ Jsender::Rack.error(message: 'some custom failure message', code: 201, flow_id: '123')
+ => [201, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>"123"}, "{\"status\":\"error\",\"message\":\"some custom failure message\"}"]
 ```
 
+### Returns Rack Response Tuple for Middlewares
+
+Rack middlware responses require that the body of the response tuple is in an array. Enable this using the body_as_array parameter (false by default):
+
+```ruby
+Jsender::Rack.error(body_as_array: true)
+ => [500, {"Content-Type"=>"application/json", "X-Flow-Identifier"=>nil}, ["{\"status\":\"error\",\"message\":\"An error has occurred\"}"]]
+```
 
 ## Development
 

data/jsender.gemspec

@@ -6,11 +6,11 @@ require 'jsender/version'
 Gem::Specification.new do |spec|
   spec.name          = "jsender"
   spec.version       = Jsender::VERSION
-  spec.authors       = ["Ernst van Graan", "Charles Mulder"]
-  spec.email         = ["ernst.van.graan@hetzner.co.za", "charles.mulder@hetzner.co.za"]
+  spec.authors       = ["Hetzner Seals Team"]
+  spec.email         = ["seals@hetzner.co.za"]
 
   spec.summary       = %q{JSender facilitates a simple jsend implementation for ruby}
-  spec.description   = %q{JSender facilitates a simple jsend implementation for ruby}
+  spec.description   = %q{JSender facilitates a simple jsend implementation for ruby with json and rack helpers}
   spec.homepage      = "https://github.com/hetznerZA/jsender"
   spec.license       = "MIT"
 

data/lib/jsender.rb

@@ -1,136 +1,6 @@
 require 'jsender/version'
+require 'jsender/json'
+require 'jsender/rack'
 
 module Jsender
-  extend self
-
-  def report(status, message, result = nil)
-    return {'status' => 'error', 'message' => message} if status == 'error'
-    data = compile_data(result)
-    data['notifications'] = message.is_a?(Array) ? message : [message]
-    {'status' => status, 'data' => data}
-  end
-
-  def error(message = nil)
-    report('error', message)
-  end
-
-  def failure(message = nil, data = nil)
-    message ||= 'fail'
-    report('fail', message, data)
-  end
-
-  def fail_data(data = nil)
-    failure(nil, data)
-  end
-
-  def success_data(data = nil)
-    success(nil, data)
-  end
-
-  def success(message = nil, data = nil)
-    message ||= 'success'
-    report('success', message, data)
-  end
-
-  def has_data?(result, key = nil)
-    return false if key.nil?
-    return false if (result.nil?) or (result['data'].nil?)
-    return false if (not key.nil?) and (result['data'][key].nil?)
-    true
-  end
-
-  def notifications_include?(result, pattern)
-    return false unless has_data?(result, 'notifications')
-    result['data']['notifications'].to_s.include?(pattern)
-  end
-
-  ##
-  # @param data optional [Hash]
-  # @return [String] jsend json
-  def success_json(data = nil)
-    raise ArgumentError, 'Optional data argument should be of type Hash' if invalid_hash?(data)
-    return JSON.generate({
-                             :status => 'success',
-                             :data => data
-                         })
-  end
-
-  ##
-  # @param data optional [Hash]
-  # @return [String] jsend json
-  def fail_json(data = nil)
-    raise ArgumentError, 'Optional data argument should be of type Hash' if invalid_hash?(data)
-    return JSON.generate({
-                             :status => 'fail',
-                             :data => data
-                         })
-  end
-
-  ##
-  # @param msg [String]
-  # @param code optional [Integer]
-  # @param data optional [Hash]
-  # @return [String] jsend json
-  def error_json(msg, code = nil, data = nil)
-    code, data = validate_and_sanitize(msg, code, data)
-    jsend = {
-        :status => 'error',
-        :message => msg
-    }
-    generate_error_json(jsend, code, data)
-  end
-
-  private
-
-  def invalid_integer?(value)
-    (not value.nil?) and (not value.is_a? Integer)
-  end
-
-  def invalid_hash?(data)
-    if not data.nil?
-      return true if not data.is_a? Hash
-    end
-    false
-  end
-
-  def generate_error_json(jsend, code, data)
-    jsend['code'] = code unless code.nil?
-    jsend['data'] = data unless data.nil?
-    return JSON.generate(jsend)
-  end
-
-  def validate_and_sanitize(msg, code, data)
-    validate_message(msg)
-    code, data = set_code_and_data(code, data)
-    validate_data(data)
-    validate_code(code)
-    return code, data
-  end
-
-  def set_code_and_data(code, data)
-    code, data = nil, code if not code.is_a? Integer and code.is_a? Hash and data.nil?
-    return code, data
-  end
-
-  def validate_message(msg)
-    raise ArgumentError, 'Missing required message of type String' if msg.empty? or not msg.is_a? String
-  end
-
-  def validate_data(data)
-    raise ArgumentError, 'Optional data argument should be of type Hash' if invalid_hash?(data)
-  end
-
-  def validate_code(code)
-    raise ArgumentError, 'Optional code argument should be of type Integer' if invalid_integer?(code)
-  end
-
-  def compile_data(result)
-    data ||= {}
-    result = {'result' => result} unless result.is_a? Hash
-    result.each do |key, value|
-      data[key] = value
-    end
-    data
-  end
-
 end

data/lib/jsender/json.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module Jsender
+  module Json
+    extend self
+
+    def error(message: "An error has occurred")
+      {
+        'status' => 'error',
+        'message' => message
+      }.to_json
+    end
+
+    def failure(message: "A failure has occurred")
+      {
+        'status' => 'fail',
+        'data' => {
+         'message' => message
+        }
+      }.to_json
+    end
+
+    def success(data: nil)
+      {
+        'status' => 'success',
+        'data' => data
+      }.to_json
+    end
+  end
+end

data/lib/jsender/rack.rb

@@ -0,0 +1,44 @@
+module Jsender
+  module Rack
+    extend self
+
+    def error(code: 500, flow_id: nil, message: "An error has occurred", body_as_array: false)
+      [
+        code,
+        headers(flow_id: flow_id),
+        body(data: Jsender::Json.error(message: message), body_as_array: body_as_array)
+      ]
+    end
+
+    def failure(code: 400, flow_id: nil, message: "A failure has occurred", body_as_array: false)
+      [
+        code,
+        headers(flow_id: flow_id),
+        body(data: Jsender::Json.failure(message: message), body_as_array: body_as_array)
+      ]
+    end
+
+    def success(code: 200, flow_id: nil, data: nil, body_as_array: false)
+      [
+        code,
+        headers(flow_id: flow_id),
+        body(data: Jsender::Json.success(data: data), body_as_array: body_as_array)
+      ]
+    end
+
+    private
+
+    def body(data:, body_as_array: false)
+      return [data] if body_as_array
+      data
+    end
+
+    def headers(flow_id:)
+      {
+        'Content-Type' => 'application/json',
+        'X-Flow-Identifier' => flow_id
+      }
+    end
+  end
+
+end

data/lib/jsender/version.rb

@@ -1,3 +1,3 @@
 module Jsender
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsender
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
-- Ernst van Graan
-- Charles Mulder
+- Hetzner Seals Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-11 00:00:00.000000000 Z
+date: 2018-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,10 +80,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: JSender facilitates a simple jsend implementation for ruby
+description: JSender facilitates a simple jsend implementation for ruby with json
+  and rack helpers
 email:
-- ernst.van.graan@hetzner.co.za
-- charles.mulder@hetzner.co.za
+- seals@hetzner.co.za
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -92,7 +91,6 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
-- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -101,6 +99,8 @@ files:
 - bin/setup
 - jsender.gemspec
 - lib/jsender.rb
+- lib/jsender/json.rb
+- lib/jsender/rack.rb
 - lib/jsender/version.rb
 homepage: https://github.com/hetznerZA/jsender
 licenses:
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: JSender facilitates a simple jsend implementation for ruby