Implement LiquidCachedAssigns

app/controllers/concerns/liquid_enabled_resource.rb

@@ -35,6 +35,6 @@ def project_assigns
     project = Project.find(params[:project_id])
     authorize! :use, project
 
-    LiquidAssignsService.new(project: project, text: params[:text]).assigns
+    LiquidCachedAssigns.new(project: project)
   end
 end

app/services/liquid_cached_assigns.rb

@@ -0,0 +1,57 @@
+class LiquidCachedAssigns < Hash
+  AVAILABLE_PROJECT_ASSIGNS = %w{ evidences issues nodes notes project tags }.freeze
+
+  attr_accessor :assigns, :project
+
+  def initialize(project:)
+    @project = project
+
+    @assigns = { 'project' => ProjectDrop.new(project) }
+    @assigns.merge!(assigns_pro)
+  end
+
+  def [](record_type)
+    assigns[record_type] ||= cached_drops(record_type)
+  end
+
+  def key?(key)
+    AVAILABLE_PROJECT_ASSIGNS.include?(key.to_s) || assigns.key?(key)
+  end
+
+  def merge!(hash)
+    @assigns.merge!(hash)
+    self
+  end
+
+  private
+
+  def assigns_pro
+    {}
+  end
+
+  def cached_drops(record_type)
+    records = project_records(record_type)
+
+    return [] if records.empty?
+
+    cache_key = ActiveSupport::Cache.expand_cache_key([project.id, records], 'liquid')
+    drop_class = "#{record_type.singularize.camelize}Drop".constantize
+
+    Rails.cache.fetch(cache_key) do
+      records.map { |record| drop_class.new(record) }
+    end
+  end
+
+  def project_records(record_type)
+    return [] unless AVAILABLE_PROJECT_ASSIGNS.include?(record_type)
+
+    case record_type
+    when 'evidences'
+      project.evidence
+    when 'nodes'
+      project.nodes.user_nodes
+    else
+      project.send(record_type.to_sym)
+    end
+  end
+end

spec/services/liquid_cached_assigns_spec.rb

@@ -0,0 +1,61 @@
+require 'rails_helper'
+
+RSpec.describe LiquidCachedAssigns do
+  let!(:project) { create(:project) }
+  let(:liquid_assigns) { described_class.new(project: project) }
+
+  before do
+    node = create(:node, project: project)
+    issue = create(:issue, node: project.issue_library)
+    create(:evidence, issue: issue, node: node)
+    create(:note, node: node)
+    create(:tag)
+  end
+
+  context 'fetching an assign from an available collection' do
+    it 'lazily loads the assigns' do
+      expect(liquid_assigns.assigns.keys).to_not include(
+        %w{issues evidences nodes notes tags}
+      )
+    end
+
+    it 'builds a hash of liquid assigns' do
+      expect(liquid_assigns['project'].name).to eq(project.name)
+      expect(liquid_assigns['issues'].map(&:title)).to eq(project.issues.map(&:title))
+      expect(liquid_assigns['evidences'].map(&:title)).to eq(project.evidence.map(&:title))
+      expect(liquid_assigns['nodes'].map(&:label)).to eq(project.nodes.user_nodes.map(&:label))
+      expect(liquid_assigns['notes'].map(&:title)).to eq(project.notes.map(&:title))
+      expect(liquid_assigns['tags'].map(&:display_name)).to eq(project.tags.map(&:display_name))
+    end
+  end
+
+  context 'fetching an assign from a unavailable collection' do
+    it 'returns an empty array' do
+      expect(liquid_assigns['fake']).to be_empty
+    end
+  end
+
+  context 'with pro records', skip: !defined?(Dradis::Pro)  do
+    let!(:project) { create(:project, :with_team) }
+
+    before do
+      report_content = project.content_library
+      report_content.properties = { 'dradis.project' => project.name }
+      report_content.save
+
+      create(:content_block, project: project)
+    end
+
+    context 'fetching an assign from an available collection' do
+      it 'lazily loads the assigns' do
+        expect(liquid_assigns.assigns.keys).to_not include('content_blocks')
+      end
+
+      it 'builds a hash with Dradis::Pro assigns' do
+        expect(liquid_assigns['document_properties'].available_properties).to eq({ 'dradis.project' => project.name })
+        expect(liquid_assigns['team'].name).to eq(project.team.name)
+        expect(liquid_assigns['content_blocks'].map(&:content)).to eq(project.content_blocks.map(&:content))
+      end
+    end
+  end
+end