noir 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba0f4b6e225d9fd7b76ac11a2880ea68e6f07f63
+  data.tar.gz: a9f636f6d453963747b276222fb16c35a1589b6a
+SHA512:
+  metadata.gz: 4d80e2b8ba59dde0ce9e726368f5123ae5ca0c836fb0e3cc0649dac7db1699dcb3e46ff276417aa23416707d923fedccdba7661a58a7e0510bc8df9029f4341d
+  data.tar.gz: 09fd81daeaa775c0a75a8742fac986047cfd084df5a77e67e495106ac049f1155f232bb872ba582048735fdfd3524d4f9fee82c99abb06f11d857827cfc654c6

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iris.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 atton
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+# Noir
+
+Noir is utility commands for atton.
+
+
+## Installation
+
+    $ gem install noir
+
+## Usage
+
+    $ noir <command> [sub-command...] [args-for-command]
+
+## Enable Completion
+
+    Add this code in .zshrc
+
+    ``` if which noir  >& /dev/null; then eval "$(noir init zsh)"; fi ```
+
+## Contributing
+
+1. Fork it ( http://github.com/atton-/noir/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/noir

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'noir'
+
+begin
+  Noir.main
+rescue => e
+  puts e.message
+end

data/lib/noir.rb

@@ -0,0 +1,13 @@
+require 'noir/version'
+require 'noir/options'
+require 'noir/executer'
+require 'noir/base'
+require 'noir/base/terminal_command'
+require 'noir/command'
+
+module Noir
+  def self.main
+    Noir::Options.parse_options_from_argv!
+    Noir::Executer.execute
+  end
+end

data/lib/noir/base.rb

@@ -0,0 +1,7 @@
+require 'noir/base/command'
+require 'noir/base/terminal_command'
+
+module Noir
+  module Base
+  end
+end

data/lib/noir/base/command.rb

@@ -0,0 +1,41 @@
+module Noir::Base
+
+  class Command
+
+    class << self   # class methods
+      def description
+        if @description.nil?
+          raise "Undefined description : " + self.to_s
+        else
+          puts self.to_s.split(':').last.downcase.ljust(15) + " : " + @description
+        end
+      end
+
+      def execute *args
+        if self == Noir::Base::Command
+          raise 'called raw Noir::Base::Command.execute. please call it in extended class.'
+        end
+
+        # check invalid command
+        check_command_not_found *args
+
+        # default execute is show description with sub commands.
+        description
+        puts '-- sub commands --'
+        sub_commands.map{|c|eval(self.to_s + '::' + c.to_s)}.each{|c| c.description}
+      end
+
+      def sub_commands
+        consts = constants - superclass.constants
+        consts = consts.select{|c| const_get(c).ancestors.include?(Noir::Base::Command)}
+      end
+
+      def check_command_not_found command=nil, *args
+        return if command.nil?
+
+        raise 'command not found : ' + command
+      end
+    end
+
+  end
+end

data/lib/noir/base/terminal_command.rb

@@ -0,0 +1,17 @@
+module Noir::Base
+  class TerminalCommand < Noir::Base::Command
+
+    class << self
+
+      def execute *args
+        if self == Noir::Base::TerminalCommand
+          raise 'called raw Noir::Base::TerminalCommand.execute. please call it in extended class.'
+        end
+
+        raise 'please override in extended class'
+      end
+
+    end
+
+  end
+end

data/lib/noir/command.rb

@@ -0,0 +1,14 @@
+class Noir::Command < Noir::Base::Command
+  class << self
+    def execute *args
+      # if arguments missing. call help.
+      Noir::Command::Help.execute if args.size.zero?
+      check_command_not_found *args
+    end
+  end
+end
+
+require 'noir/command/init'
+require 'noir/command/completion'
+require 'noir/command/help'
+require 'noir/command/new'

data/lib/noir/command/completion.rb

@@ -0,0 +1,51 @@
+class Noir::Command::Completion < Noir::Base::TerminalCommand
+
+  @description = 'it is completion for shell. return command suggestion'
+
+  class << self
+
+    def execute *args
+      if Noir::Options.exist? Noir::Options::Help
+        description
+        exit
+      end
+      puts suggestions(args)
+    end
+
+    def suggestions list
+      if list.size.zero?
+        return suggestions_from_command Noir::Command, nil
+      end
+
+      commands  = [:Noir, :Command] + list
+
+      matched_commands = [commands.first]
+      commands = commands.drop(1)
+
+      while true
+        consts = eval(matched_commands.map(&:to_s).join('::')).constants(true)
+
+        break if commands.size.zero?
+        matched_command = consts.find{|c| c.to_s.downcase == commands.first.to_s.downcase}
+        break if matched_command.nil?
+
+        matched_commands << matched_command
+        commands = commands.drop(1)
+      end
+
+      command_class = eval(matched_commands.map(&:to_s).join('::'))
+      suggestions_from_command(command_class, commands.first)
+    end
+
+    def suggestions_from_command klass, pattern = nil
+      suggests = klass.constants(true).map(&:to_s).map(&:downcase)
+
+      unless pattern.nil?
+        suggests = suggests.select{|c| c.start_with? pattern.downcase}
+      end
+
+      return suggests
+    end
+  end
+
+end

data/lib/noir/command/help.rb

@@ -0,0 +1,19 @@
+class Noir::Command::Help < Noir::Base::TerminalCommand
+
+  @description = "show help"
+
+  class << self
+    def execute *args
+      check_command_not_found *args
+
+      puts 'noir : utilities'
+      puts '-----'
+
+      Noir::Command.constants(true).
+        map{|c| eval('Noir::Command::'+c.to_s)}.
+        select{|c| c.ancestors.include? Noir::Base::Command}.
+        each(&:description)
+    end
+  end
+
+end

data/lib/noir/command/init.rb

@@ -0,0 +1,5 @@
+class Noir::Command::Init < Noir::Base::Command
+  @description = "init script for shell"
+end
+
+require 'noir/command/init/zsh'

data/lib/noir/command/init/zsh.rb

@@ -0,0 +1,33 @@
+class Noir::Command::Init::Zsh < Noir::Base::TerminalCommand
+  @description = "init script for zsh"
+
+  # enable completion for zsh
+  # wrote this code in .zshrc
+  # if which noir  >& /dev/null; then eval "$(noir init zsh)"; fi
+
+  InitScript = %q(
+
+if [[ ! -o interactive ]]; then
+  return
+fi
+
+compctl -K _noir noir
+
+_noir() {
+  local words completions
+  read -cA words
+
+  completions="$(noir completion ${words[2,-2]})"
+
+  reply=("${(ps:\n:)completions}")
+}
+
+  )
+  class << self
+
+    def execute *args
+      puts InitScript
+    end
+
+  end
+end

data/lib/noir/command/new.rb

@@ -0,0 +1,5 @@
+class Noir::Command::New < Noir::Base::Command
+  @description = 'Create new files'
+end
+
+require 'noir/command/new/note'

data/lib/noir/command/new/note.rb

@@ -0,0 +1,16 @@
+require 'date'
+require 'fileutils'
+
+class Noir::Command::New::Note < Noir::Base::TerminalCommand
+  @description = 'create empty txt. filename format is <serial-no>_<date>.txt'
+
+  class << self
+
+    def execute *args
+      note_num  = Dir.glob('[0-9]*_????????.txt').size + 1
+      note_name = format("%02d", note_num) + '_' + Time.now.strftime('%Y%m%d') + '.txt'
+      FileUtils.touch(note_name)
+    end
+
+  end
+end

data/lib/noir/executer.rb

@@ -0,0 +1,46 @@
+module Noir
+  class Executer
+
+    def self.command_from_argv
+      args          = ARGV.clone
+      noir_commands = Noir::Command.constants(true).map(&:to_s)
+      command_arr   = ['Noir', 'Command']   # command prefix
+
+
+      while !args.empty?
+        arg = args.shift
+
+        if matched_command = noir_commands.find{|c| c.downcase == arg.downcase}
+
+          command_arr << matched_command
+          command = eval(command_arr.join('::'))
+          if command.superclass == Noir::Base::Command
+            noir_commands = command.constants(true).map(&:to_s) # search next command in sub class
+          elsif command.superclass ==  Noir::Base::TerminalCommand
+            break                                               # search finished by terminal command
+          else
+            command_arr.pop
+            # delete last matched_command, because this class is not inherited Noir::Base::Command
+            command = eval(command_arr.join('::'))
+            break
+          end
+        end
+      end
+
+      return command || Noir::Command  # default command
+    end
+
+    def self.args_from_argv
+      argv         = ARGV.clone
+      command_str  = self.command_from_argv.to_s.sub(/^Noir::Command/, '')
+      command_str  = command_str.sub(/^::/, '')
+      command_size = command_str.split('::').size
+      return argv.drop(command_size)
+    end
+
+    def self.execute
+      command_from_argv.execute *args_from_argv
+    end
+
+  end
+end

data/lib/noir/options.rb

@@ -0,0 +1,29 @@
+require 'optparse'
+
+module Noir
+
+  class Options
+
+    Help = :help
+
+    @@options = {}
+
+    def self.parse_options_from_argv!
+      parser = OptionParser.new
+
+      parser.program_name = 'noir'
+      parser.version      = Noir::VERSION
+      parser.on('-h', '--help'){|v| @@options[Noir::Options::Help] = v}
+
+      parser.parse!(ARGV)
+
+      @@options
+    end
+
+    def self.exist? const_symbol = nil
+      @@options.has_key?(const_symbol)
+    end
+  end
+
+end
+

data/lib/noir/version.rb

@@ -0,0 +1,3 @@
+module Noir
+  VERSION = "0.0.1"
+end

data/noir.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'noir/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "noir"
+  spec.version       = Noir::VERSION
+  spec.authors       = ["atton"]
+  spec.email         = ["e115763@gmail.com"]
+  spec.summary       = %q{Utilities for atton.}
+  spec.description   = %q{Untility commands with completion for atton.}
+  spec.homepage      = "http://github.com/atton-/noir"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake",    "10.1.1"
+  spec.add_development_dependency "rspec",   "3.0.0.beta2"
+end

data/spec/noir/command/completion_spec.rb

@@ -0,0 +1,75 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::Completion' do
+  it 'is Noir::Command::TerminalCommand' do
+    expect(Noir::Command::Completion.class).to eq(Class)
+  end
+
+  describe 'suggestions' do
+    before do
+      stub_commands
+    end
+
+    it 'return all command from nil' do
+      expect(Noir::Command::Completion.suggestions([])).to include('hoge')
+      expect(Noir::Command::Completion.suggestions([])).to include('fuga')
+    end
+
+    it 'return nil from unmatched pattern' do
+      expect(Noir::Command::Completion.suggestions(['piyo'])).to eq([])
+    end
+
+    it 'return matched command name' do
+      list = ['h']
+      expect(Noir::Command::Completion.suggestions(list)).to     include('hoge')
+      expect(Noir::Command::Completion.suggestions(list)).to_not include('fuga')
+    end
+
+    it 'return command list in sub command' do
+      list = ['hoge']
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subcommand')
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subcommandtwo')
+      expect(Noir::Command::Completion.suggestions(list)).to_not include('subsubcommand')
+    end
+
+    it 'return matched command name list in sub command' do
+      list = ['hoge', 's']
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subcommand')
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subcommandtwo')
+      expect(Noir::Command::Completion.suggestions(list)).to_not include('subsubcommand')
+    end
+
+    it 'return empty when not matched name in command' do
+      list = ['hoge', 'p']
+      expect(Noir::Command::Completion.suggestions(list)).to     eq([])
+    end
+
+    it 'return sub sub commands list in sub command' do
+      list = ['hoge', 'subcommand']
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subsubcommand')
+      expect(Noir::Command::Completion.suggestions(list)).to_not include('subcommand')
+    end
+
+    it 'return empty when not matched name in sub sub command' do
+      list = ['hoge', 'subcommand', 's']
+      expect(Noir::Command::Completion.suggestions(list)).to     include('subsubcommand')
+      expect(Noir::Command::Completion.suggestions(list)).to_not include('subcommand')
+    end
+
+    it 'return empty when not matched name in sub command' do
+      list = ['hoge', 'subcommand', 'aaaaaaa']
+      expect(Noir::Command::Completion.suggestions(list)).to     eq([])
+    end
+
+    it 'return empty in terminal command' do
+      list = ['hoge', 'subcommand', 'subsubcommand']
+      expect(Noir::Command::Completion.suggestions(list)).to     eq([])
+    end
+
+    it 'return empty in terminal command' do
+      list = ['fuga']
+      expect(Noir::Command::Completion.suggestions(list)).to     eq([])
+    end
+  end
+end

data/spec/noir/command/help_spec.rb

@@ -0,0 +1,16 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::Help' do
+  it 'is inherited Noir::Base::TerminalCommand' do
+    expect(Noir::Command::Help.ancestors).to include(Noir::Base::TerminalCommand)
+  end
+
+  it 'is output when execute' do
+    expect{Noir::Command::Help.execute}.to output.to_stdout
+  end
+
+  it 'is raise exception when apply arguments' do
+    expect{Noir::Command::Help.execute 'abc'}.to raise_error
+  end
+end

data/spec/noir/command/init/zsh_spec.rb

@@ -0,0 +1,12 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::Init::Zsh' do
+  it 'is inherited Noir::Base::TerminalCommand' do
+    expect(Noir::Command::Init::Zsh.superclass).to eq(Noir::Base::TerminalCommand)
+  end
+
+  it 'is output in execute' do
+    expect{expect{Noir::Command::Init::Zsh.execute []}.to output.to_stdout}.to_not raise_error
+  end
+end

data/spec/noir/command/init_spec.rb

@@ -0,0 +1,8 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::Init' do
+  it 'is inherited Noir::Base::Command' do
+    expect(Noir::Command::Init.superclass).to eq(Noir::Base::Command)
+  end
+end

data/spec/noir/command/new/note_spec.rb

@@ -0,0 +1,8 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::New::Note' do
+  it 'is TerminalCommand' do
+    expect(Noir::Command::New::Note.superclass).to eq(Noir::Base::TerminalCommand)
+  end
+end

data/spec/noir/command/new_spec.rb

@@ -0,0 +1,8 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command::New' do
+  it 'is Command' do
+    expect(Noir::Command::New.superclass).to eq(Noir::Base::Command)
+  end
+end

data/spec/noir/command_spec.rb

@@ -0,0 +1,8 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Command' do
+  it 'is Class' do
+    expect(Noir::Command.class).to eq(Class)
+  end
+end

data/spec/noir/executer_spec.rb

@@ -0,0 +1,167 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Executer' do
+
+  # define command for tests
+  before do
+    stub_commands
+  end
+
+  it 'is class' do
+    expect(Noir::Executer.class).to eq(Class)
+  end
+
+  describe 'command_from_argv' do
+
+    describe 'in undefined argv' do
+      before do
+        stub_const('ARGV', [])
+        stub_const('Noir::Command::Help', Class.new(Noir::Base::Command))
+      end
+
+      it 'return Noir::Command' do
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command)
+      end
+    end
+
+    describe 'in defined argv' do
+
+      it 'return command' do
+        stub_const 'ARGV', ['hoge']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge)
+      end
+
+      it 'return command if has other arguments' do
+        stub_const 'ARGV', ['hoge', 'aaa']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge)
+      end
+
+      it 'return command if has sub non command' do
+        stub_const 'ARGV', ['hoge', 'SubNonCommand']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge)
+      end
+
+      it 'return sub command' do
+        stub_const 'ARGV', ['hoge', 'subcommand']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge::SubCommand)
+      end
+
+      it 'return sub command if has other arguments' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'aaa']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge::SubCommand)
+      end
+
+      it 'return sub command if has sub non command' do
+        stub_const 'ARGV', ['hoge', 'SubCommand', 'SubSubNonCommand']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge::SubCommand)
+      end
+
+      it 'return sub sub command' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'subsubcommand']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge::SubCommand::SubSubCommand)
+      end
+
+      it 'return sub sub command if has other arguments' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'subsubcommand', 'aaa']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Hoge::SubCommand::SubSubCommand)
+      end
+
+      it 'return terminal command' do
+        stub_const 'ARGV', ['fuga']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Fuga)
+      end
+
+      it 'return terminal command if has other arguments' do
+        stub_const 'ARGV', ['fuga', 'aaa']
+        expect(Noir::Executer.command_from_argv).to eq(Noir::Command::Fuga)
+      end
+
+    end
+  end
+
+  describe 'args_from_argv' do
+
+    describe 'in undefined ARGV' do
+      before { stub_const('ARGV', []) }
+
+      it 'return []' do
+        expect(Noir::Executer.args_from_argv).to eq([])
+      end
+    end
+
+    describe 'in defined argv' do
+
+      it 'return [] if only command' do
+        stub_const 'ARGV', ['hoge']
+        expect(Noir::Executer.args_from_argv).to eq([])
+      end
+
+      it 'return single arg if argv is comamnd + arg' do
+        stub_const 'ARGV', ['hoge', 'aaa']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa'])
+      end
+
+      it 'return multi arg if argv is comamnd + args' do
+        stub_const 'ARGV', ['hoge', 'aaa', 'bbb']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa', 'bbb'])
+      end
+
+      it 'return single arg if argv is command +  sub non command' do
+        stub_const 'ARGV', ['hoge', 'SubNonCommand']
+        expect(Noir::Executer.args_from_argv).to eq(['SubNonCommand'])
+      end
+
+      it 'return [] if argv is command + sub command' do
+        stub_const 'ARGV', ['hoge', 'subcommand']
+        expect(Noir::Executer.args_from_argv).to eq([])
+      end
+
+      it 'return single arg if argv is command + sub command + arg' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'aaa']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa'])
+      end
+
+      it 'return multi arg if argv is command + sub command + args' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'aaa', 'bbb']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa', 'bbb'])
+      end
+
+      it 'return single arg if argv is command + sub command + subsubnoncommand' do
+        stub_const 'ARGV', ['hoge', 'SubCommand', 'SubSubNonCommand']
+        expect(Noir::Executer.args_from_argv).to eq(['SubSubNonCommand'])
+      end
+
+      it 'return [] if argv is command + sub command + sub sub command' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'subsubcommand']
+        expect(Noir::Executer.args_from_argv).to eq([])
+      end
+
+      it 'return single arg, if argv is command + sub command + sub sub command + arg' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'subsubcommand', 'aaa']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa'])
+      end
+
+      it 'return multi arg, if argv is command + sub command + sub sub command + args' do
+        stub_const 'ARGV', ['hoge', 'subcommand', 'subsubcommand', 'aaa', 'bbb']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa', 'bbb'])
+      end
+
+      it 'return [] if argv is terminal command' do
+        stub_const 'ARGV', ['fuga']
+        expect(Noir::Executer.args_from_argv).to eq([])
+      end
+
+      it 'return single arg, if argv is terminal command + arg' do
+        stub_const 'ARGV', ['fuga', 'aaa']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa'])
+      end
+
+      it 'return single arg, if argv is terminal command + args' do
+        stub_const 'ARGV', ['fuga', 'aaa', 'bbb']
+        expect(Noir::Executer.args_from_argv).to eq(['aaa', 'bbb'])
+      end
+
+    end
+  end
+end

