activeadmin_addons 0.12.0 → 1.0.0

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/display_name_spec.rb

@@ -0,0 +1,71 @@
+require 'rails_helper'
+
+describe "display_name" do
+
+  include ActiveAdmin::ViewHelpers
+
+  ActiveAdmin::Application.new.display_name_methods.map(&:to_s).each do |m|
+    it "should return #{m} when defined" do
+      klass = Class.new do
+        define_method(m) { m }
+      end
+      expect(display_name klass.new).to eq m
+    end
+  end
+
+  it "should memoize the result for the class" do
+    subject = Class.new.new
+    expect(subject).to receive(:name).twice.and_return "My Name"
+    expect(display_name subject).to eq "My Name"
+    expect(ActiveAdmin.application).to_not receive(:display_name_methods)
+    expect(display_name subject).to eq "My Name"
+  end
+
+  it "should not call a method if it's an association" do
+    klass = Class.new
+    subject = klass.new
+    allow(klass).to receive(:reflect_on_all_associations).and_return [ double(name: :login) ]
+    allow(subject).to receive :login
+    expect(subject).to_not receive :login
+    allow(subject).to receive(:email).and_return 'foo@bar.baz'
+    expect(display_name subject).to eq 'foo@bar.baz'
+  end
+
+  it "should return `nil` when the passed object is `nil`" do
+    expect(display_name nil).to eq nil
+  end
+
+  it "should return 'false' when the passed objct is `false`" do
+    expect(display_name false).to eq "false"
+  end
+
+  it "should default to `to_s`" do
+    subject = Class.new.new
+    expect(display_name subject).to eq subject.to_s
+  end
+
+  context "when no display name method is defined" do
+    context "on a Rails model" do
+      it "should show the model name" do
+        class ThisModel
+          extend ActiveModel::Naming
+        end
+        subject = ThisModel.new
+        expect(display_name subject).to eq "This model"
+      end
+
+      it "should show the model name, plus the ID if in use" do
+        subject = Tagging.create!
+        expect(display_name subject).to eq "Tagging #1"
+      end
+
+      it "should translate the model name" do
+        with_translation activerecord: {models: {tagging: {one: "Different"}}} do
+          subject = Tagging.create!
+          expect(display_name subject).to eq "Different #1"
+        end
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
+
+  describe "class methods" do
+    before :all do
+
+      begin
+        # The mime type to be used in respond_to |format| style web-services in rails
+        Mime::Type.register "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", :xlsx
+      rescue NameError
+        puts "Mime module not defined. Skipping registration of xlsx"
+      end
+
+      class Foo
+        include ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
+      end
+    end
+
+    it "extends the class to add a formats class method that returns the default formats." do
+      expect(Foo.formats).to eq [:csv, :xml, :json]
+    end
+
+    it "does not let you alter the formats array directly" do
+      Foo.formats << :xlsx
+      expect(Foo.formats).to eq [:csv, :xml, :json]
+    end
+
+    it "allows us to add new formats" do
+      Foo.add_format :xlsx
+      expect(Foo.formats).to eq [:csv, :xml, :json, :xlsx]
+    end
+
+    it "raises an exception if you provide an unregisterd mime type extension" do
+      expect{ Foo.add_format :hoge }.to raise_error
+    end
+
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/fields_for_spec.rb

