safemode 1.3.1 → 2.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,45 +1,41 @@
1
1
  module Safemode
2
2
  class Parser < Ruby2Ruby
3
- # @@parser = defined?(RubyParser) ? 'RubyParser' : 'ParseTree'
4
- @@parser = 'RubyParser'
5
-
6
3
  class << self
7
4
  def jail(code, allowed_fcalls = [])
8
5
  @@allowed_fcalls = allowed_fcalls
9
6
  tree = parse code
10
7
  self.new.process(tree)
11
8
  end
12
-
9
+
13
10
  def parse(code)
14
- case @@parser
15
- # when 'ParseTree'
16
- # ParseTree.translate(code)
17
- when 'RubyParser'
18
- RubyParser.new.parse(code)
19
- else
20
- raise "unknown parser #{@@parser}"
21
- end
22
- end
23
-
24
- def parser=(parser)
25
- @@parser = parser
11
+ Prism::Translation::RubyParser.parse(code)
26
12
  end
27
13
  end
28
-
29
- def jail(str, parentheses = false)
30
- str = parentheses ? "(#{str})." : "#{str}." if str
14
+
15
+ def jail(str, parentheses = false, safe_call: false)
16
+ str = if str
17
+ dot = safe_call ? "&." : "."
18
+ parentheses ? "(#{str})#{dot}" : "#{str}#{dot}"
19
+ end
31
20
  "#{str}to_jail"
32
21
  end
33
22
 
34
23
  # split up #process_call. see below ...
35
- def process_call(exp)
36
- receiver = jail process_call_receiver(exp)
37
- name = exp.shift
38
- args = process_call_args(exp)
24
+ def process_call(exp, safe_call = false)
25
+ _, recv, name, *args = exp
39
26
 
40
- process_call_code(receiver, name, args)
27
+ # ERB emits literal template text as string literals. Freezing one only
28
+ # affects that template-generated string, not a string passed in by the caller.
29
+ if name == :freeze && args.empty? && recv && recv.sexp_type == :str
30
+ return "(#{process recv}).freeze"
31
+ end
32
+
33
+ receiver = jail(process_call_receiver(recv), safe_call: safe_call)
34
+ arguments = process_call_args(name, args)
35
+
36
+ process_call_code(receiver, name, arguments, safe_call)
41
37
  end
42
-
38
+
43
39
  def process_fcall(exp)
44
40
  # using haml we probably never arrive here because :lasgn'ed :fcalls
45
41
  # somehow seem to change to :calls somewhere during processing
@@ -69,9 +65,17 @@ module Safemode
69
65
  end
70
66
  end
71
67
 
68
+ def process_for(exp)
69
+ _, recv, iter, body = exp
70
+ receiver = jail(process(recv), true)
71
+ variable = process(iter)
72
+ body = process(body) || '# do nothing'
73
+ "for #{variable} in #{receiver} do\n#{indent(body)}\nend"
74
+ end
75
+
72
76
  # see http://www.namikilab.tuat.ac.jp/~sasada/prog/rubynodes/nodes.html
73
77
 
74
- allowed = [ :call, :vcall, :evstr,
78
+ ALLOWED_NODES = [ :call, :safe_call, :fcall, :vcall, :evstr, :const, :arglist,
75
79
  :lvar, :dvar, :ivar, :lasgn, :masgn, :dasgn, :dasgn_curr,
76
80
  :lit, :str, :dstr, :dsym, :nil, :true, :false,
77
81
  :array, :zarray, :hash, :dot2, :dot3, :flip2, :flip3,
@@ -85,29 +89,48 @@ module Safemode
85
89
  # :colon2 is used for module constants
86
90
  :colon2,
87
91
  # unnecessarily advanced?
88
- :argscat, :argspush, :splat, :block_pass,
89
- :op_asgn1, :op_asgn2, :op_asgn_and, :op_asgn_or,
92
+ :argscat, :argspush, :splat, :kwsplat,
93
+ # NOTE: op_asgn*/safe_op_asgn* do not insert .to_jail on the
94
+ # receiver. Setters are called directly on the real object, bypassing Jail.
95
+ :op_asgn, :op_asgn1, :op_asgn2, :op_asgn_and, :op_asgn_or,
96
+ :safe_op_asgn, :safe_op_asgn2,
97
+ # pattern matching (Ruby 3.0+)
98
+ :in, :array_pat, :hash_pat, :find_pat, :kwrest,
90
99
  # needed for haml
91
- :block ]
100
+ :block ].freeze
101
+
102
+ def process(exp)
103
+ if exp && !ALLOWED_NODES.include?(exp.sexp_type)
104
+ raise_security_error(exp.sexp_type, nil)
105
+ end
106
+ super
107
+ end
92
108
 