data/spec/noir/noir/base/command_spec.rb

@@ -0,0 +1,119 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Base::Command' do
+
+  it 'is class' do
+    expect(Noir::Base::Command.class).to eq(Class)
+  end
+
+  describe 'Command.description' do
+    it 'raise exception if description is nil.' do
+      expect{Noir::Base::Command.description}.to raise_error(RuntimeError)
+    end
+
+    it 'output description if description is not nil' do
+      Noir::Base::Command.instance_variable_set :@description, "hoge"
+      expect{Noir::Base::Command.description}.to output.to_stdout
+      Noir::Base::Command.instance_variable_set :@description, nil
+    end
+
+    it 'not effect that set description into superclass to subclass' do
+      Noir::Base::Command.class_variable_set :@@description, "hoge"
+      stub_const('Hoge', Class.new(Noir::Base::Command))
+      expect{Hoge.description}.to raise_error
+      Noir::Base::Command.class_variable_set :@@description, nil
+    end
+  end
+
+  describe 'Command.execute' do
+    before { stub_const('Hoge', Class.new(Noir::Base::Command)) }
+
+    it 'raise exception if called in not extended class' do
+      expect{Noir::Base::Command.execute}.to raise_error(RuntimeError)
+    end
+
+    it 'raise exception if called in extended class but undefined description' do
+      expect{Hoge.execute}.to raise_error
+    end
+
+    it 'output description if called in extended class and defined description' do
+      Hoge.instance_variable_set :@description, "hoge"
+      expect{Hoge.execute}.to output.to_stdout
+    end
+  end
+
+  describe 'Command.sub_commands' do
+    it 'return [] when not defined sub commands' do
+      expect(Noir::Base::Command.sub_commands).to eq([])
+    end
+
+    describe 'when defined sub commands.' do
+      before do
+        stub_const('Hoge'                               , Class.new(Noir::Base::Command))
+        stub_const('Hoge::SubCommand'                   , Class.new(Noir::Base::Command))
+        stub_const('Hoge::SubCommand::SubSubCommand'    , Class.new(Noir::Base::Command))
+        stub_const('Hoge::SubCommand::SubSubNonCommand' , Class.new)
+        stub_const('Hoge::SubCommandTwo'                , Class.new(Noir::Base::Command))
+        stub_const('Hoge::SubNonCommand'                , Class.new)
+
+=begin
+        # stub_const is this structure
+        class Hoge < Noir::Base::Command
+          class SubCommand < Noir::Base::Command
+            class SubSubCommand < Noir::Base::Command
+            end
+            class SubSubNonCommand
+            end
+          end
+          class SubCommandTwo < Noir::Base::Command
+          end
+
+          class SubNonCommand
+          end
+        end
+=end
+
+        @commands = Hoge.sub_commands
+      end
+
+      it 'return subcommands' do
+        expect(@commands).to eq([:SubCommand, :SubCommandTwo])
+      end
+
+      it 'not include symbol that not inherited Noir::Base::Command' do
+        expect(@commands).not_to include(:SubNonCommand)
+      end
+
+      it 'not include symbol that subsub command' do
+        expect(@commands).not_to include(:SubSubCommand)
+      end
+
+      it 'not include self' do
+        expect(@commands).not_to include(:Hoge)
+      end
+
+      describe 'in sub command' do
+        before { @commands = Hoge::SubCommand.sub_commands }
+
+        it 'return sub sub command' do
+          expect(@commands).to eq([:SubSubCommand])
+        end
+
+        it 'not include sub sub non command' do
+          expect(@commands).not_to include(:SubSubNonCommand)
+        end
+
+        it 'not include sub command' do
+          expect(@commands).not_to include(:SubCommand, :SubCommandTwo, :SubNonCommand)
+        end
+
+        it 'not include self class' do
+          expect(@commands).not_to include(:SubCommand)
+        end
+
+      end
+    end
+
+  end
+end

