dorian 2.1.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 926123b36e9d821e68bec3a83818a70f7a39f6f52c1fa5d19ac777dc98b64da0
-  data.tar.gz: ae5fda1a6fb16ae0ae1d3fd61a329608586329fde537e4c4430513f0d2e1eb25
+  metadata.gz: dc5cf78891ac8f7ed7f4ebe350d639c6e42bc7cfa2a8bd1fa6ad526b3e9785db
+  data.tar.gz: '018eee86347e85d6e02b12d23f0a8eadb34a1ba429e0881d8c14fe656a3fa956'
 SHA512:
-  metadata.gz: 5c9bbdc2e3951bd84159719b1292dce233c4092937cdb18054301e438517030bf4bf3b2352a89ec1cb705751130f8f374b1bc40b7496951be21b7744be36cf5c
-  data.tar.gz: 1e9210a0bf87c799539ac9ce4c39dd774c4483facdd326718c31bb3655a895a08b1aae273e80eb87a0f32ad6aa46491bbe73a4a2ec5645102ee4c59665019f50
+  metadata.gz: 98bfeb69db7cc33735780171db3a4f507e6d13f233bd18b2ae0c0e1d264999bff7827fabb5cbcd4590afdc3bf870d4a6d1c701f2257b502bb72f9ad3ea01f11a
+  data.tar.gz: a3351fdbc3b191402813581845e15fd049276510365a13417d461a9806c1f018073e6c65ab2974167269386cab2a569ec70a4c94302ce8740b3ae1ccb0df6654

data/VERSION

@@ -1 +1 @@
-2.1.0
+2.2.1

data/lib/dorian/bin.rb

@@ -5,8 +5,11 @@ require "dorian/arguments"
 require "dorian/eval"
 require "dorian/progress"
 require "dorian/to_struct"
+require "git"
 require "json"
+require "net/http"
 require "parallel"
+require "uri"
 require "yaml"
 
 class Dorian
@@ -26,7 +29,7 @@ class Dorian
       "ymll" => :yamll
     }.freeze
 
-    attr_reader :parsed, :command, :arguments, :ruby
+    attr_reader :parsed, :command, :arguments, :ruby, :ruby_before, :ruby_after
 
     def initialize
       @parsed =
@@ -116,15 +119,64 @@ class Dorian
       when :each
         arguments.delete("each")
         @command = :each
-        @ruby = arguments.join(" ")
-        @arguments = []
+        @ruby = arguments.delete_at(0)
         command_each
       when :all
         arguments.delete("all")
         @command = :all
-        @ruby = arguments.join(" ")
-        @arguments = []
+        @ruby = arguments.delete_at(0)
         command_all
+      when :before
+        arguments.delete("before")
+        @command = :before
+        @ruby = arguments.delete_at(0)
+        command_before
+      when :after
+        arguments.delete("after")
+        @command = :after
+        @ruby = arguments.delete_at(0)
+        command_after
+      when :between
+        arguments.delete("between")
+        @command = :between
+        @ruby_after = arguments.delete_at(0)
+        @ruby_before = arguments.delete_at(0)
+        command_between
+      when :select
+        arguments.delete("select")
+        @command = :select
+        @ruby = arguments.delete_at(0)
+        command_select
+      when :reject
+        arguments.delete("reject")
+        @command = :reject
+        @ruby = arguments.delete_at(0)
+        command_reject
+      when :tally
+        arguments.delete("tally")
+        @command = :tally
+        @ruby = arguments.delete_at(0)
+        command_tally
+      when :anonymize
+        arguments.delete("anonymize")
+        @command = :anonymize
+        command_anonymize
+      when :append
+        arguments.delete("append")
+        @command = :append
+        command_append
+      when :prepend
+        arguments.delete("prepend")
+        @command = :prepend
+        command_prepend
+      when :chat
+        arguments.delete("chat")
+        @command = :chat
+        command_chat
+      when :commit
+        arguments.delete("commit")
+        @command = :commit
+        command_commit
       else
         arguments.delete("read")
         @command = :read
@@ -136,6 +188,43 @@ class Dorian
       parsed.files
     end
 
+    def command_chat
+      puts completion(
+             token: token(".chat"),
+             model: "gpt-4o",
+             messages: [{ role: :user, content: everything.join("\n") }]
+           )
+    end
+
+    def command_commit
+      system_prompt = "simple, clear, short, lowercase commit message"
+      prompt_1 = "for the following diff:"
+      prompt_2 = "for the following git status:"
+      prompt_3 = "for the following comment:"
+
+      content_1 = short(`git diff --staged`)
+      content_2 = short(`git status`)
+      content_3 = short(arguments.join("\n"))
+
+      abort "no staged files" if content_1.empty?
+
+      messages = [
+        { role: :system, content: system_prompt },
+        { role: :system, content: prompt_1 },
+        { role: :user, content: content_1 },
+        { role: :system, content: prompt_2 },
+        { role: :user, content: content_2 },
+        { role: :system, content: prompt_3 },
+        { role: :user, content: content_3 }
+      ]
+
+      message = completion(token: token(".commit"), model: "gpt-4o", messages:)
+
+      Git.open(".").commit(message)
+
+      puts message
+    end
+
     def command_read
       each(stdin_files + files) do |input|
         outputs(reads(File.read(input)), file: input)
@@ -145,20 +234,106 @@ class Dorian
     end
 
     def everything
-      read_stdin_files + read_files + stdin_arguments + arguments
+      read_stdin_files + stdin_arguments + read_files + arguments
     end
 
     def command_each
       each(everything) do |input|
-        each(lines(reads(input)), progress: true) do |line|
-          evaluates(ruby, it: line)
-        end
+        each(lines(reads(input)), progress: true) { |line| evaluates(it: line) }
+      end
+    end
+
+    def command_tally
+      each(everything) do |input|
+        outputs(
+          JSON.pretty_generate(
+            map(lines(reads(input)), progress: true) do |element|
+              if ruby.to_s.empty?
+                element
+              else
+                evaluates(it: element, returns: true, stdout: false).returned
+              end
+            end.tally
+          )
+        )
       end
     end
 
     def command_all
-      each(everything, progress: true) do |input|
-        evaluates(ruby, it: reads(input))
+      each(everything, progress: true) { |input| evaluates(it: reads(input)) }
+    end
+
+    def command_append
+      outputs(everything.sum { |input| lines(reads(input)) })
+    end
+
+    def command_prepend
+      outputs(everything.reverse.sum { |input| lines(reads(input)) })
+    end
+
+    def command_select
+      each(stdin_files + files) do |input|
+        outputs(
+          select(lines(reads(File.read(input)))) { |element| match?(element) },
+          file: input
+        )
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(select(lines(reads(input))) { |element| match?(element) })
+      end
+    end
+
+    def command_reject
+      each(stdin_files + files) do |input|
+        outputs(
+          reject(lines(reads(File.read(input)))) { |element| match?(element) },
+          file: input
+        )
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(reject(lines(reads(input))) { |element| match?(element) })
+      end
+    end
+
+    def command_after
+      each(stdin_files + files) do |input|
+        outputs(after(lines(reads(File.read(input)))), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(after(lines(reads(input))))
+      end
+    end
+
+    def command_before
+      each(stdin_files + files) do |input|
+        outputs(before(reads(File.read(input))), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(before(lines(reads(input))))
+      end
+    end
+
+    def command_between
+      each(stdin_files + files) do |input|
+        outputs(between(lines(reads(File.read(input)))), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(between(lines(reads(input))))
+      end
+    end
+
+    def command_anonymize
+      each(stdin_files + files) do |input|
+        outputs(anonymize(reads(File.read(input))), file: input)
+      end
+
+      each(stdin_arguments + arguments) do |input|
+        outputs(anonymize(reads(input)))
       end
     end
 
@@ -400,6 +575,24 @@ class Dorian
       end
     end
 
+    def select(collection, progress: false, &)
+      collection = wrap(collection)
+      progress_bar = progress ? create_progress_bar(collection.size) : nil
+
+      collection.select do |element|
+        yield(element).tap { progress_bar&.increment }
+      end
+    end
+
+    def reject(collection, progress: false, &)
+      collection = wrap(collection)
+      progress_bar = progress ? create_progress_bar(collection.size) : nil
+
+      collection.reject do |element|
+        yield(element).tap { progress_bar&.increment }
+      end
+    end
+
     def lines(input)
       if input.is_a?(String)
         input.lines.map(&:rstrip)
@@ -441,8 +634,128 @@ class Dorian
       Dorian::Progress.create(total:, format: progress_format)
     end
 
+    def after(input, ruby: @ruby_after || @ruby)
+      if ruby.to_i.to_s == ruby
+        input[(ruby.to_i)..]
+      else
+        selected = false
+
+        input.select do |element|
+          selected = true if match?(element, ruby:)
+          selected
+        end
+      end
+    end
+
+    def before(input, ruby: @ruby_before || @ruby)
+      if ruby.to_i.to_s == ruby
+        input[..(ruby.to_i)]
+      else
+        selected = true
+
+        input.select do |element|
+          selected.tap { selected = false if match?(element, ruby:) }
+        end
+      end
+    end
+
+    def between(input, ruby_before: @ruby_before, ruby_after: @ruby_after)
+      if ruby_before.to_i.to_s == ruby_before &&
+           ruby_after.to_i.to_s == ruby_after
+        input[(ruby_after.to_i)..(ruby_before.to_i)]
+      else
+        selected = false
+
+        input.select do |element|
+          selected = true if match?(element, ruby: ruby_after)
+          selected.tap do
+            selected = false if match?(element, ruby: ruby_before)
+          end
+        end
+      end
+    end
+
+    def anonymize(input)
+      if input.is_a?(String)
+        input.gsub(/[a-z]/, "a").gsub(/[A-Z]/, "A").gsub(/[0-9]/, "0")
+      elsif input.is_a?(Integer)
+        0
+      elsif input.is_a?(Float)
+        0.0
+      elsif input.is_a?(TrueClass) || input.is_a?(FalseClass)
+        false
+      elsif input.nil?
+        nil
+      elsif input.is_a?(Hash)
+        input.transform_values { |value| anonymize(value) }
+      elsif input.is_a?(Array)
+        input.map { |element| anonymize(element) }
+      elsif input.is_a?(Struct)
+        anonymize(input.from_deep_struct).to_deep_struct
+      else
+        raise "#{input.class.inspect} not supported"
+      end
+    end
+
+    def match?(element, ruby: @ruby)
+      !!evaluates(ruby:, it: element, stdout: false, returns: true).returned
+    end
+
+    def token(file)
+      token_file = File.join(Dir.home, file)
+
+      if File.exist?(token_file)
+        token = File.read(token_file).strip
+      else
+        print "token: "
+        token = gets.strip
+        File.write(token_file, token)
+        puts "token written to #{token_file}"
+      end
+
+      token
+    end
+
+    def completion(token:, model:, messages:)
+      body =
+        post(
+          "https://api.openai.com/v1/chat/completions",
+          headers: {
+            "Content-Type" => "application/json",
+            "Authorization" => "Bearer #{token}"
+          },
+          body: { model:, messages: }.to_json
+        )
+
+      json = JSON.parse(body)
+      output = json.dig("choices", 0, "message", "content")
+
+      if output
+        output.strip
+      else
+        abort JSON.pretty_generate(json)
+      end
+    end
+
+    def post(url, headers: {}, body: {})
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Post.new(uri.path, headers)
+      request.body = body
+      http.request(request).body
+    end
+
+    def short(string)
+      string[0..5000]
+    end
+
+    def encoder
+      Tiktoken.encoding_for_model("gpt-4o")
+    end
+
     def evaluates(
-      ruby,
+      ruby: @ruby,
       it: nil,
       debug: debug?,
       stdout: stdout?,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dorian
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Dorian Marié
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-02 00:00:00.000000000 Z
+date: 2024-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: csv
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -143,16 +157,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.4
+      version: '3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: a collection of gems