decidim 0.4.4 → 0.5.0

data/decidim-core/lib/decidim/stats_registry.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class stores different stats computations and resolves them given a context.
+  class StatsRegistry
+    HIGH_PRIORITY = 1
+    MEDIUM_PRIORITY = 2
+    LOW_PRIORITY = 3
+
+    attr_reader :stats
+
+    # Public: Initializes the object with an optional stats array
+    #
+    # stats - An array of Hashes to represent a stat object
+    def initialize(stats = [])
+      @stats = stats
+    end
+
+    # Public: Register a stat
+    #
+    # name - The name of the stat
+    # options - A hash of options
+    #         * primary: Whether the stat is primary or not.
+    #         * priority: The priority of the stat used for render issues.
+    # block - A block that receive the features to filter out the stat.
+    def register(name, options = {}, &block)
+      stat = @stats.detect { |s| s[:name] == name }
+      raise StandardError, "Stats '#{name}' is already registered." if stat.present?
+
+      options[:primary] ||= false
+      options[:priority] ||= LOW_PRIORITY
+
+      @stats.push(name: name,
+                  primary: options[:primary],
+                  priority: options[:priority],
+                  tag: options[:tag],
+                  block: block)
+    end
+
+    # Public: Returns a number returned by executing the corresponding block.
+    #
+    # name - The name of the stat
+    # context - An arbritrary context object to compute the result.
+    # start_at - A date to filter resources created after it
+    # end_at - A date to filter resources created before it.
+    #
+    # Returns the result of executing the stats block using the passing context or an error.
+    def resolve(name, context, start_at = nil, end_at = nil)
+      stat = @stats.detect { |s| s[:name] == name }
+      return stat[:block].call(context, start_at, end_at) if stat.present?
+      raise StandardError, "Stats '#{name}' is not registered."
+    end
+
+    # Public: Resolves every stat with the given context and return an enumerator
+    #
+    # context - An arbritrary context object to compute the result.
+    # start_at - A date to filter resources created after it
+    # end_at - A date to filter resources created before it
+    #
+    # Returns an Enumerator where each value is a tuple of name and resolved value
+    def with_context(context, start_at = nil, end_at = nil)
+      Enumerator.new do |yielder|
+        @stats.each do |stat|
+          yielder << [stat[:name], resolve(stat[:name], context, start_at, end_at)]
+        end
+      end
+    end
+
+    # Public: Creates a new registry with the filtered stats
+    #
+    # conditions - A hash of conditions
+    #            * primary: Whether the stat is primary or not.
+    #            * priority: The priority of the stat used for render issues.
+    #
+    # Returns a new StatsRegistry with the filtered stats
+    def filter(conditions)
+      filtered_stats = @stats.select do |stat|
+        selected = true
+        conditions.each do |condition, value|
+          selected = false if stat[condition] != value
+        end
+        selected
+      end
+      StatsRegistry.new(filtered_stats)
+    end
+
+    # Public: Creates a new registry with all stats except the provided ones
+    #
+    # names - An Array of stats names to exclude
+    #
+    # Returns a new StatsRegistry with the selected stats
+    def except(names)
+      filtered_stats = @stats.reject do |stat|
+        names.include? stat[:name]
+      end
+      StatsRegistry.new(filtered_stats)
+    end
+
+    # Public: Creates a new registry with only the stats included into the provided ones
+    #
+    # names - An Array of stats names to include
+    #
+    # Returns a new StatsRegistry with the selected stats
+    def only(names)
+      filtered_stats = @stats.select do |stat|
+        names.include? stat[:name]
+      end
+      StatsRegistry.new(filtered_stats)
+    end
+  end
+end

data/decidim-core/lib/decidim/translatable_attributes.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A set of convenience methods to deal with I18n attributes and validations
+  # in a way that's compatible with Virtus and ActiveModel, thus making it easy
+  # to integrate into Rails' forms and similar workflows.
+  module TranslatableAttributes
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Public: Mirrors Virtus' `attribute` interface to define attributes in
+      # multiple locales.
+      #
+      # name - The attribute's name
+      # type - The attribute's Type
+      #
+      # Example:
+      #
+      #   translatable_attribute(:name, String)
+      #   # This will generate: `name_ca`, `name_en`, `name_ca=`, `name_en=`
+      #   # and will keep them synchronized with a hash in `name`:
+      #   # name = { "ca" => "Hola", "en" => "Hello" }
+      #
+      # Returns nothing.
+      def translatable_attribute(name, type, *options)
+        attribute name, Hash, default: {}
+
+        locales.each do |locale|
+          attribute_name = "#{name}_#{locale}".gsub("-", "__")
+          attribute attribute_name, type, *options
+
+          define_method attribute_name do
+            translatable_attribute_getter(name, locale)
+          end
+
+          alias_method "#{attribute_name}_virtus=", "#{attribute_name}="
+
+          define_method "#{attribute_name}=" do |value|
+            new_value = send("#{attribute_name}_virtus=", value)
+            translatable_attribute_setter(name, locale, new_value)
+          end
+        end
+      end
+
+      def locales
+        Decidim.available_locales
+      end
+    end
+
+    private
+
+    def translatable_attribute_setter(name, locale, value)
+      public_send("#{name}=", (public_send(name) || {}).merge(locale => value))
+    end
+
+    def translatable_attribute_getter(name, locale)
+      field = public_send(name) || {}
+      corrected_locale = locale.to_s.gsub("__", "-")
+      field[corrected_locale] || field[corrected_locale.to_sym]
+    end
+  end
+end

data/decidim-core/lib/devise/models/decidim_validatable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Devise
+  module Models
+    # Validatable creates all needed validations for a user email and password.
+    # Automatically validate if the email is present, unique and its format is
+    # valid. Also tests presence of password, confirmation and length.
+    #
+    # == Options
+    #
+    # Validatable adds the following options to devise_for:
+    #
+    #   * +email_regexp+: the regular expression used to validate e-mails;
+    #   * +password_length+: a range expressing password length. Defaults to 8..72.
+    #
+    module DecidimValidatable
+      # All validations used by this module.
+      VALIDATIONS = [:validates_presence_of, :validates_uniqueness_of, :validates_format_of,
+                     :validates_confirmation_of, :validates_length_of].freeze
+
+      def self.required_fields(_klass)
+        []
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+        assert_validations_api!(base)
+
+        base.class_eval do
+          validates_presence_of :email, if: :email_required?
+          validates_uniqueness_of :email, allow_blank: true, if: :email_changed?, scope: :organization
+          validates_format_of :email, with: email_regexp, allow_blank: true, if: :email_changed?
+
+          validates_presence_of :password, if: :password_required?
+          validates_confirmation_of :password, if: :password_required?
+          validates_length_of :password, within: password_length, allow_blank: true
+        end
+      end
+
+      def self.assert_validations_api!(base) #:nodoc:
+        unavailable_validations = VALIDATIONS.reject { |v| base.respond_to?(v) }
+
+        unless unavailable_validations.empty?
+          raise "Could not use :validatable module since #{base} does not respond " \
+                "to the following methods: #{unavailable_validations.to_sentence}."
+        end
+      end
+
+      protected
+
+      # Checks whether a password is needed or not. For validations only.
+      # Passwords are always required if it's a new record, or if the password
+      # or confirmation are being set somewhere.
+      def password_required?
+        !persisted? || !password.nil? || !password_confirmation.nil?
+      end
+
+      def email_required?
+        true
+      end
+
+      # Methods to be injected at class level.
+      module ClassMethods
+        Devise::Models.config(self, :email_regexp, :password_length)
+      end
+    end
+  end
+end

data/decidim-core/lib/tasks/decidim_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+namespace :decidim do
+  desc "Install migrations from Decidim to the app."
+  task upgrade: ["railties:install:migrations"]
+end

data/decidim-core/spec/commands/decidim/authorize_user_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  describe AuthorizeUser do
+    let(:user) { create(:user) }
+    let(:document_number) { "12345678X" }
+    let(:handler) do
+      DummyAuthorizationHandler.new(
+        document_number: document_number,
+        user: user
+      )
+    end
+
+    subject { described_class.new(handler) }
+
+    context "when the form is not authorized" do
+      before do
+        expect(handler).to receive(:valid?).and_return(false)
+      end
+
+      it "is not valid" do
+        expect { subject.call }.to broadcast(:invalid)
+      end
+    end
+
+    context "when everything is ok" do
+      it "creates an authorization for the user" do
+        expect { subject.call }.to change { user.authorizations.count }.by(1)
+      end
+
+      it "stores the metadata" do
+        subject.call
+
+        expect(user.authorizations.first.metadata["document_number"]).to eq("12345678X")
+      end
+    end
+
+    describe "uniqueness" do
+      let(:user) { create(:user) }
+      let(:unique_id) { "foo" }
+
+      before do
+        Decidim.authorization_handlers.push(DummyAuthorizationHandler)
+      end
+
+      after do
+        Decidim.authorization_handlers.delete(DummyAuthorizationHandler)
+      end
+
+      context "when there's no other authorizations" do
+        it "is valid if there's no authorization with the same id" do
+          expect { subject.call }.to change { user.authorizations.count }.by(1)
+        end
+      end
+
+      context "when there's other authorizations" do
+        let!(:other_user) { create(:user, organization: user.organization) }
+
+        before do
+          create(:authorization,
+                 user: other_user,
+                 unique_id: document_number,
+                 name: handler.handler_name)
+        end
+
+        it "is invalid if there's another authorization with the same id" do
+          expect { subject.call }.to change { user.authorizations.count }.by(0)
+        end
+      end
+    end
+  end
+end

