scoped-concerns 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 244c3ca326094f41d147f31cfd45f6335fa601e7d99bd6fe477f8c429bbd0657
+  data.tar.gz: cc65ed38693ddfe83c6fffc4993f54836a55cb51521697cf7c3d69bbeb942100
+SHA512:
+  metadata.gz: 63a38e08a0bf82682854a5491319e55dac9185125663b47a379d9748fb71a60bd04767dc376f0d4e4a99cb394455f801bb4529869e7b056454fa48bbc880e467
+  data.tar.gz: 76ceec63edf7e391b8ea15aee64b35028e4b8e49a15e186e4944575a84e421a9c355037a88798f0b9cf46f629b3be2f889a8ff866f8ae8c945fde6b695a7b3c0

data/.gitignore

@@ -0,0 +1,4 @@
+tags
+.ruby-version
+.ruby-gemset
+.gemsetrc

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Three Funky Monkeys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# Scoped Concerns
+
+Scoped-Concerns is a tiny utility library to help you encapsulate responsibilities in your Ruby applications by providing a common interface and a common response object for the so called _service classes_ or how we like to call them: _concerns_.
+
+We've been playing around with this concept in a few applications and it was evolving until this point that we feel it reusable enough to become a separated library.
+
+## Install
+
+It's a Ruby gem in rubygems.org, so is as simple as:
+
+```
+gem install scoped-concerns
+```
+
+## Usage
+
+Include `Scoped::Concern` in your service (concern) class, and implement your constructor and the `run` methods with the logic for your domain. For example
+
+```Ruby
+module MyApp
+  module Concerns
+    class ActivateUser
+      include Scoped::Concern
+
+      def initialize(params = {})
+        @user_id = params[:user_id]
+      end
+
+      def run
+        user = User.find(@user_id)
+        return error(user: [:not_valid]) unless user
+
+        begin
+          user.activate!
+          success(user: "Activated")
+        rescue => e
+          logger.log(e.message)
+          error(update: [:not_valid])
+        end
+      end
+    end
+  end
+end
+```
+
+Then you can use this concern in your endpoints logic, like:
+
+```Ruby
+on "activate/:id" do |id|
+  response = MyApp::Concerns::ActivateUser.run(user_id: id)
+
+  if response.success?
+    json(message: "User has been activated")
+  else
+    json_error(message: [response.errors[:update], response.errors[:user]].join("\n"))
+  end
+end
+```
+
+`Scoped-Concerns` provides the `run`, `error` and `success` helper methods through `Concern` module and the `Scoped::Response` class as a standard response format.
+
+`Scoped-Concerns` proposes the following conventions:
+
+* Parameters to a concern should always be a `Hash`, even if you need only one parameter (see example above)
+* A `Concern` should always return a `Scoped::Response` object. (`success` and `error` helper methods return this)
+
+### Response
+
+The `Scoped::Response` class has the `result` and `errors` attributes, both of them must be hashes. The keys of these `Hash`es will depend on your application domain, but, at least, you know that you'll deal with `Hash`es.
+
+The `Scoped::Response` class also has a `success?` instance utility method that is a wrapper to `@errors.empty?` for readability's sake.

data/Rakefile

@@ -0,0 +1,6 @@
+desc "Run tests"
+task "test" do
+  Dir["./test/**/**_test.rb"].each do |f|
+    load f
+  end
+end

data/lib/scoped-concerns.rb

@@ -0,0 +1,2 @@
+require_relative 'scoped-concerns/response'
+require_relative 'scoped-concerns/concern'

data/lib/scoped-concerns/concern.rb

@@ -0,0 +1,25 @@
+module Scoped
+  module Concern
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def run(params = {})
+        instance = new(params)
+        instance.run
+      end
+    end
+
+    module InstanceMethods
+      def success(results = {})
+        Response.new(result: results)
+      end
+
+      def error(errors = {})
+        Response.new(errors: errors)
+      end
+    end
+  end
+end

