cuttlebone 0.1.3

data/.gitignore

@@ -0,0 +1,6 @@
+.rvmrc
+.bundle
+.autotest
+Gemfile.lock
+coverage/
+pkg/

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+## 0.1.2 / 2011-03-18
+
+* Changed directory structure to look like a real gem. :)
+* Finalized initial test cases (spec/cucumber).
+* github.com release!
+* Added my original todo example using the new syntax.
+
+## 0.1.1 / 2011-03-15
+
+* Added new test cases and new "polished" features.
+
+## 0.1.0 / 2010-07-06
+
+* After a long (inactive) year, some projects generated a need to push
+  cuttlebone a little further.  There are no new features but tests and
+  documentation.
+
+## 0.0.1 / 2009-05-13
+
+* Birthday!  Presentation on the topic (and my proof of concept demo):
+  http://www.viddler.com/explore/budapestrb/videos/4/
+

data/Gemfile

@@ -0,0 +1,2 @@
+source :gemcutter
+gemspec

data/README.md

@@ -0,0 +1,56 @@
+# cuttlebone
+
+Cuttlebone helps you creating shell-alike applications.  Easily.
+
+## INSTALL AND USAGE
+
+Install Ruby 1.9.2, clone, setup, try. :)  Check `examples` and `features`
+directories for examples.
+
+## TODO
+
+* Documentation-documentation-documentation...
+
+* Tests-tests-tests...
+
+* Methods defined in context definitions should be called from command/prompt
+  blocks.
+
+* For Symbol contexts special attribute and method definitions should work
+  intuitively.
+
+* Terminal handling, colors, sizes (eg.
+  http://codeidol.com/other/rubyckbk/User-Interface/Determining-Terminal-Size/,
+  ncurses(?)).
+
+* Autocomplete (eg. cldwalker/bond or with a new approach based on 1.9.2's
+  readline enhancement).
+
+* Asynchronous (server-initiated) output.
+
+* Web driver.
+
+## LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009-2011 Golda Bence <bence@golda.me>
+
+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/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+CUTTLEBONE_GEMSPEC = eval(File.read(File.expand_path('../cuttlebone.gemspec', __FILE__)))
+
+desc 'Default: run specs'
+task :default => 'spec'
+
+namespace :spec do
+  desc 'Run all specs in spec directory (format=progress)'
+  RSpec::Core::RakeTask.new(:progress) do |t|
+    t.pattern = './spec/**/*_spec.rb'
+    t.rspec_opts = ['--color', '--format=progress']
+  end
+
+  desc 'Run all specs in spec directory (format=documentation)'
+  RSpec::Core::RakeTask.new(:documentation) do |t|
+    t.pattern = './spec/**/*_spec.rb'
+    t.rspec_opts = ['--color', '--format=documentation']
+  end
+
+  desc "Run specs with rcov"
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.pattern = './spec/**/*_spec.rb'
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'gems/,spec/,features/']
+  end
+end
+
+task :spec => 'spec:progress'
+
+desc 'Run all cucumber tests.'
+Cucumber::Rake::Task.new do |t|
+end
+
+desc 'Generate documentation for the a4-core plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'A4::Core'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=UTF-8'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rake::GemPackageTask.new(CUTTLEBONE_GEMSPEC) do |p|
+  p.gem_spec = CUTTLEBONE_GEMSPEC
+end

data/cuttlebone.gemspec

