ballast 1.9.3 → 2.0.0

data/lib/ballast/concerns/ajax.rb

@@ -1,134 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Ballast
-  # A set of concerns to address common issues.
-  module Concerns
-    # A concern to handle AJAX and HTTP requests.
-    module Ajax
-      extend ActiveSupport::Concern
-
-      # Checks if the current request is AJAX.
-      #
-      # @return [Boolean] `true` if the request is AJAX, `false` otherwise.
-      def is_ajax?
-        ((request.respond_to?(:xhr?) && request.xhr?) || params[:xhr].to_boolean) ? true : false
-      end
-
-      # Prepares an AJAX response.
-      #
-      # @param status [Symbol|Fixnum] The HTTP status of the response.
-      # @param data [Object] Additional data to append to the response.
-      # @param error [Object] A error to append to the response.
-      def prepare_ajax(status = :ok, data = nil, error = nil)
-        rv = {status: status}.ensure_access(:indifferent)
-        rv[:error] = error if error.present?
-        rv[:data] = data if data.present?
-        rv
-      end
-
-      # Sends an AJAX response to the client.
-      #
-      # @param data [Hash] The response to send.
-      # @param status [Symbol|Fixnum] The HTTP status of the response, *ignored if already set in data*.
-      # @param format [Symbol] The content type of the response.
-      # @param pretty_json [Boolean] If JSON response must be pretty formatted.
-      def send_ajax(data, status: :ok, format: :json, pretty_json: false)
-        if !performed? then
-          # Prepare data
-          data = prepare_ajax_send(data, status)
-
-          # Setup callback and format
-          format, callback, content_type = format_ajax_send(format)
-          status = data[:status]
-
-          # Adjust data
-          data = (pretty_json ? Oj.dump(data) : ActiveSupport::JSON.encode(data)) if [:json, :jsonp, :text].include?(format)
-
-          # Render
-          render(format => data, status: status, callback: callback, content_type: content_type)
-        end
-      end
-
-      # Updates an AJAX response from a operation, taking either the response data or the first error.
-      #
-      # @param data [Hash] The current data.
-      # @param operation [Operation] The operation to gather data from.
-      # @return [Hash] The updated data.
-      def update_ajax(data, operation = nil)
-        operation ||= @operation
-        data.merge!(operation.success? ? {data: operation.response[:data]} : {error: operation.errors.first})
-        data
-      end
-
-      # Prevents HTTP caching.
-      def prevent_caching
-        response.headers.merge!({
-          "Cache-Control" => "no-cache, no-store, max-age=0, must-revalidate",
-          "Pragma" => "no-cache",
-          "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT"
-        })
-      end
-
-      # Allows HTTP Cross-Origin Resource Sharing.
-      #
-      # @param allow_origin [String] The value for the `Access-Control-Allow-Origin` header.
-      # @param allow_methods [Array] A list of methods for the `Access-Control-Allow-Methods` header.
-      # @param allow_headers [String] The value for the `Access-Control-Allow-Headers` header.
-      # @param max_age [Float|Fixnum] The value for the `Access-Control-Max-Age` header.
-      # @param allow_credentials [Boolean] The value for the `Access-Control-Allow-Credentials` header.
-      def allow_cors(allow_origin: "*", allow_methods: [:post, :get, :options], allow_headers: "*", max_age: 1.year, allow_credentials: false)
-        headers.merge!({
-          "Access-Control-Allow-Origin" => allow_origin,
-          "Access-Control-Allow-Methods" => allow_methods.collect {|m| m.to_s.upcase }.join(", "),
-          "Access-Control-Allow-Headers" => allow_headers,
-          "Access-Control-Max-Age" => max_age.to_i.to_s
-        })
-
-        headers["Access-Control-Allow-Credentials"] = "true" if allow_credentials
-      end
-
-      # Generates a robots.txt file.
-      #
-      # @param configuration [Array] An array of list of agent and paths to include.
-      def generate_robots_txt(configuration = nil)
-        rv = configuration.ensure_array([["*", "/"]], true, true, false) { |entry|
-          agent = entry.shift
-          paths = entry.map {|e| "Disallow: #{e}" }
-
-          "User-agent: #{agent}\n#{paths.join("\n")}"
-        }.join("\n\n")
-
-        render(text: rv, content_type: "text/plain")
-      end
-      alias_method :disallow_robots, :generate_robots_txt
-
-      private
-        # Prepares data for sending back to the client.
-        #
-        # @param data [Object] The data to send back. Can be a full response or partial data.
-        # @param status [Symbol|Fixnum] The HTTP status to set if a new response must be created.
-        # @return [Hash] An HTTP response.
-        def prepare_ajax_send(data, status)
-          data = prepare_ajax(status, data) if !data.is_a?(Hash)
-          data[:status] ||= status
-          data[:status] = Rack::Utils.status_code(data[:status].to_s.to_sym) if !data[:status].is_a?(Fixnum)
-          data
-        end
-
-        # Sets up parameters to send a response.
-        #
-        # @param format [Symbol] The format of the data.
-        # @return [Array] An array of format, callback and content_type.
-        def format_ajax_send(format)
-          format = (format || params[:format] || request.format || "json").to_sym
-          callback = [:jsonp, :pretty_jsonp].include?(format) ? (params[:callback] || "jsonp#{Time.now.to_i}") : nil
-          content_type = (format == :text) ? "text/plain" : nil
-
-          [format, callback, content_type]
-        end
-    end
-  end
-end

