decidim-decidim_awesome 0.5.1

data/lib/decidim/decidim_awesome/content_renderers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module ContentRenderers
+      autoload :MarkdownRenderer, "decidim/decidim_awesome/content_renderers/markdown_renderer"
+    end
+  end
+end

data/lib/decidim/decidim_awesome/content_renderers/markdown_renderer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "redcarpet"
+
+module Decidim
+  module DecidimAwesome
+    module ContentRenderers
+      # A renderer that processes markdown
+      class MarkdownRenderer < Decidim::ContentRenderers::BaseRenderer
+        # @return [String] the content ready to display (contains HTML)
+        def render(options = { filter_html: true, autolink: true, no_intra_emphasis: true, fenced_code_blocks: true, disable_indented_code_blocks: true, tables: true })
+          md = Redcarpet::Markdown.new(Redcarpet::Render::HTML, options).render(content)
+          "<div class=\"awesome-markdown-editor\">#{md}</div>"
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/context_analyzers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module ContextAnalyzers
+      autoload :RequestAnalyzer, "decidim/decidim_awesome/context_analyzers/request_analyzer"
+      autoload :ComponentAnalyzer, "decidim/decidim_awesome/context_analyzers/component_analyzer"
+      autoload :ParticipatorySpaceAnalyzer, "decidim/decidim_awesome/context_analyzers/participatory_space_analyzer"
+    end
+  end
+end

data/lib/decidim/decidim_awesome/context_analyzers/component_analyzer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module ContextAnalyzers
+      # Translates a decidim component to detected participatory spaces and components
+      class ComponentAnalyzer
+        def initialize(component)
+          @component = component
+          @context = {}
+        end
+
+        def self.context_for(component)
+          analyzer = new component
+          analyzer.extract_context!
+          analyzer.context
+        end
+
+        attr_reader :component, :context
+
+        def extract_context!
+          if @component.respond_to? :participatory_space
+            @context[:participatory_space_manifest] = @component.participatory_space.manifest.name.to_s
+            @context[:participatory_space_slug] = @component.participatory_space&.slug
+          end
+
+          if @component.respond_to? :component
+            @context[:component_manifest] = @component.component.manifest.name.to_s
+            @context[:component_id] = @component.component&.id&.to_s
+          elsif @component.is_a? Decidim::Component
+            @context[:component_manifest] = @component.manifest.name.to_s
+            @context[:component_id] = @component&.id&.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/context_analyzers/participatory_space_analyzer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module ContextAnalyzers
+      # Translates a decidim participatory_space to detected participatory spaces
+      class ParticipatorySpaceAnalyzer
+        def initialize(participatory_space)
+          @participatory_space = participatory_space
+          @context = {}
+        end
+
+        def self.context_for(participatory_space)
+          analyzer = new participatory_space
+          analyzer.extract_context!
+          analyzer.context
+        end
+
+        attr_reader :participatory_space, :context
+
+        def extract_context!
+          return unless @participatory_space.respond_to? :manifest
+          return unless @participatory_space.manifest.is_a? Decidim::ParticipatorySpaceManifest
+
+          @context[:participatory_space_manifest] = @participatory_space.manifest.name.to_s
+          @context[:participatory_space_slug] = @participatory_space&.slug
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/context_analyzers/request_analyzer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module ContextAnalyzers
+      # Translates some Decidim URL path to detected participatory spaces and components
+      class RequestAnalyzer
+        def initialize(request)
+          @request = request
+          @context = {}
+        end
+
+        def self.context_for(request)
+          analyzer = new request
+          analyzer.extract_context!
+          analyzer.context
+        end
+
+        attr_reader :request, :context
+
+        def extract_context!
+          path = URI.parse(@request.url).path
+          context_from_path path
+        end
+
+        private
+
+        # In the frontend there's no a 100% correspondence between url and manifest name
+        def participatory_spaces
+          spaces = Decidim.participatory_space_manifests.map do |space|
+            [space.name.to_s, space.name.to_s]
+          end.to_h
+          spaces.merge(
+            "processes" => "participatory_processes",
+            "participatory_process_groups" => "participatory_processes",
+            "assemblies_types" => "assemblies"
+          )
+        end
+
+        def process_admin_segments(segments)
+          spaces = participatory_spaces
+          return unless spaces[segments[0]]
+
+          @context[:participatory_space_manifest] = spaces[segments[0]]
+          @context[:participatory_space_slug] = segments[1] if segments[1].present?
+
+          return unless segments[2].presence == "components" && segments[3].present?
+
+          @context[:component_id] = segments[3]
+          # Try to infer component_manifest
+          c = Component.find_by(id: segments[3])
+          @context[:component_manifest] = c.manifest_name if c
+        end
+
+        def process_front_segments(segments)
+          spaces = participatory_spaces
+          return unless spaces[segments[0]]
+
+          @context[:participatory_space_manifest] = spaces[segments[0]]
+          @context[:participatory_space_slug] = segments[1] if segments[1].present?
+
+          return unless segments[2].presence == "f" && segments[3].present?
+
+          @context[:component_id] = segments[3]
+          # Try to infer component_manifest
+          c = Component.find_by(id: segments[3])
+          @context[:component_manifest] = c.manifest_name if c
+        end
+
+        def system_manifest?(path)
+          patterns = [
+            %r{^/admin/newsletters},
+            %r{^/admin/organization},
+            %r{^/admin/static_pages}
+          ]
+          path.match(Regexp.union(patterns))
+        end
+
+        def context_from_path(path)
+          if system_manifest?(path)
+            @context[:participatory_space_manifest] = "system"
+            return
+          end
+
+          segments = path.sub(%r{^/}, "").split("/")
+          return if segments.blank?
+
+          if segments[0] == "admin"
+            segments.shift
+            return process_admin_segments(segments)
+          end
+          process_front_segments(segments)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/engine.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rails"
+require "decidim/core"
+require "decidim/decidim_awesome/awesome_helpers"
+
+module Decidim
+  module DecidimAwesome
+    # This is the engine that runs on the public interface of decidim_awesome.
+    class Engine < ::Rails::Engine
+      isolate_namespace Decidim::DecidimAwesome
+
+      routes do
+        post :editor_images, to: "editor_images#create"
+      end
+
+      initializer "decidim_awesome.view_helpers" do
+        ActionView::Base.send :include, AwesomeHelpers
+      end
+
+      initializer "decidim_decidim_awesome.assets" do |app|
+        app.config.assets.precompile += %w(decidim_decidim_awesome_manifest.js decidim_decidim_awesome_manifest.css)
+        # add to precompile any present
+        Dir.glob(Rails.root.join("app", "assets", "themes", "*.*")).each do |path|
+          app.config.assets.precompile << path
+        end
+      end
+
+      # Prepare a zone to create overrides
+      # https://edgeguides.rubyonrails.org/engines.html#overriding-models-and-controllers
+      config.to_prepare do
+        Dir.glob("#{Engine.root}/app/awesome_overrides/**/*_override.rb").each do |override|
+          require_dependency override
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/iframe_component/component.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_dependency "decidim/components/namer"
+
+Decidim.register_component(:awesome_iframe) do |component|
+  component.engine = Decidim::DecidimAwesome::IframeComponent::Engine
+  # component.admin_engine = Decidim::DecidimAwesome::AdminIframeEngine
+  component.icon = "decidim/meetings/icon.svg" # TODO: create a Icon
+  component.permissions_class_name = "Decidim::DecidimAwesome::Permissions"
+
+  # These actions permissions can be configured in the admin panel
+  # component.actions = %w()
+
+  component.settings(:global) do |settings|
+    # Add your global settings
+    # Available types: :integer, :boolean
+    # settings.attribute :announcement, type: :text, translated: true, editor: true
+    settings.attribute :iframe, type: :text
+    settings.attribute :viewport_width, type: :boolean, default: false
+    settings.attribute :no_margins, type: :boolean, default: false
+  end
+
+  component.settings(:step) do |settings|
+    # Add your settings per step
+    # settings.attribute :announcement, type: :text, translated: true, editor: true
+    settings.attribute :iframe, type: :text
+  end
+
+  # component.register_stat :some_stat do |context, start_at, end_at|
+  #   # Register some stat number to the application
+  # end
+
+  component.seeds do |participatory_space|
+    # Create a Iframe and a few geolocated proposals
+    admin_user = Decidim::User.find_by(
+      organization: participatory_space.organization,
+      email: "admin@example.org"
+    )
+
+    params = {
+      name: Decidim::Components::Namer.new(participatory_space.organization.available_locales, :awesome_iframe).i18n_name,
+      manifest_name: :awesome_iframe,
+      published_at: Time.current,
+      participatory_space: participatory_space,
+      settings: {
+        announcement: { en: Faker::Lorem.paragraphs(2).join("\n") }
+      }
+    }
+
+    component = Decidim.traceability.perform_action!(
+      "publish",
+      Decidim::Component,
+      admin_user,
+      visibility: "all"
+    ) do
+      Decidim::Component.create!(params)
+    end
+  end
+end

