pragmater 7.1.0 → 8.3.0

data/lib/pragmater/cli/options/defaults.yml

@@ -0,0 +1,6 @@
+:insert:
+  :comments: []
+  :includes: []
+:remove:
+  :comments: []
+  :includes: []

data/lib/pragmater/cli/options/insert_remove.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module CLI
+    module Options
+      # Defines gem insert and remove options.
+      class InsertRemove
+        def initialize values, parser: OptionParser.new
+          @values = values
+          @parser = parser
+        end
+
+        def call
+          parser.separator "\nOPTIONS:\n"
+          parser.separator "\nInsert/Remove:\n"
+          private_methods.grep(/add_/).each { |method| __send__ method }
+          parser
+        end
+
+        private
+
+        attr_reader :values, :parser
+
+        def add_comments
+          parser.on "--comments a,b,c", Array, "Add pragma comments." do |comments|
+            values[:comments] = comments
+          end
+        end
+
+        def add_includes
+          parser.on "--includes a,b,c", Array, "Add console support." do |includes|
+            values[:includes] = includes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pragmater/cli/options/merger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require "runcom"
+
+module Pragmater
+  module CLI
+    module Options
+      # Merges arguments with configuration for fully assembled configuration for use by shell.
+      class Merger
+        DEFAULTS = YAML.load_file(Pathname(__dir__).join("defaults.yml")).freeze
+        CONFIGURATION = Runcom::Config.new "#{Identity::NAME}/configuration.yml", defaults: DEFAULTS
+
+        def initialize configuration = CONFIGURATION, assembler = Assembler.new
+          @configuration = configuration
+          @assembler = assembler
+        end
+
+        def call arguments = []
+          assembler.call(arguments).then do |options|
+            case options
+              in insert: path, **settings then build_insert_options path, settings
+              in remove: path, **settings then build_remove_options path, settings
+              else options
+            end
+          end
+        end
+
+        def configuration_path
+          configuration.current
+        end
+
+        def usage
+          assembler.to_s
+        end
+
+        private
+
+        attr_reader :configuration, :assembler
+
+        def build_insert_options path, options
+          {insert: path, **configuration.to_h.fetch(:insert).merge(options)}
+        end
+
+        def build_remove_options path, options
+          {remove: path, **configuration.to_h.fetch(:remove).merge(options)}
+        end
+      end
+    end
+  end
+end

data/lib/pragmater/cli/shell.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module CLI
+    # The command line interface for this gem.
+    class Shell
+      def initialize merger: Options::Merger.new, runner: Runner, helper: Helper.new
+        @merger = merger
+        @runner = runner
+        @helper = helper
+      end
+
+      def call arguments = []
+        case merger.call arguments
+          in insert: path, **options then insert_pragmas options, path
+          in remove: path, **options then remove_pragmas options, path
+          in config:, edit:, **remainder then edit_configuration
+          in config:, info:, **remainder then print_configuration
+          in version:, **remainder then print_version
+          in help:, **remainder then print_usage
+          else print_usage
+        end
+      end
+
+      private
+
+      attr_reader :merger, :runner, :helper
+
+      def insert_pragmas options, path
+        runner.for(**options.merge(action: :insert, root_dir: path))
+              .call
+              .map { |file| helper.info "Processed: #{file}." }
+      end
+
+      def remove_pragmas options, path
+        runner.for(**options.merge(action: :remove, root_dir: path))
+              .call
+              .map { |file| helper.info "Processed: #{file}." }
+      end
+
+      def edit_configuration
+        helper.run "#{ENV["EDITOR"]} #{merger.configuration_path}"
+      end
+
+      def print_configuration
+        merger.configuration_path.then do |path|
+          return helper.info "No configuration found." unless path
+
+          helper.info "#{path}\n"
+          helper.info path.read
+        end
+      end
+
+      def print_version
+        helper.info Identity::VERSION_LABEL
+      end
+
+      def print_usage
+        helper.info merger.usage
+      end
+    end
+  end
+end

data/lib/pragmater/context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pragmater
+  # Provides context for runner.
+  Context = Struct.new :action, :root_dir, :comments, :includes, keyword_init: true do
+    def initialize *arguments
+      super
+
+      self[:root_dir] ||= "."
+      self[:comments] = Array comments
+      self[:includes] = Array includes
+    end
+  end
+end

data/lib/pragmater/formatters/general.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Formatters
+    # Formats general pragmas in a consistent manner.
+    class General
+      PATTERN = /
+        \A      # Start of line.
+        \#      # Start of comment.
+        \s?     # Space - optional.
+        \w+     # Key - One or more word characters only.
+        :       # Delimiter.
+        \s?     # Space - optional.
+        [\w-]+  # Value - One or more word or dash characters.
+        \Z      # End of line.
+      /x.freeze
+
+      def initialize string, pattern: PATTERN
+        @string = string
+        @pattern = pattern
+      end
+
+      def call
+        return string unless string.match? pattern
+
+        string.split(":").then { |key, value| "# #{key.gsub(/\#\s?/, "")}: #{value.strip}" }
+      end
+
+      private
+
+      attr_reader :string, :pattern
+    end
+  end
+end

