bales 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8545457d99fcc8ad1f955a400e85117f9232bafb
-  data.tar.gz: 6b071c4698777e472fbced6eac86c5c4ecf398c4
+  metadata.gz: 17750f3056694dcabc3be1c2ac111978e179043f
+  data.tar.gz: b6087e538fd4eccb2e614b1dbd539cf4058b5e90
 SHA512:
-  metadata.gz: e993e329e43ce41ee9388ccc0e6fe4170df541b0545a699bbfdab237768e69bace8b8e1b8198756403d387430b897d4ea0ffbaff0c80e5b842b70cf7b8d4df39
-  data.tar.gz: 0c8ae1f87771e60d703be9338c8438bc529acfd85ed2bb43b5f5fd706ac08c0ba397f14bcd2ee7093742ec0557398a4995b5ad4ca2fdd323bae35e8c6e25bab0
+  metadata.gz: 05e0241f93ac005d784ca7d66bc806de2e5ef609c947bf69c1cdbbd338512f6c6170697f47561a6476ac40084e02a958caf1f3da1cba73fb230a575de5347c51
+  data.tar.gz: 31421e16c924c9dfc59318117c9c597f51a31925c7b75bc43248613fa4505f57888cdb0f33e7eb456ab7c5fcdac76f416e5ca158404836e99ae3d20a978b8511

data/lib/bales/application.rb

@@ -174,10 +174,14 @@ module Bales
                  .map { |p| p.capitalize }
                  .join
           name = "#{const}::#{part}"
-          if const.const_defined? name
-            const = eval(name)
-            depth += 1
-          else
+          begin
+            if const.const_defined? name
+              const = eval(name)
+              depth += 1
+            else
+              break
+            end
+          rescue NameError
             break
           end
         end

data/lib/bales/command/help.rb

@@ -41,8 +41,13 @@ class Bales::Command::Help < Bales::Command
     end
 
     ns.constants
-      .select { |c| ns.const_defined? "#{ns}::#{c}" }
-      .select { |c| eval("#{ns}::#{c}").class == Class }
+      .select { |c|
+      begin
+        ns.const_defined? "#{ns}::#{c}"
+      rescue NameError
+        false
+      end
+    }.select { |c| eval("#{ns}::#{c}").class == Class }
       .select { |c| eval("#{ns}::#{c}") <= Bales::Command }
       .map { |c| eval "#{ns}::#{c}" }
   end

data/lib/bales/version.rb

@@ -1,3 +1,3 @@
 module Bales
-  VERSION="0.1.1"
+  VERSION="0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bales
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ryan S. Northrup
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-18 00:00:00.000000000 Z
+date: 2015-09-05 00:00:00.000000000 Z
 dependencies: []
 description: A framework for building command-line applications
 email:
@@ -19,15 +19,10 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/bales.rb
-- lib/bales.rb~
 - lib/bales/application.rb
-- lib/bales/application.rb~
 - lib/bales/command.rb
-- lib/bales/command.rb~
 - lib/bales/command/help.rb
-- lib/bales/command/help.rb~
 - lib/bales/version.rb
-- lib/bales/version.rb~
 homepage: http://github.com/YellowApple/bales
 licenses:
 - MIT
@@ -38,17 +33,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Ruby on Bales

data/lib/bales.rb~

