cucumba 0.0.5

data/lib/cucumba/rails.rb

@@ -0,0 +1,60 @@
+require 'drb'
+require 'cucumba/rails/model'
+
+module Cucumba
+  # Cucumba rails client
+  class Rails
+
+    class ServerNotFound < Exception
+    end
+
+    attr_reader :host, :port, :drb_port, :description, :environment
+
+    def initialize(config)
+      @host = config[:host]
+      @port = config[:port] || 80
+      @drb_port = @port+1000
+      @run = config[:run]
+      @description = config[:desc]
+      @environment = config[:env]
+      if config[:path]
+	@path = File.join(config[:path])
+      else
+	@path = File.join('.')
+      end
+      @path = File.expand_path(@path)
+      @pid_file = File.join(@path,'tmp/pids/server.pid')
+      @server = DRbObject.new(nil, drb_url)
+    end
+
+    # url where rails application lives
+    def url
+      'http://'+@host+':'+@port.to_s
+    end
+
+    def drb_url
+      'druby://'+@host+':'+@drb_port.to_s
+    end
+
+    def rails_root
+      @path
+    end
+
+    def run?
+      @run
+    end
+
+    def model(model_name)
+      Model.new(model_name,@server)
+    end
+    alias :m :model
+
+    def execute(code)
+      @server.execute(code)
+    end
+    alias :e :execute
+
+  end
+end
+
+DRb.start_service

data/lib/cucumba/rails/model.rb

@@ -0,0 +1,26 @@
+module Cucumba
+  class Rails
+    class Model
+
+      class NotFoundError < Exception
+      end
+
+      def initialize(model_name,server)
+	@server = server
+	if @server.has_model?(model_name)
+	  @model = model_name
+	else
+	  raise NotFoundError
+	end
+      end
+
+      def method_missing(method,*args)
+        if @server.model_has_method?(@model,method)
+	  @server.invoke_method_on_model(@model,method,args)
+	else
+	  super
+	end
+      end
+    end
+  end
+end

data/lib/cucumba/rails/runner.rb

@@ -0,0 +1,73 @@
+require 'cucumba'
+require 'net/http'
+
+module Cucumba
+
+  class Rails
+
+    def rails_start!
+      if run?
+	puts "=> #{self.description} booting..."
+	boot!
+	wait_untill_alive!
+      end
+    end
+
+    def rails_stop!
+      pid = File.read(@pid_file).to_i
+      puts "=> Killing alive server #{self.description}(pid:#{pid})"
+      Process.kill('INT',pid)
+    rescue Errno::ESRCH, Errno::ENOENT
+      puts "=> Server #{self.description} is not running"
+    end
+
+    private
+
+    def boot!
+      cmd = "ruby #{File.join(@path,'script','server')}"
+      cmd+= " --port=#{@port}"
+      cmd+= " --daemon"
+      cmd+= " --environment=#{@environment}"
+      puts `#{cmd}`
+    end
+
+    def wait_untill_alive!
+      check_start_time = Time.now
+      loop do
+	raise TimeoutError, "server #{self.description} start timeout" if (200-(Time.now.to_i - check_start_time.to_i)) <= 0
+	if alive?
+	  puts "=> #{self.description} alive!"
+	  break
+	else
+	  sleep 0.2
+	end
+      end
+    end
+
+    def alive?
+      Net::HTTP.start(@host, @port) { |http| http.get('/rails/info/properties') }
+    rescue Errno::ECONNREFUSED, Errno::EBADF
+      return false
+    end
+
+  end
+
+  class <<self
+
+    # run all cucumba servers that should be run(:run => true)
+    def servers_start!
+      config.each do |server_config|
+	Cucumba[server_config[:name]].rails_stop!
+	Cucumba[server_config[:name]].rails_start!
+      end
+    end
+    alias :start_servers! :servers_start!
+
+    def servers_stop!
+      config.each { |server_config| Cucumba[server_config[:name]].rails_stop! }
+    end
+    alias :stop_servers! :servers_stop!
+
+  end
+
+end

data/lib/cucumba/server.rb

@@ -0,0 +1,14 @@
+lib = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+$:.unshift(lib) unless $:.include?(lib)
+
+require 'cucumba/rails/runner'
+
+Cucumba.servers_start!
+trap(:INT) do
+  puts
+  Cucumba.servers_stop!
+  exit 0
+end
+
+puts "=> press Ctrl-C to exit and kill servers"
+sleep

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/cucumba.rb'}"
+puts "Loading cucumba gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+load File.dirname(__FILE__) + "/../Rakefile"
+require 'rubyforge'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+download = "http://rubyforge.org/projects/#{$hoe.rubyforge_name}"
+version  = $hoe.version
+
+def rubyforge_project_id
+  RubyForge.new.configure.autoconfig["group_ids"][$hoe.rubyforge_name]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)

data/spec/cucumba_configuration_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Cucumba configuration" do
+  def load_fake_rails_module
+    Object.const_set "Rails", Module.new
+  end
+
+  def remove_fake_rails_module
+    Object.send :remove_const, :Rails
+  end
+
+  def force_cucumba_reload_config
+    Cucumba.send :class_variable_set, :@@config, nil
+  end
+
+  before :all do
+    load_fake_rails_module
+  end
+
+  before :each do
+    force_cucumba_reload_config
+    @good_config = [{
+      :name => 'name',
+      :host => 'some.host',
+      :port => 4321,
+      :desc => 'description',
+      :env  => 'test',
+      :run  => true
+      #TODO :ssl => false
+    }]
+  end
+
+  context "good configuration" do
+    it "one server" do
+      YAML.should_receive(:load_file).once.and_return(@good_config)
+      Rails.should_receive(:root).and_return('/path/to/rails/app')
+
+      [:name, "name"].each do |server|
+	client = Cucumba[server]
+
+	client.should be_instance_of(Cucumba::Rails)
+	client.host.should == 'some.host'
+	client.port.should == 4321
+	client.rails_root == '/path/to/rails/app'
+	client.drb_port.should == 5321
+	client.url.should == 'http://some.host:4321'
+	client.drb_url.should == 'druby://some.host:5321'
+	client.description.should == 'description'
+	client.environment.should == 'test'
+	client.run?.should be_true
+      end
+    end
+
+    it "should not be runned if run false" do
+      @good_config.first[:run]=false
+      YAML.should_receive(:load_file).once.and_return(@good_config)
+      Rails.should_receive(:root)
+      Cucumba[:name].run?.should be_false
+    end
+
+    it "should be runned if undefined rails" do
+      remove_fake_rails_module
+      YAML.should_receive(:load_file).once.and_return(@good_config)
+      Cucumba[:name].run?.should be_true
+    end
+  end
+
+  context "bad configuration" do
+
+    it "should raise exception if config not found" do
+      Rails.should_receive(:root)
+      YAML.should_receive(:load_file).once.and_raise(Errno::ENOENT)
+      lambda { Cucumba[:some] }.should raise_exception(Cucumba::ConfigNotFound)
+    end
+
+    it "should raise exception if server not found in config" do
+      Rails.should_receive(:root)
+      YAML.should_receive(:load_file).once.and_return(@good_config)
+      lambda { Cucumba[:wrong] }.should raise_exception(Cucumba::Rails::ServerNotFound)
+    end
+
+  end
+
+  after :all do
+    begin
+      remove_fake_rails_module
+    rescue NameError
+    end
+  end
+
+end
+
+describe 'Group without Rails' do
+  it "should not have Rails" do
+    defined?(Rails).should be_false
+  end
+end

data/spec/cucumba_spec_rails.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path(File.dirname(__FILE__) + '/support/sample_app/config/environment')
+
+describe "Cucumba[:server]" do
+
+  it "should return instance of Cucumba::Rails" do
+    Cucumba[:test].should be_instance_of(Cucumba::Rails)
+  end
+
+  context "#model" do
+
+    it "should return instace of Cucumba::Rails::Model" do
+      [ Cucumba[:test].model("User"), Cucumba[:test].m("User"), Cucumba[:test].model(:User), Cucumba[:test].m(:User) ].each do |model|
+	model.should be_instance_of(Cucumba::Rails::Model)
+      end
+    end
+
+    it "should invoke existing methods" do
+      users_count_was = User.all.count
+      Cucumba[:test].m("User").create!(:name => 'test user', :password => 'secret')
+      (User.all.count - users_count_was).should == 1
+      User.last.name.should == 'test user'
+      User.last.password.should == 'secret'
+    end
+
+    it "should invoke method without arguments" do
+      Cucumba[:test].m(:User).columns
+    end
+
+    it "should eval code in server side" do
+      Cucumba[:test].execute("User.create!(:name => 'some name', :password => 'zecred')")
+      User.last.name.should == 'some name'
+      User.last.password == 'zecred'
+    end
+
+    it "should eval code and raise exception if exception appears on server side" do
+      lambda { Cucumba[:test].e("UnknownModel") }.should raise_exception(RuntimeError)
+    end
+
+    it "should invoke this method" do
+      Cucumba[:test].m(:User).method_with_args(:name, :first => 'bla', :last => 'alb')
+    end
+
+    it "should raise exception if model does not exists" do
+      lambda { Cucumba[:test].m("Unknown") }.should raise_exception(Cucumba::Rails::Model::NotFoundError)
+    end
+
+    it "should raise exception if model's method does not exists" do
+      lambda { Cucumba[:test].m(:User).blabla }.should raise_exception(NoMethodError)
+    end
+
+    it "should raise exception if exception appears on server" do
+      lambda { Cucumba[:test].m(:User).create!(:password => 'secret') }.should raise_exception(RuntimeError,"ActiveRecord::RecordInvalid Validation failed: Name can't be blank")
+    end
+
+  end
+end