cmds 0.0.3 → 0.0.4

data/lib/cmds.rb

@@ -1,393 +1,36 @@
 # stdlib
 require 'shellwords'
 require 'open3'
-require 'erubis'
+require 'thread'
 
 # deps
 require 'nrser'
 
 # project
+require "cmds/capture"
+require "cmds/debug"
+require "cmds/erb_context"
+require "cmds/io_handler"
+require "cmds/pipe"
+require "cmds/result"
+require "cmds/shell_eruby"
+require "cmds/stream"
+require "cmds/sugar"
+require "cmds/util"
 require "cmds/version"
 
 class Cmds
-  class Result
-    attr_reader :cmd, :status, :out, :err
-
-    def initialize cmd, status, out, err
-      @cmd = cmd
-      @status = status
-      @out = out
-      @err = err
-    end
-
-    def ok?
-      @status == 0
-    end
-
-    def error?
-      ! ok?
-    end
-
-    # raises an error if there was one
-    def raise_error
-      if error?
-        msg = NRSER.squish <<-BLOCK
-          command `#{ @cmd }` exited with status #{ @status }
-          and stderr output #{ err.inspect }
-        BLOCK
-
-        raise SystemCallError.new msg, @status
-      end
-    end
-  end
-
-  # extension of Erubis' EscapedEruby (which auto-escapes `<%= %>` and
-  # leaves `<%== %>` raw) that calls `Cmds.expand_sub` on the value
-  class ShellEruby < Erubis::EscapedEruby
-    def escaped_expr code
-      "::Cmds.expand_sub(#{code.strip})"
-    end
-  end
-
-  class ERBContext < BasicObject
-    def initialize args, kwds
-      @args = args
-      @kwds = kwds
-      @arg_index = 0
-    end
-
-    def method_missing sym, *args, &block
-      if args.empty? && block.nil?
-        if sym.to_s[-1] == '?'
-          key = sym.to_s[0...-1].to_sym
-          @kwds[key]
-        else
-          @kwds.fetch sym
-        end
-      else
-        super
-      end
-    end
-
-    def get_binding
-      ::Kernel.send :binding
-    end
-
-    def arg
-      @args.fetch(@arg_index).tap {@arg_index += 1}
-    end
-  end
-
-  # shortcut for Shellwords.escape
-  # 
-  # also makes it easier to change or customize or whatever
-  def self.esc str
-    Shellwords.escape str
-  end
-
-  # escape option hash.
-  #
-  # this is only useful for the two common option styles: 
-  #
-  # -   single character keys become `-<char> <value>`
-  #
-  #         {x: 1}    => "-x 1"
-  # 
-  # -   longer keys become `--<key>=<value>` options
-  # 
-  #         {blah: 2} => "--blah=2"
-  #
-  # if you have something else, you're going to have to just put it in
-  # the cmd itself, like:
-  # 
-  #     Cmds "blah -assholeOptionOn:%{s}", "ok"
-  # 
-  # or whatever similar shit said command requires.
-  #
-  # however, if the value is an Array, it will repeat the option for each
-  # value:
-  # 
-  #     {x:     [1, 2, 3]} => "-x 1 -x 2 -x 3"
-  #     {blah:  [1, 2, 3]} => "--blah=1 --blah=2 --blah=3"
-  # 
-  # i can't think of any right now, but i swear i've seen commands that take
-  # opts that way.
-  # 
-  def self.expand_option_hash hash
-    hash.map {|key, values|
-      # keys need to be strings
-      key = key.to_s unless key.is_a? String
-
-      [key, values]
-
-    }.sort {|(key_a, values_a), (key_b, values_b)|
-      # sort by the (now string) keys
-      key_a <=> key_b
-
-    }.map {|key, values|
-      # for simplicity's sake, treat all values like an array
-      values = [values] unless values.is_a? Array
-
-      # keys of length 1 expand to `-x v` form
-      expanded = if key.length == 1
-        values.map {|value|
-          if value.nil?
-            "-#{ esc key }"
-          else
-            "-#{ esc key } #{ esc value}"
-          end
-        }
-
-      # longer keys expand to `--key=value` form
-      else
-        values.map {|value|
-          if value.nil?
-            "--#{ esc key }"
-          else
-            "--#{ esc key }=#{ esc value }"
-          end
-        }
-      end
-    }.flatten.join ' '
-  end # ::expand_option_hash
-
-  # expand one of the substitutions
-  def self.expand_sub sub
-    case sub
-    when nil
-      # nil is just an empty string, NOT an empty string bash token
-      ''
-    when Hash
-      expand_option_hash sub
-    else
-      esc sub.to_s
-    end
-  end # ::expand_sub
-
-  # substitute values into a command, escaping them for the shell and
-  # offering convenient expansions for some structures.
-  # 
-  # `cmd` is a string that can be substituted via ruby's `%` operator, like
-  # 
-  #     "git diff %s"
-  # 
-  # for positional substitution, or 
-  # 
-  #     "git diff %{path}"
-  # 
-  # for keyword substitution.
-  # 
-  # `subs` is either:
-  # 
-  # -   an Array when `cmd` has positional placeholders
-  # -   a Hash when `cmd` has keyword placeholders.
-  # 
-  # the elements of the `subs` array or values of the `subs` hash are:
-  # 
-  # -   strings that are substituted into `cmd` after being escaped:
-  #     
-  #         sub "git diff %{path}", path: "some path/to somewhere"
-  #         # => 'git diff some\ path/to\ somewhere'
-  # 
-  # -   hashes that are expanded into options:
-  #     
-  #         sub "psql %{opts} %{database} < %{filepath}",
-  #           database: "blah",
-  #           filepath: "/where ever/it/is.psql",
-  #           opts: {
-  #             username: "bingo bob",
-  #             host: "localhost",
-  #             port: 12345,
-  #           }
-  #         # => 'psql --host=localhost --port=12345 --username=bingo\ bob blah < /where\ ever/it/is.psql'
-  # 
-  def self.sub cmd, args = [], kwds = {}
-    raise TypeError.new("args must be an Array") unless args.is_a? Array
-    raise TypeError.new("kwds must be an Hash") unless kwds.is_a? Hash
-
-    context = ERBContext.new(args, kwds)
-    erb = ShellEruby.new(replace_shortcuts cmd)
-
-    NRSER.squish erb.result(context.get_binding)
-  end # ::sub
-
-  def self.subs_to_args_kwds_input subs
-    args = []
-    kwds = {}
-    input = nil
-
-    case subs.length
-    when 0
-      # nothing to do
-    when 1
-      # can either be a hash, which is interpreted as a keywords,
-      # or an array, which is interpreted as positional arguments
-      case subs[0]
-      when Hash
-        kwds = subs[0]
-
-      when Array
-        args = subs[0]
-
-      else
-        raise TypeError.new NRSER.squish <<-BLOCK
-          first *subs arg must be Array or Hash, not #{ subs[0].inspect }
-        BLOCK
-      end
-
-    when 2, 3
-      # first arg needs to be an array, second a hash, and optional third
-      # can be input
-      unless subs[0].is_a? Array
-        raise TypeError.new NRSER.squish <<-BLOCK
-          first *subs arg needs to be an array, not #{ subs[0].inspect }
-        BLOCK
-      end
-
-      unless subs[1].is_a? Hash
-        raise TypeError.new NRSER.squish <<-BLOCK
-          second *subs arg needs to be a Hash, not #{ subs[1].inspect }
-        BLOCK
-      end
-
-      args, kwds, input = subs
-    else
-      raise ArgumentError.new NRSER.squish <<-BLOCK
-        must provide one or two *subs arguments, received #{ 1 + subs.length }
-      BLOCK
-    end
-
-    [args, kwds, input]
-  end
-
-  # create a new Cmd from template and subs and call it
-  def self.run template, *subs
-    args, kwds, input = subs_to_args_kwds_input subs
-    self.new(template, args: args, kwds: kwds, input: input).call
-  end
-
-  def self.ok? template, *subs
-    args, kwds, input = subs_to_args_kwds_input subs
-    self.new(template, args: args, kwds: kwds, input: input).ok?
-  end
-
-  def self.error? template, *subs
-    args, kwds, input = subs_to_args_kwds_input subs
-    self.new(template, args: args, kwds: kwds, input: input).error?
-  end
-
-  def self.raise_on_error template, *subs
-    args, kwds, input = subs_to_args_kwds_input subs
-    self.new(
-      template,
-      args: args,
-      kwds: kwds,
-      input: input,
-      raise_on_error: true
-    ).call
-  end
-
-  def self.replace_shortcuts template
-    template
-      .gsub(
-        # %s => <%= arg %>
-        /(\A|[[:space:]])\%s(\Z|[[:space:]])/,
-        '\1<%= arg %>\2'
-      )
-      .gsub(
-        # %%s => %s (escpaing)
-        /(\A|[[:space:]])(\%+)\%s(\Z|[[:space:]])/,
-        '\1\2s\3'
-      )
-      .gsub(
-        # %{key} => <%= key %>, %{key?} => <%= key? %>
-        /(\A|[[:space:]])\%\{([a-zA-Z_]+\??)\}(\Z|[[:space:]])/,
-        '\1<%= \2 %>\3'
-      )
-      .gsub(
-        # %%{key} => %{key}, %%{key?} => %{key?} (escpaing)
-        /(\A|[[:space:]])(\%+)\%\{([a-zA-Z_]+\??)\}(\Z|[[:space:]])/,
-        '\1\2{\3}\4'
-      )
-      .gsub(
-        # %<key>s => <%= key %>, %<key?>s => <%= key? %>
-        /(\A|[[:space:]])\%\<([a-zA-Z_]+\??)\>s(\Z|[[:space:]])/,
-        '\1<%= \2 %>\3'
-      )
-      .gsub(
-        # %%<key>s => %<key>s, %%<key?>s => %<key?>s (escaping)
-        /(\A|[[:space:]])(\%+)\%\<([a-zA-Z_]+\??)\>s(\Z|[[:space:]])/,
-        '\1\2<\3>s\4'
-      )
-  end
-
-  attr_reader :tempalte, :args, :kwds, :input, :raise_on_error
+  attr_reader :template, :args, :kwds, :input, :assert
 
   def initialize template, opts = {}
+    Cmds.debug "Cmds constructed",
+      template: template,
+      options: opts
+
     @template = template
     @args = opts[:args] || []
     @kwds = opts[:kwds] || {}
     @input = opts[:input] || nil
-    @raise_on_error = opts[:raise_on_error] || false
-  end #initialize
-
-  def call *subs
-    # merge any stored args and kwds and get any overriding input
-    args, kwds, input = merge_subs subs
-
-    cmd = Cmds.sub @template, args, kwds
-
-    out, err, status = if input.nil?
-      Open3.capture3 cmd
-    else
-      Open3.capture3 cmd, stdin_data: input
-    end
-
-    result = Cmds::Result.new cmd, status.exitstatus, out, err
-
-    result.raise_error if @raise_on_error
-
-    return result
-  end #call
-
-  # returns a new `Cmds` with the subs merged in
-  def curry *subs
-    args, kwds, input = merge_subs(subs)
-    self.class.new @template, args: args, kwds: kwds, input: input
-  end
-
-  def ok?
-    call.ok?
-  end
-
-  def error?
-    call.error?
-  end
-
-  private
-
-    def merge_subs subs
-      # break `subs` into `args` and `kwds`
-      args, kwds, input = Cmds.subs_to_args_kwds_input subs
-
-      # use any default input if we didn't get a new one
-      input = @input if input.nil?
-
-      [@args + args, @kwds.merge(kwds), input]
-    end #merge_subs
-
-  # end private
-end # Cmds
-
-# convenience for Cmds::run
-def Cmds *args
-  Cmds.run *args
-end
-
-def Cmds? *args
-  Cmds.ok? *args
-end
-
-def Cmds! *args
-  Cmds.raise_on_error *args
-end
+    @assert = opts[:assert] || false
+  end # #initialize
+end