@@ -1,236 +0,0 @@
-# :main: README.md
-
-##
-# Ruby on Bales (or just "Bales" for short) is to command-line apps what
-# Ruby on Rails (or just "Rails" for short) is to websites/webapps.
-#
-# The name (and concept) was shamelessly stolen from Jason R. Clark's
-# "Testing the Multiverse" talk at Ruby on Ales 2015.  Here's to hoping that
-# we, as a Ruby programming community, can get a headstart on a command-line
-# app framework *before* the Puma-Unicorn Wars ravage the Earth.
-module Bales
-  ##
-  # Base class for Bales apps.  Your command-line program should create a
-  # subclass of this, then call said subclass' #parse_and_run instance
-  # method, like so:
-  #
-  # ```ruby
-  # class MyApp::Application < Bales::Application
-  #   # insert customizations here
-  # end
-  #
-  # MyApp::Application.parse_and_run
-  # ```
-  class Application
-    ##
-    # Runs the specified command (should be a valid class; preferably, should
-    # be a subclass of Bales::Command).  Takes a list of positional args
-    # followed by named options.
-    def self.run(command=Bales::Command::Help, *args, **opts)
-      command.run *args, **opts
-    end
-
-    ##
-    # Parses ARGV (or some other array if you specify one), returning the
-    # class of the identified command, a hash containing the passed-in
-    # options, and a list of any remaining arguments
-    def self.parse(argv=ARGV)
-      command, result = parse_command_name argv.dup
-      opts, args = command.parse_opts result
-      return command, args, opts
-    end
-
-    ##
-    # Parses ARGV (or some other array if you specify one) for a command to
-    # run and its arguments/options, then runs the command.
-    def self.parse_and_run(argv=ARGV)
-      command, args, opts = parse argv
-      run command, *args, **opts
-    end
-
-    private
-
-    def parse_command_name(argv)
-      command_name_parts = []
-      argv.each do |arg|
-        last if arg.match(/^-/)
-        test = args_to_constant [*command_name_parts, arg]
-        if eval("defined? #{test}") == "constant"
-          command_name_parts.push argv.shift
-        else
-          last
-        end
-      end
-      command = args_to_constant [*command_name_parts, arg]
-      command, argv
-    end
-
-    def args_to_constant(argv)
-      result = argv.dup
-      result.map! do |arg|
-        arg.capitalize
-        arg.gsub('-','_').split('_').map { |e| e.capitalize}.join
-      end
-      result.join('::')
-    end
-  end
-
-  ##
-  # Base class for all Bales commands.  Subclass this class to create your
-  # own command, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Hello < Bales::Command
-  #   def self.run(*args, **opts)
-  #     puts "Hello, world!"
-  #   end
-  # end  # produces a `my-app hello` command that prints "Hello, world!"
-  # ```
-  #
-  # Note that the above will accept any number of arguments (including none
-  # at all!).  If you want to change this behavior, change `self.run`'s
-  # signature, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Smack < Bales::Command
-  #   def self.run(target, **opts)
-  #     puts "#{target} has been smacked with a large trout"
-  #   end
-  # end
-  # ```
-  #
-  # Subcommands are automatically derived from namespacing, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::Foo::Bar < Bales::Command
-  #   def self.run(*args, **opts)
-  #     # ...
-  #   end
-  # end  # produces `my-app foo bar`
-  # ```
-  #
-  # Camel-cased command classes can be accessed using either hyphenation or
-  # underscores, like so:
-  #
-  # ```ruby
-  # class MyApp::Command::FooBarBaz < Bales::Command
-  #   # ...
-  # end
-  # # valid result: "my-app foo-bar-baz"
-  # # also valid: "my-app foo_bar_baz"
-  # ```
-  class Command
-    @options = {}
-
-    ##
-    # Runs the command with the provided list of arguments and named options.
-    # Your command should override this method (which by default does
-    # nothing), since this is the method that `Bales::Application.run` calls
-    # in order to actually run your command.
-    #
-    # For example:
-    #
-    # ```ruby
-    # class MyApp::Command::Hello < Bales::Command
-    #   def self.run(*args, **opts)
-    #     puts "Hello, world!"
-    #   end
-    # end
-    # ```
-    def self.run(*args, **opts)
-    end
-
-    ##
-    # Defines a named option that the command will accept, along with some
-    # named arguments:
-    #
-    # `:short_form` (optional)
-    # : A shorthand flag to use for the option (like `-v`).  This should be a
-    #   string, like `"-v"`.
-    #
-    # `:long_form` (optional)
-    # : A longhand flag to use for the option (like `--verbose`).  This is
-    #   derived from the name of the option if not specified.  This should be
-    #   a string, like `"--verbose"`
-    #
-    # `:type` (optional)
-    # : The type that this option represents.  Defaults to `TrueClass` if
-    #   `:arg` is not specified; else, defaults to `String`.  This must be a
-    #   valid class name.
-    #
-    #   A special note on boolean options: if you want your boolean to
-    #   default to `true`, set `:type` to `TrueClass`.  Likewise, if you want
-    #   it to default to `false`, set `:type` to `FalseClass`.
-    #
-    # `:arg` (required unless `:type` is `TrueClass` or `FalseClass`)
-    # : The name of the argument this option accepts.  This must not be
-    #   defined if `:type` is either `TrueClass` or `FalseClass`; for all
-    #   other types, this must be specified.  As mentioned above, though, if
-    #   `:type` is unspecified, the existence of `:arg` then determines
-    #   whether the option's `:type` should default to `TrueClass` or
-    #   `String`.  This should be a symbol, like `:level`.
-    #
-    # Aside from the hash of option-options, `option` takes a single `name`
-    # argument, which should be a symbol representing the name of the option
-    # to be set, like `:verbose`.
-    def self.option(name, **opts)
-      name = name.to_sym
-      opts[:long_form] ||= "--#{name.to_s}".gsub("_","-")
-
-      unless opts[:type].class == Class
-        raise ArgumentError, ":type option should be a valid class"
-      end
-
-      if opts[:type] == TrueClass or opts[:type] == FalseClass
-        raise ArgumentError, ":arg in boolean opt" unless opts[:arg].nil?
-      else
-        raise ArgumentError, "missing :arg" if opts[:arg].nil?
-      end
-
-      @options[name] = opts
-    end
-
-    ##
-    # Takes an ARGV-like array and returns a hash of options and what's left
-    # of the original array.  This is rarely needed for normal use, but is
-    # an integral part of how a Bales::Application parses the ARGV it
-    # receives.
-    #
-    # Normally, this should be perfectly fine to leave alone, but if you
-    # prefer to define your own parsing method (e.g. if you want to specify
-    # an alternative format for command-line options, or you are otherwise
-    # dissatisfied with the default approach of wrapping OptionParser), this
-    # is the method you'd want to override.
-    def self.parse_opts(argv)
-      optparser = OptionParser.new
-      result = {}
-      @options.each do |name, opts|
-        result[name] = opts[:default]
-        parser_args = []
-        parser_args.push opts[:short_form]
-        parser_args.push opts[:long_form]
-        unless opts[:type] == TrueClass or opts[:type] == FalseClass
-          parser_args.push opts[:type]
-        end
-        parser_args.push opts[:description]
-
-        if opts[:type] == FalseClass
-          optparser.on(*parser_args) do |value|
-            result[name] = !value
-          end
-        else
-          optparser.on(*parser_args) do |value|
-            result[name] = value
-          end
-        end
-      end
-    end
-  end
-
-  class Command::Help < Command
-    def self.run(*args, **opts)
-      puts "This will someday output some help text"
-
-    end
-  end
-end

