moses 0.1.9 → 0.1.10

data/VERSION

@@ -1 +1 @@
-0.1.9
+0.1.10

data/lib/moses.rb

@@ -1,3 +1,8 @@
+$: << File.join(File.expand_path('../..', __FILE__), 'lib')
+
+require "moses/argument"
+require "moses/arguments"
+
 module Moses
 
   VERSION_FILE = 'VERSION'
@@ -55,88 +60,67 @@ module Moses
 
   def run
     @options = {}
-    @args = Array.try_convert ARGV
+    @args = Moses::Arguments.new
     parse_options
     parse_command
     set_option_command
 
-    self.send(@command) if valid_command?
-    self.send(@default_command || :help) if @command.nil?
+    if valid_command?
+      self.send(@command)
+    else
+      self.send(@default_command || :help)
+    end
   end
 
   private
 
   def parse_options
-    @args.each_with_index do |arg, index|
-      if flag?(arg)
-        #TODO split compound single dash flags -abc
-        next_index = index + 1
-        if variable_option? index
-          create_variable_option(arg, next_index)
-        else
-          create_boolean_option(arg)
-        end
-      end
+    args.each do |arg|
+      @options[arg.to_sym] = args.get_variable(arg) if arg.flag?
     end
-    @args.delete_if { |a| flag?(a) }
   end
 
   def parse_command
-    unless default_command && @args.first == default_command
-      @command = @args.shift.to_sym if @args.first && @args.first.respond_to?(:to_sym)
-    end
+    @command = args.shift.to_sym if args.first && non_default_command?
   end
 
   def set_option_command
     @options.each do |opt, v|
-      if self.class.method_defined?(:option_commands) && option_commands[opt]
-        @command = option_commands[opt]
-        return
-      end
-
-      if default_option_commands[opt]
-        @command = default_option_commands[opt]
-        return
-      end
+      return @command = option_commands[opt] if has_option_command?(opt)
+      return @command = default_option_commands[opt] if default_option_commands[opt]
     end
   end
 
-  def valid_command?
-    default_commands.include?(@command) || self.class.method_defined?(:commands) && [*commands].include?(@command) && self.class.method_defined?(@command)
+  def default_command?
+    default_command && args.first == default_command
   end
 
-  def create_variable_option(flag, next_index)
-    key = flag.gsub(/^--/, '').to_sym
-    if not_flag? @args[next_index]
-      value = @args[next_index]
-      @args.delete_at next_index
-    end
+  def non_default_command?
+    !default_command?
+  end
 
-    @options[key] = value || true
+  def valid_command?
+    @command && default_commands.include?(@command) || has_command?(@command)
   end
 
-  def create_boolean_option(flag)
-    key = flag.gsub(/^-{1,2}/, '').to_sym
-    @options[key] = true
+  def has_commands?
+    self.class.method_defined?(:commands)
   end
 
-  def flag?(arg)
-    arg =~ /^-/
+  def has_command?(command)
+    has_commands? && [*commands].include?(command) && command_defined?(@command)
   end
 
-  def long_flag?(arg)
-    arg =~ /^-{2}/
+  def command_defined?(commant)
+    self.class.method_defined?(command)
   end
 
-  def not_flag?(arg)
-    arg =~ /^[^-]/
+  def has_option_commands?
+    self.class.method_defined?(:option_commands)
   end
 
-  def variable_option?(i)
-    arg = @args[i]
-    next_arg = @args[i+1]
-    #TODO: remove long_flag? check for short flag compatibility
-    long_flag?(arg) && next_arg && not_flag?(next_arg)
+  def has_option_command?(command)
+    has_option_commands? && !!option_commands[command]
   end
 
   def help
@@ -157,5 +141,4 @@ module Moses
     content = File.read(File.expand_path(Moses::VERSION_FILE)) if File.exist?(File.expand_path(Moses::VERSION_FILE))
     content
   end
-
 end

data/lib/moses/application.rb