data/decidim-core/spec/commands/decidim/create_omniauth_registration_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module Decidim
+  module Comments
+    describe CreateOmniauthRegistration do
+      describe "call" do
+        let(:organization) { create(:organization) }
+        let(:email) { "user@from-facebook.com" }
+        let(:provider) { "facebook" }
+        let(:uid) { "12345" }
+        let(:oauth_signature) { OmniauthRegistrationForm.create_signature(provider, uid) }
+        let(:verified_email) { email }
+        let(:form_params) do
+          {
+            "user" => {
+              "provider" => provider,
+              "uid" => uid,
+              "email" => email,
+              "email_verified" => true,
+              "name" => "Facebook User",
+              "oauth_signature" => oauth_signature
+            }
+          }
+        end
+        let(:form) do
+          OmniauthRegistrationForm.from_params(
+            form_params
+          ).with_context(
+            current_organization: organization
+          )
+        end
+        let(:command) { described_class.new(form, verified_email) }
+
+        describe "when the form oauth_signature cannot ve verified" do
+          let(:oauth_signature) { "1234" }
+
+          it "raises a InvalidOauthSignature exception" do
+            expect { command.call }.to raise_error InvalidOauthSignature
+          end
+        end
+
+        describe "when the form is not valid" do
+          before do
+            expect(form).to receive(:invalid?).and_return(true)
+          end
+
+          it "broadcasts invalid" do
+            expect { command.call }.to broadcast(:invalid)
+          end
+
+          it "doesn't create a comment" do
+            expect do
+              command.call
+            end.not_to change { User.count }
+          end
+        end
+
+        describe "when the form is valid" do
+          it "broadcasts ok" do
+            expect { command.call }.to broadcast(:ok)
+          end
+
+          it "creates a new user" do
+            expect(SecureRandom).to receive(:hex).and_return("abcde1234")
+
+            expect do
+              command.call
+            end.to change { User.count }.by(1)
+
+            user = User.find_by_email(form.email)
+            expect(user.encrypted_password).not_to be_nil
+            expect(user.email).to eq(form.email)
+            expect(user.organization).to eq(organization)
+            expect(user).to be_confirmed
+            expect(user.valid_password?("abcde1234")).to eq(true)
+          end
+
+          describe "user linking" do
+            context "with a verified email" do
+              let(:verified_email) { email }
+
+              it "links a previously existing user" do
+                user = create(:user, email: email, organization: organization)
+                expect { command.call }.to change { User.count }.by(0)
+
+                expect(user.identities.length).to eq(1)
+              end
+            end
+
+            context "with an unverified email" do
+              let(:verified_email) { nil }
+
+              it "doesn't link a previously existing user" do
+                user = create(:user, email: email, organization: organization)
+                expect { command.call }.to broadcast(:error)
+
+                expect(user.identities.length).to eq(0)
+              end
+            end
+          end
+
+          it "creates a new identity" do
+            expect do
+              command.call
+            end.to change { Identity.count }.by(1)
+            last_identity = Identity.last
+            expect(last_identity.provider).to eq(form.provider)
+            expect(last_identity.uid).to eq(form.uid)
+            expect(last_identity.organization).to eq(organization)
+          end
+
+          it "confirms the user if the email is already verified" do
+            expect_any_instance_of(User).to receive(:skip_confirmation!)
+            command.call
+          end
+        end
+
+        describe "when a user exists with that identity" do
+          it "broadcasts ok" do
+            user = create(:user, email: email, organization: organization)
+            create(:identity, user: user, provider: provider, uid: uid)
+
+            expect { command.call }.to broadcast(:ok)
+          end
+        end
+      end
+    end
+  end
+end