data/lib/bales/application.rb~

@@ -1,71 +0,0 @@
-##
-# Base class for Bales apps.  Your command-line program should create a
-# subclass of this, then call said subclass' #parse_and_run instance
-# method, like so:
-#
-# ```ruby
-# class MyApp::Application < Bales::Application
-#   # insert customizations here
-# end
-#
-# MyApp::Application.parse_and_run
-# ```
-class Bales::Application
-  @default_command = Bales::Command::Help
-  def self.default(command=Bales::Command::Help)
-    @default_command = command
-  end
-
-  ##
-  # Runs the specified command (should be a valid class; preferably, should
-  # be a subclass of Bales::Command).  Takes a list of positional args
-  # followed by named options.
-  def self.run(command, *args, **opts)
-    command.run *args, **opts
-  end
-
-  ##
-  # Parses ARGV (or some other array if you specify one), returning the
-  # class of the identified command, a hash containing the passed-in
-  # options, and a list of any remaining arguments
-  def self.parse(argv=ARGV)
-    command, result = parse_command_name argv.dup
-    command ||= @default_command
-    opts, args = command.parse_opts result
-    return command, args, opts
-  end
-
-  ##
-  # Parses ARGV (or some other array if you specify one) for a command to
-  # run and its arguments/options, then runs the command.
-  def self.parse_and_run(argv=ARGV)
-    command, args, opts = parse argv
-    run command, *args, **opts
-  end
-
-  private
-
-  def self.parse_command_name(argv)
-    command_name_parts = []
-    argv.each do |arg|
-      last if arg.match(/^-/)
-      test = args_to_constant [*command_name_parts, arg]
-      if eval("defined? #{test}") == "constant"
-        command_name_parts.push argv.shift
-      else
-        last
-      end
-    end
-    command = args_to_constant [*command_name_parts]
-    return command, argv
-  end
-
-  def self.args_to_constant(argv)
-    result = argv.dup
-    result.map! do |arg|
-      arg.capitalize
-      arg.gsub('-','_').split('_').map { |e| e.capitalize}.join
-    end
-    eval result.join('::')
-  end
-end