@@ -0,0 +1,50 @@
+require 'active_admin/view_helpers/fields_for'
+
+describe ActiveAdmin::ViewHelpers::FormHelper, ".fields_for" do
+  include ActiveAdmin::ViewHelpers::FormHelper
+
+  it "should skip :action, :controller and :commit" do
+    expect(fields_for_params(
+      scope: "All", action: "index", controller: "PostController", commit: "Filter", utf8: "Yes!")).
+      to eq [ { scope: "All" } ]
+  end
+
+  it "should skip the except" do
+    expect(fields_for_params({scope: "All", name: "Greg"}, except: :name)).
+      to eq [ { scope: "All" } ]
+  end
+
+  it "should allow an array for the except" do
+    expect(fields_for_params({scope: "All", name: "Greg", age: "12"}, except: [:name, :age])).
+      to eq [ { scope: "All" } ]
+  end
+
+  it "should work with hashes" do
+    params = fields_for_params(filters: { name: "John", age: "12" })
+
+    expect(params.size).to eq 2
+    expect(params).to include({"filters[name]" => "John" })
+    expect(params).to include({ "filters[age]" => "12" })
+  end
+
+  it "should work with nested hashes" do
+    expect(fields_for_params(filters: { user: { name: "John" }})).
+      to eq [ { "filters[user][name]" => "John" } ]
+  end
+
+  it "should work with arrays" do
+    expect(fields_for_params(people: ["greg", "emily", "philippe"])).
+      to eq [ { "people[]" => "greg" },
+                  { "people[]" => "emily" },
+                  { "people[]" => "philippe" } ]
+  end
+
+  it "should work with symbols" do
+    expect(fields_for_params(filter: :id)).
+      to eq [ { filter: "id" } ]
+  end
+
+  it "should work with booleans" do
+    expect(fields_for_params(booleantest: false)).to eq [ { booleantest: false } ]
+  end
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/flash_helper_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+describe ActiveAdmin::ViewHelpers::FlashHelper do
+
+  describe '.flash_messages' do
+    let(:view) { action_view }
+
+    it "should not include 'timedout' flash messages by default" do
+      view.request.flash[:alert] = "Alert"
+      view.request.flash[:timedout] = true
+      expect(view.flash_messages).to include 'alert'
+      expect(view.flash_messages).to_not include 'timedout'
+    end
+
+    it "should not return flash messages included in flash_keys_to_except" do
+      expect(view.active_admin_application).to receive(:flash_keys_to_except).and_return ["hideme"]
+      view.request.flash[:alert] = "Alert"
+      view.request.flash[:hideme] = "Do not show"
+      expect(view.flash_messages).to include 'alert'
+      expect(view.flash_messages).to_not include 'hideme'
+    end
+
+  end
+end
+

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/form_helper_spec.rb

