hexx 1.1.1 → 2.0.0

data/lib/hexx/service/parameters.rb

@@ -0,0 +1,45 @@
+module Hexx
+  class Service
+
+    # Contains methods to declare parameters and set their values.
+    module Parameters
+      extend ActiveSupport::Concern
+
+      # Methods to declare and allow services params.
+      module ClassMethods
+
+        private
+
+        def params
+          @params ||= []
+        end
+
+        def allow_params(*keys)
+          @params = keys.map(&:to_s)
+          attr_accessor(*params)
+        end
+      end
+
+      # Initializes a service object with a hash of parameters.
+      #
+      # @example
+      #   Service.new(hash = {})
+      #
+      # Params:
+      # +hash+:: a hash of parameters for the service.
+      #
+      def initialize(hash = {})
+        extract_params_from hash
+        params.each { |key, value| send "#{ key }=", value }
+      end
+
+      private
+
+      attr_reader :params
+
+      def extract_params_from(hash)
+        @params = hash.stringify_keys.slice(*(self.class.send :params))
+      end
+    end
+  end
+end

data/lib/hexx/service/transactions.rb

@@ -0,0 +1,30 @@
+require "hexx/service/invalid"
+
+module Hexx
+  class Service
+
+    # Declares the <tt>##transaction</tt> private instance method.
+    module Transactions
+      include Wisper::Publisher
+
+      private
+
+      # Yields the block and publishes :error notification with
+      # error messages in case of any standard exception being raised.
+      def transaction
+        run_and_rescue do
+          validate!
+          yield
+        end
+      end
+
+      def run_and_rescue
+        yield
+      rescue Service::Invalid => err
+        publish :error, Message.from(err.service)
+      rescue => err
+        publish :error, [Message.new(type: "error", text: err.message)]
+      end
+    end
+  end
+end

data/lib/hexx/service/validations.rb

@@ -0,0 +1,18 @@
+module Hexx
+  class Service
+
+    # Defines methods for active record validation.
+    module Validations
+
+      # Includes the <tt>ActiveModel::Validations</tt> module to the service.
+      def self.included(klass)
+        klass.include ActiveModel::Validations
+      end
+
+      # Runs validations and raises <tt>Service::Error</tt> if validations fail.
+      def validate!
+        fail Invalid.new(self) unless valid?
+      end
+    end
+  end
+end

data/lib/hexx/service.rb

@@ -0,0 +1,21 @@
+require "hexx/service/messages"
+require "hexx/service/parameters"
+require "hexx/service/validations"
+require "hexx/service/transactions"
+
+module Hexx
+
+  # Base class for service objects.
+  class Service
+    include Messages, Parameters, Transactions, Validations
+
+    # Runs the service object.
+    #
+    # The method must be defined in a specific service class,
+    # inherited from <tt>Hexx::Service</tt>.
+    #
+    def run
+      fail NotImplementedError.new "#{ self.class.name }#run not implemented."
+    end
+  end
+end

data/lib/hexx/version.rb

@@ -1,6 +1,6 @@
-# Core classes to follow hexagonal domain architecture.
+# Namespace for the gem.
 module Hexx
 
   # Current release.
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

data/lib/hexx.rb

@@ -1,2 +1,8 @@
-lib = File.dirname(__FILE__)
-Dir[File.join(lib, "hexx/**/*.rb")].each { |file| require file }
+require "active_model"
+require "wisper"
+require "hexx/models"
+require "hexx/service"
+
+# Namespace for the gem.
+module Hexx
+end

data/spec/hexx/models_spec.rb

@@ -1,3 +1,5 @@
+require "spec_helper"
+
 module Hexx
   describe Models do
 
@@ -6,7 +8,7 @@ module Hexx
     # ==========================================================================
 
     around do |example|
-      class TestModel; include Models; end
+      class TestModel; extend Models; end
       class TestAttribute; end
       example.run
       Hexx.send :remove_const, :TestAttribute
@@ -18,20 +20,15 @@ module Hexx
       allow(TestAttribute).to receive(:new) { |val| coerced_attribute if val }
     end
 
-    # ==========================================================================
-    # Prepare variables
-    # ==========================================================================
-
-    subject      { TestModel }
-    let(:object) { subject.new }
-
     # ==========================================================================
     # Run tests
     # ==========================================================================
 
     describe ".attr_coerced" do
 
-      before { subject.send :attr_coerced, :name, type: TestAttribute }
+      subject      { TestModel }
+      before       { subject.send :attr_coerced, :name, type: TestAttribute }
+      let(:object) { TestModel.new }
 
       it "coerces an attribute with given type" do
         expect { object.name = "some name" }