data/lib/bales/command.rb~

@@ -1,189 +0,0 @@
-##
-# Base class for all Bales commands.  Subclass this class to create your
-# own command, like so:
-#
-# ```ruby
-# class MyApp::Command::Hello < Bales::Command
-#   def self.run(*args, **opts)
-#     puts "Hello, world!"
-#   end
-# end  # produces a `my-app hello` command that prints "Hello, world!"
-# ```
-#
-# Note that the above will accept any number of arguments (including none
-# at all!).  If you want to change this behavior, change `self.run`'s
-# signature, like so:
-#
-# ```ruby
-# class MyApp::Command::Smack < Bales::Command
-#   def self.run(target, **opts)
-#     puts "#{target} has been smacked with a large trout"
-#   end
-# end
-# ```
-#
-# Subcommands are automatically derived from namespacing, like so:
-#
-# ```ruby
-# class MyApp::Command::Foo::Bar < Bales::Command
-#   def self.run(*args, **opts)
-#     # ...
-#   end
-# end  # produces `my-app foo bar`
-# ```
-#
-# Camel-cased command classes can be accessed using either hyphenation or
-# underscores, like so:
-#
-# ```ruby
-# class MyApp::Command::FooBarBaz < Bales::Command
-#   # ...
-# end
-# # valid result: "my-app foo-bar-baz"
-# # also valid: "my-app foo_bar_baz"
-# ```
-class Bales::Command
-  @options = {}
-  def self.options
-    @options
-  end
-  def self.options=(new)
-    @options = new
-  end
-
-  ##
-  # Assigns an action to this command.  Said action is represented as a
-  # block, which should accept an array of arguments and a hash of options.
-  # For example:
-  #
-  # ```ruby
-  # class MyApp::Hello < Bales::Command
-  #   action do |args, opts|
-  #     puts "Hello, world!"
-  #   end
-  # end
-  # ```
-  def self.action(&code)
-    @action = code
-  end
-
-  def self.run(*args, **opts)
-    @action.call(args, opts)
-  end
-
-  ##
-  # Defines a named option that the command will accept, along with some
-  # named arguments:
-  #
-  # `:short_form` (optional)
-  # : A shorthand flag to use for the option (like `-v`).  This should be a
-  #   string, like `"-v"`.
-  #
-  # `:long_form` (optional)
-  # : A longhand flag to use for the option (like `--verbose`).  This is
-  #   derived from the name of the option if not specified.  This should be
-  #   a string, like `"--verbose"`
-  #
-  # `:type` (optional)
-  # : The type that this option represents.  Defaults to `TrueClass`.
-  #   Should be a valid class name, like `String` or `Integer`
-  #
-  #   A special note on boolean options: if you want your boolean to
-  #   default to `true`, set `:type` to `TrueClass`.  Likewise, if you want
-  #   it to default to `false`, set `:type` to `FalseClass`.
-  #
-  # `:arg` (optional)
-  # : The name of the argument this option accepts.  This should be a
-  #   symbol (like :level) or `false` (if the option is a boolean flag).
-  #   Defaults to the name of the option or (if the option's `:type` is
-  #   `TrueClass` or `FalseClass`) `false`.
-  #
-  #   If this is an array, and `:type` is set to `Enumerable` or some
-  #   subclass thereof, this will instead be interpreted as a list of
-  #   sample arguments during option parsing.  It's recommended you set
-  #   this accordingly if `:type` is `Enumerable` or any of its subclasses.
-  #
-  # `:required` (optional)
-  # : Whether or not the option is required.  This should be a boolean
-  #   (`true` or `false`).  Default is `false`.
-  #
-  # Aside from the hash of option-options, `option` takes a single `name`
-  # argument, which should be a symbol representing the name of the option
-  # to be set, like `:verbose`.
-  def self.option(name, **opts)
-    name = name.to_sym
-    opts[:long_form] ||= "--#{name.to_s}".gsub("_","-")
-
-    unless opts[:type].is_a? Class
-      raise ArgumentError, ":type option should be a valid class"
-    end
-
-    unless opts[:type].is_a?(TrueClass) or opts[:type].is_a?(FalseClass)
-      opts[:arg] ||= name
-    end
-
-    # if opts[:type] == TrueClass or opts[:type] == FalseClass
-    #   raise ArgumentError, ":arg in boolean opt" unless opts[:arg].nil?
-    # else
-    #   raise ArgumentError, "missing :arg" if opts[:arg].nil?
-    # end
-
-    result = {}
-    result[name] = opts
-    self.options = result
-  end
-
-  ##
-  # Takes an ARGV-like array and returns a hash of options and what's left
-  # of the original array.  This is rarely needed for normal use, but is
-  # an integral part of how a Bales::Application parses the ARGV it
-  # receives.
-  #
-  # Normally, this should be perfectly fine to leave alone, but if you
-  # prefer to define your own parsing method (e.g. if you want to specify
-  # an alternative format for command-line options, or you are otherwise
-  # dissatisfied with the default approach of wrapping OptionParser), this
-  # is the method you'd want to override.
-  def self.parse_opts(argv)
-    optparser = OptionParser.new
-    result = {}
-    @options.each do |name, opts|
-      result[name] = opts[:default]
-      parser_args = []
-      parser_args.push opts[:short_form]
-      if opts[:type].is_a?(TrueClass) or opts[:type].is_a?(FalseClass)
-        parser_args.push opts[:long_form]
-      else
-        argstring = opts[:arg].to_s.upcase
-        if opts[:required]
-          parser_args.push "#{opts[:long_form]} #{argstring}"
-        else
-          parser_args.push "#{opts[:long_form]} [#{argstring}]"
-          parser_args.push opts[:type]
-        end
-        parser_args.push opts[:description]
-
-        if opts[:type].is_a? FalseClass
-          optparser.on(*parser_args) do |value|
-            result[name] = !value
-          end
-        else
-          optparser.on(*parser_args) do |value|
-            result[name] = value
-          end
-        end
-      end
-
-      opt_parser.parse! argv
-      return result, argv
-    end
-  end
-end
-
-##
-# Default help command.  You'll probably use your own...
-class Bales::Command::Help < Bales::Command
-  action do |args, opts|
-    puts "This will someday output some help text"
-  end
-end

data/lib/bales/command/help.rb~

@@ -1,37 +0,0 @@
-##
-# Prints help text for a given namespace
-class Bales::Command::Help < Bales::Command
-  action do |args, opts|
-    puts "This will someday output some help text"
-  end
-
-  private
-
-  def commands(ns)
-    unless eval("defined? #{ns}") == "constant"
-      raise ArgumentError, "expected a constant, but got a #{ns.class}"
-    end
-
-    ns.constants
-      .select { |c| eval("#{ns}::#{c}") <= Bales::Command }
-      .map { |c| eval "#{ns}::#{c}" }
-  end
-
-  def format_option(name, opts, width=72)
-    long = "#{opts[:long_form]}"
-    if opts[:type] <= TrueClass or opts[:type] <= FalseClass
-      if opts[:required]
-        long << " #{opts[:arg]}"
-      else
-        long << " [#{opts[:arg]}]"
-      end
-    end
-
-    output = "#{name} (#{opts[:type]}): "
-    output << "#{opts[:short_form]} / " if opts[:short_form]
-    output << long
-    output << "\n"
-    output << opts[:description]
-    output
-  end
-end

data/lib/bales/version.rb~

@@ -1,3 +0,0 @@
-module Bales
-  VERSION="0.0.0"
-end