data/spec/noir/noir/base/terminal_command_spec.rb

@@ -0,0 +1,33 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Base::TerminalCommand' do
+
+  it 'is class' do
+    expect(Noir::Base::TerminalCommand.class).to eq(Class)
+  end
+
+  it 'is inherited Noir::Base::Command' do
+    expect(Noir::Base::TerminalCommand.ancestors).to include(Noir::Base::Command)
+  end
+
+  describe '.execute' do
+    before { stub_const('Hoge', Class.new(Noir::Base::TerminalCommand)) }
+
+    it 'raise exception when not overrided' do
+      expect{Noir::Base::TerminalCommand.execute}.to raise_error(RuntimeError, /^called raw/)
+    end
+
+    it 'raise exception in extended class not overrided' do
+      expect{Hoge.execute}.to raise_error(RuntimeError, /^please override/)
+    end
+
+    it 'raise exception in extended class not overrided' do
+      def Hoge.execute *args
+        puts "hoge"
+      end
+      expect{Hoge.execute}.to output("hoge\n").to_stdout
+    end
+  end
+
+end

data/spec/noir/noir/base_spec.rb

@@ -0,0 +1,10 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Base' do
+
+  it "is module" do
+    expect(Noir::Base.class).to eq(Module)
+  end
+
+end

data/spec/noir/noir_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'noir'
+
+describe Noir do
+
+
+  it 'is can access Noir::VERSION' do
+    expect(Noir.class_eval('Noir::VERSION.class')).to eq(String)
+  end
+
+  it 'is can access Noir::Options' do
+    expect(Noir.class_eval('Noir::Options.class')).to eq(Class)
+  end
+
+  it 'is can access Noir::Base' do
+    expect(Noir.class_eval('Noir::Base.class')).to eq(Module)
+  end
+
+  it 'is can access Noir::Base::Command' do
+    expect(Noir.class_eval('Noir::Base::Command.class')).to eq(Class)
+  end
+
+  it 'is can access Noir::Base::TerminalCommand' do
+    expect(Noir.class_eval('Noir::Base::TerminalCommand.class')).to eq(Class)
+  end
+
+end

data/spec/noir/options_spec.rb

@@ -0,0 +1,52 @@
+require 'noir'
+require 'spec_helper'
+
+describe 'Noir::Options' do
+
+  it 'is Class' do
+    expect(Noir::Options.class).to eq(Class)
+  end
+
+  describe 'Noir::Options.exist?' do
+    after {Noir::Options.class_variable_set :@@options, {}}
+
+    it 'is return false if argument is nil.' do
+      expect(Noir::Options.exist? nil).to eq(false)
+    end
+
+    it '(Help) is return false if ARGV not include "-h"' do
+      expect(Noir::Options.exist? Noir::Options::Help).to eq(false)
+    end
+
+    it '(Help) is return true if ARGV include "-h"' do
+      stub_const('ARGV', ['-h'])
+      Noir::Options.parse_options_from_argv!
+      expect(Noir::Options.exist? Noir::Options::Help).to eq(true)
+    end
+
+    it '(Help) is return false if ARGV not include "--help"' do
+      expect(Noir::Options.exist? Noir::Options::Help).to eq(false)
+    end
+
+    it '(Help) is return true if ARGV include "--help"' do
+      stub_const('ARGV', ['--help'])
+      Noir::Options.parse_options_from_argv!
+      expect(Noir::Options.exist? Noir::Options::Help).to eq(true)
+    end
+
+    it 'exit with output version if ARGV include "-v"' do
+      stub_const('ARGV', ['-v'])
+      expect {
+        expect{Noir::Options.parse_options_from_argv!}.to raise_error(SystemExit)
+      }.to output('noir ' + Noir::VERSION + "\n").to_stdout
+    end
+
+    it 'exit with output version if ARGV include "--version"' do
+      stub_const('ARGV', ['--version'])
+      expect {
+        expect{Noir::Options.parse_options_from_argv!}.to raise_error(SystemExit)
+      }.to output('noir ' + Noir::VERSION + "\n").to_stdout
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'noir'
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+# utils
+
+def stub_commands
+  stub_const('Noir::Command::Hoge'                               , Class.new(Noir::Base::Command))
+  stub_const('Noir::Command::Hoge::SubCommand'                   , Class.new(Noir::Base::Command))
+  stub_const('Noir::Command::Hoge::SubCommand::SubSubCommand'    , Class.new(Noir::Base::Command))
+  stub_const('Noir::Command::Hoge::SubCommand::SubSubNonCommand' , Class.new)
+  stub_const('Noir::Command::Hoge::SubCommandTwo'                , Class.new(Noir::Base::Command))
+  stub_const('Noir::Command::Hoge::SubNonCommand'                , Class.new)
+  stub_const('Noir::Command::Fuga'                               , Class.new(Noir::Base::TerminalCommand))
+
+=begin
+        # stub_const is this structure
+        module Noir::Command
+          class Hoge < Noir::Base::Command
+            class SubCommand < Noir::Base::Command
+              class SubSubCommand < Noir::Base::Command
+              end
+              class SubSubNonCommand
+              end
+            end
+            class SubCommandTwo < Noir::Base::Command
+            end
+
+            class SubNonCommand
+            end
+          end
+          class Fuga < Noir::Base::TerminalCommand
+          end
+        end
+=end
+
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: noir
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- atton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+description: Untility commands with completion for atton.
+email:
+- e115763@gmail.com
+executables:
+- noir
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/noir
+- lib/noir.rb
+- lib/noir/base.rb
+- lib/noir/base/command.rb
+- lib/noir/base/terminal_command.rb
+- lib/noir/command.rb
+- lib/noir/command/completion.rb
+- lib/noir/command/help.rb
+- lib/noir/command/init.rb
+- lib/noir/command/init/zsh.rb
+- lib/noir/command/new.rb
+- lib/noir/command/new/note.rb
+- lib/noir/executer.rb
+- lib/noir/options.rb
+- lib/noir/version.rb
+- noir.gemspec
+- spec/noir/command/completion_spec.rb
+- spec/noir/command/help_spec.rb
+- spec/noir/command/init/zsh_spec.rb
+- spec/noir/command/init_spec.rb
+- spec/noir/command/new/note_spec.rb
+- spec/noir/command/new_spec.rb
+- spec/noir/command_spec.rb
+- spec/noir/executer_spec.rb
+- spec/noir/noir/base/command_spec.rb
+- spec/noir/noir/base/terminal_command_spec.rb
+- spec/noir/noir/base_spec.rb
+- spec/noir/noir_spec.rb
+- spec/noir/options_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/atton-/noir
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Utilities for atton.
+test_files:
+- spec/noir/command/completion_spec.rb
+- spec/noir/command/help_spec.rb
+- spec/noir/command/init/zsh_spec.rb
+- spec/noir/command/init_spec.rb
+- spec/noir/command/new/note_spec.rb
+- spec/noir/command/new_spec.rb
+- spec/noir/command_spec.rb
+- spec/noir/executer_spec.rb
+- spec/noir/noir/base/command_spec.rb
+- spec/noir/noir/base/terminal_command_spec.rb
+- spec/noir/noir/base_spec.rb
+- spec/noir/noir_spec.rb
+- spec/noir/options_spec.rb
+- spec/spec_helper.rb