@@ -1,25 +1,25 @@
-require 'moses'
-require 'fileutils'
-require 'active_support/inflector'
+require "moses"
+require "fileutils"
+require "erb"
+require "active_support/inflector"
 
 class Moses::Application
   include Moses
   commands :create
-  attr_reader :root_path
+  attr_reader :root_path, :app_name
 
   def initialize(root_path = Dir.getwd)
     @root_path = root_path
   end
 
   def create
-    if @args.first
-      @app_name = @args.first
+    if @app_name = args.first
       create_app_dir
+      create_bin_dir
+      create_lib_dir
       create_help_file
       create_version_file
-      create_bin_dir
       create_bin_file
-      create_lib_dir
       create_application_class
     else
       output.puts "You need to name your application: moses create myapp"
@@ -29,60 +29,77 @@ class Moses::Application
   private
 
   def create_app_dir
-    FileUtils.mkdir("#{@root_path}/#{@app_name}") unless File.directory?("#{@root_path}/#{@app_name}")
+    create_directory(app_dir)
+  end
+
+  def create_bin_dir
+    create_directory(bin_dir)
+  end
+
+  def create_lib_dir
+    FileUtils.mkdir(lib_dir) unless File.directory?(lib_dir)
   end
 
   def create_help_file
-    unless File.file?("#{@root_path}/#{@app_name}/HELP.md")
-      FileUtils.touch("#{@root_path}/#{@app_name}/HELP.md")
-      File.open("#{@root_path}/#{@app_name}/HELP.md", 'w+') do |f|
-        f << "Todo: Add your own instructions"
-      end
-    end
+    copy_template("HELP.md", help_file)
   end
 
   def create_version_file
-    unless File.file?("#{@root_path}/#{@app_name}/VERSION")
-      FileUtils.touch("#{@root_path}/#{@app_name}/VERSION")
-      File.open("#{@root_path}/#{@app_name}/VERSION", 'w+') do |f|
-        f << "0.0.0"
-      end
-    end
+    copy_template("VERSION", version_file)
   end
 
-  def create_bin_dir
-    FileUtils.mkdir("#{@root_path}/#{@app_name}/bin") unless File.directory?("#{@root_path}/#{@app_name}/bin")
+  def create_bin_file
+    unless File.file?(bin_file)
+      bin_template = ERB.new(File.read(template("bin_file.erb")))
+      File.open(bin_file, "w+") { |f| f << bin_template.result(binding) }
+      FileUtils.chmod("u+x", bin_file)
+    end
   end
 
-  def create_bin_file
-    unless File.file?("#{@root_path}/#{@app_name}/bin/#{@app_name}")
-      FileUtils.touch("#{@root_path}/#{@app_name}/bin/#{@app_name}")
-      FileUtils.chmod("u+x", "#{@root_path}/#{@app_name}/bin/#{@app_name}")
-      File.open("#{@root_path}/#{@app_name}/bin/#{@app_name}", 'w+') do |f|
-        f << %Q{#!/usr/bin/env ruby
-$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
-require "#{@app_name}"
-#{@app_name.camelize}.new.run
-        }
-      end
+  def create_application_class
+    unless File.file?(app_class_file)
+      class_template = ERB.new(File.read(template("app_class.erb")))
+      File.open(app_class_file, 'w+') { |f| f << class_template.result(binding) }
     end
   end
 
-  def create_lib_dir
-    FileUtils.mkdir("#{@root_path}/#{@app_name}/lib") unless File.directory?("#{@root_path}/#{@app_name}/lib")
+  def app_dir
+    File.join(root_path, app_name)
   end
 
-  def create_application_class
-    unless File.file?("#{@root_path}/#{@app_name}/lib/#{@app_name}.rb")
-      FileUtils.touch("#{@root_path}/#{@app_name}/lib/#{@app_name}.rb")
-      File.open("#{@root_path}/#{@app_name}/lib/#{@app_name}.rb", 'w+') do |f|
-        f << %Q{require "moses"
+  def bin_dir
+    File.join(app_dir, "bin")
+  end
 
-class #{@app_name.camelize}
-  include Moses
-end
-        }
-      end
-    end
+  def lib_dir
+    File.join(app_dir, "lib")
+  end
+
+  def help_file
+    File.join(app_dir, "HELP.md")
+  end
+
+  def version_file
+    File.join(app_dir, "VERSION")
+  end
+
+  def bin_file
+    File.join(bin_dir, app_name)
   end
-end
+
+  def app_class_file
+    File.join(lib_dir, "#{app_name}.rb")
+  end
+
+  def template(filename)
+    File.join(File.dirname(File.expand_path("../..", __FILE__)), "templates", filename)
+  end
+
+  def copy_template(src, dest)
+    FileUtils.cp(template(src), dest) unless File.file?(dest)
+  end
+
+  def create_directory(dir)
+    FileUtils.mkdir(dir) unless File.directory?(dir)
+  end
+end

data/lib/moses/argument.rb

@@ -0,0 +1,36 @@
+module Moses
+  class Argument < String
+
+    attr_accessor :value
+
+    def initialize(string)
+      @value = string
+      super(string)
+    end
+
+    def to_s
+      value
+    end
+
+    def flag?
+      self =~ /^-/ ? true : false
+    end
+
+    def short_flag?
+      self =~ /^-{1}[^-]/ ? true : false
+    end
+
+    def long_flag?
+      self =~ /^-{2}/ ? true : false
+    end
+
+    def not_flag?
+      !flag?
+    end
+
+    def to_sym
+      value.gsub(/^-{1,2}/, '').to_sym
+    end
+
+  end
+end

data/lib/moses/arguments.rb

@@ -0,0 +1,34 @@
+class Moses::Arguments < Array
+  attr_reader :variables
+
+  def initialize
+    @variables = {}
+    super(args)
+  end
+
+  def has_variable?(arg)
+    return true if variables[arg]
+    next_index = self.index(arg) + 1
+    next_arg = self[next_index]
+    #TODO: remove long_flag? check for short flag compatibility
+    arg.long_flag? && next_arg && next_arg.not_flag?
+  end
+
+  def get_variable(arg)
+    return variables[arg] if variables[arg]
+    if has_variable?(arg) || arg.flag?
+      next_arg = self[self.index(arg) + 1]
+      value = next_arg || true
+      @variables[arg] ||= value
+      self.delete_at(self.index(next_arg)) if next_arg
+      self.delete_at self.index(arg)
+      variables[arg]
+    end
+  end
+
+  private
+
+  def args
+    Array.try_convert(ARGV).map { |arg| Moses::Argument.new(arg) }
+  end
+end

data/moses.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "moses"
-  s.version = "0.1.9"
+  s.version = "0.1.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dayton Nolan"]
@@ -31,11 +31,23 @@ Gem::Specification.new do |s|
     "bin/moses",
     "lib/moses.rb",
     "lib/moses/application.rb",
+    "lib/moses/argument.rb",
+    "lib/moses/arguments.rb",
     "moses.gemspec",
     "moses.png",
     "spec/application_spec.rb",
+    "spec/argument_spec.rb",
+    "spec/arguments_spec.rb",
+    "spec/fixtures/HELP.md",
+    "spec/fixtures/VERSION",
+    "spec/fixtures/app_class.rb",
+    "spec/fixtures/bin_file",
     "spec/moses_spec.rb",
-    "spec/spec_helper.rb"
+    "spec/spec_helper.rb",
+    "templates/HELP.md",
+    "templates/VERSION",
+    "templates/app_class.erb",
+    "templates/bin_file.erb"
   ]
   s.homepage = "http://github.com/daytonn/moses"
   s.licenses = ["Apache 2.0"]

data/spec/application_spec.rb

@@ -3,89 +3,72 @@ require 'moses/application'
 require 'pry'
 
 describe Moses::Application do