data/lib/scoped-concerns/response.rb

@@ -0,0 +1,19 @@
+module Scoped
+  class InvalidType < RuntimeError;end
+
+  class Response
+    attr_accessor :result, :errors
+
+    def initialize(result: {}, errors: {})
+      raise InvalidType, "result must be a hash" unless result.is_a?(Hash)
+      raise InvalidType, "errors must be a hash" unless errors.is_a?(Hash)
+
+      @result = result
+      @errors = errors
+    end
+
+    def success?
+      @errors.empty?
+    end
+  end
+end

data/ruby-version.sample

@@ -0,0 +1 @@
+2.4.1

data/scoped-concerns.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "scoped-concerns"
+  s.version = "0.1.0"
+  s.summary = "Gem for Pure Ruby Objects to encapsulate specific behavior"
+  s.license = "MIT"
+  s.description = "Gem for Pure Ruby Objects to encapsulate specific behavior"
+  s.authors = ["Leonardo Mateo", "Lautaro Orazi"]
+  s.email = ["kandalf@threefunkymonkeys.com", "taro@threefunkymonkeys.com"]
+  s.homepage = "https://github.com/threefunkymonkeys/scoped-concerns"
+  s.require_paths = ["lib"]
+
+  s.files = `git ls-files`.split("\n")
+end

data/test/concern/concern_test.rb

@@ -0,0 +1,30 @@
+require_relative '../test_helper'
+
+class MyConcern
+  include Scoped::Concern
+end
+
+describe Scoped::Concern do
+  it "should add class run method" do
+    assert MyConcern.respond_to?(:run)
+  end
+
+  it "should add instance success and error methods" do
+    concern = MyConcern.new
+
+    assert concern.respond_to?(:success)
+    assert concern.respond_to?(:error)
+  end
+
+  it "should return a Response instance with no errors" do
+    concern = MyConcern.new
+    result = { message: "Done" }
+
+    response = concern.success(result)
+
+    assert response.is_a?(Scoped::Response)
+    assert response.errors.empty?
+
+    assert_equal result, response.result
+  end
+end

data/test/concern/response_test.rb

@@ -0,0 +1,34 @@
+require_relative '../test_helper'
+
+describe Scoped::Response do
+  it "should expose result and errors" do
+    response = Scoped::Response.new
+
+    assert response.respond_to?(:result)
+    assert response.respond_to?(:errors)
+  end
+
+  it "should not accept other than a Hash for result" do
+    assert_raises(Scoped::InvalidType, "result must be a Hash") do
+      Scoped::Response.new(result: "Hallo")
+    end
+  end
+
+  it "should not accept other than a Hash for errors" do
+    assert_raises(Scoped::InvalidType, "result must be a Hash") do
+      Scoped::Response.new(errors: "Hallo")
+    end
+  end
+
+  it "should be successful if no errors" do
+    response = Scoped::Response.new(result: { message: "I'm successful" })
+    assert response.success?
+  end
+
+  it "should not be successful if errors" do
+    response = Scoped::Response.new(result: { message: "I'm successful" },
+                                       errors: { success: "No, you're not" })
+
+    assert !response.success?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'pp'
+require_relative '../lib/scoped-concerns'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: scoped-concerns
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leonardo Mateo
+- Lautaro Orazi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-19 00:00:00.000000000 Z
+dependencies: []
+description: Gem for Pure Ruby Objects to encapsulate specific behavior
+email:
+- kandalf@threefunkymonkeys.com
+- taro@threefunkymonkeys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/.gitkeep
+- lib/scoped-concerns.rb
+- lib/scoped-concerns/concern.rb
+- lib/scoped-concerns/response.rb
+- ruby-version.sample
+- scoped-concerns.gemspec
+- test/concern/concern_test.rb
+- test/concern/response_test.rb
+- test/test_helper.rb
+homepage: https://github.com/threefunkymonkeys/scoped-concerns
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Gem for Pure Ruby Objects to encapsulate specific behavior
+test_files: []