93
109
  disallowed = [ # :self, # self doesn't seem to be needed for vcalls?
94
110
  # see below for :const handling
95
111
  :defn, :defs, :alias, :valias, :undef, :class, :attrset,
96
112
  :module, :sclass, :colon3,
97
- :fbody, :scope, :block_arg, :postexe,
113
+ :fbody, :scope, :block_arg, :postexe, :preexe,
98
114
  :redo, :retry, :begin, :rescue, :resbody, :ensure,
99
115
  :defined, :super, :zsuper, :return,
100
116
  :dmethod, :bmethod, :to_ary, :svalue, :match,
101
- :attrasgn, :cdecl, :cvasgn, :cvdecl, :cvar, :gvar, :gasgn,
117
+ :attrasgn, :safe_attrasgn,
118
+ :cdecl, :cvasgn, :cvdecl, :cvar, :gvar, :gasgn,
102
119
  :xstr, :dxstr,
103
120
  # not sure how secure ruby regexp is, so leave it out for now
104
- :dregx, :dregx_once, :match2, :match3, :nth_ref, :back_ref ]
121
+ :dregx, :dregx_once, :match2, :match3, :nth_ref, :back_ref,
122
+ # block_pass represents &:method, which would bypass the whitelist e.g. by array.each(&:destroy)
123
+ # at this point we don't know the receiver so we rather disable it completely,
124
+ # use array.each { |item| item.destroy } instead
125
+ :block_pass,
126
+ # lambda creates Proc objects
127
+ :lambda ]
105
128
 
106
- # SexpProcessor bails when we overwrite these ... but they are listed as
129
+ # SexpProcessor bails when we overwrite these ... but they are listed as
107
130
  # "internal nodes that you can't get to" in sexp_processor.rb
108
131
  # :ifunc, :method, :last, :opt_n, :cfunc, :newline, :alloca, :memo, :cref
109
-
110
- disallowed.each do |name|
132
+
133
+ disallowed.each do |name|
111
134
  define_method "process_#{name}" do |arg|
112
135
  code = super(arg)
113
136
  raise_security_error(name, code)
@@ -115,74 +138,142 @@ module Safemode
115
138
  end
116
139
 
117
140
  def process_const(arg)
118
- if RUBY_VERSION >= "1.9" && arg.sexp_type == :Encoding
119
- # handling of Encoding constants in ruby 1.9.
141
+ sexp_type = arg.sexp_body.sexp_type # constants are encoded as: "s(:const, :Encoding)"
142
+ if sexp_type == :Encoding
143
+ # handling of Encoding constants.
120
144
  # Note: ruby_parser evaluates __ENCODING__ to s(:colon2, s(:const, :Encoding), :UTF_8)
121
145
  "#{super(arg).gsub('-', '_')}"
122
- elsif arg.sexp_type == :String
146
+ elsif sexp_type == :String
123
147
  # Allow String.new as used in ERB in Ruby 2.4+ to create a string buffer
124
148
  super(arg).to_s
125
149
  else
126
150
  raise_security_error("constant", super(arg))
127
151
  end
128
152
  end
129
-
153
+
130
154
  def raise_security_error(type, info)
131
155
  raise Safemode::SecurityError.new(type, info)
132
156
  end
133
-
157
+
134
158
  # split up Ruby2Ruby#process_call monster method so we can hook into it
135
159
  # in a more readable manner
136
160
 
137
- def process_call_receiver(exp)
138
- receiver_node_type = exp.first.nil? ? nil : exp.first.first
139
- receiver = process exp.shift
140
- receiver = "(#{receiver})" if
141
- Ruby2Ruby::ASSIGN_NODES.include? receiver_node_type
161
+ def process_call_receiver(recv)
162
+ receiver_node_type = recv && recv.sexp_type
163
+ receiver = process recv
164
+ receiver = "(#{receiver})" if ASSIGN_NODES.include? receiver_node_type
142
165
  receiver
143
166
  end
144
167
 
145
- def process_call_args(exp)
146
- args = []
147
- while not exp.empty? do
148
- args_exp = exp.shift
149
- if args_exp && args_exp.first == :array # FIX
150
- processed = "#{process(args_exp)[1..-2]}"
151
- else
152
- processed = process args_exp
153
- end
154
- args << processed unless (processed.nil? or processed.empty?)
168
+ def process_call_args(name, args)
169
+ in_context :arglist do
170
+ max = args.size - 1
171
+ args = args.map.with_index { |arg, i|
172
+ arg_type = arg.sexp_type
173
+ is_empty_hash = arg == s(:hash)
174
+ arg = process arg
175
+
176
+ next if arg.empty?
177
+
178
+ strip_hash = (arg_type == :hash and
179
+ not BINARY.include? name and
180
+ not is_empty_hash and
181
+ (i == max or args[i + 1].sexp_type == :splat))
182
+ wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
183
+
184
+ arg = arg[2..-3] if strip_hash
185
+ arg = "(#{arg})" if wrap_arg
186
+
187
+ arg
188
+ }.compact
155
189
  end
156
- args.empty? ? nil : args.join(", ")
157
190
  end
158
191
 
159
- def process_call_code(receiver, name, args)
192
+ def process_call_code(receiver, name, args, safe_call)
160
193
  case name
161
- when :<=>, :==, "!=".to_sym, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :** then
162
- "(#{receiver} #{name} #{args})"
194
+ when *BINARY then
195
+ if safe_call
196
+ "#{receiver}&.#{name}(#{args.join(", ")})"
197
+ elsif args.length > 1
198
+ "#{receiver}.#{name}(#{args.join(", ")})"
199
+ else
200
+ "(#{receiver} #{name} #{args.join(", ")})"
201
+ end
163
202
  when :[] then
164
- "#{receiver}[#{args}]"
203
+ receiver ||= "self"
204
+ "#{receiver}[#{args.join(", ")}]"
205
+ when :[]= then
206
+ receiver ||= "self"
207
+ rhs = args.pop
208
+ "#{receiver}[#{args.join(", ")}] = #{rhs}"
209
+ when :"!" then
210
+ "(not #{receiver})"
165
211
  when :"-@" then
166
212
  "-#{receiver}"
167
213
  when :"+@" then
168
214
  "+#{receiver}"
169
215
  else
