rom-files 0.2.0

data/spec/lib/rom/files/dataset/sort_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rom/files/dataset'
+require 'shared/rom/files/media_dataset'
+
+RSpec.describe ROM::Files::Dataset, '#sort' do
+  include_context 'media dataset'
+
+  its(:sorting) { is_expected.to eq nil }
+
+  context '()' do
+    subject { dataset.sort }
+
+    its(:sorting) { is_expected.to eq :to_s }
+  end
+
+  context '(method)' do
+    subject { dataset.sort(:basename) }
+
+    its(:sorting) { is_expected.to eq :basename }
+  end
+end

data/spec/lib/rom/files/dataset_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rom/files/dataset'
+require 'rom/lint/spec'
+require 'shared/rom/files/media_files'
+
+RSpec.describe ROM::Files::Dataset do
+  include_context 'media files'
+
+  subject(:dataset) { connection.create_dataset(dir) }
+  let(:connection) { ROM::Files::Connection.new(uri) }
+
+  it_behaves_like "a rom enumerable dataset"
+
+  its(:path) { is_expected.to eq uri }
+  its(:mime_type) { is_expected.to eq nil }
+  its(:inside_paths) { is_expected.to eq [Pathname(dir)] }
+  its(:include_patterns) { is_expected.to eq %w[*] }
+  its(:exclude_patterns) { is_expected.to eq [] }
+  its(:sorting) { is_expected.to eq nil }
+  its(:row_proc) { is_expected.to be_a Proc }
+  its(:count) { is_expected.to eq 3 }
+  its(:each) { is_expected.to be_a Enumerator }
+
+  describe '#with' do
+    subject(:new_dataset) { dataset.with(options) }
+    let(:options) { {} }
+
+    context '(path:)' do
+      let(:options) { Hash[path: Pathname.pwd] }
+      its(:path) { is_expected.to eq Pathname.pwd }
+    end
+  end
+
+  context '#at' do
+    subject(:new_dataset) { dataset.at('~') }
+
+    its(:path) { is_expected.to eq Pathname('~') }
+  end
+
+  context '#up' do
+    subject(:new_dataset) { dataset.up }
+
+    its(:path) { is_expected.to eq uri.join('..') }
+  end
+
+  context '#dig' do
+    subject(:new_dataset) { dataset.up.dig(dir) }
+
+    its(:path) { is_expected.to eq uri.join('../media') }
+  end
+end

data/spec/lib/rom/files/extensions/text/attributes_inferrer_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rom/files/extensions/text/attributes_inferrer'
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Extensions::Text::AttributesInferrer do
+  include_context 'media files'
+
+  subject(:inferrer) { described_class.new(attr_class: attr_class) }
+  let(:attr_class) { ROM::Files::Attribute }
+
+  its(:attr_class) { is_expected.to eq attr_class }
+
+  describe '#call' do
+    subject(:result) { inferrer.(schema, gateway) }
+    let(:relation_name) { ROM::Relation::Name.new(:text, 'text/plain') }
+    let(:schema) { ROM::Files::Schema.new(relation_name) }
+
+    it { is_expected.to be_a Array }
+    its(:size) { is_expected.to eq 2 }
+
+    describe 'inferred' do
+      subject(:inferred) { result.first }
+
+      it { is_expected.to be_a Array }
+      its(:size) { is_expected.to eq 2 }
+
+      describe '__FILE__' do
+        subject(:attribute) { inferred.first }
+
+        it { is_expected.to be_a attr_class }
+        its(:name) { is_expected.to eq ROM::Files::ID }
+        its(:primitive) { is_expected.to eq Pathname }
+        its(:primary_key?) { is_expected.to be true }
+      end
+
+      describe 'DATA' do
+        subject(:attribute) { inferred[1] }
+
+        it { is_expected.to be_a attr_class }
+        its(:name) { is_expected.to eq :DATA }
+        its(:primitive) { is_expected.to eq String }
+        its(:primary_key?) { is_expected.to be false }
+      end
+    end
+
+    describe 'missing' do
+      subject(:missing) { result.last }
+
+      it { is_expected.to be_a Array }
+      its(:size) { is_expected.to eq 0 }
+    end
+  end
+end

data/spec/lib/rom/files/gateway_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rom/lint/spec'
+require 'rom/files/gateway'
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Gateway do
+  include_context 'media relation'
+
+  subject(:gateway_instance) { ROM::Gateway.setup(identifier, uri) }
+  let(:gateway) { described_class }
+  let(:identifier) { :files }
+
+  it_behaves_like "a rom gateway"
+
+  describe '#use_logger' do
+    let(:logger) { Logger.new(STDOUT) }
+    it 'sets logger' do
+      gateway_instance.use_logger(logger)
+      expect(gateway_instance.logger).to eq logger
+    end
+  end
+
+  describe '#dataset?' do
+    subject { gateway_instance.dataset?(relation) }
+
+    context 'with existing relation' do
+      let(:relation) { :media }
+
+      it { is_expected.to be true }
+    end
+
+    context 'with non-existing relation' do
+      let(:relation) { :not_here }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/lib/rom/files/plugins/schema/contents_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Plugins::Schema::Contents do
+  include_context 'media relation'
+
+  subject(:schema) { schema_dsl.() }
+  let(:relation) { ROM::Relation::Name[:media] }
+  let(:schema_dsl) do
+    ROM::Schema::DSL.new(relation, adapter: :files)
+  end
+
+  # @param name [Symbol]
+  # @param type [Dry::Types::Definition]
+  # @return [ROM::Attribute]
+  def build_attribute(name = :DATA, type: ROM::Types::String)
+    ROM::Attribute.new(
+      type.meta(name: name, source: relation, DATA: true)
+    )
+  end
+
+  describe '.apply' do
+    let(:type) { ROM::Types::Date }
+
+    context 'use :contents' do
+      before { schema_dsl.use :contents }
+      its([:DATA]) { is_expected.to eql build_attribute }
+
+      context 'contents(name)' do
+        before { schema_dsl.contents :custom }
+        its([:custom]) { is_expected.to eql build_attribute(:custom) }
+      end
+
+      context 'contents(name, type)' do
+        before { schema_dsl.contents :custom, type }
+        its([:custom]) { is_expected.to eql build_attribute(:custom, type: type) }
+      end
+
+      context 'contents(name, type:)' do
+        before { schema_dsl.contents :custom, type: type }
+        its([:custom]) { is_expected.to eql build_attribute(:custom, type: type) }
+      end
+
+      context 'contents(type:)' do
+        before { schema_dsl.contents type: type }
+        its([:DATA]) { is_expected.to eql build_attribute(type: type) }
+      end
+    end
+
+    context 'use :contents, name:' do
+      before { schema_dsl.use :contents, name: :contents }
+      its([:contents]) { is_expected.to eql build_attribute :contents }
+    end
+
+    context 'use :contents, type:' do
+      before { schema_dsl.use :contents, type: type }
+      its([:DATA]) { is_expected.to eql build_attribute type: type }
+    end
+
+    context 'use :contents, name:, type:' do
+      before { schema_dsl.use :contents, name: :contents, type: type }
+      its([:contents]) { is_expected.to eql build_attribute :contents, type: type }
+    end
+  end
+end

data/spec/lib/rom/files/plugins/schema/mime_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Plugins::Schema::Mime do
+  include_context 'media relation'
+
+  subject(:schema) { schema_dsl.() }
+  let(:relation) { ROM::Relation::Name[:media] }
+  let(:schema_dsl) do
+    ROM::Schema::DSL.new(relation, adapter: :files)
+  end
+
+  # @param name [Symbol]
+  # @param type [Dry::Types::Definition]
+  # @return [ROM::Attribute]
+  def build_attribute(name = :mime_type, type: ROM::Files::Types::MimeType.optional)
+    ROM::Attribute.new(
+      type.meta(name: name, source: relation, __proc__: described_class::PROC)
+    )
+  end
+
+  describe '.apply' do
+    let(:type) { ROM::Types::Date }
+
+    context 'use :mime' do
+      before { schema_dsl.use :mime }
+      its([:mime_type]) { is_expected.to eql build_attribute }
+
+      context 'mime(name)' do
+        before { schema_dsl.mime :custom }
+        its([:custom]) { is_expected.to eql build_attribute(:custom) }
+      end
+
+      context 'mime(name, type)' do
+        before { schema_dsl.mime :custom, type }
+        its([:custom]) { is_expected.to eql build_attribute(:custom, type: type) }
+      end
+
+      context 'mime(name, type:)' do
+        before { schema_dsl.mime :custom, type: type }
+        its([:custom]) { is_expected.to eql build_attribute(:custom, type: type) }
+      end
+
+      context 'mime(type:)' do
+        before { schema_dsl.mime type: type }
+        its([:mime_type]) { is_expected.to eql build_attribute(type: type) }
+      end
+    end
+
+    context 'use :mime, name:' do
+      before { schema_dsl.use :mime, name: :mime }
+      its([:mime]) { is_expected.to eql build_attribute :mime }
+    end
+
+    context 'use :mime, type:' do
+      before { schema_dsl.use :mime, type: type }
+      its([:mime_type]) { is_expected.to eql build_attribute type: type }
+    end
+
+    context 'use :mime, name:, type:' do
+      before { schema_dsl.use :mime, name: :mime, type: type }
+      its([:mime]) { is_expected.to eql build_attribute :mime, type: type }
+    end
+  end
+end

