rpms/rubygem-ruby2ruby/F-11 import.log, NONE, 1.1 pt_testcase.rb, NONE, 1.1 rubygem-ruby2ruby.spec, NONE, 1.1 .cvsignore, 1.1, 1.2 sources, 1.1, 1.2
Matthew Kent
mkent at fedoraproject.org
Fri Dec 4 04:29:12 UTC 2009
- Previous message (by thread): rpms/rubygem-ruby2ruby/devel import.log, NONE, 1.1 pt_testcase.rb, NONE, 1.1 rubygem-ruby2ruby.spec, NONE, 1.1 .cvsignore, 1.1, 1.2 sources, 1.1, 1.2
- Next message (by thread): rpms/nss/devel 533125-ammend.patch,NONE,1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Author: mkent
Update of /cvs/pkgs/rpms/rubygem-ruby2ruby/F-11
In directory cvs1.fedora.phx.redhat.com:/tmp/cvs-serv29994/F-11
Modified Files:
.cvsignore sources
Added Files:
import.log pt_testcase.rb rubygem-ruby2ruby.spec
Log Message:
- Initial CVS import
--- NEW FILE import.log ---
rubygem-ruby2ruby-1_2_4-2_fc13:F-11:rubygem-ruby2ruby-1.2.4-2.fc13.src.rpm:1259900613
--- NEW FILE pt_testcase.rb ---
$TESTING = true
require 'minitest/unit'
require 'sexp_processor' # for deep_clone
# key:
# wwtt = what were they thinking?
# TODO: <ko1_> 1.8.7 support {|&b|} syntax
class Examples
attr_reader :reader
attr_writer :writer
def a_method(x); x+1; end
alias an_alias a_method
define_method(:bmethod_noargs) do
x + 1
end
define_method(:unsplatted) do |x|
x + 1
end
define_method :splatted do |*args|
y = args.first
y + 42
end
define_method :dmethod_added, instance_method(:a_method) if
RUBY_VERSION < "1.9"
end
class ParseTreeTestCase < MiniTest::Unit::TestCase
attr_accessor :processor # to be defined by subclass
def setup
super
@processor = nil
end
def after_process_hook klass, node, data, input_name, output_name
end
def before_process_hook klass, node, data, input_name, output_name
end
def self.add_test name, data, klass = self.name[4..-1]
name = name.to_s
klass = klass.to_s
if testcases.has_key? name then
if testcases[name].has_key? klass then
warn "testcase #{klass}##{name} already has data"
else
testcases[name][klass] = data
end
else
warn "testcase #{name} does not exist"
end
end
def self.add_tests name, hash
name = name.to_s
hash.each do |klass, data|
warn "testcase #{klass}##{name} already has data" if
testcases[name].has_key? klass
testcases[name][klass] = data
end
end
def self.clone_same
@@testcases.each do |node, data|
data.each do |key, val|
if val == :same then
prev_key = self.previous(key)
data[key] = data[prev_key].deep_clone
end
end
end
end
def self.copy_test_case nonverbose, klass
verbose = nonverbose + "_mri_verbose_flag"
testcases[verbose][klass] = testcases[nonverbose][klass]
end
def self.generate_test klass, node, data, input_name, output_name
klass.send(:define_method, "test_#{node}".to_sym) do
flunk "Processor is nil" if processor.nil?
assert data.has_key?(input_name), "Unknown input data"
assert data.has_key?(output_name), "Missing test data"
$missing[node] << output_name unless data.has_key? output_name
input = data[input_name].deep_clone
expected = data[output_name].deep_clone
case expected
when :unsupported then
assert_raises(UnsupportedNodeError) do
processor.process(input)
end
else
extra_expected = []
extra_input = []
_, expected, extra_expected = *expected if
Array === expected and expected.first == :defx
_, input, extra_input = *input if
Array === input and input.first == :defx
# OMG... I can't believe I have to do this this way. these
# hooks are here instead of refactoring this define_method
# body into an assertion. It'll allow subclasses to hook in
# and add behavior before or after the processor does it's
# thing. If you go the body refactor route, some of the
# RawParseTree test casese fail for completely bogus reasons.
before_process_hook klass, node, data, input_name, output_name
refute_nil data[input_name], "testcase does not exist?"
@result = processor.process input
assert_equal(expected, @result,
"failed on input: #{data[input_name].inspect}")
after_process_hook klass, node, data, input_name, output_name
extra_input.each do |extra|
processor.process(extra)
end
extra = processor.extra_methods rescue []
assert_equal extra_expected, extra
end
end
end
def self.generate_tests klass
install_missing_reporter
clone_same
output_name = klass.name.to_s.sub(/^Test/, '')
input_name = self.previous(output_name)
@@testcases.each do |node, data|
next if [:skip, :unsupported].include? data[input_name]
next if data[output_name] == :skip
generate_test klass, node, data, input_name, output_name
end
end
def self.inherited klass
super
generate_tests klass unless klass.name =~ /TestCase/
end
def self.install_missing_reporter
unless defined? $missing then
$missing = Hash.new { |h,k| h[k] = [] }
at_exit {
at_exit {
warn ""
$missing.sort.each do |name, klasses|
warn "add_tests(#{name.inspect},"
klasses.map! { |klass| " #{klass.inspect} => :same" }
warn klasses.join("\n") + ")"
end
warn ""
}
}
end
end
def self.previous(key, extra=0) # FIX: remove R2C code
idx = @@testcase_order.index(key)
raise "Unknown class #{key} in @@testcase_order" if idx.nil?
case key
when "RubyToRubyC" then
idx -= 1
end
@@testcase_order[idx - 1 - extra]
end
def self.testcase_order; @@testcase_order; end
def self.testcases; @@testcases; end
def self.unsupported_tests *tests
tests.flatten.each do |name|
add_test name, :unsupported
end
end
############################################################
[...4018 lines suppressed...]
add_tests("unless_pre_not",
"Ruby" => "unless not b then a end",
"RawParseTree" => [:if, [:vcall, :b], [:vcall, :a], nil],
"ParseTree" => s(:if, s(:call, nil, :b, s(:arglist)),
s(:call, nil, :a, s(:arglist)), nil),
"Ruby2Ruby" => "a if b")
add_tests("until_post",
"Ruby" => "begin\n (1 + 1)\nend until false",
"RawParseTree" => [:until, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], false],
"ParseTree" => s(:until, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), false))
add_tests("until_post_not",
"Ruby" => "begin\n (1 + 1)\nend until not true",
"RawParseTree" => [:while, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], false],
"ParseTree" => s(:while, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), false),
"Ruby2Ruby" => "begin\n (1 + 1)\nend while true")
add_tests("until_pre",
"Ruby" => "until false do\n (1 + 1)\nend",
"RawParseTree" => [:until, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:until, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true))
add_tests("until_pre_mod",
"Ruby" => "(1 + 1) until false",
"RawParseTree" => [:until, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:until, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "until false do\n (1 + 1)\nend")
add_tests("until_pre_not",
"Ruby" => "until not true do\n (1 + 1)\nend",
"RawParseTree" => [:while, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:while, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "while true do\n (1 + 1)\nend")
add_tests("until_pre_not_mod",
"Ruby" => "(1 + 1) until not true",
"RawParseTree" => [:while, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:while, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "while true do\n (1 + 1)\nend")
add_tests("valias",
"Ruby" => "alias $y $x",
"RawParseTree" => [:valias, :$y, :$x],
"ParseTree" => s(:valias, :$y, :$x))
add_tests("vcall",
"Ruby" => "method",
"RawParseTree" => [:vcall, :method],
"ParseTree" => s(:call, nil, :method, s(:arglist)))
add_tests("while_post",
"Ruby" => "begin\n (1 + 1)\nend while false",
"RawParseTree" => [:while, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], false],
"ParseTree" => s(:while, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), false))
add_tests("while_post2",
"Ruby" => "begin\n (1 + 2)\n (3 + 4)\nend while false",
"RawParseTree" => [:while, [:false],
[:block,
[:call, [:lit, 1], :+, [:array, [:lit, 2]]],
[:call, [:lit, 3], :+, [:array, [:lit, 4]]]],
false],
"ParseTree" => s(:while, s(:false),
s(:block,
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 2))),
s(:call, s(:lit, 3), :+,
s(:arglist, s(:lit, 4)))),
false))
add_tests("while_post_not",
"Ruby" => "begin\n (1 + 1)\nend while not true",
"RawParseTree" => [:until, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], false],
"ParseTree" => s(:until, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), false),
"Ruby2Ruby" => "begin\n (1 + 1)\nend until true")
add_tests("while_pre",
"Ruby" => "while false do\n (1 + 1)\nend",
"RawParseTree" => [:while, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:while, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true))
add_tests("while_pre_mod",
"Ruby" => "(1 + 1) while false",
"RawParseTree" => [:while, [:false],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:while, s(:false),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "while false do\n (1 + 1)\nend") # FIX can be one liner
add_tests("while_pre_nil",
"Ruby" => "while false do\nend",
"RawParseTree" => [:while, [:false], nil, true],
"ParseTree" => s(:while, s(:false), nil, true))
add_tests("while_pre_not",
"Ruby" => "while not true do\n (1 + 1)\nend",
"RawParseTree" => [:until, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:until, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "until true do\n (1 + 1)\nend")
add_tests("while_pre_not_mod",
"Ruby" => "(1 + 1) while not true",
"RawParseTree" => [:until, [:true],
[:call, [:lit, 1], :+,
[:array, [:lit, 1]]], true],
"ParseTree" => s(:until, s(:true),
s(:call, s(:lit, 1), :+,
s(:arglist, s(:lit, 1))), true),
"Ruby2Ruby" => "until true do\n (1 + 1)\nend") # FIX
add_tests("xstr",
"Ruby" => "`touch 5`",
"RawParseTree" => [:xstr, 'touch 5'],
"ParseTree" => s(:xstr, 'touch 5'))
add_tests("yield_0",
"Ruby" => "yield",
"RawParseTree" => [:yield],
"ParseTree" => s(:yield))
add_tests("yield_1",
"Ruby" => "yield(42)",
"RawParseTree" => [:yield, [:lit, 42]],
"ParseTree" => s(:yield, s(:lit, 42)))
add_tests("yield_array_0",
"Ruby" => "yield([])",
"RawParseTree" => [:yield, [:zarray], true],
"ParseTree" => s(:yield, s(:array)))
add_tests("yield_array_1",
"Ruby" => "yield([42])",
"RawParseTree" => [:yield, [:array, [:lit, 42]], true],
"ParseTree" => s(:yield, s(:array, s(:lit, 42))))
add_tests("yield_array_n",
"Ruby" => "yield([42, 24])",
"RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]], true],
"ParseTree" => s(:yield, s(:array, s(:lit, 42), s(:lit, 24))))
add_tests("yield_n",
"Ruby" => "yield(42, 24)",
"RawParseTree" => [:yield, [:array, [:lit, 42], [:lit, 24]]],
"ParseTree" => s(:yield, s(:lit, 42), s(:lit, 24)))
add_tests("zarray",
"Ruby" => "a = []",
"RawParseTree" => [:lasgn, :a, [:zarray]],
"ParseTree" => s(:lasgn, :a, s(:array)))
add_tests("zsuper",
"Ruby" => "def x\n super\nend",
"RawParseTree" => [:defn, :x,
[:scope, [:block, [:args], [:zsuper]]]],
"ParseTree" => s(:defn, :x, s(:args),
s(:scope, s(:block, s(:zsuper)))))
end
--- NEW FILE rubygem-ruby2ruby.spec ---
# Generated from ruby2ruby-1.2.4.gem by gem2rpm -*- rpm-spec -*-
%global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
%global gemname ruby2ruby
%global geminstdir %{gemdir}/gems/%{gemname}-%{version}
%global rubyabi 1.8
Summary: Generate pure ruby from RubyParser compatible Sexps
Name: rubygem-%{gemname}
Version: 1.2.4
Release: 2%{?dist}
Group: Development/Languages
License: MIT
URL: http://seattlerb.rubyforge.org/ruby2ruby/
Source0: http://gems.rubyforge.org/gems/%{gemname}-%{version}.gem
# These test cases are carried in the ParseTree gem in test/. Carry them here
# rather than attempting to install ParseTree-doc in check and introducing a circular
# dependency
Source1: pt_testcase.rb
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
Requires: rubygem(sexp_processor)
Requires: rubygem(ruby_parser)
Requires: ruby(rubygems)
Requires: ruby(abi) = %{rubyabi}
BuildRequires: ruby(rubygems)
BuildRequires: ruby(abi) = %{rubyabi}
BuildRequires(check): rubygem(rake), rubygem(hoe), rubygem(minitest)
BuildRequires(check): rubygem(sexp_processor), rubygem(ruby_parser)
BuildArch: noarch
Provides: rubygem(%{gemname}) = %{version}
%description
ruby2ruby provides a means of generating pure ruby code easily from
RubyParser compatible Sexps. This makes making dynamic language
processors in ruby easier than ever!
%package doc
Summary: Documentation for %{name}
Group: Documentation
Requires: %{name} = %{version}-%{release}
%description doc
This package contains documentation for %{name}.
%prep
%setup -q -c -T
%build
mkdir -p .%{gemdir}
gem install -V \
--local \
--install-dir $(pwd)/%{gemdir} \
--force --rdoc \
%{SOURCE0}
cp -p %{SOURCE1} $(pwd)/%{geminstdir}/test/
%install
rm -rf %{buildroot}
mkdir -p %{buildroot}%{gemdir}
cp -a .%{gemdir}/* %{buildroot}%{gemdir}/
mkdir -p %{buildroot}/%{_bindir}
mv %{buildroot}%{gemdir}/bin/* %{buildroot}/%{_bindir}
rmdir %{buildroot}%{gemdir}/bin
find %{buildroot}%{geminstdir}/bin -type f | xargs chmod a+x
# Drop the standalone mode for tests - won't run that way due to missing
# rubygems require anyway.
find %{buildroot}%{geminstdir}/test -type f | \
xargs -n 1 sed -i -e '/^#!\/usr\/.*\/ruby.*/d'
find %{buildroot}%{geminstdir}/lib -type f | \
xargs -n 1 sed -i -e '/^#!\/usr\/bin\/env.*/d'
# Ships with extremely tight permissions, bring them inline with other gems
find %{buildroot}%{geminstdir} -type f | \
xargs chmod 0644
find %{buildroot}%{geminstdir}/bin -type f | \
xargs chmod 0755
%clean
rm -rf %{buildroot}
%check
pushd .%{geminstdir}
rake test
%files
%defattr(-,root,root,-)
%{_bindir}/r2r_show
%doc %{geminstdir}/History.txt
%doc %{geminstdir}/Manifest.txt
%doc %{geminstdir}/README.txt
%dir %{geminstdir}
%{geminstdir}/bin
%{geminstdir}/lib
%{gemdir}/cache/%{gemname}-%{version}.gem
%{gemdir}/specifications/%{gemname}-%{version}.gemspec
%files doc
%defattr(-,root,root,-)
%{geminstdir}/Rakefile
%{geminstdir}/.autotest
%{geminstdir}/test
%{gemdir}/doc/%{gemname}-%{version}
%changelog
* Sun Nov 29 2009 Matthew Kent <mkent at magoazul.com> - 1.2.4-2
- Move pt_testcase.rb to the build stage so it's included in the rpm (#541512).
- Drop version requirements for sexp_processor and ruby_parser as they are new
packages (#541512).
* Mon Nov 16 2009 Matthew Kent <mkent at magoazul.com> - 1.2.4-1
- Initial package
Index: .cvsignore
===================================================================
RCS file: /cvs/pkgs/rpms/rubygem-ruby2ruby/F-11/.cvsignore,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -p -r1.1 -r1.2
--- .cvsignore 3 Dec 2009 06:38:47 -0000 1.1
+++ .cvsignore 4 Dec 2009 04:29:12 -0000 1.2
@@ -0,0 +1 @@
+ruby2ruby-1.2.4.gem
Index: sources
===================================================================
RCS file: /cvs/pkgs/rpms/rubygem-ruby2ruby/F-11/sources,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -p -r1.1 -r1.2
--- sources 3 Dec 2009 06:38:47 -0000 1.1
+++ sources 4 Dec 2009 04:29:12 -0000 1.2
@@ -0,0 +1 @@
+30cfdb7213e23639a4139a78308206ea ruby2ruby-1.2.4.gem
- Previous message (by thread): rpms/rubygem-ruby2ruby/devel import.log, NONE, 1.1 pt_testcase.rb, NONE, 1.1 rubygem-ruby2ruby.spec, NONE, 1.1 .cvsignore, 1.1, 1.2 sources, 1.1, 1.2
- Next message (by thread): rpms/nss/devel 533125-ammend.patch,NONE,1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the fedora-extras-commits
mailing list