zorglub 0.0.1

data/spec/node_spec.rb

@@ -0,0 +1,157 @@
+# -*- coding: UTF-8 -*-
+#
+require 'spec_helper'
+#
+describe Zorglub do
+    #
+    describe Zorglub::Node do
+        #
+        it "engine should return default Node's engine" do
+            Node0.engine.should == Zorglub::Config.engine
+            Node0.engine.should == Zorglub::Config[:engine]
+        end
+        #
+        it "layout should return default Node's layout" do
+            Node0.layout.should == Zorglub::Config.layout
+        end
+        #
+        it "engine should return class defined Node's engine" do
+            Node1.engine.should == "engine-1"
+            Node3.engine.should == "engine-2"
+        end
+        #
+        it "layout should return class defined Node's layout" do
+            Node1.layout.should == "layout-1"
+            Node3.layout.should == "layout-2"
+        end
+        #
+        it "engine should return engine inherited from Node2" do
+            Node2.engine.should == "engine-1"
+        end
+        #
+        it "layout should return layout inherited from Node2" do
+            Node2.layout.should == "layout-1"
+        end
+        #
+        it "r should build a well formed path" do
+            Node1.r(1,'arg2',"some").should == "/node1/1/arg2/some"
+        end
+        #
+        it "instance level map should work" do
+            r = Node0.my_call '/with_2args/1/2'
+            h = YAML.load r.body[0]
+            h[:map].should == '/node0'
+        end
+        #
+        it "should return err404 response when no method found" do
+            Node0.respond_to?('noresponse').should be_false
+            r = Node0.my_call '/noresponse'
+            r.status.should == 404
+        end
+        #
+        it "simple method should respond" do
+            r = Node0.my_call '/hello'
+            r.status.should == 200
+            r.body[0].should == 'world'
+        end
+        #
+        it "instance level args should work" do
+            r = Node0.my_call '/with_2args/1/2'
+            h = YAML.load r.body[0]
+            h[:args][0].should == '1'
+            h[:args][1].should == '2'
+        end
+        #
+        it "should raise error when too much arguments" do
+            lambda{ r = Node0.my_call '/with_2args/1/2/3' }.should raise_error ArgumentError
+        end
+        #
+        it "layout proc, method level layout and engine definitions should work" do
+            r = Node0.my_call '/index'
+            r.status.should == 200
+            h = YAML.load r.body[0]
+            ly = File.join Zorglub::Config.root, Zorglub::Config.layout_dir, Node0.layout
+            vu = File.join Zorglub::Config.root, Zorglub::Config.view_dir, Node0.r, 'index'
+            h[:path].should == ly
+            h[:layout].should == ly
+            h[:view].should == vu
+        end
+        #
+        it "layout proc, method level layout and engine definitions should work" do
+            r = Node1.my_call '/index'
+            r.status.should == 200
+            h = YAML.load r.body[0]
+            ly = File.join Zorglub::Config.root, Zorglub::Config.layout_dir, 'main.spec'
+            vu = File.join Zorglub::Config.root, Zorglub::Config.view_dir, Node1.r, 'index.spec'
+            h[:path].should == ly
+            h[:layout].should == ly
+            h[:view].should == vu
+        end
+        #
+        it "before_all hook should work" do
+            Node3.before = 0
+            Node3.after = 0
+            Node3.before.should == 0
+            Node3.my_call '/index'
+            Node3.before.should == 1
+            Node3.my_call '/index'
+            Node3.before.should == 2
+            Node3.my_call '/index'
+            Node3.before.should == 3
+        end
+        #
+        it "after_all hook should work" do
+            Node3.before = 0
+            Node3.after = 0
+            Node3.after.should == 0
+            Node3.my_call '/index'
+            Node3.after.should == 1
+            Node3.my_call '/index'
+            Node3.after.should == 2
+            Node3.my_call '/index'
+            Node3.after.should == 3
+        end
+        #
+        it "should find view and layout and render them" do
+            r = Node0.my_call '/do_render'
+            r.status.should == 200
+            r.body[0].should == "layout_start view_content layout_end"
+        end
+        #
+        it "partial should render correctly" do
+            Node0.partial(:do_partial, 1, 2).should == 'partial_content'
+        end
+        #
+        it "method level view should work" do
+            Node0.partial(:other_view).should == 'partial_content'
+        end
+        #
+        it "redirect should work" do
+            r = Node0.my_call '/do_redirect'
+            r.status.should == 302
+            r.header['location'].should == Node0.r(:do_partial,1,2,3)
+        end
+        #
+        it "inherited_vars should be inherited and extended" do
+            r = Node5.my_call '/index'
+            vars = YAML.load r.body[0]
+            vars.should == ['js0','js1','js3','jsx','css0','css1','css2']
+            vars[7].should be_nil
+        end
+        #
+        it "inherited_vars should be extended at method level" do
+            r = Node4.my_call '/more'
+            vars = YAML.load r.body[0]
+            vars.should == ['js0','js1','js2']
+            vars[3].should be_nil
+        end
+        #
+        it "inherited_vars should be untouched" do
+            r = Node4.my_call '/index'
+            vars = YAML.load r.body[0]
+            vars.should == ['js0','js1']
+            vars[2].should be_nil
+        end
+    end
+    #
+end

data/spec/spec_helper.rb

@@ -0,0 +1,136 @@
+#! /usr/bin/env ruby
+#
+begin
+    require 'simplecov'
+    SimpleCov.start do
+        add_filter 'spec'
+    end
+rescue LoadError
+end
+#
+require 'yaml'
+#
+require 'zorglub'
+#
+HASH_PROC = Proc.new { |path,obj| {:path=>path,:layout=>obj.layout,:view=>obj.view,:args=>obj.args,:map=>obj.map}.to_yaml }
+RENDER_PROC = Proc.new { |path,obj|
+    case obj.state
+    when :layout
+        "layout_start #{obj.content} layout_end"
+    when :view
+        "view_content"
+    when :partial
+        'partial_content'
+    else
+        raise Exception.new
+    end
+}
+Zorglub::Config.register_engine 'default', nil, HASH_PROC
+Zorglub::Config.register_engine 'engine-1', 'spec', HASH_PROC
+Zorglub::Config.register_engine 'engine-2', 'spec', HASH_PROC
+Zorglub::Config.register_engine 'real', nil, RENDER_PROC
+#
+Zorglub::Config[:engine] = 'default'
+Zorglub::Config.root = File.join Dir.pwd, 'spec', 'data'
+#
+class Zorglub::Node
+    def self.my_call uri
+        call( {'PATH_INFO'=>uri} )
+    end
+end
+#
+class Temp < Zorglub::Node
+end
+#
+class Node0 < Zorglub::Node
+    # default
+    def index
+        html
+    end
+    def hello
+        no_layout
+        'world'
+    end
+    def with_2args a1, a2
+    end
+    def do_render
+        engine 'real'
+    end
+    def do_partial a1, a2
+        engine 'real'
+    end
+    def other_view
+        engine 'real'
+        view r('do_partial')
+    end
+    def do_redirect
+        redirect r(:do_partial,1,2,3)
+    end
+end
+#
+class Node1 < Zorglub::Node
+    layout 'layout-1'
+    engine 'engine-1'
+    def index
+        layout 'main'
+        engine 'engine-2'
+    end
+end
+#
+class Node2 < Node1
+    # inherited from Node1
+end
+#
+class Node3 < Zorglub::Node
+    @before=0
+    @after=0
+    class << self
+        attr_accessor :before, :after
+    end
+    before_all do |node|
+        Node3.before +=1
+    end
+    after_all do |node|
+        Node3.after +=1
+    end
+    layout 'layout-2'
+    engine 'engine-2'
+    def index
+        (self.class.before-self.class.after).should == 1
+    end
+end
+#
+class Node4 < Zorglub::Node
+    inherited_var :js,'js0','js1'
+    def index
+        no_layout
+        inherited_var(:js).to_yaml
+    end
+    def more
+        no_layout
+        inherited_var(:js,'js2').to_yaml
+    end
+end
+#
+class Node5 < Node4
+    inherited_var :js, 'js3'
+    inherited_var :css, 'css0', 'css1'
+    def index
+        no_layout
+        js = inherited_var(:js,'jsx')
+        css = inherited_var(:css, 'css0', 'css1','css2')
+        js.concat(css).to_yaml
+    end
+end
+#
+APP = Zorglub::App.new do
+    map '/node0', Node0
+    map '/node1', Node1
+    map '/node3', Node3
+    map '/node4', Node4
+    map '/node5', Node5
+end
+class Node2
+    map APP, '/node2'
+end
+#

data/tasks/ann.rake