data/scratch/popen3.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'open3'
+require 'thread'
+require 'pty'
+
+master, slave = PTY.open
+
+Open3.popen3("./test/tick.rb 10") do |stdin, stdout, stderr, thread|
+  {
+    stdout => ["out", $stdout],
+    stderr => ["err", $stderr],
+  }.each do |src, (name, dest)|
+
+    puts "starting #{ name } thread"
+    Thread.new do
+      loop do
+        puts "getting #{ name } line..."
+        line = src.gets
+        puts "got #{ name } line."
+        if line.nil?
+          puts "#{ name } done, breaking."
+          break
+        else
+          puts "wiriting #{ line.bytesize } bytes to #{ name }."
+          dest.puts line
+        end
+      end
+    end
+  end
+
+  thread.join
+end

data/scratch/proxy.rb

@@ -0,0 +1,5 @@
+require 'cmds'
+
+Cmds.enable_debug do
+  Cmds.new("./test/questions.rb").proxy
+end

data/spec/cmds/assert_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "Cmds::assert" do
+  it "should raise an error when the command fails" do
+    expect{ Cmds.assert "exit 1" }.to raise_error Errno::EPERM
+  end
+
+  it "should do the same for Cmds!" do
+    expect{ Cmds! "exit 1" }.to raise_error Errno::EPERM
+  end
+
+  it "should be chainable when the command is ok" do
+    expect( Cmds!("echo hey").out ).to eq "hey\n"
+    expect( Cmds.new("echo hey").capture.assert.out ).to eq "hey\n"
+  end
+end # Cmds::run

data/spec/cmds/capture_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe "Cmds::capture" do
+  it "captures stdout" do
+    expect(
+      Cmds.new(%{ruby -e '$stdout.puts "hey"'}).capture.out
+    ).to eq "hey\n"
+  end
+
+  it "captures stderr" do
+    expect(
+      Cmds.new(%{ruby -e '$stderr.puts "ho"'}).capture.err
+    ).to eq "ho\n"
+  end
+
+  context "echo_cmd.rb 'hello world!'" do
+
+    shared_examples "executes correctly" do
+      it_behaves_like "ok"
+
+      it "should have 'hello world!' as ARGV[0]" do
+        expect( JSON.load(result.out)['ARGV'][0] ).to eq "hello world!"
+      end
+    end # executes correctly
+
+    context "positional args" do
+      let(:result) {
+        Cmds "./test/echo_cmd.rb <%= arg %>", ["hello world!"]
+      }
+
+      it_behaves_like "executes correctly"
+    end
+
+    context "keyword args" do
+      let(:result) {
+        Cmds "./test/echo_cmd.rb <%= s %>", s: "hello world!"
+      }
+
+      it_behaves_like "executes correctly"
+    end
+
+  end # context echo_cmd.rb 'hello world!'
+
+  # context "feeding kwargs to args cmd" do
+  #   let(:result) {
+  #     Cmds "./test/echo_cmd.rb %s", s: "sup y'all"
+  #   }
+
+  #   it "" do
+  #     expect( result.cmd ).to eq nil
+  #   end
+  # end
+
+  it "should error when second (subs) arg is not a hash or array" do
+    expect {
+      Cmds "./test/echo_cmd.rb <%= arg %>", "hello world!"
+    }.to raise_error TypeError
+  end
+
+  it "is reusable" do
+    args_cmd = Cmds.new "./test/echo_cmd.rb <%= arg %>"
+    kwds_cmd = Cmds.new "./test/echo_cmd.rb <%= s %>"
+
+    args = ["arg one", "arg two", "arg three"]
+
+    args.each do |arg|
+      results = [
+        args_cmd.capture([arg]),
+        kwds_cmd.capture(s: arg)
+      ]
+
+      results.each do |result|
+        expect( echo_cmd_argv result ).to eq [arg]
+      end
+    end
+  end # is reusable
+
+  context "input" do
+    let(:input) {
+      <<-BLOCK
+        one
+        two
+        three
+        four!
+      BLOCK
+    }
+
+    it "accepts input via options" do
+      cmd = Cmds.new(ECHO_CMD, input: input)
+      expect( echo_cmd_stdin cmd.capture ).to eq input
+    end
+
+    it "accepts input via block" do
+      cmd = Cmds.new ECHO_CMD
+      expect( echo_cmd_stdin cmd.capture { input } ).to eq input
+    end
+
+    it "accepts input from a stream" do
+      File.open "./test/lines.txt" do |f|
+        input = f.read
+        f.rewind
+
+        cmd = Cmds.new ECHO_CMD
+        expect( echo_cmd_stdin cmd.capture { f } ).to eq input
+      end
+    end
+  end # context input
+end # Cmds::capture

data/spec/cmds/curry_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe "Cmds::curry" do
   it "currys" do
-    base = Cmds.new "./test/echo_cmd.rb <%= x %> <%= y %>"
+    base = Cmds.new "#{ ECHO_CMD } <%= x %> <%= y %>"
 
     x1 = base.curry x: 1
     x2 = base.curry x: 2
 
-    expect_argv( x1.call y: 'why' ).to eq ['1', 'why']
-    expect_argv( x2.call y: 'who' ).to eq ['2', 'who']
-    expect_argv( base.call x: 3, y: 4 ).to eq ['3', '4']
+    expect( echo_cmd_argv x1.call y: 'why' ).to eq ['1', 'why']
+    expect( echo_cmd_argv x2.call y: 'who' ).to eq ['2', 'who']
+    expect( echo_cmd_argv base.call x: 3, y: 4 ).to eq ['3', '4']
   end # it currys
 end # Cmds::run

data/spec/cmds/error_spec.rb

@@ -1,8 +1,13 @@
 require 'spec_helper'
 
 describe "Cmds::error?" do
-  it "works" do
+  it "works through instance method" do
+    expect( Cmds.new("true").error? ).to be false
+    expect( Cmds.new("false").error? ).to be true
+  end
+
+  it "works through class method" do
     expect( Cmds.error? "true").to be false
     expect( Cmds.error? "false").to be true
   end
-end # Cmds::ok?
+end # Cmds::error?

data/spec/cmds/ok_spec.rb

@@ -1,8 +1,18 @@
 require 'spec_helper'
 
 describe "Cmds::ok?" do
-  it "works" do
+  it "works through instance method" do
+    expect( Cmds.new("true").ok? ).to be true
+    expect( Cmds.new("false").ok? ).to be false
+  end
+
+  it "works through class method" do
     expect( Cmds.ok? "true").to be true
     expect( Cmds.ok? "false").to be false
   end
+
+  it "workds through global method" do
+    expect( Cmds? "true" ).to be true
+    expect( Cmds? "false" ).to be false
+  end
 end # Cmds::ok?