data/lib/pragmater/formatters/main.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Formatters
+    # Formats all pragmas in a consistent manner.
+    class Main
+      FORMATTERS = [General, Shebang].freeze
+      PATTERN = FORMATTERS.map { |formatter| formatter::PATTERN }
+                          .then { |patterns| Regexp.union(*patterns) }
+                          .freeze
+
+      def initialize string, formatters: FORMATTERS
+        @string = string
+        @formatters = formatters
+      end
+
+      def call
+        formatters.reduce(string) { |pragma, formatter| formatter.new(pragma).call }
+      end
+
+      private
+
+      attr_reader :string, :formatters
+    end
+  end
+end

data/lib/pragmater/formatters/shebang.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Formatters
+    # Formats shebang pragmas in a consistent manner.
+    class Shebang
+      PATTERN = %r(\A\#!\s?/.*ruby\Z).freeze
+
+      def initialize string, pattern: PATTERN
+        @string = string
+        @pattern = pattern
+      end
+
+      def call
+        return string unless string.match? pattern
+
+        string.split("!").then { |octothorpe, path| "#{octothorpe}! #{path.strip}" }
+      end
+
+      private
+
+      attr_reader :string, :pattern
+    end
+  end
+end

data/lib/pragmater/identity.rb

@@ -5,7 +5,8 @@ module Pragmater
   module Identity
     NAME = "pragmater"
     LABEL = "Pragmater"
-    VERSION = "7.1.0"
+    VERSION = "8.3.0"
     VERSION_LABEL = "#{LABEL} #{VERSION}"
+    SUMMARY = "A command line interface for managing/formatting source file pragma comments."
   end
 end

data/lib/pragmater/parsers/comments.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Parsers
+    # Manages pragma comments.
+    class Comments
+      def initialize older, newer, formatter: Formatters::Main
+        @formatter = formatter
+        @older = format older
+        @newer = format newer
+      end
+
+      def insert
+        older.union newer
+      end
+
+      def remove
+        older - older.intersection(newer)
+      end
+
+      private
+
+      attr_reader :formatter, :older, :newer
+
+      def format pragmas
+        Array(pragmas).map { |pragma| formatter.new(pragma).call }
+      end
+    end
+  end
+end

data/lib/pragmater/parsers/file.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Parsers
+    # Parses a file into pragma comment and body lines.
+    class File
+      def initialize pattern: Formatters::Main::PATTERN,
+                     comments: Comments,
+                     processor: Processors::Handler.new
+        @pattern = pattern
+        @comments = comments
+        @processor = processor
+      end
+
+      def call path, new_comments, action:
+        path.each_line
+            .partition { |line| line.match? pattern }
+            .then do |old_comments, body|
+              processor.call action, wrap_in_new_line(old_comments, new_comments, action), body
+            end
+      end
+
+      private
+
+      attr_reader :pattern, :comments, :processor
+
+      def wrap_in_new_line old_comments, new_comments, action
+        comments.new(old_comments, new_comments).public_send(action).map { |line| "#{line}\n" }
+      end
+    end
+  end
+end

data/lib/pragmater/processors/handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Processors
+    # Handles the insertion or removal of pragma comments.
+    class Handler
+      DEFAULTS = {
+        insert: Inserter,
+        remove: Remover
+      }.freeze
+
+      def initialize processors: DEFAULTS
+        @processors = processors
+      end
+
+      def call action, comments, body
+        processors.fetch(action).new(comments, body).call
+      end
+
+      private
+
+      attr_reader :processors
+    end
+  end
+end

data/lib/pragmater/processors/inserter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Processors
+    # Inserts new pragma comments.
+    class Inserter
+      def initialize comments, body
+        @comments = comments
+        @body = body
+      end
+
+      def call
+        body.first.then do |first|
+          comments.append "\n" unless first == "\n" || body.empty?
+          comments + body
+        end
+      end
+
+      private
+
+      attr_reader :comments, :body
+    end
+  end
+end

data/lib/pragmater/processors/remover.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pragmater
+  module Processors
+    # Removes existing pragma comments.
+    class Remover
+      def initialize comments, body
+        @comments = comments
+        @body = body
+      end
+
+      def call
+        body.first.then do |first_line|
+          body.delete_at 0 if first_line == "\n" && comments.empty?
+          comments + body
+        end
+      end
+
+      private
+
+      attr_reader :comments, :body
+    end
+  end
+end

data/lib/pragmater/runner.rb

@@ -1,32 +1,29 @@
 # frozen_string_literal: true
 
+require "refinements/pathnames"
+
 module Pragmater
   # Adds/removes pragma comments for files in given path.
   class Runner
-    # rubocop:disable Metrics/ParameterLists
-    def initialize path = ".", comments: [], includes: [], writer: Writer
-      @path = Pathname path
-      @comments = Array comments
-      @includes = Array includes
-      @writer = writer
-    end
-    # rubocop:enable Metrics/ParameterLists
+    using Refinements::Pathnames
 
-    def files
-      return [] unless path.exist? && path.directory? && !includes.empty?
+    def self.for **attributes
+      new Context[attributes]
+    end
 
-      Pathname.glob(%(#{path}/{#{includes.join ","}})).select(&:file?)
+    def initialize context, parser: Parsers::File.new
+      @context = context
+      @parser = parser
     end
 
-    def run action:
-      files.each do |file|
-        writer.new(file, comments).public_send action
-        yield file if block_given?
+    def call
+      Pathname(context.root_dir).files("{#{context.includes.join ","}}").map do |path|
+        path.write parser.call(path, context.comments, action: context.action).join
       end
     end
 
     private
 
-    attr_reader :path, :comments, :includes, :writer
+    attr_reader :context, :parser
   end
 end