data/spec/lib/rom/files/plugins/schema/stat_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Plugins::Schema::Stat do
+  FIELD = ROM::Files::Plugins::Schema::Stat::NAME
+
+  include_context 'media relation'
+
+  subject(:schema) { schema_dsl.() }
+  let(:relation_name) { ROM::Relation::Name[:media] }
+  let(:schema_dsl) do
+    ROM::Schema::DSL.new(relation_name, adapter: :files)
+  end
+
+  # @param name [Symbol]
+  # @param type [Dry::Types::Definition]
+  # @param stat [Symbol]
+  # @return [ROM::Attribute]
+  def build_attribute(name = FIELD,
+                      type: ROM::Files::Types::FileStat,
+                      stat: (name == FIELD) || name)
+    ROM::Attribute.new(
+      type.meta(name: name, source: relation_name, __stat__: stat)
+    )
+  end
+
+  describe '.apply' do
+    context 'use :stat' do
+      before { schema_dsl.use :stat }
+
+      its([:stat]) { is_expected.to eql build_attribute }
+
+      context 'stat :stat' do
+        before { schema_dsl.stat :stat }
+
+        its([:stat]) { is_expected.to eql build_attribute(:stat) }
+      end
+
+      context 'stat stats:' do
+        before { schema_dsl.stat stats: %i[atime] }
+
+        its('to_h.keys') { is_expected.to eql %i[stat atime] }
+        its([:stat]) { is_expected.to eql build_attribute }
+        its([:atime]) { is_expected.to eql build_attribute(:atime, type: ROM::Files::Types::Time) }
+      end
+
+      context 'stat false, stats:' do
+        before { schema_dsl.stat false, stats: %i[atime] }
+
+        its('to_h.keys') { is_expected.to eql %i[atime] }
+        its([:atime]) { is_expected.to eql build_attribute(:atime, type: ROM::Files::Types::Time) }
+      end
+
+      context 'stat stats: [aliased]' do
+        before { schema_dsl.stat stats: %i[created_at] }
+
+        its('to_h.keys') { is_expected.to eql %i[stat created_at] }
+        its([:stat]) { is_expected.to eql build_attribute }
+        its([:created_at]) { is_expected.to eql build_attribute(:created_at, type: ROM::Files::Types::Time, stat: :birthtime) }
+      end
+
+      context 'stat aliases:' do
+        before { schema_dsl.stat aliases: { modified_at: :mtime } }
+
+        its('to_h.keys') { is_expected.to eql %i[stat modified_at] }
+        its([:stat]) { is_expected.to eql build_attribute }
+        its([:modified_at]) { is_expected.to eql build_attribute(:modified_at, type: ROM::Files::Types::Time, stat: :mtime) }
+      end
+    end
+
+    context 'use :stat, name:' do
+      before { schema_dsl.use :stat, name: :stat }
+
+      its([:stat]) { is_expected.to eql build_attribute(:stat) }
+    end
+
+    context 'use :stat, stats:' do
+      before { schema_dsl.use :stat, stats: %i[atime] }
+
+      its('to_h.keys') { is_expected.to eql %i[stat atime] }
+      its([:stat]) { is_expected.to eql build_attribute }
+      its([:atime]) { is_expected.to eql build_attribute(:atime, type: ROM::Files::Types::Time) }
+    end
+
+    context 'use :stat, name: false, stats:' do
+      before { schema_dsl.use :stat, name: false, stats: %i[atime] }
+
+      its('to_h.keys') { is_expected.to eql %i[atime] }
+      its([:atime]) { is_expected.to eql build_attribute(:atime, type: ROM::Files::Types::Time) }
+    end
+
+    context 'use :stat, stats: [aliased]' do
+      before { schema_dsl.use :stat, stats: %i[created_at] }
+
+      its('to_h.keys') { is_expected.to eql %i[stat created_at] }
+      its([:stat]) { is_expected.to eql build_attribute }
+      its([:created_at]) { is_expected.to eql build_attribute(:created_at, type: ROM::Files::Types::Time, stat: :birthtime) }
+    end
+
+    context 'use :stat, aliases:' do
+      before { schema_dsl.use :stat, aliases: { modified_at: :mtime } }
+
+      its('to_h.keys') { is_expected.to eql %i[stat modified_at] }
+      its([:stat]) { is_expected.to eql build_attribute }
+      its([:modified_at]) { is_expected.to eql build_attribute(:modified_at, type: ROM::Files::Types::Time, stat: :mtime) }
+    end
+  end
+end

data/spec/lib/rom/files/relation/pluck_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rom/files/relation'
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Relation, '#pluck' do
+  include_context 'media relation'
+
+  context 'with method name' do
+    subject { relation.pluck(:basename) }
+
+    it { is_expected.to eql([Pathname('some_image.png'), Pathname('some_file.txt'), Pathname('some_markdown.md')]) }
+  end
+
+  context 'with block' do
+    subject { relation.pluck { |path| path.basename.to_s } }
+
+    it { is_expected.to eql %w[some_image.png some_file.txt some_markdown.md] }
+  end
+end

data/spec/lib/rom/files/relation/reject_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rom/files/relation'
+require 'shared/rom/files/media_relation'
+
+RSpec.describe ROM::Files::Relation, '#reject' do
+  include_context 'media relation'
+
+  subject(:names) { relation.pluck(:basename) }
+
+  context '(list, of, patterns)' do
+    let(:relation) { super().reject('*.txt', '*.md') }
+
+    it { is_expected.to eql [P('some_image.png')] }
+  end
+
+  context '(glob_expression)' do
+    let(:relation) { super().reject('*.{txt,md}') }
+
+    it { is_expected.to eql [P('some_image.png')] }
+  end
+end