rom-files 0.2.0

data/lib/rom/files/relation.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'rom/relation'
+require_relative 'attribute'
+require_relative 'schema'
+require_relative 'schema/inferrer'
+
+module ROM
+  module Files
+    class Relation < ROM::Relation
+      extend Forwardable
+      include Enumerable
+      include Files
+
+      adapter :files
+      schema_attr_class Files::Attribute
+      schema_class Files::Schema
+      schema_inferrer Files::Schema::Inferrer.new.freeze
+
+      def initialize(*) # :nodoc:
+        super
+        @dataset = @dataset.with(row_proc: schema.row_proc) if schema
+      end
+
+      # @!attribute [r] dataset
+      #   @return [Files::Dataset]
+      # @!attribute [r] schema
+      #   @return [Files::Schema]
+
+      # @!group Reading
+
+      # @!method select(*patterns)
+      #   @param (see Dataset#select)
+      #   @return [Relation]
+      #
+      # @!method select_append(*patterns)
+      #   @param (see Dataset#select_append)
+      #   @return [Relation]
+      #
+      # @!method inside(*prefixes)
+      #   @param (see Dataset#inside)
+      #   @return [Relation]
+      #
+      # @!method recursive
+      #   @return [Relation]
+      #
+      # @!method reject(*patterns)
+      #   @param (see Dataset#reject)
+      #   @return [Relation]
+      #
+      # @!method reject_append(*patterns)
+      #   @param (see Dataset#reject_append)
+      #   @return [Relation]
+      #
+      # @!method sort(sorting = :to_s)
+      #   @param (see Dataset#sort)
+      #   @return [Relation]
+      #
+      # @!method restrict(criteria = nil)
+      #   @param (see Dataset#restrict)
+      #   @return [Relation]
+      #
+      # @!method join(*args)
+      #   @param (see Dataset#join)
+      #   @return [Relation]
+      forward :select, :select_append, :reject, :reject_append,
+              :inside, :recursive, :sort, :restrict, :join
+
+      # @!method mime_type
+      #   @return [MIME::Type, nil]
+      #
+      #   @see Dataset#mime_type
+      #
+      # @!method pluck
+      #   @return [Array]
+      #
+      #   @see Dataset#pluck
+      #
+      # @!method recursive?
+      #   @return [Boolean]
+      #
+      #   @see Dataset#recursive?
+      def_instance_delegators :dataset, :mime_type, :recursive?, :pluck
+
+      # Project a relation with provided attribute names
+      #
+      # @param names [Array<Symbol>] A list with attribute names
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def project(*names)
+        schema.project(*names).(self)
+      end
+
+      # Return relation count
+      #
+      # @example
+      #   users.count
+      #   # => 12
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def count
+        dataset.count
+      end
+
+      # @!group Writing
+
+      def create(tuple)
+        dataset.write(
+          identify(tuple),
+          contents_for(tuple)
+        )
+      end
+      alias << create
+
+      def update(tuple, attributes = {})
+        dataset.write(
+          identify(tuple),
+          contents_for(tuple.merge(attributes))
+        )
+      end
+
+      def delete(tuple)
+        dataset.delete(identify(tuple))
+      end
+
+      # @!method identify(tuple)
+      #   @param (see Schema#identify)
+      #   @return (see Schema#identify)
+      #   @see Schema#identify
+      #
+      # @!method contents_for(tuple)
+      #   @param (see Schema#contents_for)
+      #   @return (see Schema#contents_for)
+      #   @see Schema#contents_for
+      def_instance_delegators :schema, :identify, :contents_for
+    end
+  end
+end

