drudge 0.4.0

data/spec/drudge/parsers/tokenizer_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'drudge/parsers/tokenizer'
+
+class Drudge
+
+  module Parsers
+    describe Tokenizer do
+
+      describe ".tokenize" do
+
+        it "converts an array of command line arguments into an array of sexps" do
+          tokens = Tokenizer.tokenize(%w[hello world])
+
+          expect(tokens).to be_kind_of(Enumerable)
+          
+          tokens.each do |type, arg, meta|
+            expect(type).to eq :val
+            expect(arg).to be_kind_of(String)
+            expect(meta).to include(:loc)
+          end
+        end
+
+        it "converts an ordinary argument 'arg' into the sexp [:val, 'arg']" do
+          tokens = Tokenizer.tokenize(%w[hello world])
+
+          expect(tokens).to eq [[:val, 'hello', {loc: [0, 0, 5]}],
+                                [:val, 'world', {loc: [1, 0, 5]}]]
+        end
+      end
+
+      describe ".untokenize" do
+        let(:sexps) { [[:val, 'hello', {loc: [0, 0, 5]}],
+                       [:val, 'dear', {loc: [1, 0, 4]}],
+                       [:val, 'world', {loc: [2, 0, 5]}]] }
+
+        it "converts an array of s-exps into a string" do
+          expect(Tokenizer.untokenize(sexps)).to eq "hello dear world"
+        end
+      end
+
+      describe ".underline_token" do 
+        let(:sexps) { [[:val, 'hello', {loc: [0, 0, 5]}],
+                       [:val, 'dear', {loc: [1, 0, 4]}],
+                       [:val, 'world', {loc: [2, 0, 5]}]] }
+
+        it "underlines first token" do
+          expect(Tokenizer.underline_token(sexps, sexps[0])).to eq "~~~~~"
+        end
+
+        it "underlines the second token" do
+          expect(Tokenizer.underline_token(sexps, sexps[1])).to eq "      ~~~~"
+        end
+
+        it "underlines the third token" do
+          expect(Tokenizer.underline_token(sexps, sexps[2])).to eq "           ~~~~~"
+        end
+
+        it "underlines the end of string when token is nil" do
+          expect(Tokenizer.underline_token(sexps, nil)).to eq "                 ^"
+        end
+
+        it "can be told which underline char to use" do
+          expect(Tokenizer.underline_token(sexps, sexps[0], underline_char: "-")).to eq "-----"
+        end
+      end
+
+    end
+
+  end
+end
+

data/spec/drudge/parsers_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+require 'drudge/parsers'
+require 'drudge/errors'
+
+class Drudge
+
+  describe Parsers do
+    include Parsers
+
+    describe "#parser" do
+      it "takes a block and extends it with ArgumentParser" do
+        p = parser { |input| EOS }
+
+        expect(p).to be_kind_of(Parsers::ArgumentParser) 
+      end
+    end
+
+    describe "basic parsers" do
+      describe ".value" do
+        context "without arguments" do 
+          subject { value }
+
+          it { should parse([[:val, "test"]]).as("test") }
+          it { should_not parse([[:foo, "bar"]]) }
+          it { should_not parse([]) }
+          it { should_not parse(nil) }
+        end
+
+        context "with a string argument 'something'" do
+          subject { value("something") }
+
+          it { should parse([[:val, "something"]]).as("something") }
+          it { should_not parse([[:val, "something else"]]) }
+          it { should_not parse([[:foo, "bar"]]) }
+        end
+
+        context "with a regexp argument /^ab.+/" do
+          subject { value(/^ab.+/) }
+
+          it { should parse([[:val, "abc"]]).as("abc") }
+          it { should parse([[:val, "abd"]]).as("abd") }
+          it { should_not parse([[:val, "cabc"]]) }
+          it { should_not parse([[:val, "something else"]]) }
+          it { should_not parse([[:foo, "bar"]]) }
+        end
+      end
+    end
+
+    describe "command & argument parsers" do
+
+      describe ".arg" do
+
+        context "with a single argument" do
+          context "arg parser for the arg named 'test'" do
+            subject { arg(:test) }
+
+            it { should tokenize_and_parse(%w[anything]).as([:arg, "anything"]) }
+
+            it "should include the expected paraemeter name in the error message" do
+              expect(subject.call([])).to eq(Failure("expected a value for <test>", []))
+            end
+          end
+
+          context "arg sequence" do
+            subject { arg(:first) > arg(:second) }
+
+            it { should tokenize_and_parse(%w[arg1 arg2]).as([[:arg, "arg1"], [:arg, "arg2"]]) }
+            it { should_not tokenize_and_parse(%w[arg1]) }
+            it { should_not tokenize_and_parse(%w[]) }
+          end
+
+          context "arg sequence with :eos" do
+            let(:p) { arg(:first) > arg(:second) > eos }
+            subject { p }
+
+            it { should tokenize_and_parse(%w[arg1 arg2]).as([[:arg, "arg1"], [:arg, "arg2"]]) }
+            it { should_not tokenize_and_parse(%w[arg1 arg2 arg3]) }
+          end
+        end
+
+        context "with a provided parser" do
+            subject { arg(:test, value("TEST")) }
+          describe "arg parser that acceptes only 'TEST'" do
+
+            it { should tokenize_and_parse(%w[TEST]).as([:arg, "TEST"]) }
+
+            it { should_not tokenize_and_parse(%w[anything]) }
+          end
+
+        end
+
+      end
+
+      describe ".command" do
+        context "command parser for command 'hello'" do
+          subject { command("hello") }
+
+          it { should tokenize_and_parse(%w[hello]).as([:arg, "hello"]) }
+          it { should_not tokenize_and_parse(%w[HELLO]) }
+        end
+      end
+
+      describe "collated arguments" do
+        let(:p) {  command("hello") > arg(:first) > arg(:second) <= eos }
+        subject { p.collated_arguments }
+
+        it { should tokenize_and_parse(%w[hello first second]).as({args: %w[hello first second]}) } 
+      end
+
+
+    end
+
+
+    describe Parsers::ArgumentParser do
+      include Parsers::ParseResults
+
+      context "a parser built with #parser" do
+        subject do
+          parser do |input|
+            if input[0][0] == :val && input[0][1] == "hello"
+              Success(Single(input[0][1]), input.drop(1))
+            else
+              Failure("f", input)
+            end
+          end
+        end
+
+        describe "#parse" do
+          it "tokenizes an array of [command line] args and parses it at once" do
+
+            expect(subject.parse(%w[hello world])).to eq(Success(Single("hello"), [[:val, "world", {:loc=>[1, 0, 5]}]]))
+          end
+        end
+
+        describe "#parse!" do
+          it "is like #parse, but returns just the result when successful" do
+            expect(subject.parse!(%w[hello world])).to eq("hello")
+          end
+
+          it "upon failed parse, it raises a CommandArgumentError" do
+            expect { subject.parse!(%w[world hello])}.to raise_error(ParseError)
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+Dir["./spec/support/**/*.rb"].each {|f| require f}