data/lib/ballast/context.rb

@@ -1,38 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Ballast
-  # A context for an operation. It is basically a Hash with few enhancements, like owner, errors and output support.
-  class Context < Interactor::Context
-    # Builds a new context.
-    #
-    # @param owner [Object] The owner of this context.
-    # @param additional [Hash] Additional parameters to include into the context.
-    def self.build(owner, additional = {})
-      super({
-        owner: owner,
-        errors: [],
-        output: nil,
-        response: HashWithIndifferentAccess.new
-      }.merge(additional).ensure_access(:indifferent))
-    end
-
-    # Lookups missing methods in the delegatee hash.
-    #
-    # @param method [Symbol] The method to lookup.
-    # @param args [Array] The arguments passed to the method. *This is ignored.*
-    # @param block [Proc] The block passed to the method. *This is ignored.*
-    # @return [Object] The value for the method, if present.
-    def method_missing(method, *args, &block)
-      object = __getobj__
-
-      if object[method] then
-        object[method]
-      else
-        super(method, *args, &block)
-      end
-    end
-  end
-end

data/lib/ballast/operation.rb

@@ -1,136 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Ballast
-  # A operation represents a single responsibility class. Subclasses should only expose and override the #perform method.
-  class Operation
-    extend ::Forwardable
-    include Interactor
-    def_delegators :context, :owner, :errors, :response, :output
-
-    # Performs the operation.
-    #
-    # @param owner_or_context [Object|Context] If is a context, then it will be the context of the operation, otherwise a blank a context with the object
-    #   as owner will be created.
-    # @param context [NilClass] The context for the operation. *Ignored if `owner_or_context` is a context.*
-    # @param params [Hash] The additional parameters for the new context. *Ignored if `owner_or_context` is a context.*
-    # @return [Operation] The performed operation.
-    def self.perform(owner_or_context, context: nil, params: {})
-      arg = owner_or_context
-      arg = (context || ::Ballast::Context.build(owner_or_context, params)) if !arg.is_a?(::Ballast::Context)
-      super(arg)
-    end
-
-    # Creates a new operation.
-    #
-    # @param context [Context] The context for the operation.
-    def initialize(context)
-      @context = context
-      setup
-    end
-
-    # Sets up the response hash from instance variables.
-    #
-    # @param force [Boolean] Whether to setup the response even if the operation failed.
-    # @return [Hash] The response hash.
-    def setup_response(force = false)
-      if success? || force then
-        vars = instance_variables
-        vars.delete(:@context)
-
-        context.response.merge!(vars.reduce({}){ |rv, var|
-          rv[var.to_s.gsub(/[:@]/, "")] = instance_variable_get(var)
-          rv
-        })
-      end
-
-      context.response
-    end
-
-    # Imports the response hash into the target instance variables.
-    #
-    # @param target [Object] The target of the import.
-    # @param fields [Array] The keys to import.
-    # @param overwrite [Boolean] Whether to overwrite existing variables into the target. If set to `false`, any overwrite will raise an `ArgumentError`.
-    def import_response(target, *fields, overwrite: true)
-      fields.each do |field|
-        raise ArgumentError.new(field) if target.instance_variable_get("@#{field}") && !overwrite
-        target.instance_variable_set("@#{field}", response[field])
-      end
-    end
-
-    # Performs the operation handling base errors.
-    #
-    # @param setup_response_after [Boolean] Whether to setup the response after processing.
-    def perform_with_handling(setup_response_after = true)
-      begin
-        yield
-      rescue Lazier::Exceptions::Debug => de
-        raise de
-      rescue => e
-        e.is_a?(::Ballast::Errors::BaseError) ? fail!(e.response) : raise(e)
-      end
-
-      setup_response if setup_response_after
-    end
-
-    # Marks failure of the operation appending the error to the context.
-    #
-    # @param error [Object|NilClass] The error to store.
-    def fail!(error = nil)
-      errors << error if error
-      super()
-    end
-
-    # Imports the current operation errors into the target's `@error` instance variable or in the flash hash.
-    #
-    # @param target [Object] The target of the import.
-    # @param to_flash [Boolean] If to import the error in the target's flash object rather than the instance variable.
-    # @param first_only [Boolean] If to only import the first error.
-    def import_error(target, to_flash = true, first_only = true)
-      values = errors
-      values = values.map {|v| v[:error] } if to_flash
-      values = values.first if first_only
-
-      if to_flash then
-        target.flash[:error] = values
-      else
-        target.instance_variable_set(:@error, values)
-      end
-    end
-
-    # Resolves a numeric error to a human readable message.
-    #
-    # @param error [BaseError|Fixnum] The error to resolve.
-    # @param supported_messages [Hash] The list of supported error codes.
-    # @param only_message [Boolean] If to only return the message string rather than a full error hash.
-    # @return [String|Hash] The error with a human readable message or the message alone.
-    def resolve_error(error, supported_messages = {}, only_message = false)
-      code = (error.respond_to?(:response) ? error.response : 500).to_integer(500)
-      rv = {status: code, error: supported_messages.fetch(code, "Oops! We're having some issue. Please try again later.")}
-      only_message ? rv[:error] : rv
-    end
-
-    # If running under eventmachine, run the block in a thread of its threadpool using EM::Synchrony, otherwise run the block normally.
-    #
-    # @param block [Proc] The block to run.
-    def in_em_thread(&block)
-      Ballast.in_em_thread(&block)
-    end
-
-    # Forwards any missing method to the owner.
-    #
-    # @param method [Symbol] The method to forward.
-    # @param args [Array] The arguments to pass to the method.
-    # @param block [Proc] The block to pass to the method.
-    def method_missing(method, *args, &block)
-      if owner.respond_to?(method)
-        owner.send(method, *args, &block)
-      else
-        super(method, *args, &block)
-      end
-    end
-  end
-end

data/lib/ballast/operations_chain.rb

@@ -1,45 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-module Ballast
-  # A operation made of several operation run sequentially passing the common context. The chain will stop on the first failure.
-  #
-  # @attribute [r] operations
-  #   @return [Array] The list of operations performed.
-  class OperationsChain < Operation
-    include ::Interactor::Organizer
-    attr_reader :operations
-
-    # Performs the chain.
-    #
-    # @param argument [Object|Context] If is a context, then it will be the context of the operation, unless a blank a context with the object
-    #   as owner will be created.
-    # @param operations [Array] The list of operations to perform.
-    # @param context [NilClass] The context for the operation. *Ignored if `owner_or_context` is a context.*
-    # @param params [Hash] The additional parameters for the new context. *Ignored if `owner_or_context` is a context.*
-    # @return [Operation] The performed chain.
-    def self.perform(argument, operations, context: nil, params: {})
-      argument = (context || ::Ballast::Context.build(argument, params)) if !argument.is_a?(::Ballast::Context)
-      new(operations, argument).tap(&:perform)
-    end
-
-    # Creates a new chain.
-    #
-    # @param operations [Array] The list of operations to perform.
-    # @param context [Context] The context for the chain.
-    def initialize(operations, context)
-      @context = context
-      @operations = operations.ensure_array
-    end
-
-    private
-      # Returns the operations to perform.
-      #
-      # @return [Array] An array of operations to perform.
-      def interactors
-        @operations
-      end
-  end
-end

data/spec/ballast/concerns/ajax_spec.rb

@@ -1,141 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-require "spec_helper"
-
-describe Ballast::Concerns::Ajax do
-  class AjaxMockClass < OpenStruct
-    include Ballast::Concerns::Ajax
-
-    def initialize(attrs)
-      @operation = OpenStruct.new(attrs.delete(:operation))
-      super(attrs)
-    end
-  end
-
-  subject{ AjaxMockClass.new(response: OpenStruct.new(headers: {}), headers: {}, params: {}, performed?: false) }
-
-  describe "#is_ajax?" do
-    it "should return false by default" do
-      expect(AjaxMockClass.new(request: {}, params: {}).is_ajax?).to be(false)
-    end
-
-    it "should return true when the request is XHR" do
-      expect(AjaxMockClass.new(request: OpenStruct.new(xhr?: true)).is_ajax?).to be(true)
-    end
-
-    it "should return true when the parameter is overriden" do
-      expect(AjaxMockClass.new(params: {xhr: true}).is_ajax?).to be(true)
-    end
-  end
-
-  describe "#prepare_ajax" do
-    it "should return a default hash" do
-      expect(subject.prepare_ajax).to be_a(HashWithIndifferentAccess)
-      expect(subject.prepare_ajax).to eq({status: :ok}.with_indifferent_access)
-    end
-
-    it "should accept overrides for the status" do
-      expect(subject.prepare_ajax(:forbidden)).to eq({status: :forbidden}.with_indifferent_access)
-    end
-
-    it "should accept overrides for the data" do
-      expect(subject.prepare_ajax(:ok, "DATA")).to eq({status: :ok, data: "DATA"}.with_indifferent_access)
-    end
-
-    it "should accept overrides for the error" do
-      expect(subject.prepare_ajax(:ok, nil, "ERROR")).to eq({status: :ok, error: "ERROR"}.with_indifferent_access)
-    end
-  end
-
-  describe "#send_ajax" do
-    before(:each) do
-      allow(subject).to receive(:render) {|args| args}
-    end
-
-    it "should prepare the data if the data is not already an Hash" do
-      expect(subject).to receive(:prepare_ajax).with(:ok, "DATA").and_call_original
-      expect(subject).to receive(:render).with(json: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: nil, content_type: nil)
-      subject.send_ajax("DATA")
-    end
-
-    it "translate HTTP status" do
-      expect(Rack::Utils).to receive(:status_code).with(:forbidden).and_call_original
-      expect(subject.send_ajax("DATA", status: :forbidden)[:status]).to eq(403)
-    end
-
-    it "should setup the right content type for text" do
-      expect(subject).to receive(:render).with(text: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: nil, content_type: "text/plain")
-      subject.send_ajax("DATA", format: :text)
-    end
-
-    it "should set the right callback for JSONP" do
-      subject.params[:callback] = "callback"
-      expect(subject).to receive(:render).with(jsonp: "{\"status\":200,\"data\":\"DATA\"}", status: 200, callback: "callback", content_type: nil)
-      subject.send_ajax("DATA", format: :jsonp)
-    end
-  end
-
-  describe "#update_ajax" do
-    it "should merge the data from successful operations" do
-      subject = AjaxMockClass.new(operation: {success?: true, response: {data: "DATA"}})
-      expect(subject.update_ajax({existing: true})).to eq({existing: true, data: "DATA"})
-    end
-
-    it "should merge the data from failed operations" do
-      subject = AjaxMockClass.new(operation: {success?: false, errors: ["ERROR"]})
-      expect(subject.update_ajax({existing: true})).to eq({existing: true, error: "ERROR"})
-    end
-  end
-
-  describe "#prevent_caching" do
-    it "should append correct headers" do
-      subject.prevent_caching
-
-      expect(subject.response.headers).to eq({
-        "Cache-Control" => "no-cache, no-store, max-age=0, must-revalidate",
-        "Pragma" => "no-cache",
-        "Expires" => "Fri, 01 Jan 1990 00:00:00 GMT"
-      })
-    end
-  end
-
-  describe "#allow_cors" do
-    it "should append correct headers" do
-      subject.allow_cors
-
-      expect(subject.headers).to eq({
-        "Access-Control-Allow-Origin" => "*",
-        "Access-Control-Allow-Methods" => "POST, GET, OPTIONS",
-        "Access-Control-Allow-Headers" => "*",
-        "Access-Control-Max-Age" => "31557600"
-      })
-    end
-
-    it "should append custom headers values" do
-      subject.allow_cors(allow_origin: "ORIGIN", allow_methods: [:first, :second], allow_headers: "_", max_age: 1.day, allow_credentials: true)
-
-      expect(subject.headers).to eq({
-        "Access-Control-Allow-Origin" => "ORIGIN",
-        "Access-Control-Allow-Methods" => "FIRST, SECOND",
-        "Access-Control-Allow-Headers" => "_",
-        "Access-Control-Max-Age" => "86400",
-        "Access-Control-Allow-Credentials" => "true"
-      })
-    end
-  end
-
-  describe "#generate_robots_txt" do
-    it "should generate a robots.txt file which prevents everything by default" do
-      expect(subject).to receive(:render).with(text: "User-agent: *\nDisallow: /", content_type: "text/plain")
-      subject.disallow_robots
-    end
-
-    it "should generate a robots.txt file which prevents everything by default" do
-      expect(subject).to receive(:render).with(text: "User-agent: A\nDisallow: B\nDisallow: C\nDisallow: D\n\nUser-agent: E\nDisallow: F\nDisallow: \nDisallow: G", content_type: "text/plain")
-      subject.generate_robots_txt([["A", "B", "C", "D"], ["E", "F", "", "G"]])
-    end
-  end
-end

data/spec/ballast/context_spec.rb

@@ -1,23 +0,0 @@
-#
-# This file is part of the ballast gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
-# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
-#
-
-require "spec_helper"
-
-describe Ballast::Context do
-  describe ".build" do
-    it "should prepare data" do
-      expect(Interactor::Context).to receive(:build).with({owner: "OWNER", errors: [], output: nil, response: an_instance_of(HashWithIndifferentAccess), a: 1, b: 2}.with_indifferent_access)
-      Ballast::Context.build("OWNER", {a: 1, b: 2})
-    end
-  end
-
-  describe "#method_missing" do
-    it "should lookup for keys in the object" do
-      context = Ballast::Context.build(nil, {output: 1})
-      expect(context.output).to eq(1)
-      expect { context.input }.to raise_error(NoMethodError)
-    end
-  end
-end