data/lib/rom/files/schema.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rom/schema'
+require_relative 'types'
+require_relative 'associations'
+
+module ROM
+  module Files
+    # Specialized schema for files adapter
+    #
+    # @api public
+    class Schema < ROM::Schema
+      # Abstract method for creating a new relation based on schema definition
+      #
+      # This can be used by views to generate a new relation automatically.
+      # In example a schema can project a relation, join any additional relations
+      # if it include_patterns attributes from other relations etc.
+      #
+      # Default implementation is a no-op and it simply returns back untouched relation
+      #
+      # @param [Relation] relation
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def call(relation)
+        relation.new(relation.dataset.with(row_proc: row_proc), schema: self)
+      end
+
+      # @return [Method, Proc]
+      def row_proc
+        method(:load_attributes)
+      end
+
+      # @param pathname [Pathname]
+      # @return [Hash{Symbol => Object}]
+      def load_attributes(pathname)
+        attributes.each_with_object({}) do |attribute, result|
+          result[attribute.name] = attribute.(pathname)
+          result
+        end
+      end
+
+      # @param tuple [Hash]
+      # @return [Pathname]
+      def identify(tuple)
+        path = (primary_key_names || [ID]).map do |name|
+          tuple[name]
+        end.compact
+        return unless path.any?
+        Pathname(path.shift).join(*path)
+      end
+
+      # @param tuple [Hash]
+      # @return [String]
+      def contents_for(tuple)
+        contents = attributes.each_with_object([]) do |attr, result|
+          result << tuple[attr.name] if attr.meta[DATA]
+        end.compact
+        contents.join if contents.any?
+      end
+
+      # Internal hook used during setup process
+      #
+      # @see Schema#finalize_associations!
+      #
+      # @api private
+      def finalize_associations!(relations:)
+        super do
+          associations.map do |definition|
+            Files::Associations.const_get(definition.type).new(definition, relations)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/schema/attributes_inferrer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'dry/core/class_attributes'
+require 'rom/files/constants'
+require 'rom/files/attribute'
+require 'mime/types/full'
+
+module ROM
+  module Files
+    class Schema < ROM::Schema
+      # @api private
+      class AttributesInferrer
+        extend Dry::Core::ClassAttributes
+        extend Initializer
+
+        KNOWN_COLUMNS = [ID].freeze
+
+        # @!method self.registry
+        #   @return [Hash{String => AttributesInferrer}]
+        defines :registry, :attr_class
+        registry Hash.new(new.freeze)
+        attr_class Files::Attribute
+
+        # @param type [String]
+        # @param inferrer [AttributesInferrer]
+        # @return [AttributesInferrer]
+        def self.register(type, inferrer)
+          registry[type] = inferrer
+        end
+
+        def self.registered?(type)
+          registry.key?(type)
+        end
+
+        # @param mime_type [String]
+        # @return [AttributesInferrer]
+        def self.[](mime_type)
+          registry[mime_type]
+        end
+
+        # @!attribute [r] attr_class
+        #   @return [Class(Files::Attribute)]
+        option :attr_class, default: -> { self.class.attr_class }
+
+        # @param schema [ROM::Files::Schema]
+        # @param gateway [ROM::Files::Gateway]
+        #
+        # @api private
+        def call(schema, gateway)
+          inferred = infer_attributes(schema, gateway)
+
+          missing = columns - inferred.map { |attr| attr.meta[:name] }
+
+          [inferred, missing]
+        end
+
+        undef :with
+
+        # @return [Files::Attribute]
+        def build(type, name, schema)
+          attr_class.new(type.meta(name: name, source: schema.name))
+        end
+
+        # @return [Array<Symbol>]
+        def columns
+          KNOWN_COLUMNS
+        end
+
+        def with(new_options)
+          self.class.new(options.merge(new_options))
+        end
+
+        def infer_attributes(schema, _gateway)
+          [build(Types::Path, ID, schema)]
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/schema/inferrer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rom/schema'
+require 'rom/schema/inferrer'
+require_relative '../attribute'
+require_relative 'attributes_inferrer'
+
+module ROM
+  module Files
+    class Schema < ROM::Schema
+      class Inferrer < ROM::Schema::Inferrer
+        # @!attribute [r] attributes_inferrer
+        #   @return [Array(Array, Array)]
+        attributes_inferrer ->(schema, gateway, options) do
+          dataset = gateway.dataset(schema.name.dataset)
+          inferrer = if dataset.mime_type
+                       if AttributesInferrer.registered?(content_type = dataset.mime_type.content_type)
+                         AttributesInferrer[content_type].with(options)
+                       elsif AttributesInferrer.registered?(media_type = dataset.mime_type.media_type)
+                         AttributesInferrer[media_type].with(options)
+                       else
+                         AttributesInferrer.new(**options)
+                       end
+                     else
+                       AttributesInferrer.new(**options)
+                     end
+          inferrer.(schema, gateway)
+        end
+
+        # @!attribute [r] attr_class
+        #   @return [Class]
+        attr_class Files::Attribute
+      end
+    end
+  end
+end

