dorian 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f442cb1d0f47b1eed61e28ae03731f5c6992e61bf074dbaa3f8b54d185dad8d7
-  data.tar.gz: 877156a017e90bdc05a57b03f072467a9ab97d4ad4880d4be4fd6ef0e6ee5948
+  metadata.gz: 926123b36e9d821e68bec3a83818a70f7a39f6f52c1fa5d19ac777dc98b64da0
+  data.tar.gz: ae5fda1a6fb16ae0ae1d3fd61a329608586329fde537e4c4430513f0d2e1eb25
 SHA512:
-  metadata.gz: b1676c471187b363b7ed432d331d7b3ce5b20992e7f57712088bc79a182db567a140fdc2edd5af8be674031e82862b1bedd514a19434f7d81630b1b2cbb771a6
-  data.tar.gz: c2569fa773cc0fd88871ca875a6a1fa304c06e746cecd403e591b7dbcb3e19f2e3a6e3877cd19b8071c9b0966219b03306bdd6d5f4850b57f0acffc859b40fe2
+  metadata.gz: 5c9bbdc2e3951bd84159719b1292dce233c4092937cdb18054301e438517030bf4bf3b2352a89ec1cb705751130f8f374b1bc40b7496951be21b7744be36cf5c
+  data.tar.gz: 1e9210a0bf87c799539ac9ce4c39dd774c4483facdd326718c31bb3655a895a08b1aae273e80eb87a0f32ad6aa46491bbe73a4a2ec5645102ee4c59665019f50

data/VERSION

@@ -1 +1 @@
-2.0.1
+2.1.0

data/lib/dorian/bin.rb

@@ -6,8 +6,8 @@ require "dorian/eval"
 require "dorian/progress"
 require "dorian/to_struct"
 require "json"
-require "yaml"
 require "parallel"
+require "yaml"
 
 class Dorian
   class Bin
@@ -21,10 +21,12 @@ class Dorian
       "jsonl" => :jsonl,
       "raw" => :raw,
       "yaml" => :yaml,
-      "yml" => :yaml
+      "yml" => :yaml,
+      "yamll" => :yamll,
+      "ymll" => :yamll
     }.freeze
 
-    attr_reader :parsed, :command, :arguments
+    attr_reader :parsed, :command, :arguments, :ruby
 
     def initialize
       @parsed =
@@ -47,6 +49,15 @@ class Dorian
           parallel: {
             alias: :p
           },
+          parallel_type: {
+            alias: :pt,
+            type: :string,
+            default: :processes
+          },
+          n: {
+            type: :integer,
+            default: 100
+          },
           rails: {
             alias: :r
           },
@@ -73,7 +84,8 @@ class Dorian
           progress: :boolean,
           headers: :boolean,
           progress_format: {
-            alias: :pf
+            alias: :pf,
+            type: :string
           },
           pretty: {
             default: true
@@ -87,7 +99,9 @@ class Dorian
           }
         )
 
-      @command, *@arguments = parsed.arguments
+      @arguments = parsed.arguments
+      @command = arguments.first
+      @ruby = nil
     end
 
     def self.run(...)
@@ -99,12 +113,22 @@ class Dorian
       abort VERSION if version?
 
       case command&.to_sym
-      when :read, nil
-        command_read
       when :each
+        arguments.delete("each")
+        @command = :each
+        @ruby = arguments.join(" ")
+        @arguments = []
         command_each
+      when :all
+        arguments.delete("all")
+        @command = :all
+        @ruby = arguments.join(" ")
+        @arguments = []
+        command_all
       else
-        abort "#{command} not supported"
+        arguments.delete("read")
+        @command = :read
+        command_read
       end
     end
 
@@ -117,17 +141,27 @@ class Dorian
         outputs(reads(File.read(input)), file: input)
       end
 
-      each(stdin_arguments) { |input| outputs(reads(input)) }
+      each(stdin_arguments + arguments) { |input| outputs(reads(input)) }
+    end
+
+    def everything
+      read_stdin_files + read_files + stdin_arguments + arguments
     end
 
     def command_each
-      each(read_stdin_files + read_files + stdin_arguments) do |input|
-        each(lines(reads(input))) do |line|
-          evaluates(arguments.join(" "), it: line)
+      each(everything) do |input|
+        each(lines(reads(input)), progress: true) do |line|
+          evaluates(ruby, it: line)
         end
       end
     end
 
+    def command_all
+      each(everything, progress: true) do |input|
+        evaluates(ruby, it: reads(input))
+      end
+    end
+
     def outputs(content, file: nil)
       if write? && file
         File.write(file, to_output(content))
@@ -141,25 +175,22 @@ class Dorian
 
       case output
       when :csv
-        CSV.generate(headers: headers_of(content)) do |csv|
-          csv << headers_of(content) if headers_of(content)
-
-          each(content) { |row| csv << row }
-        end
+        (headers_of(content) ? headers_of(content).to_csv : "") +
+          map(content) do |element|
+            CSV.generate(headers: headers_of(content)) do |csv|
+              csv << wrap(element)
+            end
+          end.join
       when :json
         pretty? ? JSON.pretty_generate(content) : content.to_json
-      when :jsonl
+      when :jsonl, :yamll
         map(content, &:to_json).join("\n")
       when :raw
         content
-      when :ruby
-        content.inspect
-      when :rubyl
-        map(content, &:inspect).join("\n")
       when :yaml
         content.to_yaml
       else
-        abort "#{output} not supported"
+        abort "#{output.inspect} not supported"
       end
     end
 
@@ -173,15 +204,19 @@ class Dorian
         end
       when :json
         JSON.parse(content).to_deep_struct
-      when :jsonl
+      when :jsonl, :yamll
         map(content.lines) { |line| JSON.parse(line) }.to_deep_struct
       when :raw
         content
       when :yaml
-        YAML.safe_load(content)
+        YAML.safe_load(content).to_deep_struct
       else
-        abort "#{input} not supported"
+        abort "#{input.inspect} not supported"
       end
+    rescue JSON::ParserError => e
+      abort "invalid json: #{e.message}"
+    rescue Psych::SyntaxError => e
+      abort "invalid yaml: #{e.message}"
     end
 
     def pretty?
@@ -190,13 +225,15 @@ class Dorian
 
     def read_stdin
       @read_stdin ||= $stdin.each_line.to_a
+    rescue Interrupt
+      abort "interupt in read_stdin"
     end
 
     def stdin_files
-      return [] if files.any?
-      return [] unless stdin == :files
+      return [] if files.any? || arguments.any?
+      return [] if stdin != :files
 
-      read_stdin.map(&:rstrip)
+      map(read_stdin, &:rstrip)
     end
 
     def read_stdin_files
@@ -208,7 +245,7 @@ class Dorian
     end
 
     def stdin_arguments
-      return [] if files.any?
+      return [] if files.any? || arguments.any?
       return [] if stdin == :files
 
       [read_stdin.join]
@@ -218,6 +255,10 @@ class Dorian
       options.stdin.to_sym
     end
 
+    def deep?
+      !!options.deep
+    end
+
     def options
       parsed.options
     end
@@ -294,26 +335,110 @@ class Dorian
       parsed.help
     end
 
+    def n
+      options.n
+    end
+
+    def parallel_type
+      options.parallel_type&.to_sym
+    end
+
     def headers_of(content)
-      return unless headers?
       return unless content.respond_to?(:first)
       return unless content.first
       return unless content.first.respond_to?(:to_h)
       return unless content.first.to_h.keys.any?
 
       content.first.to_h.keys
+    rescue TypeError
+      nil
+    end
+
+    def parallel_options
+      if parallel_type == :processes
+        { in_processes: n }
+      elsif parallel_type == :threads
+        { in_threads: n }
+      else
+        abort "#{parallel_type.inspect} not supported"
+      end
     end
 
-    def each(collection, &)
-      parallel? ? Parallel.each(collection, &) : collection.each(&)
+    def each(collection, options: parallel_options, progress: false, &)
+      collection = wrap(collection)
+      progress_bar = progress ? create_progress_bar(collection.size) : nil
+
+      if parallel?
+        Parallel.each(
+          collection,
+          **options,
+          finish: ->(*) { progress_bar&.increment },
+          &
+        )
+      else
+        collection.each do |element|
+          yield(element).tap { progress_bar&.increment }
+        end
+      end
     end
 
-    def map(collection, &)
-      parallel? ? Parallel.map(collection, &) : collection.map(&)
+    def map(collection, options: parallel_options, progress: false, &)
+      collection = wrap(collection)
+      progress_bar = progress ? create_progress_bar(collection.size) : nil
+
+      if parallel?
+        Parallel.map(
+          collection,
+          **options,
+          finish: ->(*) { progress_bar&.increment },
+          &
+        )
+      else
+        collection.map do |element|
+          yield(element).tap { progress_bar&.increment }
+        end
+      end
     end
 
     def lines(input)
-      input.is_a?(String) ? input.lines.map(&:rstrip) : Array(input)
+      if input.is_a?(String)
+        input.lines.map(&:rstrip)
+      elsif deep?
+        deep_lines(input)
+      else
+        Array(input)
+      end
+    end
+
+    def deep_lines(input)
+      case input
+      when Array
+        [input.to_deep_struct] +
+          input.flat_map { |element| deep_lines(element) }
+      when Hash
+        [input.to_deep_struct] +
+          input.flat_map { |key, value| deep_lines([key, value]) }
+      when Struct
+        deep_lines(input.from_deep_struct).to_deep_struct
+      else
+        [input.to_deep_struct]
+      end
+    end
+
+    def wrap(ruby)
+      if ruby.is_a?(Hash)
+        ruby
+      elsif ruby.respond_to?(:to_a)
+        ruby.to_a
+      else
+        Array(ruby)
+      end
+    end
+
+    def create_progress_bar(total)
+      return unless progress?
+
+      Dorian::Progress.create(total:, format: progress_format)
     end
 
     def evaluates(
@@ -324,6 +449,7 @@ class Dorian
       stderr: stderr?,
       colorize: colorize?,
       rails: rails?,
+      fast: fast?,
       returns: false
     )
       Dorian::Eval.eval(
@@ -334,6 +460,7 @@ class Dorian
         stderr:,
         colorize:,
         rails:,
+        fast:,
         returns:
       )
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dorian
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Dorian Marié
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-31 00:00:00.000000000 Z
+date: 2024-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: csv