data/spec/hexx/service/invalid_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module Hexx
+  class Service
+    describe Invalid do
+
+      describe ".new" do
+
+        subject { Invalid }
+
+        it "fails if no arguments given" do
+          expect { subject.new }.to raise_error { ArgumentError }
+        end
+
+        it "fails unless given argument is a service" do
+          expect { subject.new "wrong" }.to raise_error { ArgumentError }
+        end
+
+        it "initializes the #service" do
+          expect { subject.new Service.new }.not_to raise_error
+        end
+      end
+
+      describe "#messages" do
+
+        let(:service) { Service.new }
+        before do
+          allow(service).to receive_message_chain(:errors, :values)
+            .and_return [%w(1 2)]
+        end
+        subject { Invalid.new(service).messages }
+
+        it "returns a list of messages" do
+          expect(subject.map(&:class).uniq).to eq [Service::Message]
+          expect(subject.map(&:type).uniq).to eq ["error"]
+          expect(subject.map(&:text).uniq).to eq %w(1 2)
+        end
+      end
+
+      describe "#message" do
+
+        let(:service) { Service.new }
+        subject       { Invalid.new(service).message }
+
+        it "returns a proper message" do
+          expect(subject).to eq "Service invalid: #{ service.inspect }"
+        end
+      end
+    end
+  end
+end

data/spec/hexx/service/message_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+module Hexx
+  class Service
+    describe Message do
+
+      describe ".new" do
+
+        subject { Message }
+
+        it "requires type" do
+          expect { subject.new text: "" }.to raise_error
+        end
+
+        it "requires text" do
+          expect { subject.new type: "" }.to raise_error
+        end
+      end
+
+      describe ".from" do
+
+        subject       { Message }
+        let(:service) { Service.new }
+        before        { service.send(:errors).add :base, :text }
+
+        it "extracts error messages from a record" do
+          message = subject.from(service).first
+          expect(message).to be_kind_of Message
+          expect(message.type).to eq "error"
+          expect(message.text).to eq service.errors.values.flatten.first
+        end
+      end
+
+      describe "#type" do
+
+        subject { Message.new type: "info", text: "text" }
+
+        it "returns message type" do
+          expect(subject.type).to eq "info"
+        end
+      end
+
+      describe "#text" do
+
+        subject { Message.new type: "info", text: "text" }
+
+        it "returns message text" do
+          expect(subject.text).to eq "text"
+        end
+      end
+
+      describe "#==" do
+
+        let!(:params) { { type: "info", text: "text" } }
+
+        it "returns true if type and text of two messages are the same" do
+          expect(Message.new params).to eq(Message.new params)
+        end
+
+        it "returns false if types of two messages are different" do
+          expect(Message.new params)
+            .not_to eq(Message.new params.merge(type: "error"))
+        end
+
+        it "returns false if texts of two messages are different" do
+          expect(Message.new params)
+            .not_to eq(Message.new params.merge(text: "another"))
+        end
+
+        it "returns false when a message compares to non-message" do
+          expect(Message.new params).not_to eq("text")
+        end
+      end
+
+      describe "#<=>" do
+
+        let!(:aa) { Message.new type: "a", text: "a" }
+        let!(:ab) { Message.new type: "a", text: "b" }
+        let!(:ba) { Message.new type: "b", text: "a" }
+
+        it "orders messages by type" do
+          expect(aa < ba).to be_truthy
+        end
+
+        it "orders messages by text" do
+          expect(aa < ab).to be_truthy
+        end
+
+        it "orders messages first by type" do
+          expect(ab < ba).to be_truthy
+        end
+
+        it "fails when compared with non-message" do
+          expect { ab < "" }.to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/hexx/service_spec.rb

@@ -0,0 +1,183 @@
+require "spec_helper"
+
+module Hexx
+  describe Service do
+
+    describe "class methods" do
+
+      around :each do |example|
+        class TestService < Service; end
+        example.run
+        Hexx.send :remove_const, :TestService
+      end
+
+      subject { TestService }
+
+      it "includes ActiveModel::Validations" do
+        expect(subject.ancestors).to be_include ActiveModel::Validations
+      end
+
+      it "includes Whisper::Publisher" do
+        expect(subject.ancestors).to be_include Wisper::Publisher
+      end
+
+      describe ".allow_params" do
+
+        let(:attribute) { :name }
+        before          { subject.send :allow_params, attribute }
+
+        it "defines attributes" do
+          expect(subject.instance_methods).to be_include attribute
+        end
+      end
+
+      describe ".new" do
+
+        let(:value)    { "text" }
+        before         { subject.send :allow_params, :name }
+        let!(:service) { subject.new name: value, wrong: "wrong" }
+
+        it "stringifies params' keys" do
+          expect(service.send(:params)["name"]).to eq value
+          expect(service.send(:params)[:name]).to be_nil
+        end
+
+        it "whitelistes params" do
+          expect(service.send(:params)["wrong"]).to be_nil
+        end
+
+        it "initializes attributes from params" do
+          expect(service.send :name).to eq value
+        end
+      end
+    end
+
+    describe "##validate!" do
+
+      it "passes when object is valid" do
+        expect { subject.validate! }.not_to raise_error
+      end
+
+      it "fails when object is invalid" do
+        allow(subject).to receive(:valid?).and_return false
+        expect { subject.validate! }
+          .to raise_error { Service::Invalid.new(subject) }
+      end
+    end
+
+    describe "##params" do
+
+      it "is defined" do
+        expect { subject.send :params }.not_to raise_error
+      end
+    end
+
+    describe "##t" do
+
+      let(:scope)      { %w(activemodel messages models hexx/service) }
+      let(:traslation) { I18n.t(:text, scope: scope, name: "name") }
+
+      it "translates symbols in the service scope" do
+        expect(subject.send :t, :text, name: "name").to eq traslation
+      end
+
+      it "doesn't translate the string" do
+        expect(subject.send :t, "text").to eq "text"
+      end
+    end
+
+    describe "##messages" do
+
+      it "returns an array" do
+        expect(subject.send :messages).to be_kind_of Array
+      end
+    end
+
+    describe "##add_message" do
+
+      before        { subject.send :add_message, :info, :text }
+      let(:message) { subject.send(:messages).first }
+
+      it "adds a new message" do
+        expect(message).to be_kind_of Service::Message
+        expect(message.type).to eq "info"
+      end
+
+      it "translates a symbol" do
+        translation = subject.send :t, :text
+        expect(message.text).to eq translation
+      end
+    end
+
+    describe "##transaction" do
+
+      let(:listener) { double "listener" }
+      before { subject.subscribe listener }
+
+      it "yields a block" do
+        value  = "Hello!"
+        result = subject.send(:transaction) { value }
+        expect(result).to eq value
+      end
+
+      context "when a service invalid" do
+
+        before { allow(subject).to receive(:validate!) { fail } }
+
+        it "doesn't yield a block" do
+          value  = "Hello!"
+          result = subject.send(:transaction) { value }
+          expect(result).not_to eq value
+        end
+
+        it "publishes an :error" do
+          expect(listener).to receive(:error)
+          subject.send(:transaction)
+        end
+      end
+
+      context "when a block raises Service::Invalid error" do
+
+        before { subject.send(:errors).add :base, :text }
+        let(:run) do
+          subject.send(:transaction) { fail Service::Invalid.new(subject) }
+        end
+
+        it "rescues" do
+          expect { run }.not_to raise_error
+        end
+
+        it "publishes an :error with service messages" do
+          expect(listener).to receive(:error) do |messages|
+            expect(messages).to eq Service::Message.from(subject)
+          end
+          run
+        end
+      end
+
+      context "when a block raises StandardError" do
+
+        let(:run) { subject.send(:transaction) { fail "text" } }
+
+        it "rescues" do
+          expect { run }.not_to raise_error
+        end
+
+        it "publishes an :error with a message" do
+          expect(listener).to receive(:error) do |messages|
+            expect(messages)
+              .to eq [Service::Message.new(type: "error", text: "text")]
+          end
+          run
+        end
+      end
+    end
+
+    describe "#run" do
+
+      it "fails with NotImplementedError" do
+        expect { subject.run }.to raise_error { NotImplementedError }
+      end
+    end
+  end
+end

data/spec/{support/initializers → initializers}/i18n.rb

@@ -1 +1,3 @@
+require "i18n"
+
 I18n.enforce_available_locales = false

data/spec/spec_helper.rb

@@ -1,9 +1,7 @@
-ENV["RAILS_ENV"] ||= "test"
-
 root = File.dirname File.dirname(__FILE__)
 
+# Support files and Rspec settings
+Dir[File.join(root, "spec/initializers/*.rb")].each { |file| require file }
+
 # Application files
 require File.join(root, "lib/hexx.rb")
-
-# Support files and Rspec settings
-Dir[File.join(root, "spec/support/**/*.rb")].each { |file| require file }