rom-files 0.2.0

data/lib/rom/files/associations.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'associations/many_to_many'
+require_relative 'associations/many_to_one'
+require_relative 'associations/one_to_many'
+require_relative 'associations/one_to_one'

data/lib/rom/files/associations/many_to_many.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rom/associations/many_to_many'
+
+module ROM
+  module Files
+    module Associations
+      class ManyToMany < ROM::Associations::ManyToMany
+      end
+    end
+  end
+end

data/lib/rom/files/associations/many_to_one.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rom/associations/many_to_one'
+
+module ROM
+  module Files
+    module Associations
+      class ManyToOne < ROM::Associations::ManyToOne
+      end
+    end
+  end
+end

data/lib/rom/files/associations/one_to_many.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rom/associations/one_to_many'
+
+module ROM
+  module Files
+    module Associations
+      class OneToMany < ROM::Associations::OneToMany
+      end
+    end
+  end
+end

data/lib/rom/files/associations/one_to_one.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rom/memory/associations/one_to_many'
+
+module ROM
+  module Files
+    module Associations
+      class OneToOne < OneToMany
+      end
+    end
+  end
+end

data/lib/rom/files/attribute.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'rom/attribute'
+require_relative 'constants'
+
+module ROM
+  module Files
+    class Attribute < ROM::Attribute
+      # @param [Pathname] pathname
+      # @return [Object]
+      def call(pathname)
+        return type[pathname.read] if meta[Files::DATA]
+        return type[pathname.stat] if meta[:__stat__].is_a?(TrueClass)
+        return type[pathname.stat.send(meta[:__stat__])] if meta[:__stat__]
+        return type[meta[:__proc__].(pathname)] if meta[:__proc__]
+        type[pathname]
+      end
+    end
+  end
+end

data/lib/rom/files/commands/create.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rom/commands/create'
+
+module ROM
+  module Files
+    module Commands
+      class Create < ROM::Commands::Create
+        adapter :files
+
+        # @param tuples [Array<Hash>]
+        def execute(tuples)
+          tuples.each { |tuple| relation << tuple }
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/commands/delete.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rom/commands/delete'
+
+module ROM
+  module Files
+    module Commands
+      class Delete < ROM::Commands::Delete
+        adapter :files
+
+        def execute
+          relation.each { |tuple| source.delete(tuple) }
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/commands/update.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rom/commands/update'
+
+module ROM
+  module Files
+    module Commands
+      class Update < ROM::Commands::Update
+        adapter :files
+
+        def execute(attributes)
+          relation.each { |tuple| source.update(tuple, attributes) }
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/connection.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'concurrent/hash'
+require 'mime/types/full'
+require_relative 'dataset'
+
+module ROM
+  module Files
+    class Connection
+      extend Forwardable
+
+      # @param path [Pathname, #to_s]
+      def initialize(path = Pathname.pwd)
+        @path = Pathname(path).expand_path
+        @data = Concurrent::Hash.new
+      end
+
+      # @return [Pathname]
+      attr_reader :path
+
+      # Dataset registry
+      #
+      # @return [Concurrent::Hash]
+      #
+      # @api private
+      attr_reader :data
+
+      # @!method []
+      #   @return [Dataset]
+      #
+      #   @api private
+      #
+      # @!method size
+      #   Return registered datasets count
+      #
+      #   @return [Integer]
+      #
+      #   @api private
+      def_instance_delegators :data, :[], :size
+
+      # @param name [String, Symbol]
+      # @return [Dataset]
+      def create_dataset(name)
+        mime_type = MIME::Types[name].first
+        @data[name] = if mime_type
+                        build_dataset(mime_type: mime_type)
+                      else
+                        build_dataset(inside_paths: [name])
+                      end
+      end
+
+      def build_dataset(options)
+        Dataset.new([], options.merge(connection: self))
+      end
+
+      # @return [Boolean]
+      def key?(name)
+        MIME::Types[name].any? || path_for(name).exist?
+      end
+
+      # @param patterns [Array<String>]
+      # @param path [Pathname]
+      # @param exclude_patterns [Array<String>]
+      # @param sorting [#to_proc, nil]
+      # @param directories [Boolean]
+      # @return [Array<Pathname>]
+      def search(patterns, path: self.path, exclude_patterns: EMPTY_ARRAY, sorting: nil, directories: false)
+        files = patterns.inject([]) do |result, pattern|
+          result + Pathname.glob(path_for(pattern, path: path)).map { |found| found.relative_path_from(path) }
+        end
+        files = files.reject(&:directory?) unless directories
+        files = files.reject do |match|
+          exclude_patterns.any? do |pattern|
+            match.fnmatch(pattern, File::FNM_EXTGLOB)
+          end
+        end
+        files = files.sort_by(&sorting) if sorting
+        files
+      end
+
+      # @param id [Pathname, #to_s]
+      # @return [String]
+      def read(id)
+        path_for(id).read
+      end
+
+      # @param id [Pathname, #to_s]
+      # @param contents [String, #to_s]
+      # @return [String]
+      def write(id, contents)
+        path_for(id).write(contents.to_s)
+      end
+
+      # @param id [Pathname, #to_s]
+      # @return [String]
+      def binread(id)
+        path_for(id).binread
+      end
+
+      # @param id [Pathname, #to_s]
+      # @param contents [String, #to_s]
+      # @return [String]
+      def binwrite(id, contents)
+        path_for(id).binwrite(contents)
+      end
+
+      # @param id [Pathname, #to_s]
+      def delete(id)
+        path_for(id).delete
+      end
+
+      private
+
+      # @return [Pathname]
+      def path_for(name, path: self.path)
+        path.join(name.to_s)
+      end
+    end
+  end
+end

data/lib/rom/files/constants.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dry/core/constants'
+
+module ROM
+  module Files
+    include Dry::Core::Constants
+
+    ID = :__FILE__
+    DATA = :DATA
+    HERE = %w[.].freeze
+    ALL = %w[*].freeze
+    RECURSIVE_PATTERN = '**'
+    RECURSIVE_EXPRESSION = /#{Regexp.escape(RECURSIVE_PATTERN)}/
+  end
+end

data/lib/rom/files/dataset.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'rom/initializer'
+require 'rom/support/memoizable'
+require 'rom/memory/dataset'
+
+require_relative 'connection'
+require_relative 'constants'
+require_relative 'types'
+
+require_relative 'dataset/filtering'
+require_relative 'dataset/mime_type'
+require_relative 'dataset/paths'
+require_relative 'dataset/sorting'
+
+module ROM
+  module Files
+    class Dataset < Memory::Dataset
+      extend Forwardable
+
+      include Dry::Equalizer(:mime_type, :inside_paths, :include_patterns, :exclude_patterns, :sorting)
+      include Filtering
+      include MimeType
+      include Paths
+      include Sorting
+
+      # @!method initialize(mime_type: nil, inside_paths: ['.'], include_patterns: ['*'], exclude_patterns: [], sorting: nil)
+      #   @param inside_paths [Pathname, #to_s]
+      #     list of directories to search files in
+      #   @param include_patterns [Array<String, #to_s>]
+      #     array of patterns to be selected inside `path`, maps to {#include_patterns}
+      #   @param exclude_patterns [Array<String, #to_s>]
+      #     array of patterns to be rejected inside `path`, maps to {#exclude_patterns}
+      #   @param sorting [Symbol, Proc, nil]
+      #     see {#sorting}
+
+      # @!attribute [r] connection
+      #   @return [Connection]
+      option :connection, default: proc { Connection.new }
+
+      # @!attribute [r] path
+      #   @return [Connection]
+      option :path, Types::Coercible::Pathname, default: proc { connection.path }
+
+      def at(path)
+        with(path: Pathname(path))
+      end
+
+      def dig(path)
+        with(path: self.path.join(path))
+      end
+
+      def up(level = 1)
+        path = self.path
+        level.times { path = path.dirname }
+        with(path: path)
+      end
+
+      # @!method project(*names)
+      # Project a dataset
+      #
+      # @param names [Array<Symbol>] A list of attribute names
+      #
+      # @return [Dataset]
+      #
+      # @api public
+
+      # @!method join(*args)
+      #
+      # Join with other datasets
+      #
+      # @param args [Array<Dataset>] A list of dataset to join with
+      #
+      # @return [Dataset]
+      #
+      # @api public
+
+      # @!method restrict(criteria = nil)
+      # Restrict a dataset
+      #
+      # @param criteria [Hash] A hash with conditions
+      #
+      # @return [Dataset]
+      #
+      # @api public
+    end
+  end
+end

data/lib/rom/files/dataset/filtering.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rom/memory/dataset'
+
+module ROM
+  module Files
+    class Dataset < Memory::Dataset
+      module Filtering
+        def self.included(other)
+          super(other)
+          other.module_eval do
+            option :inside_paths, Types::Strict::Array.of(Types::Coercible::Pathname), default: proc { HERE }
+            option :include_patterns, Types::Strict::Array.of(Types::Coercible::String), default: proc { ALL }
+            option :exclude_patterns, Types::Strict::Array.of(Types::Coercible::String), default: proc { EMPTY_ARRAY }
+            option :search_recursive, Types::Bool, default: proc { true }
+          end
+        end
+
+        # @!group Reading
+
+        # @!attribute [r] inside_paths
+        #   Array of glob patterns to select files inside
+        #   @return [Array<String>]
+
+        # @!attribute [r] include_patterns
+        #   Array of glob patterns to be selected inside {#inside_paths}
+        #   @return [Array<String>]
+
+        # @!attribute [r] exclude_patterns
+        #   Array of filename patterns to be rejected
+        #   @return [Array<String>]
+
+        # @!attribute [r] search_recursive
+        #   Whether to search for files only in specific directory/ies or recursively
+        #   @return [Boolean]
+
+        # @return [Dataset]
+        def select(*patterns)
+          with(include_patterns: patterns.uniq)
+        end
+
+        # @return [Dataset]
+        def select_append(*patterns)
+          with(include_patterns: (include_patterns + patterns).uniq)
+        end
+
+        # @return [Dataset]
+        def inside(*paths)
+          with(inside_paths: paths)
+        end
+
+        # @return [Dataset]
+        def inside_append(*paths)
+          with(inside_paths: (inside_paths + paths).uniq)
+        end
+
+        # @return [Dataset]
+        def recursive
+          with(search_recursive: true)
+        end
+
+        # @return [Dataset]
+        def not_recursive
+          with(search_recursive: false)
+        end
+
+        # @return [Array<Pathname>]
+        def search_patterns
+          inside_paths.inject([]) do |result, path|
+            path = path.join('**') if search_recursive
+            result + include_patterns.map do |pattern|
+              path.join(pattern)
+            end
+          end
+        end
+
+        # @return [Boolean]
+        def recursive?
+          search_recursive ||
+            inside_paths.all? { |path| path.to_s =~ RECURSIVE_EXPRESSION } ||
+            include_patterns.all? { |pattern| pattern =~ RECURSIVE_EXPRESSION }
+        end
+
+        # @return [Dataset]
+        def reject(*patterns)
+          with(exclude_patterns: patterns.uniq)
+        end
+
+        # @return [Dataset]
+        def reject_append(*patterns)
+          with(exclude_patterns: (exclude_patterns + patterns).uniq)
+        end
+      end
+    end
+  end
+end