+  let(:tmp_dir) { Dir.mktmpdir }
+  let(:app_dir) { File.join(tmp_dir, "test_app") }
+  let(:lib_dir) { File.join(app_dir, "lib") }
+  let(:bin_dir) { File.join(app_dir, "bin") }
+  let(:help_file) { File.join(app_dir, "HELP.md") }
+  let(:version_file) { File.join(app_dir, "VERSION") }
+  let(:bin_file) { File.join(bin_dir, "test_app") }
+  let(:app_class_file) { File.join(lib_dir, "test_app.rb") }
+  subject { Moses::Application.new tmp_dir }
+
+  after do
+    FileUtils.rm_rf tmp_dir
+  end
 
-  describe "create" do
-
-    before do
-      @bin = File.expand_path(File.join("bin", "moses"))
-      @tmp_dir = Dir.mktmpdir
-      @app = Moses::Application.new @tmp_dir
+  describe "initialization" do
+    it "has default root_path" do
+      subject = Moses::Application.new
+      expect(subject.root_path).to eq(File.dirname(File.expand_path('..', __FILE__)))
     end
 
-    after do
-      FileUtils.rm_rf @tmp_dir
+    it "can be initialized with a root_path" do
+      expect(subject.root_path).to eq(tmp_dir)
     end
+  end
 
-    describe "initialization" do
-      it "has default root_path" do
-        app = Moses::Application.new
-        expect(app.root_path).to eq(File.dirname(File.expand_path('..', __FILE__)))
-      end
-
-      it "can be initialized with a root_path" do
-        expect(@app.root_path).to eq(@tmp_dir)
-      end
+  describe "create" do
+    before do
+      subject.instance_variable_set(:@args, ['test_app'])
+      subject.create
     end
 
-    describe "create" do
-      before do
-        @app.instance_variable_set(:@args, ['test_app'])
-        @app.create
-      end
-
-      it "makes a directory for the application" do
-        expect(File.directory?("#{@tmp_dir}/test_app")).to be_true
-      end
-
-      it "makes a HELP file" do
-        expect(File.file?("#{@tmp_dir}/test_app/HELP.md")).to be_true
-        expect(File.read("#{@tmp_dir}/test_app/HELP.md")).to eq("Todo: Add your own instructions")
-      end
-
-      it "makes a version file" do
-        expect(File.file?("#{@tmp_dir}/test_app/VERSION")).to be_true
-        expect(File.read("#{@tmp_dir}/test_app/VERSION")).to eq("0.0.0")
-      end
+    it "makes a directory for the application" do
+      expect(File.directory?(app_dir)).to be_true
+    end
 
-      it "makes a bin directory" do
-        expect(File.directory?("#{@tmp_dir}/test_app/bin")).to be_true
-      end
+    it "makes a HELP file" do
+      expect(File.read(help_file)).to eq(fixture_content("HELP.md"))
+    end
 
-      it "makes an executable file" do
-        expect(File.file?("#{@tmp_dir}/test_app/bin/test_app")).to be_true
-        expect(File.executable?("#{@tmp_dir}/test_app/bin/test_app")).to be_true
-        expected_content = %Q{#!/usr/bin/env ruby
-$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
-require "test_app"
-TestApp.new.run
-        }
-        expect(File.read("#{@tmp_dir}/test_app/bin/test_app")).to eq(expected_content)
-      end
+    it "makes a version file" do
+      expect(File.read(version_file)).to eq(fixture_content("VERSION"))
+    end
 
-      it "makes a lib directory" do
-        expect(File.directory?("#{@tmp_dir}/test_app/lib")).to be_true
-      end
+    it "makes a bin directory" do
+      expect(File.directory?(bin_dir)).to be_true
+    end
 
-      it "makes an applcation class file" do
-        expect(File.file?("#{@tmp_dir}/test_app/lib/test_app.rb")).to be_true
-        expected_content = %Q{require "moses"
+    it "makes an executable file" do
+      expect(File.read(bin_file)).to eq(fixture_content("bin_file"))
+      expect(File.executable?(bin_file)).to be_true
+    end
 
-class TestApp
-  include Moses
-end
-        }
-        expect(File.read("#{@tmp_dir}/test_app/lib/test_app.rb")).to eq(expected_content)
-      end
+    it "makes a lib directory" do
+      expect(File.directory?(lib_dir)).to be_true
+    end
 
-      it "warns you if you forget the app name" do
-        app = Moses::Application.new
-        app.instance_variable_set(:@args, [])
-        app.output.stub(:puts)
-        app.output.should_receive(:puts).with('You need to name your application: moses create myapp')
-        app.create
-      end
+    it "makes an applcation class file" do
+      expect(File.read(app_class_file)).to eq(fixture_content("app_class.rb"))
     end
 
+    it "warns you if you forget the app name" do
+      app = Moses::Application.new
+      app.instance_variable_set(:@args, [])
+      app.output.stub(:puts)
+      app.output.should_receive(:puts).with('You need to name your application: moses create myapp')
+      app.create
+    end
   end
-
-end
+end

data/spec/argument_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'moses/argument'
+
+describe Moses::Argument do
+
+  it "takes a string" do
+    expect { Moses::Argument.new }.to raise_error ArgumentError
+  end
+
+  describe "flags" do
+    let(:short_flag) { Moses::Argument.new '-f' }
+    let(:long_flag) { Moses::Argument.new '--long_flag' }
+    let(:non_flag) { Moses::Argument.new 'test' }
+
+    it "determines if the argument is a flag" do
+      expect(short_flag).to be_flag
+      expect(long_flag).to be_flag
+      expect(non_flag).not_to be_flag
+    end
+
+    it "determines if the argument is a short flag" do
+      expect(short_flag).to be_short_flag
+
+      expect(long_flag).not_to be_short_flag
+      expect(non_flag).not_to be_short_flag
+    end
+
+    it "determines if the argument is a long flag" do
+      expect(long_flag).to be_long_flag
+
+      expect(short_flag).not_to be_long_flag
+      expect(non_flag).not_to be_long_flag
+    end
+
+    it "determine if the argument is not a flag" do
+      expect(long_flag).not_to be_not_flag
+      expect(short_flag).not_to be_not_flag
+      expect(non_flag).to be_not_flag
+    end
+
+    describe "to_sym" do
+      it "removes the dashes prepending flags" do
+        expect(short_flag.to_sym).to eq(:f)
+        expect(long_flag.to_sym).to eq(:long_flag)
+      end
+
+      it "converts plain args to symbol" do
+        expect(non_flag.to_sym).to eq(:test)
+      end
+    end
+  end
+
+  describe "value" do
+    before do
+      @arg = Moses::Argument.new 'test'
+    end
+
+    it "can be assigned a value" do
+      @arg.value = 'foo'
+      expect(@arg.value).to eq('foo')
+    end
+  end
+
+  describe "to_s" do
+    before do
+      @arg = Moses::Argument.new 'test'
+    end
+
+    it "renders the original string if there is no value" do
+      expect(@arg.to_s).to eq('test')
+    end
+
+    it "renders the value when set" do
+      @arg.value = 'foo'
+      expect(@arg.to_s).to eq('foo')
+    end
+  end
+
+end

data/spec/arguments_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'moses/arguments'
+
+describe Moses::Arguments do
+  before do
+    stub_const("ARGV", ["-f", "--long-flag", "test"])
+  end
+
+  subject { Moses::Arguments.new }
+
+  it "creates an array of arguments" do
+    expect(subject.first).to be_flag
+    expect(subject.first).to be_short_flag
+    expect(subject[1]).to be_flag
+    expect(subject[1]).to be_long_flag
+    expect(subject.last).not_to be_flag
+  end
+
+  describe "has_variable?" do
+    it "returns true if the next argument exists and is not a flag" do
+      expect(subject.has_variable?(subject[1])).to be_true
+    end
+
+    it "returns false if the argument is not a flag" do
+      expect(subject.has_variable?(subject.last)).to be_false
+    end
+  end
+
+  describe "get_variable" do
+    it "returns the next argument" do
+      expect(subject.get_variable(subject[1])).to eq("test")
+    end
+
+    it "removes the variable from the arguments" do
+      subject.get_variable(subject[1])
+      expect(subject.last).not_to include("--long-flag")
+    end
+
+    it "caches the variable value" do
+      flag = subject[1].to_s
+      subject.get_variable(subject[1])
+      expect(subject).not_to include("--long-flag")
+      expect(subject.get_variable(flag)).to eq("test")
+    end
+
+    it "returns true if there is no value" do
+      expect(subject.get_variable(subject.first)).to be_true
+    end
+  end
+end

