cmds 0.0.1

data/lib/cmds.rb

@@ -0,0 +1,322 @@
+# stdlib
+require 'shellwords'
+require 'open3'
+require 'erubis'
+
+# deps
+require 'nrser'
+
+# project
+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
+  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_and_kwds subs
+    args = []
+    kwds = {}
+
+    case subs.length
+    when 0
+      # pass
+    when 1
+      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
+      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
+          third *subs arg needs to be a Hash, not #{ subs[1].inspect }
+        BLOCK
+      end
+
+      args, kwds = subs
+    else
+      raise ArgumentError.new NRSER.squish <<-BLOCK
+        must provide one or two *subs arguments, received #{ 1 + subs.length }
+      BLOCK
+    end
+
+    [args, kwds]
+  end
+
+  # create a new Cmd from template and subs and call it
+  def self.run template, *subs
+    self.new(template, *subs).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
+
+  def initialize template, *subs
+    @template = template
+    @args, @kwds = Cmds.subs_to_args_and_kwds subs
+  end #initialize
+
+  def call *subs
+    args, kwds = merge_subs subs
+
+    cmd = Cmds.sub @template, args, kwds
+
+    out, err, status = Open3.capture3 cmd
+
+    Cmds::Result.new cmd, status, out, err
+  end #call
+
+  # returns a new `Cmds` with the subs merged in
+  def curry *subs
+    self.class.new @template, *merge_subs(subs)
+  end
+
+  private
+
+    def merge_subs subs
+      # break `subs` into `args` and `kwds`
+      args, kwds = Cmds.subs_to_args_and_kwds subs
+
+      [@args + args, @kwds.merge(kwds)]
+    end #merge_subs
+
+  # end private
+end # Cmds
+
+# convenience for Cmds::run
+def Cmds *args
+  Cmds.run *args
+end

data/scratch/blah.rb

@@ -0,0 +1,6 @@
+def f *args
+  p args
+  p kwargs
+end
+
+f 1, 2, 3

data/scratch/erb.rb

@@ -0,0 +1,53 @@
+require 'shellwords'
+require 'erubis'
+require 'nrser'
+
+class ShellEruby < Erubis::EscapedEruby
+  def escaped_expr code
+    "Shellwords.escape((#{code.strip}).to_s)"
+  end
+end
+
+class ERBContext
+  def initialize args, kwargs
+    @args = args
+    @kwargs = kwargs
+    @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
+        @kwargs[key]
+      else
+        @kwargs.fetch(sym)
+      end
+    else
+      super
+    end
+  end
+
+  def get_binding
+    binding
+  end
+
+  def arg
+    @args.fetch(@arg_index).tap {@arg_index += 1}
+  end
+end
+
+tpl = <<-BLOCK
+  defaults write <%= domain %> <%= key %> -dict
+  <% values.each do |key, value| %>
+    <%= key %> <%= value %>
+  <% end %>
+BLOCK
+
+ctx = ERBContext.new [],  domain: "com.nrser.blah",
+                          key: "don't do it",
+                          values: {x: '<ex>', y: 'why'}
+
+s = NRSER.squish ShellEruby.new(tpl).result(ctx.get_binding)
+
+puts s

data/spec/cmds/call_spec.rb

@@ -0,0 +1,16 @@
+require 'json'
+
+require 'spec_helper'
+
+describe "Cmds::call" do
+  it "is reusable" do
+    args_cmd = Cmds.new "./test/echo_cmd.rb <%= arg %>"
+    kwds_cmd = Cmds.new "./test/echo_cmd.rb <%= s %>"
+
+    ["arg one", "arg two", "arg three"].each do |arg|
+      [args_cmd.call([arg]), kwds_cmd.call(s: arg)].each do |result|
+        expect_argv( result ).to eq [arg]
+      end
+    end
+  end # is reusable
+end # Cmds::run

data/spec/cmds/curry_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Cmds::curry" do
+  it "currys" do
+    base = Cmds.new "./test/echo_cmd.rb <%= 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']
+  end # it currys
+end # Cmds::run

data/spec/cmds/erb_context_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Cmds::ERBContext do
+  let(:tpl) {
+    <<-BLOCK
+      defaults
+      <% if current_host? %>
+        -currentHost <%= current_host %>
+      <% end %>
+      export <%= domain %> <%= filepath %>
+    BLOCK
+  }
+
+  def get_result tpl, bnd
+    NRSER.squish ERB.new(tpl).result(bnd.get_binding)
+  end
+
+  it "should work" do
+    bnd = Cmds::ERBContext.new [], current_host: 'xyz', domain: 'com.nrser.blah', filepath: '/tmp/export.plist'
+
+    expect(get_result tpl, bnd).to eq "defaults -currentHost xyz export com.nrser.blah /tmp/export.plist"
+  end
+end