data/lib/rom/files/types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'dry/types/pathname'
+require 'rom/types'
+require 'mime/types'
+
+module ROM
+  module Files
+    module Types
+      include ROM::Types
+
+      Path = Types::Pathname.meta(primary_key: true)
+
+      FileStat = Dry::Types::Definition[File::Stat].new(File::Stat)
+      FileType = Coercible::String.enum('file', 'directory', 'characterSpecial',
+                                        'blockSpecial', 'fifo', 'link', 'socket', 'unknown')
+      MimeType = Dry::Types::Definition[MIME::Type].new(MIME::Type).optional.constructor do |type|
+        MIME::Types[type].first
+      end
+
+      # Define a foreign key attribute type
+      #
+      # @example with default type
+      #   attribute :spec_file, Types.ForeignKey(:spec_files)
+      #
+      # @example with a custom path map
+      #   attribute :spec_file, Types.ForeignKey(:spec_files, key: ->(path) { path.pathmap('spec/%X_spec.rb') })
+      #
+      # @return [Dry::Types::Definition]
+      #
+      # @api public
+      def self.ForeignKey(relation, type = Types::Pathname, map: ->(pathname) { pathname })
+        super(relation, type.meta(__proc__: map))
+      end
+    end
+  end
+end

data/lib/rom/files/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ROM
+  module Files
+    VERSION = '0.2.0'
+  end
+end

data/rom-files.gemspec

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rom/files/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rom-files'
+  spec.version = ROM::Files::VERSION
+  spec.authors = ['Alex Semyonov', 'Héctor Ramón']
+  spec.email = %w[alex@cerebelo.info hector0193@gmail.com]
+
+  spec.summary = 'Files adapter for ROM'
+  spec.description = spec.summary
+  spec.homepage = 'https://github.com/alsemyonov/rom-files'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'mime-types', '~> 3.1'
+  spec.add_runtime_dependency 'rom', '~> 4.1'
+
+  # Extensions
+  spec.add_development_dependency 'kramdown'
+  spec.add_development_dependency 'parser'
+  spec.add_development_dependency 'xdg'
+
+  # Dependencies
+  spec.add_development_dependency 'bundler'
+
+  # Pipeline
+  spec.add_development_dependency 'rake', '~> 12.2'
+
+  # Testing
+  spec.add_development_dependency 'rspec', '~> 3.7'
+  spec.add_development_dependency 'rspec-its'
+  spec.add_development_dependency 'rubocop', '~> 0.51'
+  spec.add_development_dependency 'simplecov', '~> 0.15'
+
+  # Documentation
+  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'yard-junk'
+  spec.add_development_dependency 'yardcheck'
+end

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

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rom-files'
+require 'rspec'
+
+RSpec.describe ROM::Files::Gateway, 'usage' do
+  subject(:gateway) { ROM::Files::Gateway.new(uri) }
+  let(:uri) { SPEC_ROOT.dirname }
+
+  example 'Obtaining datasets', :aggregate_failures do
+    lib = gateway.dataset(:lib).recursive
+
+    expect(lib).to be_a ROM::Files::Dataset
+    expect(gateway.dataset?(:lib)).to be true
+
+    puts "Library files:\n", lib.pluck(&:to_s)
+
+    spec = gateway.dataset(:spec).recursive
+
+    expect(spec).to be_a ROM::Files::Dataset
+    expect(gateway.dataset?(:spec)).to be true
+
+    p "Specifications:\n", spec.pluck(&:to_s)
+  end
+end
+
+require 'rspec/autorun' if $PROGRAM_NAME == __FILE__