moses 0.1.4 → 0.1.5

data/Gemfile

@@ -1,5 +1,7 @@
 source "http://rubygems.org"
 
+gem 'activesupport'
+
 group :development do
   gem "rspec"
   gem "bundler"

data/Gemfile.lock

@@ -1,9 +1,13 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
     coderay (1.0.9)
     diff-lcs (1.2.4)
     git (1.2.5)
+    i18n (0.6.1)
     jeweler (1.8.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
@@ -11,6 +15,7 @@ GEM
       rdoc
     json (1.7.7)
     method_source (0.8.1)
+    multi_json (1.7.3)
     nyan-cat-formatter (0.5.0)
       rspec (>= 2.13)
     pry (0.9.12)
@@ -38,6 +43,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
   bundler
   jeweler
   nyan-cat-formatter

data/HELP.md

@@ -0,0 +1,10 @@
+Moses
+=====
+
+The moses command line utility is a simple script to generate a Moses application scaffold.
+
+Usage
+-----
+    moses create app_name
+    
+This creates all the necessary files and folders to create a Moses-based command line application

data/README.md

@@ -0,0 +1,191 @@
+Moses
+=====
+Moses is a simple option/command parser for building command line applications in Ruby.
+![image](moses.png)
+
+Getting Started
+---------------
+
+Installation with ruby-gems:
+
+    gem install moses
+
+Installation with bundler:
+
+    gem 'moses', '0.1.5'
+
+Creating a Moses application
+----------------------------
+
+Moses is a module that you can include into any Ruby class to provide all the plumbing you need to write command line applications. Create the following directory structure for your application
+
+- bin
+  - myapp
+- lib
+  - myapp.rb
+- VERSION
+- HELP.md (or just HELP)
+
+Create a class for your applications functionality:
+
+```rb
+  class MyApp
+    include Moses
+    commands :foo, :bar
+
+    def foo
+      # do stuff
+    end
+
+    def bar
+      # do stuff
+    end
+  end
+```
+
+Then all you need in your executable file is the following:
+
+```rb
+  #!/usr/bin/env ruby
+  $: << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+  require 'myapp'
+  MyApp.new.run
+```
+
+That's all you need to create a CLI app. You can now call your application like so:
+
+    myapp foo
+    myapp bar
+
+By default, Moses will read the contents of the HELP.md (or HELP) file in the root of your project. This will be used to display your application instructions when passed the flags `-h` and `--help`
+
+    myapp -h
+    myapp --help
+
+ Similarly, Moses will use the VERSION file with the `-v` and `--version` flags.
+
+     myapp -v
+     myapp --version
+
+You may choose not to use `VERSION` or `HELP` files in your project and simply define corresponding methods that output what you want:
+
+```rb
+def help
+  output.puts "This is my help text"
+end
+
+def version
+  output.puts "X.X.X"
+end
+```
+
+Commands
+--------
+
+Moses treats the first non-flag argument passed to it as a command (sometimes referred to as sub-commands). A command is simply a method defined in your application class. To define a command, simply add a command definition to your class and implement a method of the same name:
+
+```rb
+  class MyApp
+    include Moses
+    commands :foo
+
+    def foo
+      # do stuff
+    end
+  end
+```
+
+This will create a `foo` command that can be called from the command line: `myapp foo`
+
+### Default command
+
+Sometimes you will want to create an application that has no "sub-commands" and will simply be called from the command line with options. To run a command by default, add a default_command definition to your class:
+
+```rb
+  class MyApp
+    include Moses
+    default_command :main
+
+    def main
+      # do stuff
+    end
+  end
+```
+
+In the above example, the `main` method will execute whenever your application is run. Simply calling `myapp` from the command line will execute the `main` method.
+
+
+Options
+-------
+
+Moses will parse any flags passed to your application that begin with one or two dashes. There are two basic types of flags, boolean and variable flags.
+
+### Boolean flags
+
+Flags which begin with one dash are treated as boolean flags. A boolean flag is basically an _ON_ switch:
+
+    myapp -x
+
+The above will create an `:x` key in the `@options` hash that is true. Given the above switch, we could write code to handle that switch like so:
+
+```rb
+  if @options[:x]
+    # stuff here
+  end
+```
+
+### Variable flags
+
+Flags which begin with two dashes are slightly trickier than boolean flags. Variable flags can be either boolean or be passed a value. Variable flags will be treated as a boolean if no arguments are passed after them:
+
+    myapp --foo
+
+In the above example the value of `@options[:foo]` will be true. However if an argument is passed after the flag, it will automatically be assigned as the value:
+
+    myapp --foo bar
+
+In this case the value of `@options[:foo]` will be the string `bar`. The flag can still be treated as a boolean but it's adjacent argument can also be accessed as it's value:
+
+```rb
+  if @options[:foo]
+    x = @options[:foo] # bar
+  end
+```
+
+### Option commands
+
+It's common to run a command as the result of an option being passed (ie. `-h` or `--help`). To run a command automatically when an option is passed, simply add an `option_commands` definition to your class:
+
+```rb
+class MyApp
+  include Moses
+  option_commands({ :auto => :run_automatic })
+
+  def run_automatic
+    # automatically runs when --auto is passed
+  end
+end
+```
+
+_Note: When using `option_commands`, no other command will be run. If you wish to execute multiple commands based on an option, simply use the boolean flag._
+
+Output
+------
+
+By default Moses exposes `$stdout` through an `output` method. To output to the terminal, simply use `output.puts`:
+
+```rb
+  output.puts "This will be output to STDOUT"
+```
+
+To substitute your own output, define an initializer that overwrites the `@output` variable:
+
+```rb
+class MyApp
+  def initialize(output)
+    @output = output
+  end
+end
+
+MyApp.new(File.open('output.txt'))
+```

data/Rakefile

@@ -21,6 +21,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{Moses is a simple command parser for writing command line applications}
   gem.email = "daytonn@gmail.com"
   gem.authors = ["Dayton Nolan"]
+  gem.executables = ["moses"]
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/bin/moses

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

data/lib/moses/application.rb

@@ -0,0 +1,88 @@
+require 'moses'
+require 'fileutils'
+require 'active_support/inflector'
+
+class Moses::Application
+  include Moses
+  commands :create
+  attr_reader :root_path
+
+  def initialize(root_path = Dir.getwd)
+    @root_path = root_path
+  end
+
+  def create
+    if @args.first
+      @app_name = @args.first
+      create_app_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"
+    end
+  end
+
+  private
+
+  def create_app_dir
+    FileUtils.mkdir("#{@root_path}/#{@app_name}") unless File.directory?("#{@root_path}/#{@app_name}")
+  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
+  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
+  end
+
+  def create_bin_dir
+    FileUtils.mkdir("#{@root_path}/#{@app_name}/bin") unless File.directory?("#{@root_path}/#{@app_name}/bin")
+  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
+    end
+  end
+
+  def create_lib_dir
+    FileUtils.mkdir("#{@root_path}/#{@app_name}/lib") unless File.directory?("#{@root_path}/#{@app_name}/lib")
+  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{
+class #{@app_name.camelize}
+  include Moses
+end
+        }
+      end
+    end
+  end
+end

data/moses.gemspec

@@ -5,15 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = "moses"
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dayton Nolan"]
-  s.date = "2013-05-13"
+  s.date = "2013-05-14"
   s.description = "Moses is a simple command parser for writing command line applications"
   s.email = "daytonn@gmail.com"
+  s.executables = ["moses"]
   s.extra_rdoc_files = [
-    "LICENSE"
+    "LICENSE",
+    "README.md"
   ]
   s.files = [
     ".DS_Store",
@@ -22,11 +24,17 @@ Gem::Specification.new do |s|
     ".ruby-version",
     "Gemfile",
     "Gemfile.lock",
+    "HELP.md",
     "LICENSE",
+    "README.md",
     "Rakefile",
     "VERSION",
+    "bin/moses",
     "lib/moses.rb",
+    "lib/moses/application.rb",
     "moses.gemspec",
+    "moses.png",
+    "spec/application_spec.rb",
     "spec/moses_spec.rb",
     "spec/spec_helper.rb",
     "test.rb"
@@ -41,12 +49,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
       s.add_development_dependency(%q<pry>, [">= 0"])
       s.add_development_dependency(%q<pry-nav>, [">= 0"])
     else
+      s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
@@ -54,6 +64,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<pry-nav>, [">= 0"])
     end
   else
+    s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])