@@ -0,0 +1,83 @@
+# -*- coding: UTF-8 -*-
+#
+begin
+    require 'bones/smtp_tls'
+rescue LoadError
+    require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+    # A prerequisites task that all other tasks depend upon
+    task :prereqs
+    file PROJ.ann.file do
+        ann = PROJ.ann
+        puts "Generating #{ann.file}"
+        File.open(ann.file,'w') do |fd|
+            fd.puts("#{PROJ.name} version #{PROJ.version}")
+            fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+            fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+            fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+            fd.puts
+            fd.puts("== DESCRIPTION")
+            fd.puts
+            fd.puts(PROJ.description)
+            fd.puts
+            fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+            fd.puts
+            ann.paragraphs.each do |p|
+                fd.puts "== #{p.upcase}"
+                fd.puts
+                fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+                fd.puts
+            end
+            fd.puts ann.text if ann.text
+        end
+    end
+
+    desc "Create an announcement file"
+    task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+    desc "Send an email announcement"
+    task :email => ['ann:prereqs', PROJ.ann.file] do
+        ann = PROJ.ann
+        from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+        to   = Array(ann.email[:to])
+
+        ### build a mail header for RFC 822
+        rfc822msg =  "From: #{from}\n"
+        rfc822msg << "To: #{to.join(',')}\n"
+        rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+        rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+        rfc822msg << "\n"
+        rfc822msg << "Date: #{Time.new.rfc822}\n"
+        rfc822msg << "Message-Id: "
+        rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+        rfc822msg << File.read(ann.file)
+
+        params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+            ann.email[key]
+        end
+
+        params[3] = (PROJ.ann.email[:from] || PROJ.email) if params[3].nil?
+
+#        if ann.email[:tls] and params[4].nil?
+        if params[4].nil?
+            STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+            params[4] = STDIN.gets.chomp
+        end
+#        params = params.shift 2 if not ann.email[:tls]
+
+        ### send email
+        # TODO find a way to bypass /var/lib/gems/1.9/gems/bones-3.6.5/lib/bones/smtp_tls.rb which forces starttls usage
+        Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+    end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/constants.rb

@@ -0,0 +1,118 @@
+# -*- coding: UTF-8 -*-
+#
+require 'rbconfig'
+
+# Setup some constants
+WIN32 = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM unless defined? WIN32
+
+DEV_NULL = WIN32 ? 'NUL:' : '/dev/null'
+
+def quiet( &block )
+    io = [STDOUT.dup, STDERR.dup]
+    STDOUT.reopen DEV_NULL
+    STDERR.reopen DEV_NULL
+    block.call
+ensure
+    STDOUT.reopen io.first
+    STDERR.reopen io.last
+    $stdout, $stderr = STDOUT, STDERR
+end
+
+BUILD_DIR = "build"
+
+USE_RAKE_COMPILER = ( ( (RUBY_PLATFORM =~ /java/) ? false : true ) and test ?d, 'ext' )
+if USE_RAKE_COMPILER
+    gem 'rake-compiler', '>=0.6.0'
+    require 'rake/extensiontask'
+    ENV['RUBY_CC_VERSION'] = '1.8.7:1.9.2'
+end
+
+LIBEXT = case RbConfig::CONFIG['host_os'].downcase
+    when /darwin/
+        "dylib"
+    when /mswin|mingw/
+        "dll"
+    else
+        RbConfig::CONFIG['DLEXT']
+    end
+
+CPU = case RbConfig::CONFIG['host_cpu'].downcase
+    when /i[3456]86/
+        # Darwin always reports i686, even when running in 64bit mode
+        if RbConfig::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
+            "x86_64"
+        else
+        "i386"
+        end
+    when /amd64|x86_64/
+        "x86_64"
+    when /ppc64|powerpc64/
+        "powerpc64"
+    when /ppc|powerpc/
+        "powerpc"
+    else
+        RbConfig::CONFIG['host_cpu']
+    end
+
+OS = case RbConfig::CONFIG['host_os'].downcase
+    when /linux/
+        "linux"
+    when /darwin/
+        "darwin"
+    when /freebsd/
+        "freebsd"
+    when /openbsd/
+        "openbsd"
+    when /sunos|solaris/
+        "solaris"
+    when /mswin|mingw/
+        "win32"
+    else
+        RbConfig::CONFIG['host_os'].downcase
+    end
+
+CC=ENV['CC'] || RbConfig::CONFIG['CC'] || "gcc"
+
+GMAKE = RbConfig::CONFIG['host_os'].downcase =~ /bsd|solaris/ ? "gmake" : "make"
+
+
+DIFF = if WIN32 then 'diff.exe'
+       else
+            if quiet {system "gdiff", __FILE__, __FILE__} then 'gdiff'
+            else 'diff' end
+       end unless defined? DIFF
+
+SUDO = if WIN32 then ''
+       else
+            if quiet {system 'which sudo'} then 'sudo'
+            else '' end
+       end
+
+RCOV = WIN32 ? 'rcov.bat' : 'rcov'
+RDOC = WIN32 ? 'rdoc.bat' : 'rdoc'
+GEM  = WIN32 ? 'gem.bat'  : 'gem'
+
+%w(rcov spec/rake/spectask rubyforge bones facets/ansicode).each do |lib|
+    begin
+        require lib
+        Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", true}
+    rescue LoadError
+        Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", false}
+    end
+end
+
+HAVE_SVN = (Dir.entries(Dir.pwd).include?('.svn') and system("svn --version 2>&1 > #{DEV_NULL}"))
+HAVE_GIT = (Dir.entries(Dir.pwd).include?('.git') and system("git --version 2>&1 > #{DEV_NULL}"))
+
+# Add rake as a development dependency
+#
+PROJ.gem.development_dependencies << ['rake', '>=0.8.7']
+
+# Add bones as a development dependency
+#
+if HAVE_BONES
+    bones_version = defined?(Bones::VERSION) ? Bones::VERSION : Bones.version
+    PROJ.gem.development_dependencies << ['bones', ">= #{bones_version}"]
+end
+
+# EOF