data/lib/decidim/decidim_awesome/iframe_component/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rails"
+require "decidim/core"
+
+module Decidim
+  module DecidimAwesome
+    module IframeComponent
+      # This is the engine is used to create the component Map.
+      class Engine < ::Rails::Engine
+        isolate_namespace Decidim::DecidimAwesome::IframeComponent
+
+        routes do
+          root to: "iframe#show"
+        end
+
+        def load_seed
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/map_component/component.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_dependency "decidim/components/namer"
+
+Decidim.register_component(:awesome_map) do |component|
+  component.engine = Decidim::DecidimAwesome::MapComponent::Engine
+  # component.admin_engine = Decidim::DecidimAwesome::AdminMapEngine
+  component.icon = "decidim/meetings/icon.svg" # TODO: create a Icon
+  component.permissions_class_name = "Decidim::DecidimAwesome::Permissions"
+
+  # These actions permissions can be configured in the admin panel
+  # component.actions = %w()
+
+  component.settings(:global) do |settings|
+    # Add your global settings
+    # Available types: :integer, :boolean
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+    settings.attribute :map_height, type: :integer, default: 700
+    settings.attribute :collapse, type: :boolean, default: false
+  end
+
+  component.settings(:step) do |settings|
+    # Add your settings per step
+    settings.attribute :announcement, type: :text, translated: true, editor: true
+  end
+
+  # component.register_stat :some_stat do |context, start_at, end_at|
+  #   # Register some stat number to the application
+  # end
+
+  component.seeds do |participatory_space|
+    # Create a Map and a few geolocated proposals
+    admin_user = Decidim::User.find_by(
+      organization: participatory_space.organization,
+      email: "admin@example.org"
+    )
+
+    params = {
+      name: Decidim::Components::Namer.new(participatory_space.organization.available_locales, :awesome_map).i18n_name,
+      manifest_name: :awesome_map,
+      published_at: Time.current,
+      participatory_space: participatory_space,
+      settings: {
+        announcement: { en: Faker::Lorem.paragraphs(2).join("\n") }
+      }
+    }
+
+    component = Decidim.traceability.perform_action!(
+      "publish",
+      Decidim::Component,
+      admin_user,
+      visibility: "all"
+    ) do
+      Decidim::Component.create!(params)
+    end
+
+    # Tweak proposals in Assemblies to geolocate them
+    next unless participatory_space.manifest.name == :assemblies
+
+    participatory_space.components.each do |comp|
+      next unless comp.manifest.name == :proposals
+
+      comp.attributes["settings"]["global"]["geocoding_enabled"] = true
+      comp.save!
+
+      Decidim::Proposals::Proposal.where(component: comp).each do |proposal|
+        proposal.address = "#{Faker::Address.street_address} #{Faker::Address.zip} #{Faker::Address.city}"
+        proposal.latitude = Faker::Address.latitude
+        proposal.longitude = Faker::Address.longitude
+        proposal.save!
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/map_component/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rails"
+require "decidim/core"
+
+module Decidim
+  module DecidimAwesome
+    module MapComponent
+      # This is the engine is used to create the component Map.
+      class Engine < ::Rails::Engine
+        isolate_namespace Decidim::DecidimAwesome::MapComponent
+
+        routes do
+          root to: "map#show"
+        end
+
+        def load_seed
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/decidim/decidim_awesome/system_checker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module SystemChecker
+      class << self
+        # List of files overriden by this plugin
+        # overriden files has to match MD5 calculation to be sure is the same as the expected
+        def overrides
+          return @overrides if @overrides
+
+          # rubocop:disable Rails/DynamicFindBy
+          checksums = YAML.load_file("#{__dir__}/checksums.yml")
+          @overrides = checksums.map do |package, files|
+            props = {
+              spec: ::Gem::Specification.find_by_name(package),
+              files: files.map { |file, signatures| [file, signatures.values] }.to_h
+            }
+            [package, to_struct(props)]
+          end
+          # rubocop:enable Rails/DynamicFindBy
+          @overrides = to_struct(@overrides.to_h)
+        end
+
+        delegate :to_h, to: :overrides
+
+        def each(&block)
+          to_h.each(&block)
+        end
+
+        def each_file
+          each do |_, props|
+            props.files.each do |file, signatures|
+              yield "#{props.spec.gem_dir}#{file}", signatures
+            end
+          end
+        end
+
+        def valid?(spec, file)
+          find_signatures("#{spec.gem_dir}#{file}").detect { |s| md5("#{spec.gem_dir}#{file}") == s }
+        end
+
+        private
+
+        def find_signatures(file)
+          to_h.each do |_, props|
+            props.files.each do |f, signatures|
+              return signatures if file == "#{props.spec.gem_dir}#{f}"
+            end
+          end
+        end
+
+        def md5(file)
+          Digest::MD5.hexdigest(File.read(file))
+        end
+
+        def to_struct(obj)
+          OpenStruct.new obj
+        end
+      end
+    end
+  end
+end