170
- unless receiver.nil? then
171
- "#{receiver}.#{name}#{args ? "(#{args})" : args}"
172
- else
173
- "#{name}#{args ? "(#{args})" : args}"
216
+ args = nil if args.empty?
217
+ args = "(#{args.join(", ")})" if args
218
+ receiver = "#{receiver}." if receiver and not safe_call
219
+ receiver = "#{receiver}&." if receiver and safe_call
220
+
221
+ "#{receiver}#{name}#{args}"
222
+ end
223
+ end
224
+
225
+ # Ruby2Ruby bug: __var adds ^ (pin) to all lvars inside :in context,
226
+ # including the body after "then" where ^ is invalid syntax.
227
+ # Fix: process body outside the :in context.
228
+ def process_in(exp)
229
+ _, pattern, *body = exp
230
+
231
+ guard = extract_guard(pattern)
232
+ cond = process pattern
233
+ body = body.compact.map { |sexp|
234
+ in_context :in_body do
235
+ indent process sexp
174
236
  end
237
+ }
238
+
239
+ body << indent("# do nothing") if body.empty?
240
+ body = body.join "\n"
241
+
242
+ header = "in #{cond}"
243
+ header << " #{guard}" if guard
244
+ "#{header} then\n#{body.chomp}"
245
+ end
246
+
247
+ # Prism translates guard clauses (in pattern if cond / in pattern unless cond)
248
+ # as s(:if, guard, pattern, nil) / s(:if, guard, nil, pattern). We detect this
249
+ # and rewrite the sexp in-place so process_if renders only the pattern, then
250
+ # return the guard string for process_in to append.
251
+ def extract_guard(pattern)
252
+ return unless pattern.sexp_type == :if
253
+
254
+ _, guard_sexp, if_body, else_body = pattern
255
+ if if_body && !else_body
256
+ guard_str = in_context(:in_body) { "if #{process guard_sexp.deep_clone}" }
257
+ pattern.clear
258
+ if_body.each { |node| pattern << node }
259
+ elsif else_body && !if_body
260
+ guard_str = in_context(:in_body) { "unless #{process guard_sexp.deep_clone}" }
261
+ pattern.clear
262
+ else_body.each { |node| pattern << node }
175
263
  end
264
+
265
+ guard_str
176
266
  end
177
-
267
+
178
268
  # Ruby2Ruby process_if rewrites if and unless statements in a way that
179
269
  # makes the result unusable for evaluation in, e.g. ERB which appends a
180
- # call to to_s when using <%= %> tags. We'd need to either enclose the
270
+ # call to to_s when using <%= %> tags. We'd need to either enclose the
181
271
  # result from process_if into parentheses like (1 if true) and
182
272
  # (true ? (1) : (2)) or just use the plain if-then-else-end syntax (so
183
273
  # that ERB can safely append to_s to the resulting block).
184
274
 
185
275
  def process_if(exp)
276
+ exp.shift # remove ":if" symbol from exp
186
277
  expand = Ruby2Ruby::ASSIGN_NODES.include? exp.first.first
187
278
  c = process exp.shift
188
279
  t = process exp.shift
@@ -212,6 +303,6 @@ module Safemode
212
303
  # end
213
304
  "unless #{c} then\n#{indent(f)}\nend"
214
305
  end
215
- end
216
- end
306
+ end
307
+ end
217
308
  end
@@ -1,58 +1,66 @@
1
1
  module Safemode
2
2
  class Scope < Blankslate
3
- def initialize(delegate = nil, delegate_methods = [])
4
- @delegate = delegate
3
+ def initialize(delegate = nil, delegate_methods = [], instance_vars: {}, locals: {}, &block)
4
+ @delegate = delegate
5
5
  @delegate_methods = delegate_methods
6
- @locals = {}
7
- end
8
-
9
- def bind(instance_vars = {}, locals = {}, &block)
10
6
  @locals = symbolize_keys(locals) # why can't I just pull them to local scope in the same way like instance_vars?
11
7
  instance_vars = symbolize_keys(instance_vars)
12
8
  instance_vars.each {|key, obj| eval "@#{key} = instance_vars[:#{key}]" }
13
9
  @_safemode_output = ''
14
- binding
10
+ @binding = binding
11
+ end
12
+
13
+ def get_binding
14
+ @binding
15
15
  end
16
-
16
+
17
17
  def to_jail
18
18
  self
19
19
  end
20
-
20
+
21
21
  def puts(*args)
22
22
  print args.to_s + "\n"
23
23
  end
24
24
 
25
- def print(*args)
25
+ def print(*args)
26
26
  @_safemode_output += args.to_s
27
27
  end
28
-
28
+
29
29
  def output
30
30
  @_safemode_output
31
31
  end
32
32
 
33
- def method_missing(method, *args, &block)
33
+ def method_missing(method, *args, **kwargs, &block)
34
34
  if @locals.has_key?(method)
35
35
  @locals[method]
36
36
  elsif @delegate_methods.include?(method)
37
- @delegate.send method, *unjail_args(args), &block
37
+ @delegate.send method, *unjail_args(args), **unjail_kwargs(kwargs), &block
38
38
  else
39
39
  raise Safemode::SecurityError.new(method, "#<Safemode::ScopeObject>")
40
40
  end
41
41
  end
42
-
42
+
43
43
  private
44
-
44
+
45
45
  def symbolize_keys(hash)
46
- hash.inject({}) do |hash, (key, value)|
46
+ hash.inject({}) do |hash, (key, value)|
47
47
  hash[key.to_s.intern] = value
48
48
  hash
49
49
  end
50
50
  end
51
-
51
+
52
+ IVAR_GET = Object.instance_method(:instance_variable_get)
53
+
54
+ def unjail(arg)
55
+ arg.class.name.end_with?('::Jail') ? IVAR_GET.bind_call(arg, :@source) : arg
56
+ end
57
+
52
58
  def unjail_args(args)
53
- args.collect do |arg|
54
- arg.class.name =~ /::Jail$/ ? arg.instance_variable_get(:@source) : arg
55
- end
59
+ args.collect { |arg| unjail(arg) }
60
+ end
61
+
62
+ def unjail_kwargs(kwargs)
63
+ kwargs.map { |key, value| [unjail(key), unjail(value)] }.to_h
56
64
  end
57
65
  end
58
66
  end
data/lib/safemode.rb CHANGED
@@ -1,17 +1,8 @@
1
1
  require 'rubygems'
2
2
 
3
3
  require 'ruby2ruby'
4
- begin
5
- require 'ruby_parser' # try to load RubyParser and use it if present
6
- rescue LoadError => e
7
- end
8
- # this doesn't work somehow. Maybe something changed inside
9
- # ParseTree or sexp_processor or so.
10
- # (the require itself works, but ParseTree doesn't play nice)
11
- # begin
12
- # require 'parse_tree'
13
- # rescue LoadError => e
14
- # end
4
+ require 'prism'
5
+ require 'prism/translation/ruby_parser'
15
6
 
16
7
  require 'safemode/core_ext'
17
8
  require 'safemode/blankslate'
@@ -26,7 +17,7 @@ module Safemode
26
17
  def jail(obj)
27
18
  find_jail_class(obj.is_a?(Class) ? obj : obj.class).new obj
28
19
  end
29
-
20
+
30
21
  def find_jail_class(klass)
31
22
  while klass != Object
32
23
  return klass.const_get('Jail') if klass.const_defined?('Jail')
@@ -35,24 +26,25 @@ module Safemode
35
26
  Jail
36
27
  end
37
28
  end
38
-
29
+
39
30
  define_core_jail_classes
40
-
31
+
41
32
  class Box
42
33
  def initialize(delegate = nil, delegate_methods = [], filename = nil, line = nil)
43
- @scope = Scope.new(delegate, delegate_methods)
34
+ @delegate = delegate
35
+ @delegate_methods = delegate_methods
44
36
  @filename = filename
45
37
  @line = line
46
- end
38
+ end
47
39
 
48
40
  def eval(code, assigns = {}, locals = {}, &block)
49
41
  code = Parser.jail(code)
50
- binding = @scope.bind(assigns, locals, &block)
51
- result = Kernel.eval(code, binding, @filename || __FILE__, @line || __LINE__)
42
+ @scope = Scope.new(@delegate, @delegate_methods, instance_vars: assigns, locals: locals, &block)
43
+ Kernel.eval(code, @scope.get_binding, @filename || __FILE__, @line || __LINE__)
52
44
  end
53
-
45
+
54
46
  def output
55
47
  @scope.output
56
- end
48
+ end
57
49
  end
58
50
  end
data/safemode.gemspec CHANGED
@@ -1,36 +1,41 @@
1
- # Generated by jeweler
2
- # DO NOT EDIT THIS FILE DIRECTLY
3
- # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
4
- # -*- encoding: utf-8 -*-
5
- # stub: safemode 1.3.1 ruby lib
1
+ # frozen_string_literal: true
2
+
3
+ require 'date'
6
4
 
7
5
  Gem::Specification.new do |s|
8
6
  s.name = "safemode".freeze
9
- s.version = "1.3.1"
7
+ s.version = "2.0.3"
8
+ s.date = Date.today
9
+
10
+ s.summary = "A library for safe evaluation of Ruby code based on Prism and Ruby2Ruby"
11
+ s.description = "A library for safe evaluation of Ruby code based on RubyParser and Ruby2Ruby. Provides Rails ActionView template handlers for ERB and Haml."
12
+ s.homepage = "https://github.com/svenfuchs/safemode"
13
+ s.licenses = ["MIT"]
14
+
15
+ s.authors = [
16
+ "Sven Fuchs",
17
+ "Peter Cooper",
18
+ "Matthias Viehweger",
19
+ "Kingsley Hendrickse",
20
+ "Ohad Levy",
21
+ "Dmitri Dolguikh",
22
+ ]
10
23
 
11
- s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
12
- s.require_paths = ["lib".freeze]
13
- s.authors = ["Sven Fuchs".freeze, "Peter Cooper".freeze, "Matthias Viehweger".freeze, "Kingsley Hendrickse".freeze, "Ohad Levy".freeze, "Dmitri Dolguikh".freeze]
14
- s.date = "2017-02-13"
15
- s.description = "A library for safe evaluation of Ruby code based on RubyParser and Ruby2Ruby. Provides Rails ActionView template handlers for ERB and Haml.".freeze
16
- s.email = "ohadlevy@gmail.com".freeze
17
24
  s.extra_rdoc_files = [
25
+ "LICENSE",
18
26
  "README.markdown"
19
27
  ]
20
28
  s.files = [
21
29
  "Gemfile",
22
- "LICENCSE",
30
+ "LICENSE",
23
31
  "README.markdown",
24
32
  "Rakefile",
25
- "VERSION",
26
33
  "demo.rb",
27
34
  "init.rb",
28
35
  "lib/action_view/template_handlers/safe_erb.rb",
29
36
  "lib/action_view/template_handlers/safe_haml.rb",
30
37
  "lib/action_view/template_handlers/safemode_handler.rb",
31
38
  "lib/haml/safemode.rb",
32
- "lib/ruby_parser_string_io_patch.diff",
33
- "lib/rubyparser_bug.rb",
34
39
  "lib/safemode.rb",
35
40
  "lib/safemode/blankslate.rb",
36
41
  "lib/safemode/core_ext.rb",
@@ -44,53 +49,19 @@ Gem::Specification.new do |s|
44
49
  "test/test_helper.rb",
45
50
  "test/test_jail.rb",
46
51
  "test/test_safemode_eval.rb",
47
- "test/test_safemode_parser.rb"
52
+ "test/test_safemode_parser.rb",
53
+ "test/test_for_loop_jail.rb",
54
+ "test/test_parser_node_allowlist.rb"
48
55
  ]
49
- s.homepage = "http://github.com/svenfuchs/safemode".freeze
50
- s.licenses = ["MIT".freeze]
51
- s.rubygems_version = "2.6.10".freeze
52
- s.summary = "A library for safe evaluation of Ruby code based on ParseTree/RubyParser and Ruby2Ruby".freeze
53
56
 
54
- if s.respond_to? :specification_version then
55
- s.specification_version = 4
57
+ s.required_ruby_version = ">= 3.0", "< 3.4"
56
58
 
57
- if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
58
- s.add_runtime_dependency(%q<sexp_processor>.freeze, [">= 4.3.0"])
59
- s.add_runtime_dependency(%q<ruby2ruby>.freeze, [">= 2.0.6"])
60
- s.add_runtime_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
61
- s.add_development_dependency(%q<shoulda>.freeze, [">= 0"])
62
- s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
63
- s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
64
- s.add_development_dependency(%q<jeweler>.freeze, [">= 0"])
65
- s.add_development_dependency(%q<rcov>.freeze, [">= 0"])
66
- s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
67
- s.add_development_dependency(%q<test-unit>.freeze, [">= 0"])
68
- s.add_development_dependency(%q<rake>.freeze, [">= 0"])
69
- else
70
- s.add_dependency(%q<sexp_processor>.freeze, [">= 4.3.0"])
71
- s.add_dependency(%q<ruby2ruby>.freeze, [">= 2.0.6"])
72
- s.add_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
73
- s.add_dependency(%q<shoulda>.freeze, [">= 0"])
74
- s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
75
- s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
76
- s.add_dependency(%q<jeweler>.freeze, [">= 0"])
77
- s.add_dependency(%q<rcov>.freeze, [">= 0"])
78
- s.add_dependency(%q<simplecov>.freeze, [">= 0"])
79
- s.add_dependency(%q<test-unit>.freeze, [">= 0"])
80
- s.add_dependency(%q<rake>.freeze, [">= 0"])
81
- end
82
- else
83
- s.add_dependency(%q<sexp_processor>.freeze, [">= 4.3.0"])
84
- s.add_dependency(%q<ruby2ruby>.freeze, [">= 2.0.6"])
85
- s.add_dependency(%q<ruby_parser>.freeze, [">= 3.2.0"])
86
- s.add_dependency(%q<shoulda>.freeze, [">= 0"])
87
- s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
88
- s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
89
- s.add_dependency(%q<jeweler>.freeze, [">= 0"])
90
- s.add_dependency(%q<rcov>.freeze, [">= 0"])
91
- s.add_dependency(%q<simplecov>.freeze, [">= 0"])
92
- s.add_dependency(%q<test-unit>.freeze, [">= 0"])
93
- s.add_dependency(%q<rake>.freeze, [">= 0"])
94
- end
95
- end
59
+ s.add_runtime_dependency "ruby2ruby", "~> 2.4"
60
+ s.add_runtime_dependency "prism", "~> 1.0"
61
+ s.add_runtime_dependency "sexp_processor", "~> 4.10"
96
62
 
63
+ s.add_development_dependency "rake", "~> 13.4"
64
+ s.add_development_dependency "rdoc", "~> 7.2"
65
+ s.add_development_dependency "simplecov", "~> 0.22"
66
+ s.add_development_dependency "test-unit", "~> 3.7"
67
+ end