data/spec/cmds/expand_option_hash_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "Cmds::expand_option_hash_spec" do
+
+  context "one single char key" do
+    it "handles nil value" do
+      expect(Cmds.expand_option_hash x: nil).to eq "-x"
+    end
+
+    it "handles simple value" do
+      expect(Cmds.expand_option_hash x: 1).to eq "-x 1"
+    end
+
+    it "handles array value" do
+      expect(Cmds.expand_option_hash x: [1, 2, 3]).to eq "-x 1 -x 2 -x 3"
+    end
+  end # single char key
+
+  context "multiple single char keys" do
+    it "order expansion by key" do
+      expect(Cmds.expand_option_hash b: 2, a: 1, c: 3).to eq "-a 1 -b 2 -c 3"
+    end
+  end # multiple single char keys
+
+  context "one longer key" do
+    it "handles nil value" do
+      expect(Cmds.expand_option_hash blah: nil).to eq "--blah"
+    end
+
+    it "handles a simple value" do
+      expect(Cmds.expand_option_hash blah: 1).to eq "--blah=1"
+    end
+
+    it "handles an array value" do
+      expect(Cmds.expand_option_hash blah: [1, 2, 3]).to eq "--blah=1 --blah=2 --blah=3"
+    end
+  end # one longer key
+
+  context "multiple longer keys" do
+    it "order expansion by key" do
+      expect(Cmds.expand_option_hash bob: 2, al: 1, cat: 3).to eq "--al=1 --bob=2 --cat=3"
+    end
+  end # multiple longer keys
+
+  it "handles a mess of stuff" do
+    expect(
+      Cmds.expand_option_hash d:    1,
+                              blah: "blow", 
+                              cat:  nil, 
+                              x:    ['m', 'e',]
+    ).to eq "--blah=blow --cat -d 1 -x m -x e"
+  end
+
+  it "escapes paths" do
+    expect(
+      Cmds.expand_option_hash path: "/some folder/some where",
+                              p:    "maybe ov/er here..."
+    ).to eq '-p maybe\ ov/er\ here... --path=/some\ folder/some\ where'
+  end
+
+end # ::expand_option_hash_spec

data/spec/cmds/replace_shortcuts_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+def expect_to_replace input, output
+  [
+    "#{ input }",
+    "blah #{ input }",
+    "#{ input } blah",
+    "blah\n#{ input }\nblah",
+  ].each do |str|
+    expect( Cmds.replace_shortcuts input ).to eq output
+  end
+end
+
+describe 'Cmds::replace_shortcuts' do
+  it "should replace %s with <%= arg %>" do
+    expect_to_replace "%s", "<%= arg %>"
+  end
+
+  it "should replace %%s with %s (escaping)" do
+    expect_to_replace "%%s", "%s"
+  end
+
+it "should replace %%%s with %%s (escaping)" do
+    expect_to_replace "%%%s", "%%s"
+  end
+
+  it "should replace %{key} with <%= key %>" do
+    expect_to_replace "%{key}", "<%= key %>"
+  end
+
+  it "should replace %%{key} with %{key} (escaping)" do
+    expect_to_replace '%%{key}', '%{key}'
+  end
+
+  it "should replace %%%{key} with %%{key} (escaping)" do
+    expect_to_replace '%%%{key}', '%%{key}'
+  end
+
+  it "should replace %{key?} with <%= key? %>" do
+    expect_to_replace "%{key?}", "<%= key? %>"
+  end
+
+  it "should replace %%{key?} with %{key?} (escaping)" do
+    expect_to_replace '%%{key?}', '%{key?}'
+  end
+
+  it "should replace %%%{key?} with %%{key?} (escaping)" do
+    expect_to_replace '%%%{key?}', '%%{key?}'
+  end
+
+  it "should replace %<key>s with <%= key %>" do
+    expect_to_replace "%<key>s", "<%= key %>"
+  end
+
+  it "should replace %%<key>s with %<key>s (escaping)" do
+    expect_to_replace "%%<key>s", "%<key>s"
+  end
+
+  it "should replace %%%<key>s with %%<key>s (escaping)" do
+    expect_to_replace "%%%<key>s", "%%<key>s"
+  end
+
+  it "should replace %<key?>s with <%= key? %>" do
+    expect_to_replace '%<key?>s', '<%= key? %>'
+  end
+
+  it "should replace %%<key?>s with %<key?>s (escaping)" do
+    expect_to_replace '%%<key?>s', '%<key?>s'
+  end
+
+  it "should replace %%%<key?>s with %%<key?>s (escaping)" do
+    expect_to_replace '%%%<key?>s', '%%<key?>s'
+  end
+
+  it "should not touch % that don't fit the shortcut sytax" do
+    expect( Cmds.replace_shortcuts "50%" ).to eq "50%"
+  end
+end

data/spec/cmds/run_spec.rb

@@ -0,0 +1,49 @@
+require 'json'
+
+require 'spec_helper'
+
+describe "Cmds::run" do
+  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
+end # Cmds::run