data/spec/support/capture.rb

@@ -0,0 +1,16 @@
+# captures the STDOUT output produced by the provided block
+def capture
+  original_stdout = $stdout
+  $stdout = fake = StringIO.new
+  begin
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+  fake.string
+end
+
+
+def expect_capture(&block)
+  expect(capture &block)
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,13 @@
+require 'drudge/command'
+
+def dummy_cmd(name, args = [])
+  Drudge::Command.new(name, args, -> { puts name } )
+end
+
+def splash_param(name)
+  Drudge::Param.any(name, splatt: true)
+end
+
+def optional_param(name)
+  Drudge::Param.any(name, optional: true)
+end

data/spec/support/parser_matchers.rb

@@ -0,0 +1,42 @@
+require 'drudge/parsers/tokenizer'
+
+RSpec::Matchers.define :parse do |input|
+  match do |parser|
+    res = parser.call(input) 
+
+    res.success? and
+      res.remaining != input and
+      (res.result == @expected_output or not @expected_output)
+  end
+
+  chain :as do |expected_output|
+    @expected_output = expected_output
+  end
+end
+
+RSpec::Matchers.define :tokenize_and_parse do |input|
+  chain :as do |expected_output|
+    @expected_output = expected_output
+  end
+
+  match do |parser|
+    res = do_parse(parser, input)
+
+    res.success? and
+      (res.result == @expected_output or not @expected_output)
+  end
+
+  failure_message_for_should do |parser|
+    res = do_parse(parser, input)
+
+    if @expected_output and res.success?
+      "expected that \"#{parser}\"'s result would be #{@expected_output}, was '#{res.result}'"
+    else
+      "expected that #{parser} should tokenize and parse '#{input}'"
+    end
+  end
+
+  def do_parse(parser, input)
+    parser.call(Drudge::Parsers::Tokenizer.tokenize(input))
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: drudge
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Ognen Ivanovski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.6
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.6.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.6.1
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  A library for building command-line
+                            automation tools with the aim of transferring you (conceptionally) from the command line
+                            interface into Ruby and then letting you use build your tool in a familiar
+                            environement.
+email:
+- ognen.ivanovski@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- drudge.gemspec
+- features/optional-arguments.feature
+- features/simple-commands.feature
+- features/step_definitions/scripts_steps.rb
+- features/support/env.rb
+- features/variable-length-argument-lists.feature
+- lib/drudge.rb
+- lib/drudge/class_dsl.rb
+- lib/drudge/command.rb
+- lib/drudge/dispatch.rb
+- lib/drudge/errors.rb
+- lib/drudge/ext.rb
+- lib/drudge/kit.rb
+- lib/drudge/parsers.rb
+- lib/drudge/parsers/parse_results.rb
+- lib/drudge/parsers/primitives.rb
+- lib/drudge/parsers/tokenizer.rb
+- lib/drudge/version.rb
+- spec/drudge/class_dsl_spec.rb
+- spec/drudge/command_spec.rb
+- spec/drudge/kit_spec.rb
+- spec/drudge/parsers/parse_results_spec.rb
+- spec/drudge/parsers/primitives_spec.rb
+- spec/drudge/parsers/tokenizer_spec.rb
+- spec/drudge/parsers_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture.rb
+- spec/support/fixtures.rb
+- spec/support/parser_matchers.rb
+homepage: https://github.com/ognen/drudge
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A gem that enables you to write command line automation tools using Ruby
+  2.0.
+test_files:
+- features/optional-arguments.feature
+- features/simple-commands.feature
+- features/step_definitions/scripts_steps.rb
+- features/support/env.rb
+- features/variable-length-argument-lists.feature
+- spec/drudge/class_dsl_spec.rb
+- spec/drudge/command_spec.rb
+- spec/drudge/kit_spec.rb
+- spec/drudge/parsers/parse_results_spec.rb
+- spec/drudge/parsers/primitives_spec.rb
+- spec/drudge/parsers/tokenizer_spec.rb
+- spec/drudge/parsers_spec.rb
+- spec/spec_helper.rb
+- spec/support/capture.rb
+- spec/support/fixtures.rb
+- spec/support/parser_matchers.rb
+has_rdoc: