rom-files 0.2.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rom/memory/dataset'
+require_relative '../constants'
+
+module ROM
+  module Files
+    class Dataset < Memory::Dataset
+      module MimeType
+        def self.included(other)
+          super(other)
+          other.module_eval do
+            option :mime_type, Types::MimeType.optional,
+                   default: -> { nil }
+
+            prepend Initializer
+          end
+        end
+
+        module Initializer
+          def initialize(data, mime_type: nil, include_patterns: ALL, **options)
+            if mime_type && include_patterns.all? { |pattern| pattern !~ /\./ }
+              include_patterns = include_patterns.inject([]) do |result, pattern|
+                result + mime_type.extensions.map { |ext| "#{pattern}.#{ext}" }
+              end
+            end
+            super(data, mime_type: mime_type, include_patterns: include_patterns, **options)
+          end
+        end
+
+        # @!attribute [r] mime_type
+        #   MIME-type of files to include
+        #   @return [MIME::Type?]
+
+        # @param type [String, nil]
+        # @return [Dataset]
+        def mime(type = nil)
+          type = Types::MimeType[type] if type
+          with(mime_type: type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'rom/memory/dataset'
+require 'rom/files/constants'
+
+module ROM
+  module Files
+    class Dataset < Memory::Dataset
+      module Paths
+        def self.included(other)
+          super(other)
+          other.extend ClassInterface
+        end
+
+        module ClassInterface
+          # @return [Proc]
+          def row_proc
+            ->(path) { Hash[ID => path] }
+          end
+        end
+
+        # @!attribute [r] row_proc
+        #   @return [Proc]
+
+        # @return [Array<Pathname>]
+        def paths
+          connection.search(search_patterns, exclude_patterns: exclude_patterns, sorting: sorting, path: path)
+        end
+
+        # Pluck values from a pathname property
+        #
+        # @overload pluck(field)
+        #
+        # @example Usage with Symbol
+        #   users.pluck(:extname).uniq
+        #   # %w[.rb .rbw]
+        #
+        # @param [#to_proc, nil] field A name of the property for extracting values from pathname
+        #
+        # @overload pluck { |pathname| ... }
+        #
+        # @example Usage with block
+        #   users.pluck { |pathname| pathname.basename.to_s }
+        #   # [1, 2, 3]
+        #
+        # @return [Array]
+        #
+        # @api public
+        def pluck(field = nil, &block)
+          block ||= field&.to_proc || row_proc
+          paths.map(&block)
+        end
+
+        # @return [Array<Hash{Symbol => Pathname, String}>]
+        def data
+          pluck(row_proc)
+        end
+
+        alias to_a data
+        alias to_ary to_a
+
+        # Iterate over data using row_proc
+        #
+        # @return [Enumerator, Array] if block is not given
+        #
+        # @api private
+        def each
+          return to_enum unless block_given?
+          paths.each { |tuple| yield(row_proc[tuple]) }
+        end
+
+        # @return [Integer]
+        def count
+          to_a.size
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rom/memory/dataset'
+
+module ROM
+  module Files
+    class Dataset < Memory::Dataset
+      module Sorting
+        def self.included(other)
+          super(other)
+          other.module_eval do
+            option :sorting, Types::Symbol.optional,
+                   default: proc { nil }
+          end
+        end
+
+        # @!attribute [r] sorting
+        #   @return [Symbol, Proc, nil]
+
+        # @return [Dataset]
+        def sort(sorting = :to_s)
+          with(sorting: sorting)
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'dry/core/extensions'
+
+module ROM
+  module Files
+    module Extensions
+    end
+
+    extend Dry::Core::Extensions
+
+    register_extension :text do
+      require_relative 'extensions/text/attributes_inferrer'
+    end
+
+    register_extension :markdown do
+      require_relative 'extensions/markdown/attributes_inferrer'
+    end
+
+    register_extension :ruby do
+      require_relative 'extensions/ruby/attributes_inferrer'
+    end
+
+    register_extension :gem do
+      require 'pathname/extensions'
+      Pathname.load_extensions :pathmap
+      require_relative 'extensions/gem'
+    end
+  end
+end

data/lib/rom/files/extensions/gem.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rom/files/extensions'
+require_relative 'gem/relations/documentations'
+require_relative 'gem/relations/executables'
+require_relative 'gem/relations/implementations'
+require_relative 'gem/relations/specifications'
+
+module ROM
+  module Files
+    load_extensions :ruby, :markdown
+
+    module Extensions
+      module Gem
+        # @param config [ROM::Configuration]
+        def self.register_extension(config, gateway: :default)
+          relations = [Relations::Documentations,
+                       Relations::Executables,
+                       Relations::Implementations,
+                       Relations::Specifications]
+          relations.map do |relation|
+            relation.gateway gateway
+          end
+          config.register_relation(*relations)
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/gem/relations/documentations.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ROM
+  module Files
+    module Extensions
+      module Gem
+        module Relations
+          class Documentations < ROM::Files::Relation
+            dataset { recursive }
+
+            schema 'text/markdown', as: :documentations, infer: true do
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/gem/relations/executables.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ROM
+  module Files
+    module Extensions
+      module Gem
+        module Relations
+          class Executables < ROM::Files::Relation
+            dataset { inside('exe') }
+
+            schema '.', as: :executables, infer: true do
+              use :shebang
+              use :contents, type: ROM::Files::Types::Ruby::ASTWithComments
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/gem/relations/implementations.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ROM
+  module Files
+    module Extensions
+      module Gem
+        module Relations
+          class Implementations < ROM::Files::Relation
+            dataset { recursive.inside('lib') }
+
+            schema 'application/x-ruby', as: :implementations, infer: true do
+              use :stat
+
+              attribute :implementation_path, Types::Path
+              attribute :specification_path, Types.ForeignKey(
+                :specifications,
+                map: ->(path) { path.pathmap('spec/%X_spec.rb') }
+              )
+
+              associations do
+                has_one :specification, foreign_key: :specification_path
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/gem/relations/specifications.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ROM
+  module Files
+    module Extensions
+      module Gem
+        module Relations
+          class Specifications < ROM::Files::Relation
+            dataset { select('*_spec.rb').recursive.inside('spec') }
+
+            schema 'application/x-ruby', as: :specifications, infer: true do
+              use :stat
+
+              attribute :specification_path, Types::Path
+              attribute :implementation_path, Types.ForeignKey(
+                :implementations,
+                map: ->(path) { path.pathmap('%{^spec,}X.rb') }
+              )
+
+              associations do
+                has_one :implementation, foreign_key: :implementation_path
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/markdown/attributes_inferrer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+require_relative '../markup/attributes_inferrer'
+
+module ROM
+  module Files
+    module Extensions
+      module Markdown
+        class AttributesInferrer < Markup::AttributesInferrer
+          def markup_type
+            Types::Markdown::Document
+          end
+        end
+      end
+    end
+
+    Schema::AttributesInferrer.register 'text/markdown', Extensions::Markdown::AttributesInferrer.new.freeze
+  end
+end

data/lib/rom/files/extensions/markdown/types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'rom/files/types'
+
+module ROM
+  module Files
+    module Types
+      module Markdown
+        KDocument = ::Kramdown::Document
+
+        Document = Dry::Types::Definition[KDocument].new(KDocument).constructor do |doc|
+          doc.is_a?(KDocument) ? doc : KDocument.new(doc)
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/markup/attributes_inferrer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rom/files/schema/attributes_inferrer'
+
+module ROM
+  module Files
+    module Extensions
+      module Markup
+        class AttributesInferrer < Schema::AttributesInferrer
+          def infer_attributes(schema, gateway)
+            super + infer_markup_attributes(schema, gateway)
+          end
+
+          def infer_markup_attributes(schema, _gateway)
+            [
+              build(markup_type.meta(DATA: true), DATA, schema)
+            ]
+          end
+
+          # @return [Dry::Types::Definition]
+          def markup_type
+            raise NotImplementedError, "#{self.class}#markup_type is not implemented"
+          end
+
+          def columns
+            super + [DATA]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/files/extensions/ruby/attributes_inferrer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'types'
+require_relative '../markup/attributes_inferrer'
+
+module ROM
+  module Files
+    module Extensions
+      module Ruby
+        class AttributesInferrer < Markup::AttributesInferrer
+          # @return [Dry::Types::Definition]
+          def markup_type
+            Types::Ruby::ASTWithComments
+          end
+        end
+      end
+    end
+
+    Schema::AttributesInferrer.register 'application/x-ruby', Extensions::Ruby::AttributesInferrer.new.freeze
+  end
+end

data/lib/rom/files/extensions/ruby/types.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+old_verbose = $VERBOSE
+$VERBOSE = nil
+require 'parser/current'
+$VERBOSE = old_verbose
+require 'rom/files/types'
+
+module ROM
+  module Files
+    module Types
+      module Ruby
+        ASTNode = Parser::AST::Node
+
+        AST = ROM::Types.Constructor(ASTNode) do |doc|
+          case doc
+          when ASTNode
+            doc
+          when String
+            Parser::CurrentRuby.parse(doc)
+          when Pathname
+            Parser::CurrentRuby.parse(doc.read)
+          else
+            raise ArgumentError, "Cannot convert #{doc.inspect} to Ruby AST"
+          end
+        end
+
+        Comments = Types::Array.of(Parser::Source::Comment)
+
+        ASTWithComments = ROM::Types.Constructor(Array) do |doc|
+          case doc
+          when Array
+            doc
+          when String
+            Parser::CurrentRuby.parse_with_comments(doc)
+          when Pathname
+            Parser::CurrentRuby.parse_file_with_comments(doc.to_s)
+          else
+            raise ArgumentError, "Cannot convert #{doc.inspect} to Ruby AST"
+          end
+        end
+      end
+    end
+  end
+end