@@ -0,0 +1,27 @@
+require File.expand_path("../lib/cuttlebone/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "cuttlebone"
+  s.version     = Cuttlebone::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bence Golda"]
+  s.email       = ["bence@golda.me"]
+  s.homepage    = "http://github.com/gbence/cuttlebone"
+  s.summary     = "cuttlebone-#{Cuttlebone::VERSION}"
+  s.description = "Cuttlebone helps you creating shell-alike applications."
+
+  s.rubyforge_project         = "cuttlebone"
+  s.required_rubygems_version = ">= 1.3.7"
+
+  s.add_development_dependency "bundler",  "~> 1.0.0"
+  s.add_development_dependency "rspec",    "~> 2.5.0"
+  s.add_development_dependency "i18n"
+  s.add_development_dependency "cucumber", "~> 0.10.0"
+  s.add_development_dependency "rcov",     "~> 0.9.0"
+
+  s.files            = `git ls-files`.split("\n")
+  s.executables      = `git ls-files`.split("\n").select{|f| f =~ /^bin/}
+  s.extra_rdoc_files = [ "README.md" ]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.require_path     = 'lib'
+end

data/examples/todo.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.expand_path('../../lib/cuttlebone', __FILE__)
+
+##
+# MODEL
+
+class Task
+  @@id = 0
+  attr_accessor :id, :title
+  def initialize options={}
+    @id    = (@@id+=1)
+    @title = options.delete(:title)
+  end
+end
+
+##
+# CUTTLEBONE DESCRIPTIONS
+
+context Array do
+  #def find_task_by_id(id_s)
+  #  id = id_s.to_i
+  #  detect { |t| t.id == id }
+  #end
+
+  prompt()    { "tasks(#{size})" }
+
+  command(?l) { each { |t| output('(%03d) %50s' % [t.id, t.title]) } }
+  command(?n) { send(:<<, t = Task.new); add t }
+  command /^([0-9]+)$/ do |id_s|
+    #t = find_task_by_id(id_s)
+    id = id_s.to_i
+    t  = detect { |t| t.id == id }
+    add(t) if t
+  end
+  command /^d ([0-9]+)$/ do |id_s|
+    #t = find_task_by_id(id_s)
+    id = id_s.to_i
+    t  = detect { |t| t.id == id }
+    delete(t)
+  end
+  command(?q) { drop }
+end
+
+context Task do
+  prompt()    { ('%03d' % [id]) + (' ' + (title.size<=20 ? title : "#{title[0..18]}…") rescue '') }
+
+  command(?q) { drop }
+  command /^(.+)$/ do |text|
+    send(:title=, text)
+  end
+end
+
+at_exit do
+  Cuttlebone.run([Task.new(:title => 'x'), Task.new(:title => 'y')])
+end

data/features/example.feature

@@ -0,0 +1,53 @@
+@console @example
+Feature: a simple example
+  In order to be able to manage a simple todo list
+  As a programmer
+  I want to create cuttlebone program
+
+  Scenario: starting with no defined contexts
+    Given no cuttlebone code
+    When I start an "x" session
+    Then I should get an error
+
+  Scenario: starting with an existing context
+    Given the following cuttlebone code:
+      """
+      context "x" do
+      end
+      """
+    When I start an "x" session
+    Then I should see an empty prompt
+    And I should be in context "x"
+
+  Scenario: starting with a missing context
+    Given the following cuttlebone code:
+      """
+      context "x" do
+      end
+      """
+    When I start a "y" session
+    Then I should get an error
+
+  Scenario: starting a context with prompt defined
+    Given the following cuttlebone code:
+      """
+      context "x" do
+        prompt { "prompt" }
+      end
+      """
+    When I start an "x" session
+    Then I should see "prompt" as prompt
+
+  Scenario: invoking a simple command
+    Given the following cuttlebone code:
+      """
+      context "x" do
+        command /^y$/ do
+          self
+        end
+      end
+      """
+    When I start an "x" session
+    And I call command "y"
+    Then I should see an empty prompt
+    And I should be in context "x"

data/features/step_definitions/steps.rb

@@ -0,0 +1,76 @@
+require 'pp'
+# schema / definitions
+
+Given /^no cuttlebone code$/ do
+  Cuttlebone.definitions.clear
+end
+
+Given /^the following cuttlebone code:$/ do |string|
+  Given %{no cuttlebone code}
+  Cuttlebone.instance_eval(string)
+end
+
+# initialization
+
+Given /^a started "([^"]*)" session$/ do |objects|
+  When %{I start a #{objects.inspect} session}
+end
+
+When /^I start (?:an? )?"([^"]*)" session$/ do |objects|
+  @d = Cuttlebone::Session::Test.new(*(objects.scan(/([^,]{1,})(?:,\s*)?/).flatten))
+end
+
+# invocation
+
+When /^I call command "([^"]*)"$/ do |command|
+  @d.call(command)
+end
+
+# context related steps
+
+Then /^I should be in context "([^"]*)"$/ do |name|
+  @d.active_context.context.to_s.should == name
+end
+
+Then /^I should see a terminated session$/ do
+  @d.should be_terminated
+end
+
+Then /^I should be in the same context$/ do
+  @d.previous_active_context.should == @d.active_context
+end
+
+Then /^I should not be in the same context$/ do
+  @d.previous_active_context.should_not == @d.active_context
+end
+
+# output related steps
+
+Then /^I should see "([^"]*)"$/ do |text|
+  @d.output.should include(text)
+end
+
+# prompt related steps
+
+Then /^I should see "([^"]*)" as prompt$/ do |text|
+  @d.prompt.should include(text)
+end
+
+Then /^I should see \/([^\/]*)\/ as prompt$/ do |regexp|
+  @d.prompt.should match(regexp)
+end
+
+Then /^I should see an empty prompt$/ do
+  @d.prompt.should be_empty
+end
+
+# error related steps
+
+Then /^I should see an error$/ do
+  @d.error.should_not be_blank
+end
+
+Then /^I should get an error$/ do
+  @d.internal_error.should_not be_blank
+end
+

data/features/support/env.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'cuttlebone'))
+require 'cucumber/formatter/unicode'

data/features/support/test_driver.rb

@@ -0,0 +1,24 @@
+class Cuttlebone::Session::Test < Cuttlebone::Session::Base
+  def initialize *args
+    super
+    stack = []
+    @stack.each { |c| stack << c }
+    @stack_history = [ stack ]
+  end
+
+  def process command
+    stack = []
+    @stack.each { |c| stack << c }
+    @stack_history << stack
+    a, n, o, e = super(command)
+    @output = o
+    @error  = e
+    [ a, n, o, e ]
+  end
+
+  attr_reader :output, :error
+
+  def previous_active_context
+    @stack_history[-2].last
+  end
+end

data/features/switching_contexts.feature

@@ -0,0 +1,78 @@
+Feature: switching between contexts
+  In order to be able to manage my todo list
+  As a programmer
+  I want to switch between cuttlebone contexts
+
+  Background:
+    Given the following cuttlebone code:
+      """
+      context 'x' do
+        command 'q' do
+          drop
+        end
+        command 'y' do
+          replace 'y'
+        end
+        command 'yy' do
+          add 'y'
+        end
+        command 'x' do
+          self
+        end
+        command 'xx' do
+          add 'x'
+        end
+        command 'r' do
+          replace 'x'
+        end
+      end
+
+      context 'y' do
+        command 'q' do
+          drop
+        end
+        command 'y' do
+          self
+        end
+      end
+      """
+
+  Scenario: quitting
+    Given a started "x" session
+    When I call command "q"
+    Then I should see a terminated session
+
+  Scenario: replacing current context
+    Given a started "x" session
+    When I call command "y"
+    Then I should be in context "y"
+
+  Scenario: returning the same context
+    Given a started "x" session
+    When I call command "x"
+    Then I should be in the same context
+
+  Scenario: replacing with a similar context
+    Given a started "x" session
+    When I call command "r"
+    Then I should not be in the same context
+
+  Scenario: entering into a new context
+    Given a started "x" session
+    When I call command "yy"
+    Then I should be in context "y"
+
+  Scenario: dropping previously built context
+    Given a started "x" session
+    When I call command "yy"
+    And I call command "q"
+    Then I should be in context "x"
+
+  Scenario: consume multiple contexts and quit
+    Given a started "x,y,y,x" session
+    When I call command "q"
+    And I call command "q"
+    And I call command "q"
+    Then I should be in context "x"
+    When I call command "q"
+    Then I should see a terminated session