@@ -0,0 +1,43 @@
+require 'rails_helper'
+
+describe ActiveAdmin::ViewHelpers::FormHelper do
+
+  describe '.active_admin_form_for' do
+    let(:view) { action_view }
+    let(:resource) { double 'resource' }
+    let(:default_options) { { builder: ActiveAdmin::FormBuilder } }
+
+    it 'calls semantic_form_for with the ActiveAdmin form builder' do
+      expect(view).to receive(:semantic_form_for).with(resource, builder: ActiveAdmin::FormBuilder)
+      view.active_admin_form_for(resource)
+    end
+
+    it 'allows the form builder to be customized' do
+      # We can't use a stub here because options gets marshalled, and a new
+      # instance built. Any constant will work.
+      custom_builder = Object
+      expect(view).to receive(:semantic_form_for).with(resource, builder: custom_builder)
+      view.active_admin_form_for(resource, builder: custom_builder)
+    end
+  end
+
+  describe ".hidden_field_tags_for" do
+    let(:view) { action_view }
+
+    it "should render hidden field tags for params" do
+      html = Capybara.string view.hidden_field_tags_for(scope: "All", filter: "None")
+      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
+      expect(html).to have_selector("input#hidden_active_admin_filter[name=filter][type=hidden][value=None]")
+    end
+
+    it "should generate not default id for hidden input" do
+      expect(view.hidden_field_tags_for(scope: "All")[/id="([^"]+)"/, 1]).to_not eq "scope"
+    end
+
+    it "should filter out the field passed via the option :except" do
+      html = Capybara.string view.hidden_field_tags_for({scope: "All", filter: "None"}, except: :filter)
+      expect(html).to have_selector("input#hidden_active_admin_scope[name=scope][type=hidden][value=All]")
+    end
+  end
+end
+

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -0,0 +1,139 @@
+require 'rails_helper'
+
+describe MethodOrProcHelper do
+  let(:receiver) { double }
+
+  let(:context) do
+    obj = double receiver_in_context: receiver
+    obj.extend MethodOrProcHelper
+    obj
+  end
+
+  describe "#call_method_or_exec_proc" do
+
+    it "should call the method in the context when a symbol" do
+      expect(context.call_method_or_exec_proc(:receiver_in_context)).to eq receiver
+    end
+
+    it "should call the method in the context when a string" do
+      expect(context.call_method_or_exec_proc("receiver_in_context")).to eq receiver
+    end
+
+    it "should exec a proc in the context" do
+      test_proc = Proc.new{ raise "Success" if receiver_in_context }
+
+      expect {
+        context.call_method_or_exec_proc(test_proc)
+      }.to raise_error("Success")
+    end
+
+  end
+
+  describe "#call_method_or_proc_on" do
+
+    [:hello, 'hello'].each do |key|
+      context "when a #{key.class}" do
+        it "should call the method on the receiver" do
+          expect(receiver).to receive(key).and_return 'hello'
+
+          expect(context.call_method_or_proc_on(receiver, key)).to eq 'hello'
+        end
+
+        it "should receive additional arguments" do
+          expect(receiver).to receive(key).with(:world).and_return 'hello world'
+
+          expect(context.call_method_or_proc_on(receiver, key, :world)).to eq 'hello world'
+        end
+      end
+    end
+
+    context "when a proc" do
+
+      it "should exec the block in the context and pass in the receiver" do
+        test_proc = Proc.new do |arg|
+          raise "Success!" if arg == receiver_in_context
+        end
+
+        expect {
+          context.call_method_or_proc_on(receiver,test_proc)
+        }.to raise_error("Success!")
+      end
+
+      it "should receive additional arguments" do
+        test_proc = Proc.new do |arg1, arg2|
+          raise "Success!" if arg1 == receiver_in_context && arg2 == "Hello"
+        end
+
+        expect {
+          context.call_method_or_proc_on(receiver, test_proc, "Hello")
+        }.to raise_error("Success!")
+      end
+
+    end
+
+    context "when a proc and exec: false" do
+
+      it "should call the proc and pass in the receiver" do
+        obj_not_in_context = double
+
+        test_proc = Proc.new do |arg|
+          raise "Success!" if arg == receiver && obj_not_in_context
+        end
+
+        expect {
+          context.call_method_or_proc_on(receiver,test_proc, exec: false)
+        }.to raise_error("Success!")
+      end
+
+    end
+
+
+  end
+
+  describe "#render_or_call_method_or_proc_on" do
+    [ :symbol, Proc.new{} ].each do |key|
+      context "when a #{key.class}" do
+        it "should call #call_method_or_proc_on" do
+          options = { foo: :bar }
+          expect(context).to receive(:call_method_or_proc_on).with(receiver, key, options).and_return("data")
+          expect(context.render_or_call_method_or_proc_on(receiver, key, options)).to eq "data"
+        end
+      end
+    end
+
+    context "when a string" do
+      it "should return the string" do
+        expect(context.render_or_call_method_or_proc_on(receiver, "string")).to eq "string"
+      end
+    end
+  end
+
+  describe "#render_in_context" do
+    let(:args) { [1, 2, 3] }
+
+    context "when a Proc" do
+      let(:object) { Proc.new { } }
+
+      it "should instance_exec the Proc" do
+        expect(receiver).to receive(:instance_exec).with(args, &object).and_return("data")
+        expect(context.render_in_context(receiver, object, args)).to eq "data"
+      end
+    end
+
+    context "when a Symbol" do
+      it "should send the symbol" do
+        expect(receiver).to receive(:public_send).with(:symbol, args).and_return("data")
+        expect(context.render_in_context(receiver, :symbol, args)).to eq "data"
+      end
+    end
+
+    context "when a Object (not Proc or String)" do
+      let(:object) { Object.new }
+
+      it "should return the Object" do
+        expect(context.render_in_context(receiver, object)).to eq object
+      end
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-a5a53c3f2b8f/spec/unit/views/components/attributes_table_spec.rb