data/spec/fixtures/HELP.md

@@ -0,0 +1 @@
+Todo: Add your own instructions

data/spec/fixtures/VERSION

@@ -0,0 +1 @@
+0.0.0

data/spec/fixtures/app_class.rb

@@ -0,0 +1,5 @@
+require "moses"
+
+class TestApp
+  include Moses
+end

data/spec/fixtures/bin_file

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+require "test_app"
+TestApp.new.run

data/spec/moses_spec.rb

@@ -17,10 +17,6 @@ describe Moses do
     @app = TestAppClass.new(@output)
   end
 
-  after do
-    ARGV.clear
-  end
-
   describe 'output' do
     it "defaults to STDOUT" do
       class TestOutputAppClass
@@ -133,7 +129,6 @@ describe Moses do
     it "can be set with the class method" do
       expect(@dc_app.default_command).to eq(:some_command)
     end
-
   end
 
   describe 'option commands' do
@@ -153,8 +148,12 @@ describe Moses do
       class OptionCommandsClass
         include Moses
         option_commands({ foo: :foo, v: :verbose })
+
+        def initialize(output)
+          @output = output
+        end
       end
-      @opt_cmd = OptionCommandsClass.new
+      @opt_cmd = OptionCommandsClass.new(@output)
 
       expect(@opt_cmd.option_commands).to have_key(:foo)
       expect(@opt_cmd.option_commands).to have_key(:h)
@@ -180,8 +179,12 @@ describe Moses do
         include Moses
         commands :verbose
         option_commands({ foo: :foo, v: :verbose })
+
+        def initialize(output)
+          @output = output
+        end
       end
-      @opt_cmd = OptionCommandsClass.new
+      @opt_cmd = OptionCommandsClass.new(@output)
       stub_const("ARGV", ['-v'])
       @opt_cmd.run
       expect(@opt_cmd.command).to eq(:verbose)

data/spec/spec_helper.rb

@@ -11,4 +11,11 @@ Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
 
-end
+  def fixture(file)
+    File.join(File.expand_path("../", __FILE__), "fixtures", file)
+  end
+
+  def fixture_content(file)
+    File.read(fixture(file))
+  end
+end

data/templates/HELP.md

@@ -0,0 +1 @@
+Todo: Add your own instructions

data/templates/VERSION

@@ -0,0 +1 @@
+0.0.0

data/templates/app_class.erb

@@ -0,0 +1,5 @@
+require "moses"
+
+class <%= app_name.camelize %>
+  include Moses
+end

data/templates/bin_file.erb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+require "<%= app_name %>"
+<%= app_name.camelize %>.new.run

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moses
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
   prerelease: 
 platform: ruby
 authors:
@@ -129,11 +129,23 @@ files:
 - bin/moses
 - lib/moses.rb
 - lib/moses/application.rb
+- lib/moses/argument.rb
+- lib/moses/arguments.rb
 - moses.gemspec
 - moses.png
 - spec/application_spec.rb
+- spec/argument_spec.rb
+- spec/arguments_spec.rb
+- spec/fixtures/HELP.md
+- spec/fixtures/VERSION
+- spec/fixtures/app_class.rb
+- spec/fixtures/bin_file
 - spec/moses_spec.rb
 - spec/spec_helper.rb
+- templates/HELP.md
+- templates/VERSION
+- templates/app_class.erb
+- templates/bin_file.erb
 homepage: http://github.com/daytonn/moses
 licenses:
 - Apache 2.0
@@ -149,7 +161,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2311972291789989622
+      hash: -782149874881107108
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: