attachy 0.1.0

data/spec/models/attachy/viewer/file_field_options_spec.rb

@@ -0,0 +1,90 @@
+require 'rails_helper'
+
+RSpec.describe Attachy::Viewer, '.file_field_options' do
+  let!(:object) { create :user }
+  let!(:method) { :avatar }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object, scope: method
+  end
+
+  subject { described_class.new method, object }
+
+  context 'when :accept has invalid mime type' do
+    context 'with one type' do
+      before do
+        allow(subject).to receive(:metadata) { { accept: :abc } }
+      end
+
+      it 'does not added as attribute' do
+        el = subject.file_field_options
+
+        expect(el).to eq(class: :attachy__fileupload)
+      end
+    end
+
+    context 'with more than one type' do
+      before do
+        allow(subject).to receive(:metadata) { { accept: [:abc, :png] } }
+      end
+
+      it 'is added as attribute only the valid one' do
+        el = subject.file_field_options
+
+        expect(el).to eq(accept: 'image/png', class: :attachy__fileupload)
+      end
+    end
+  end
+
+  context 'when :accept is a valid mime type' do
+    context 'with one type' do
+      before do
+        allow(subject).to receive(:metadata) { { accept: :jpg } }
+      end
+
+      it 'is added as attribute' do
+        el = subject.file_field_options
+
+        expect(el).to eq(accept: 'image/jpeg', class: :attachy__fileupload)
+      end
+    end
+
+    context 'with more than one type' do
+      before do
+        allow(subject).to receive(:metadata) { { accept: [:jpg, :png] } }
+      end
+
+      it 'is added as attribute' do
+        el = subject.file_field_options
+
+        expect(el).to eq(accept: 'image/jpeg,image/png', class: :attachy__fileupload)
+      end
+    end
+  end
+
+  context 'when :multiple is true' do
+    before do
+      allow(subject).to receive(:metadata) { { multiple: true } }
+    end
+
+    it 'turns the field multiple' do
+      el = subject.file_field_options
+
+      expect(el).to eq(multiple: true, class: :attachy__fileupload)
+    end
+  end
+
+  context 'when :multiple is false' do
+    before do
+      allow(subject).to receive(:metadata) { { multiple: false } }
+    end
+
+    it 'does not adds the multiple attribute' do
+      el = subject.file_field_options
+
+      expect(el).to eq(class: :attachy__fileupload)
+    end
+  end
+end

data/spec/models/attachy/viewer/file_field_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+require 'cloudinary'
+
+RSpec.describe Attachy::Viewer, '.file_field' do
+  let!(:method)  { :avatar }
+  let!(:object)  { create :user }
+  let!(:options) { {} }
+  let!(:view)    { double }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object, scope: method
+  end
+
+  before { allow(subject).to receive(:file_field_options) { { key: :value } } }
+
+  subject { described_class.new method, object, options, view }
+
+  it 'returns the hidden field with attachments value' do
+    allow(view).to receive(:cl_image_upload_tag).with(method, html: subject.file_field_options, tags: [Attachy::ENV_TAG, Attachy::TMP_TAG]) { :input }
+
+    expect(subject.file_field).to eq :input
+  end
+end

data/spec/models/attachy/viewer/hidden_field_spec.rb

@@ -0,0 +1,22 @@
+require 'rails_helper'
+
+RSpec.describe Attachy::Viewer, '.hidden_field' do
+  let!(:object) { create :user }
+  let!(:method) { :avatar }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object, scope: method
+  end
+
+  before { allow(subject).to receive(:value) { :value } }
+
+  subject { described_class.new method, object }
+
+  it 'returns the hidden field with attachments value' do
+    el = subject.hidden_field
+
+    expect(el).to have_tag :input, with: { name: 'user[avatar]', type: 'hidden', value: 'value' }
+  end
+end

data/spec/models/attachy/viewer/image_spec.rb

@@ -0,0 +1,170 @@
+require 'rails_helper'
+
+RSpec.describe Attachy::Viewer, '.image' do
+  let!(:method)       { :avatar }
+  let!(:object)       { create :user }
+  let!(:viewer)       { described_class.new method, object, options }
+  let!(:default_html) { { alt: :image, height: 50, width: 150 } }
+  let!(:default_t)    { { height: 100, width: 200 } }
+  let!(:options)      { { t: default_t, html: default_html } }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object
+  end
+
+  context 'when :html is present' do
+    let!(:html_attributes) { { alt: :alt, invalid: :invalid, height: 11, width: 22 } }
+
+    context 'and :t is blank' do
+      let!(:t_attributes) { {} }
+
+      before do
+        allow_any_instance_of(Attachy::File).to receive(:url).with(t_attributes) { 'http://example.org' }
+      end
+
+      it 'adds all attributes on image' do
+        el = viewer.image(t: t_attributes, html: html_attributes)
+
+        expect(el).to have_tag 'img', with: html_attributes
+      end
+    end
+
+    context 'and :t is present' do
+      let!(:t_attributes) { { height: 1, width: 2 } }
+
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(t_attributes) { 'http://example.org' } }
+
+      it 'gives priority to :html' do
+        el = viewer.image(t: t_attributes, html: html_attributes)
+
+        expect(el).to have_tag 'img', with: html_attributes
+      end
+    end
+
+    context 'and :t is not given' do
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(default_t) { 'http://example.org' } }
+
+      it 'uses the :html attributes and transform with default :t' do
+        el = viewer.image(html: html_attributes)
+
+        expect(el).to have_tag 'img', with: {
+          'data-crop'     => 'fill',
+          'data-format'   => file.format,
+          'data-height'   => 100,
+          'data-secure'   => true,
+          'data-sign-url' => true,
+          'data-version'  => file.version,
+          'data-width'    => 200,
+          alt:               'alt',
+          height:            11,
+          invalid:           'invalid',
+          src:               'http://example.org',
+          width:             22
+        }
+      end
+    end
+  end
+
+  context 'when :html is blank' do
+    let!(:html_attributes) { {} }
+
+    context 'and :t is blank' do
+      let!(:t_attributes) { {} }
+
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(t_attributes) { 'http://example.org' } }
+
+      it 'adds only the default transformation with file attributes' do
+        el = viewer.image(t: t_attributes, html: html_attributes)
+
+        expect(el).to have_tag 'img', with: {
+          'data-format'   => file.format,
+          'data-secure'   => true,
+          'data-sign-url' => true,
+          'data-version'  => file.version
+        }
+      end
+    end
+
+    context 'and :t is present' do
+      let!(:t_attributes) { { height: 1, width: 2 } }
+
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(t_attributes) { 'http://example.org' } }
+
+      it 'adds the :t attributes on html attributes with default data' do
+        el = viewer.image(t: t_attributes, html: html_attributes)
+
+        expect(el).to have_tag 'img', with: {
+          'data-format'    => file.format,
+          'data-public-id' => file.public_id,
+          'data-secure'    => true,
+          'data-sign-url'  => true,
+          'data-version'   => file.version,
+          height:          1,
+          width:           2
+        }
+      end
+    end
+  end
+
+  context 'when :html is not given' do
+    context 'and :t is not given' do
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(default_t) { 'http://example.org' } }
+
+      it 'uses the default :html with default :t' do
+        el = viewer.image
+
+        expect(el).to have_tag 'img', with: {
+          'alt'            => 'Example',
+          'data-crop'      => 'fill',
+          'data-format'    => file.format,
+          'data-height'    => 100,
+          'data-public-id' => file.public_id,
+          'data-secure'    => true,
+          'data-sign-url'  => true,
+          'data-version'   => file.version,
+          'data-width'     => 200,
+          'height'         => 100,
+          'src'            => 'http://example.org',
+          'width'          => 200
+        }
+      end
+    end
+
+    context 'but :t is given' do
+      let!(:t_attributes) { { height: 1, width: 2 } }
+
+      before { allow_any_instance_of(Attachy::File).to receive(:url).with(t_attributes) { 'http://example.org' } }
+
+      it 'uses the default :html with given :t overriding the default :t' do
+        el = viewer.image(t: t_attributes)
+
+        expect(el).to have_tag 'img', with: {
+          'alt'            => 'Example',
+          'data-crop'      => 'fill',
+          'data-format'    => file.format,
+          'data-height'    => 1,
+          'data-public-id' => file.public_id,
+          'data-secure'    => true,
+          'data-sign-url'  => true,
+          'data-version'   => file.version,
+          'data-width'     => 2,
+          'height'         => 1,
+          'src'            => 'http://example.org',
+          'width'          => 2
+        }
+      end
+    end
+  end
+
+  context 'when given a :file' do
+    let!(:file) { build :file, format: :png, version: 7 }
+
+    it 'is used' do
+      expect(file).to receive(:url).with(default_t) { 'http://example.org' }
+
+      viewer.image file
+    end
+  end
+end

data/spec/models/attachy/viewer/link_options_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+RSpec.describe Attachy::Viewer, '.link_options' do
+  let!(:object) { create :user }
+  let!(:method) { :avatar }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object, scope: method
+  end
+
+  subject { described_class.new method, object }
+
+  it 'returns the default link options' do
+    expect(subject.link_options).to eq(class: :attachy__link)
+  end
+end

data/spec/models/attachy/viewer/link_spec.rb

@@ -0,0 +1,131 @@
+require 'rails_helper'
+
+RSpec.describe Attachy::Viewer, '.link' do
+  let!(:method)       { :avatar }
+  let!(:object)       { create :user }
+  let!(:default_html) { { alt: :image, height: 50, width: 150 } }
+  let!(:default_t)    { { height: 100, width: 200 } }
+  let!(:options)      { { t: default_t, html: default_html } }
+
+  let!(:file) do
+    allow(Cloudinary::Uploader).to receive(:remove_tag)
+
+    create :file, attachable: object
+  end
+
+  subject { described_class.new method, object, options }
+
+  describe 'default options' do
+    before do
+      allow_any_instance_of(Attachy::File).to receive(:url).with(crop: :none) { 'http://example.org' }
+    end
+
+    it 'adds the link options' do
+      expect(subject).to receive(:image).with(file, t: default_t) { :image }
+
+      el = subject.link
+
+      expect(el).to have_tag :a, with: { class: 'attachy__link' }
+    end
+  end
+
+  context 'when :t is not given' do
+    before { allow_any_instance_of(Attachy::File).to receive(:url) { 'http://example.org' } }
+
+    it 'builds the imagem with generic transform' do
+      expect(subject).to receive(:image).with(file, t: default_t) { :image }
+
+      el = subject.link
+
+      expect(el).to have_tag :a do
+        with_text 'image'
+      end
+    end
+  end
+
+  context 'when :t is given' do
+    let!(:t) { { height: 7, width: 17 } }
+
+    before { allow_any_instance_of(Attachy::File).to receive(:url) { 'http://example.org' } }
+
+    it 'builds the imagem with given transform' do
+      expect(subject).to receive(:image).with(file, t: t) { :image }
+
+      el = subject.link(t: t)
+
+      expect(el).to have_tag :a do
+        with_text 'image'
+      end
+    end
+  end
+
+  context 'when :t is not given' do
+    before { allow_any_instance_of(Attachy::File).to receive(:url).with(crop: :none) { 'http://example.org' } }
+
+    it 'builds the link url with :crop :none' do
+      expect(subject).to receive(:image).with(file, t: default_t) { :image }
+
+      el = subject.link
+
+      expect(el).to have_tag :a, with: { href: 'http://example.org' }
+    end
+
+    it 'adds it on data attributes' do
+      expect(subject).to receive(:image).with(file, t: default_t) { :image }
+
+      el = subject.link
+
+      expect(el).to have_tag :a, with: { 'data-crop' => 'none' }
+    end
+  end
+
+  context 'when :tl is given' do
+    let!(:tl) { { height: 4, width: 8 } }
+
+    before { allow_any_instance_of(Attachy::File).to receive(:url).with(tl) { 'http://example.org' } }
+
+    it 'builds the link url with given transform' do
+      expect(subject).to receive(:image).with(file, t: default_t) { :image }
+
+      el = subject.link(tl: tl)
+
+      expect(el).to have_tag :a, with: { href: 'http://example.org' }
+    end
+  end
+
+  context 'when :html is present' do
+    let!(:html) { { invalid: :invalid, target: :blank } }
+
+    before { allow_any_instance_of(Attachy::File).to receive(:url) { 'http://example.org' } }
+
+    it 'is added to html attributes' do
+      allow(subject).to receive(:image) { :image }
+
+      el = subject.link(html: html)
+
+      expect(el).to have_tag 'a', with: { invalid: 'invalid', target: 'blank' }
+    end
+  end
+
+  context 'when given a :file' do
+    let!(:file) { build :file }
+
+    it 'is used' do
+      expect(file).to receive(:url).twice { 'http://example.org' }
+
+      subject.link file
+    end
+  end
+
+  context 'when a block is given' do
+    let!(:html) { { target: :blank } }
+    let!(:tl)   { { width: 10 } }
+
+    it 'yields the :html and :attachments' do
+      subject.link(tl: tl, html: html) do |htm, attachments|
+        expect(attachments).to eq [file]
+        expect(htm).to         eq(data: { width: 10 }, target: :blank, class: :attachy__link)
+      end
+    end
+  end
+end