@@ -0,0 +1,272 @@
+require 'rails_helper'
+
+describe ActiveAdmin::Views::AttributesTable do
+
+  describe "creating with the dsl" do
+    let(:helpers) { action_view }
+
+    let(:post) do
+      post = Post.new title: "Hello World", body: nil
+      allow(post).to receive(:id){ 1 }
+      allow(post).to receive(:new_record?){ false }
+      post
+    end
+
+    let(:assigns){ { post: post } }
+
+    # Loop through a few different ways to make the same table
+    # and ensure that they produce the same results
+    {
+      "when attributes are passed in to the builder methods" => proc {
+        render_arbre_component(assigns) {
+          attributes_table_for post, :id, :title, :body
+        }
+      },
+      "when attributes are built using the block" => proc {
+        render_arbre_component(assigns) {
+          attributes_table_for post do
+            rows :id, :title, :body
+          end
+        }
+      },
+      "when each attribute is passed in by itself" => proc {
+        render_arbre_component(assigns) {
+          attributes_table_for post do
+            row :id
+            row :title
+            row :body
+          end
+        }
+      },
+      "when you create each row with a custom block" => proc {
+        render_arbre_component(assigns) {
+          attributes_table_for post do
+            row("Id")   { post.id }
+            row("Title"){ post.title }
+            row("Body") { post.body }
+          end
+        }
+      },
+      "when you create each row with a custom block that returns nil" => proc {
+        render_arbre_component(assigns) {
+          attributes_table_for post do
+            row("Id")   { text_node post.id; nil }
+            row("Title"){ text_node post.title; nil }
+            row("Body") { text_node post.body; nil }
+          end
+        }
+      },
+    }.each do |context_title, table_decleration|
+      context context_title do
+        let(:table) { instance_eval &table_decleration }
+
+        it "should render a div wrapper with the class '.attributes_table'" do
+          expect(table.tag_name).to eq 'div'
+          expect(table.attr(:class)).to include('attributes_table')
+        end
+
+        it "should add id and type class" do
+          expect(table.class_names).to include("post")
+          expect(table.id).to eq "attributes_table_post_1"
+        end
+
+        it "should render 3 rows" do
+          expect(table.find_by_tag("tr").size).to eq 3
+        end
+
+        describe "rendering the rows" do
+          [
+            ["Id" , "1"],
+            ["Title" , "Hello World"],
+            ["Body" , "<span class=\"empty\">Empty</span>"]
+          ].each_with_index do |(title, content), i|
+            describe "for #{title}" do
+              let(:current_row){ table.find_by_tag("tr")[i] }
+
+              it "should have the title '#{title}'" do
+                expect(current_row.find_by_tag("th").first.content).to eq title
+              end
+
+              it "should have the content '#{content}'" do
+                expect(current_row.find_by_tag("td").first.content.chomp.strip).to eq content
+              end
+            end
+          end
+        end # describe rendering rows
+
+      end
+    end # describe dsl styles
+
+    it "should add a class for each row based on the col name" do
+      table = render_arbre_component(assigns) {
+        attributes_table_for(post) do
+          row :title
+          row :created_at
+        end
+      }
+      expect(table.find_by_tag("tr").first.to_s.
+        split("\n").first.lstrip).
+          to eq '<tr class="row row-title">'
+
+      expect(table.find_by_tag("tr").last.to_s.
+        split("\n").first.lstrip).
+          to eq '<tr class="row row-created_at">'
+    end
+
+    it "should allow html options for the row itself" do
+      table = render_arbre_component(assigns) {
+        attributes_table_for(post) do
+          row("Wee", class: "custom_row", style: "custom_style") { }
+        end
+      }
+      expect(table.find_by_tag("tr").first.to_s.split("\n").first.lstrip).
+        to eq '<tr class="row custom_row" style="custom_style">'
+    end
+
+    it "should allow html content inside the attributes table" do
+      table = render_arbre_component(assigns) {
+        attributes_table_for(post) do
+          row("ID"){ span(post.id, class: 'id') }
+        end
+      }
+      expect(table.find_by_tag("td").first.content.chomp.strip).to eq "<span class=\"id\">1</span>"
+    end
+
+    context 'an attribute ending in _id' do
+      before do
+        post.foo_id = 23
+        post.author = User.new username: 'john_doe', first_name: 'John', last_name: 'Doe'
+      end
+      it 'should call the association if one exists' do
+        table = render_arbre_component assigns do
+          attributes_table_for post, :author_id
+        end
+        expect(table.find_by_tag('th').first.content).to eq 'Author'
+        expect(table.find_by_tag('td').first.content).to eq 'John Doe'
+      end
+      it 'should not attempt to call a nonexistant association' do
+        table = render_arbre_component assigns do
+          attributes_table_for post, :foo_id
+        end
+        expect(table.find_by_tag('th').first.content).to eq 'Foo'
+        expect(table.find_by_tag('td').first.content).to eq '23'
+      end
+    end
+
+    context "with a collection" do
+      let(:posts) do
+        [Post.new(title: "Hello World", id: 1), Post.new(title: "Multi Column", id: 2)].each_with_index do |post, index|
+          allow(post).to receive(:id).and_return(index + 1)
+          allow(post).to receive(:new_record?).and_return(false)
+        end
+      end
+
+      let(:assigns) { { posts: posts } }
+
+      let(:table) do
+        render_arbre_component(assigns) do
+          attributes_table_for posts, :id, :title
+        end
+      end
+
+      it "does not set id on the table" do
+        expect(table.attr(:id)).to be_nil
+      end
+
+      context "colgroup" do
+        let(:cols) { table.find_by_tag "col" }
+
+        it "contains a col for each record (plus headers)" do
+          expect(cols.size).to eq (2 + 1)
+        end
+
+        it "assigns an id to each col" do
+          cols[1..-1].each_with_index do |col, index|
+            expect(col.id).to eq "attributes_table_post_#{index + 1}"
+          end
+        end
+
+        it "assigns a class to each col" do
+          cols[1..-1].each_with_index do |col, index|
+            expect(col.class_names).to include("post")
+          end
+        end
+
+        it "assigns alternation classes to each col" do
+          cols[1..-1].each_with_index do |col, index|
+            expect(col.class_names).to include(["even", "odd"][index % 2])
+          end
+        end
+      end
+
+      context "when rendering the rows" do
+        it "should contain 3 columns" do
+          expect(table.find_by_tag("tr").first.children.size).to eq 3
+        end
+
+        [
+          ["Id" , "1", "2"],
+          ["Title", "Hello World", "Multi Column"],
+        ].each_with_index do |set, i|
+          describe "for #{set[0]}" do
+            let(:title){ set[0] }
+            let(:content){ set[1] }
+            let(:current_row){ table.find_by_tag("tr")[i] }
+
+            it "should have the title '#{set[0]}'" do
+              expect(current_row.find_by_tag("th").first.content).to eq title
+            end
+
+            context "with defined attribute name translation" do
+              it "should have the translated attribute name in the title" do
+                with_translation activerecord: {attributes: {post: {title: 'Translated Title', id: 'Translated Id'}}} do
+                  expect(current_row.find_by_tag("th").first.content).to eq "Translated #{title}"
+                end
+              end
+            end
+
+            set[1..-1].each_with_index do |content, index|
+              it "column #{index} should have the content '#{content}'" do
+                expect(current_row.find_by_tag("td")[index].content.chomp.strip).to eq content
+              end
+            end
+          end
+        end
+      end # describe rendering rows
+    end # with a collection
+
+
+    context "when using a single Hash" do
+      let(:table) do
+        render_arbre_component nil, helpers do
+          attributes_table_for foo: 1, bar: 2 do
+            row :foo
+            row :bar
+          end
+        end
+      end
+      it "should render" do
+        expect(table.find_by_tag("th")[0].content).to eq "Foo"
+        expect(table.find_by_tag("th")[1].content).to eq "Bar"
+        expect(table.find_by_tag("td")[0].content).to eq "1"
+        expect(table.find_by_tag("td")[1].content).to eq "2"
+      end
+    end
+
+    context "when using an Array of Hashes" do
+      let(:table) do
+        render_arbre_component nil, helpers do
+          attributes_table_for [{foo: 1},{foo: 2}] do
+            row :foo
+          end
+        end
+      end
+      it "should render" do
+        expect(table.find_by_tag("th")[0].content).to eq "Foo"
+        expect(table.find_by_tag("td")[0].content).to eq "1"
+        expect(table.find_by_tag("td")[1].content).to eq "2"
+      end
+    end
+  end
+
+end