data/lib/cuttlebone.rb

@@ -0,0 +1,19 @@
+$: << File.expand_path('../', __FILE__)
+
+require File.expand_path('../../vendor/active_support.rb', __FILE__)
+
+module Cuttlebone
+  require               'cuttlebone/exceptions'
+  autoload :Controller, 'cuttlebone/controller'
+  autoload :Definition, 'cuttlebone/definition'
+  autoload :Session,    'cuttlebone/session'
+
+  @@definitions = []
+  def self.definitions; @@definitions; end
+
+  def self.run starting_objects, default_driver=Session::Shell
+    default_driver.new(starting_objects).run
+  end
+end
+
+include Cuttlebone::Definition::DSL

data/lib/cuttlebone/controller.rb

@@ -0,0 +1,69 @@
+#
+# NOTE: we don't really want to pollute this proxy with a lot of private
+# (internal) methods to leave space for <<context>>'s real methods.
+class Cuttlebone::Controller
+
+  attr_reader :session, :context, :definition
+
+  def initialize session, context
+    @session    = session
+    @context    = context
+    @definition = Cuttlebone.definitions.find { |d| d.match(context) }
+    raise Cuttlebone::InvalidContextError, context, "No definiton was found for #{context.inspect}!" unless @definition
+  end
+
+  ##
+  # Processes a command on its context's domain.
+  #
+  def process command
+    @next_action = nil
+    @output = []
+
+    return([:self, self, [], nil]) if command.empty?
+    block, arguments = definition.proc_for(command)
+
+    instance_exec(*arguments, &block)
+    action, context = @next_action || [ :self, self ]
+
+    return([ action, context, @output, nil ])
+  rescue Cuttlebone::DoubleActionError
+    raise
+  rescue => e
+    return([ :self, self, [], %{Cuttlebone::Controller: #{e.message} (#{e.class})} ])
+  end
+
+  def prompt
+    return(instance_exec(&@definition.prompt) || '')
+  rescue => e
+    %{error: #{e.message} (#{e.class.name})}
+  end
+
+  def drop
+    __save_next_action! :drop
+  end
+
+  def add context
+    __save_next_action! :add, context
+  end
+
+  def replace context
+    __save_next_action! :replace, context
+  end
+
+  def output text
+    @output << text
+  end
+
+  def method_missing method_name, *args, &block
+    return(@context.send(method_name, *args, &block)) if @context.respond_to?(method_name)
+    return(super)
+  end
+
+  private
+
+  def __save_next_action! action, context=nil
+    raise Cuttlebone::DoubleActionError if @next_action
+    @next_action = [ action, context ]
+  end
+
+end

data/lib/cuttlebone/definition.rb

@@ -0,0 +1,58 @@
+module Cuttlebone
+  class Definition
+
+    module DSL
+      def context object, options={}, &definition
+        Cuttlebone.definitions << Definition.new(object, options, &definition)
+      end
+    end
+
+    class Parser
+      def initialize definition
+        @definition = definition
+      end
+
+      def command string_or_regexp, &block
+        @definition.commands << [ string_or_regexp, block, @last_description ]
+        @last_description = nil
+        self
+      end
+
+      def description text
+        @last_description = text
+        self
+      end
+
+      def prompt text='', &block
+        @definition.prompt = block_given? ? block : proc { text }
+      end
+    end
+
+    attr_accessor :prompt, :commands
+
+    def initialize object_or_class, options={}, &definition
+      raise ArgumentError, 'missing block' unless block_given?
+      @object_or_class = object_or_class
+      @options         = options
+      @commands        = [] #Array.new(proc { |c| [:self, c, '', nil] })
+      @prompt          = proc { |c| '' }
+
+      @parser = Parser.new(self)
+      @parser.instance_eval(&definition)
+    end
+
+    delegate :command, :to => '@parser'
+
+    def match object
+      @object_or_class === object
+      # TODO :if :unless options
+    end
+
+    def proc_for command
+      string_or_regexp, block, description = commands.find { |(sr,b,d)| sr === command } || raise(UnknownCommandError, "Unknown command: #{command.inspect}!")
+      return([ block, $~.captures ]) if $~
+      return([ block, [] ])
+    end
+  end
+
+end

data/lib/cuttlebone/exceptions.rb

@@ -0,0 +1,24 @@
+module Cuttlebone
+
+  ##
+  # Raised when Controller is invoked with an invalid (not matching) context.
+  # 
+  class InvalidContextError < StandardError
+    attr_reader :context
+    def initialize context, *args, &block
+      @context = context
+      super *args, &block
+    end
+  end
+
+  ##
+  # Raised on unknown command calls.
+  #
+  class UnknownCommandError < StandardError; end
+
+  ##
+  # Raised when multiple actions are invoked simultanously.
+  #
+  class DoubleActionError < StandardError; end
+
+end

data/lib/cuttlebone/session.rb

@@ -0,0 +1,4 @@
+module Cuttlebone::Session
+  autoload :Base, 'cuttlebone/session/base'
+  autoload :Shell, 'cuttlebone/session/shell'
+end

data/lib/cuttlebone/session/base.rb

@@ -0,0 +1,61 @@
+class Cuttlebone::Session::Base
+
+  attr_reader :stack, :internal_error
+
+  def initialize *stack_objects
+    setup_contexts 'cuttlebone.stack_objects' => stack_objects
+  end
+
+  def active_context
+    stack.last
+  end
+
+  delegate :name, :prompt, :to => :active_context
+
+  def setup_contexts env={}
+    @stack ||= (env['cuttlebone.stack_objects'] || []).map{ |o| Cuttlebone::Controller.new(self, o) }
+  rescue Cuttlebone::InvalidContextError => e
+    @internal_error = %{Context initialization failed for #{e.context.inspect}!}
+    @stack = []
+  rescue => e
+    @internal_error = %{Internal error occured: #{e.message} (#{e.class})}
+    @stack = []
+  end
+  private :setup_contexts
+
+  def process command
+    active_context = @stack.pop
+
+    action, next_context, output, error = begin
+                                            a, n, o, e = active_context.process(command)
+                                            raise ArgumentError, "Unknown action: #{a}" unless [ :self, :replace, :add, :drop ].include?(a.to_s.to_sym)
+                                            raise TypeError, "Output must be an instance of String or nil!" unless o.is_a?(Array) or o.nil?
+                                            raise TypeError, "Error must be an instance of String or nil!" unless e.is_a?(String) or e.nil?
+                                            [ a.to_s.to_sym, n, o, e ]
+                                          rescue => e
+                                            [ :self, active_context, nil, %{Cuttlebone::Session: #{e.message} (#{e.class})} ]
+                                          end
+    case action
+    when :self
+      @stack << active_context
+    when :replace
+      @stack << Cuttlebone::Controller.new(self, next_context)
+    when :add
+      @stack << active_context << Cuttlebone::Controller.new(self, next_context)
+    when :drop
+      # noop
+    end
+    [ action, next_context, output, error ]
+  end
+  private :process
+
+  def call command, env={}
+    setup_contexts env
+    process command
+  end
+
+  def terminated?
+    stack.empty?
+  end
+
+end

data/lib/cuttlebone/session/rack.rb

@@ -0,0 +1,4 @@
+class Cuttlebone::Session::Rack < Cuttlebone::Session::Base
+  def run
+  end
+end

data/lib/cuttlebone/session/shell.rb

@@ -0,0 +1,17 @@
+# TODO FIXME load readline iff it was invoked through command line interface
+require 'readline'
+
+class Cuttlebone::Session::Shell < Cuttlebone::Session::Base
+  def run
+    loop do
+      break if terminated?
+      command = Readline::readline("#{prompt} > ")
+      break unless command
+      Readline::HISTORY.push(command)
+      _, _, output, error = call(command)
+      print (output<<'').join("\n")
+      print "\033[01;31m#{error}\033[00m\n" if error
+    end
+  end
+end
+

data/lib/cuttlebone/version.rb

@@ -0,0 +1,3 @@
+module Cuttlebone
+  VERSION = "0.1.3"
+end

data/spec/controller_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Cuttlebone::Controller do
+  let(:valid_session) { mock("Cuttlebone::Session::Base") }
+  let(:valid_context) { 'x' }
+
+  let(:drop_proc)    { proc { |*args| output 'dropped'; drop } }
+  let(:self_proc)    { proc { |*args| output 'noop'; self } }
+  let(:add_proc)     { proc { |*args| output 'added'; add 'x' } } # TODO FIXME change 'x' => valid_context somehow 'cause they are the same instance
+  let(:replace_proc) { proc { |*args| output 'replaced'; replace 'x' } }
+  let(:double_action_error_proc) { proc { |*args| output 'double action error'; drop; add 'x' } }
+  let(:prompt_proc)  { proc { |*args| 'prompt' } }
+
+  let(:valid_context_definition) do
+    x = mock('Cuttlebone::Definition "x"')
+    x.stub!(:match).and_return() { |*args| args == [valid_context] }
+    x.stub!(:proc_for).with('drop').and_return(drop_proc)
+    x.stub!(:proc_for).with('self').and_return(self_proc)
+    x.stub!(:proc_for).with('add').and_return(add_proc)
+    x.stub!(:proc_for).with('replace').and_return(replace_proc)
+    x.stub!(:proc_for).with('double').and_return(double_action_error_proc)
+    x.stub!(:prompt).and_return(prompt_proc)
+    x
+  end
+
+  before :each do
+    Cuttlebone.stub!(:definitions).and_return([ valid_context_definition ])
+  end
+
+  context "given a valid context" do
+    subject { Cuttlebone::Controller.new(valid_session, valid_context) }
+
+    it "should return context object" do
+      subject.context.should == valid_context
+    end
+
+    it "should return [:self, self, nil, nil] to empty commands" do
+      subject.process('').should == [ :self, subject, [], nil ]
+    end
+
+    it "should return [:drop, nil, 'dropped', nil] to 'drop' commands" do
+      subject.process('drop').should == [:drop, nil, ['dropped'], nil]
+    end
+
+    it "should return [:self, self, 'noop', nil] to 'drop' commands" do
+      subject.process('self').should == [:self, subject, ['noop'], nil]
+    end
+
+    it "should return [:add, valid_context, 'added', nil] to 'drop' commands" do
+      subject.process('add').should == [:add, valid_context, ['added'], nil]
+    end
+
+    it "should return [:replace, valid_context, 'replaced', nil] to 'drop' commands" do
+      subject.process('replace').should == [:replace, valid_context, ['replaced'], nil]
+    end
+
+    it "should raise error on double action commands" do
+      expect{ subject.process('double') }.should raise_error(Cuttlebone::DoubleActionError)
+    end
+
+    it "should execute command in <<context>>'s context" do
+      valid_context_definition.stub!(:proc_for).with('x').and_return(proc{ x })
+      valid_context.should_receive(:x)
+      subject.process('x')
+    end
+
+    it "should execute prompt in <<context>>'s context" do
+      valid_context_definition.stub!(:prompt).and_return(proc{ x })
+      valid_context.should_receive(:x)
+      subject.prompt()
+    end
+  end
+
+  context "given an invalid context" do
+    it "should raise an exception" do
+      expect{ Cuttlebone::Controller.new(valid_session, 'invalid_context') }.should raise_error(Cuttlebone::InvalidContextError)
+    end
+  end
+end

data/spec/cuttlebone_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Cuttlebone do
+  before :each do
+    Cuttlebone.definitions.clear
+  end
+
+  it "should start with no contexts defined" do
+    Cuttlebone.definitions.should be_empty
+  end
+
+  it "should be able to evaluate new context definitions" do
+    Cuttlebone.should respond_to(:context)
+  end
+
+  it "should start a new session" do
+    Cuttlebone.should respond_to(:run)
+  end
+end

data/spec/definition_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '/spec_helper'))
+
+describe Cuttlebone::Definition do
+  let(:valid_context_identifier) { :c }
+  let(:valid_options)            { {} }
+  let(:valid_block)              { proc { command('x') {} } }
+
+  context "given valid but meaningless parameters" do
+    subject { Cuttlebone::Definition.new(valid_context_identifier, valid_options, &valid_block) }
+
+    it "should match to the context id given" do
+      subject.should match(valid_context_identifier)
+    end
+
+    it "should return prompt" do
+      subject.should respond_to(:prompt)
+      subject.prompt.should be_a(Proc)
+    end
+  end
+
+  context "given class for context matcher" do
+    let(:klass)     { Class.new(Object) }
+    let(:instance1) { klass.new }
+    let(:instance2) { klass.new }
+    let(:other_instance) { Object.new }
+    let(:subclass)  { Class.new(klass) }
+    let(:instance3) { subclass.new }
+    subject { Cuttlebone::Definition.new(klass, valid_options, &valid_block) }
+
+    it "should match instances" do
+      subject.should match(instance1)
+      subject.should match(instance2)
+      subject.should_not match(other_instance)
+    end
+
+    it "should match subclass instances" do
+      subject.should match(instance3)
+    end
+  end
+
+  context "given several commands" do
+    let(:drop_block) { proc { drop } }
+    let(:add_block)  { proc { |arg| add arg.to_s.to_sym } }
+    let(:definition_with_several_commands) do
+      proc do
+        command 'nil_will_be_self' do
+        end
+        command 'drop' do
+          drop
+        end
+        command 'add x' do
+          add 0
+        end
+        command 'replace x' do
+          replace :x
+        end
+        command 'self' do
+          self
+        end
+        command 'double_action_error' do
+          add :x
+          drop
+        end
+      end
+    end
+
+    subject { Cuttlebone::Definition.new(valid_context_identifier, valid_options, &definition_with_several_commands) }
+
+    it "should have several commands" do
+      subject.should have(6).commands
+    end
+
+    it "should parse new commands" do
+      subject.command(/new command/) { self }
+      subject.should have(7).commands
+    end
+
+    it "should return the specific block for a command" do
+      subject.command /^add (.)$/, &add_block
+
+      subject.proc_for('add x').should_not == [add_block, []]
+      subject.proc_for('add y').should == [add_block, ['y']]
+    end
+
+    it "should parse arguments properly" do
+      subject.command /^add (.)(.)?$/, &(proc{|a,b|})
+
+      subject.proc_for('add y').last.should == ['y', nil]
+      subject.proc_for('add yz').last.should == ['y', 'z']
+    end
+
+    it "should return an error for unmatched commands" do
+      expect{ subject.proc_for('unmatched') }.should raise_error(Cuttlebone::UnknownCommandError)
+    end
+
+    it "should return no error on semantically wrong commands" do
+      expect{ subject.proc_for('double_action_error') }.should_not raise_error
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec/*,gems/*" 
+--rails

data/spec/session_base_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Cuttlebone::Session::Base do
+  let(:valid_context) { 'x' }
+  let(:valid_command) { 'y' }
+
+  let(:valid_context_definition) do
+    x = mock('Definition:x')
+    x.stub!(:match).and_return() { |*args| args == [valid_context] }
+    x.stub!(:proc_for).with(any_args()).and_return([proc{}, []])
+    x
+  end
+
+  before :each do
+    Cuttlebone.stub!(:definitions).and_return([ valid_context_definition ])
+  end
+
+  context "having an active 'x' context" do
+    subject { Cuttlebone::Session::Base.new(valid_context) }
+
+    it { should_not be_terminated }
+
+    it "should have no internal error" do
+      subject.internal_error.should be_blank
+    end
+
+    it "should evaluate a string command" do
+      valid_context_definition.should_receive(:match).with(valid_context).and_return(true)
+      subject.call(valid_command)
+    end
+
+    it "should return active context" do
+      subject.should respond_to(:active_context)
+      subject.active_context.should be_a(Cuttlebone::Controller)
+    end
+
+    it "should return with a [action, context, output, error] quadruple" do
+      a, c, o, e = subject.call(valid_context)
+      [ :drop, :replace, :self, :add ].should include(a)
+      o and o.should be_a(Array)
+      e and e.should be_a(String)
+    end
+  end
+
+  context "having no active contexts" do
+    subject { Cuttlebone::Session::Base.new() }
+
+    it "should have no internal error" do
+      subject.internal_error.should be_blank
+    end
+
+    it { should be_terminated }
+  end
+
+  context "having 1 context" do
+    subject { Cuttlebone::Session::Base.new(valid_context) }
+
+    it "should have no internal error" do
+      subject.internal_error.should be_blank
+    end
+
+    it { should_not be_terminated }
+
+    it "should be terminated after a 'drop'" do
+      valid_context_definition.should_receive(:proc_for).with('drop').and_return([proc{drop}, []])
+      subject.call('drop')
+      subject.should be_terminated
+    end
+  end
+
+  context "given a wrong context" do
+    subject { Cuttlebone::Session::Base.new('invalid_context') }
+
+    it "should indicate internal error" do
+      subject.internal_error.should_not be_blank
+    end
+
+    it "should be terminated" do
+      subject.should be_terminated
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'cuttlebone'))
+
+RSpec.configure do |config|
+  config.alias_it_should_behave_like_to(:it_should_behave_like, '')
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+end

data/vendor/active_support.rb

@@ -0,0 +1,56 @@
+# (active_support)/lib/active_support/core_ext/module/remove_method.rb
+class Module
+  def remove_possible_method(method)
+    remove_method(method)
+  rescue NameError
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end
+
+# (active_support)/lib/active_support/core_ext/module/delegation.rb (stripped)
+class Module
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_" || ''
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line - 5)
+        if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
+          remove_possible_method("#{prefix}#{method}")
+        end
+
+        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+        rescue NoMethodError                                # rescue NoMethodError
+          if #{to}.nil?                                     #   if client.nil?
+            #{on_nil}                                       #     return # depends on :allow_nil
+          else                                              #   else
+            raise                                           #     raise
+          end                                               #   end
+        end                                                 # end
+      EOS
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: cuttlebone
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.3
+platform: ruby
+authors: 
+- Bence Golda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: Cuttlebone helps you creating shell-alike applications.
+email: 
+- bence@golda.me
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- cuttlebone.gemspec
+- examples/todo.rb
+- features/example.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- features/support/test_driver.rb
+- features/switching_contexts.feature
+- lib/cuttlebone.rb
+- lib/cuttlebone/controller.rb
+- lib/cuttlebone/definition.rb
+- lib/cuttlebone/exceptions.rb
+- lib/cuttlebone/session.rb
+- lib/cuttlebone/session/base.rb
+- lib/cuttlebone/session/rack.rb
+- lib/cuttlebone/session/shell.rb
+- lib/cuttlebone/version.rb
+- spec/controller_spec.rb
+- spec/cuttlebone_spec.rb
+- spec/definition_spec.rb
+- spec/rcov.opts
+- spec/session_base_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- vendor/active_support.rb
+has_rdoc: true
+homepage: http://github.com/gbence/cuttlebone
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 2700429317005123117
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.7
+requirements: []
+
+rubyforge_project: cuttlebone
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: cuttlebone-0.1.3
+test_files: []
+