data/tasks/gem.rake

@@ -0,0 +1,196 @@
+# -*- coding: UTF-8 -*-
+#
+require 'find'
+require 'rake/packagetask'
+require 'rubygems/user_interaction'
+require 'rubygems/builder'
+
+module Bones
+class GemPackageTask < Rake::PackageTask
+    # Ruby GEM spec containing the metadata for this package.  The
+    # name, version and package_files are automatically determined
+    # from the GEM spec and don't need to be explicitly provided.
+    #
+    attr_accessor :gem_spec
+
+    # Tasks from the Bones gem directory
+    attr_reader :bones_files
+
+    # Create a GEM Package task library.  Automatically define the gem
+    # if a block is given.  If no block is supplied, then +define+
+    # needs to be called to define the task.
+    #
+    def initialize(gem_spec)
+        init(gem_spec)
+        yield self if block_given?
+        define if block_given?
+    end
+
+    # Initialization tasks without the "yield self" or define
+    # operations.
+    #
+    def init(gem)
+        super(gem.name, gem.version)
+        @gem_spec = gem
+        @package_files += gem_spec.files if gem_spec.files
+        @bones_files = []
+
+        local_setup = File.join(Dir.pwd, %w[tasks setup.rb])
+        if !test(?e, local_setup)
+            Dir.glob(::Bones.path(%w[lib bones tasks *])).each {|fn| bones_files << fn}
+        end
+    end
+
+    # Create the Rake tasks and actions specified by this
+    # GemPackageTask.  (+define+ is automatically called if a block is
+    # given to +new+).
+    #
+    def define
+        super
+        task :prereqs
+        task :package => ['gem:prereqs', "#{package_dir_path}/#{gem_file}"]
+        file "#{package_dir_path}/#{gem_file}" => [package_dir_path] + package_files + bones_files do
+            when_writing("Creating GEM") {
+                chdir(package_dir_path) do
+                    Gem::Builder.new(gem_spec).build
+                    verbose(true) { mv gem_file, "../#{gem_file}" }
+                end
+            }
+        end
+
+        file package_dir_path => bones_files do
+            mkdir_p package_dir rescue nil
+
+            gem_spec.files = (gem_spec.files + bones_files.map {|fn| File.join('tasks', File.basename(fn))}).sort
+
+            bones_files.each do |fn|
+                base_fn = File.join('tasks', File.basename(fn))
+                f = File.join(package_dir_path, base_fn)
+                fdir = File.dirname(f)
+                mkdir_p(fdir) if !File.exist?(fdir)
+                if File.directory?(fn)
+                    mkdir_p(f)
+                else
+                    raise "file name conflict for '#{base_fn}' (conflicts with '#{fn}')" if test(?e, f)
+                    safe_ln(fn, f)
+                end
+            end
+        end
+    end
+
+    def gem_file
+        if @gem_spec.platform == Gem::Platform::RUBY
+            "#{package_name}.gem"
+        else
+            "#{package_name}-#{@gem_spec.platform}.gem"
+        end
+    end
+end  # class GemPackageTask
+end  # module Bones
+
+namespace :gem do
+
+    PROJ.gem._spec = Gem::Specification.new do |s|
+        s.name = PROJ.name
+        s.version = PROJ.version
+        s.summary = PROJ.summary
+        s.authors = Array(PROJ.authors)
+        s.email = PROJ.email
+        s.homepage = Array(PROJ.url).first
+        s.rubyforge_project = PROJ.rubyforge.name
+
+        s.description = PROJ.description
+
+        PROJ.gem.dependencies.each do |dep|
+            s.add_dependency(*dep)
+        end
+
+        PROJ.gem.development_dependencies.each do |dep|
+            s.add_development_dependency(*dep)
+        end
+
+        s.files = PROJ.gem.files
+        s.executables = PROJ.gem.executables.map {|fn| File.basename(fn)}
+        s.extensions = PROJ.gem.files.grep %r/extconf\.rb$/
+
+        s.bindir = 'bin'
+        dirs = Dir["{#{PROJ.libs.join(',')}}"]
+        s.require_paths = dirs unless dirs.empty?
+
+        incl = Regexp.new(PROJ.rdoc.include.join('|'))
+        excl = PROJ.rdoc.exclude.dup.concat %w[\.rb$ ^(\.\/|\/)?ext]
+        excl = Regexp.new(excl.join('|'))
+        rdoc_files = PROJ.gem.files.find_all do |fn|
+            case fn
+            when excl; false
+            when incl; true
+            else false end
+        end
+        s.rdoc_options = PROJ.rdoc.opts + ['--main', PROJ.rdoc.main]
+        s.extra_rdoc_files = rdoc_files
+
+        if test ?f, PROJ.test.file
+            s.test_file = PROJ.test.file
+        else
+            s.test_files = PROJ.test.files.to_a
+        end
+
+        # Do any extra stuff the user wants
+        PROJ.gem.extras.each do |msg, val|
+            case val
+            when Proc
+                val.call(s.send(msg))
+            else
+                s.send "#{msg}=", val
+            end
+        end
+    end  # Gem::Specification.new
+
+    Bones::GemPackageTask.new(PROJ.gem._spec) do |pkg|
+        pkg.need_tar = PROJ.gem.need_tar
+        pkg.need_zip = PROJ.gem.need_zip
+    end
+
+    desc 'Show information about the gem'
+    task :debug => 'gem:prereqs' do
+        puts PROJ.gem._spec.to_ruby
+    end
+
+    desc 'Write the gemspec '
+    task :spec => 'gem:prereqs' do
+        File.open("#{PROJ.name}.gemspec", 'w') do |f|
+            f.write PROJ.gem._spec.to_ruby
+        end
+    end
+
+    desc 'Install the gem'
+    task :install => [:clobber, 'gem:package'] do
+        sh "#{SUDO} #{GEM} install --local pkg/#{PROJ.gem._spec.full_name}"
+        # use this version of the command for rubygems > 1.0.0
+        #sh "#{SUDO} #{GEM} install --no-update-sources pkg/#{PROJ.gem._spec.full_name}"
+    end
+
+    desc 'Uninstall the gem'
+    task :uninstall do
+        installed_list = Gem.source_index.find_name(PROJ.name)
+        if installed_list and installed_list.collect { |s| s.version.to_s}.include?(PROJ.version) then
+            sh "#{SUDO} #{GEM} uninstall --version '#{PROJ.version}' --ignore-dependencies --executables #{PROJ.name}"
+        end
+    end
+
+    desc 'Reinstall the gem'
+    task :reinstall => [:uninstall, :install]
+
+    desc 'Cleanup the gem'
+    task :cleanup do
+        sh "#{SUDO} #{GEM} cleanup #{PROJ.gem._spec.name}"
+    end
+end  # namespace :gem
+
+desc 'Alias to gem:package'
+task :gem => 'gem:package'
+
+task :clobber => 'gem:clobber_package'
+remove_desc_for_task 'gem:clobber_package'
+
+# EOF