data/spec/application_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'moses/application'
+require 'pry'
+
+describe Moses::Application do
+
+  describe "create" do
+
+    before do
+      @bin = File.expand_path(File.join("bin", "moses"))
+      @tmp_dir = Dir.mktmpdir
+      @app = Moses::Application.new @tmp_dir
+    end
+
+    after do
+      FileUtils.rm_rf @tmp_dir
+    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
+    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 bin directory" do
+        expect(File.directory?("#{@tmp_dir}/test_app/bin")).to be_true
+      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 lib directory" do
+        expect(File.directory?("#{@tmp_dir}/test_app/lib")).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{
+class TestApp
+  include Moses
+end
+        }
+        expect(File.read("#{@tmp_dir}/test_app/lib/test_app.rb")).to eq(expected_content)
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moses
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-13 00:00:00.000000000 Z
+date: 2013-05-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -93,10 +109,12 @@ dependencies:
         version: '0'
 description: Moses is a simple command parser for writing command line applications
 email: daytonn@gmail.com
-executables: []
+executables:
+- moses
 extensions: []
 extra_rdoc_files:
 - LICENSE
+- README.md
 files:
 - .DS_Store
 - .document
@@ -104,11 +122,17 @@ files:
 - .ruby-version
 - Gemfile
 - Gemfile.lock
+- HELP.md
 - LICENSE
+- README.md
 - Rakefile
 - VERSION
+- bin/moses
 - lib/moses.rb
+- lib/moses/application.rb
 - moses.gemspec
+- moses.png
+- spec/application_spec.rb
 - spec/moses_spec.rb
 - spec/spec_helper.rb
 - test.rb
@@ -127,7 +151,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1441504447573939489
+      hash: 4282325133328940449
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: