Ruby Issue Tracking System: Issueshttps://redmine.ruby-lang.org/https://redmine.ruby-lang.org/favicon.ico?17113305112023-03-08T15:24:57ZRuby Issue Tracking System
Redmine Ruby master - Bug #19485 (Closed): Unexpected behavior in squiggly heredocshttps://redmine.ruby-lang.org/issues/194852023-03-08T15:24:57Zjemmai (Jemma Issroff)
<p>Based on <a href="https://ruby-doc.org/3.2.1/syntax/literals_rdoc.html" class="external">the squiggly heredoc documentation</a>, I found the following to be unexpected behavior. Explicitly, the documentation specifies, "The indentation of the least-indented line will be removed from each line of the content."</p>
<p>After running:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">File</span><span class="p">.</span><span class="nf">write</span><span class="p">(</span><span class="s2">"test.rb"</span><span class="p">,</span> <span class="s2">"p <<~EOF</span><span class="se">\n\t</span><span class="s2">a</span><span class="se">\n</span><span class="s2"> b</span><span class="se">\n</span><span class="s2">EOF</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</code></pre>
<p>and then <code>ruby test.rb</code>, I get the following output:</p>
<pre><code>"\ta\nb\n"
</code></pre>
<p>The least-indented line above is <code> b</code>, however, no leading whitespace is removed from the line containing <code>\ta</code>.</p>
<p>For another example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">File</span><span class="p">.</span><span class="nf">write</span><span class="p">(</span><span class="s2">"test.rb"</span><span class="p">,</span> <span class="s2">"p <<~EOF</span><span class="se">\n\t</span><span class="s2">A</span><span class="se">\n</span><span class="s2"> </span><span class="se">\t</span><span class="s2">B</span><span class="se">\n</span><span class="s2">EOF</span><span class="se">\n</span><span class="s2">"</span><span class="p">)</span>
</code></pre>
<p><code>ruby test.rb</code> gives:</p>
<pre><code>"A\nB\n"
</code></pre>
<p>In this case, the <code>\t</code> was removed from the line containing <code>A</code>, but more whitespace than that (<code> \t</code>) was removed from the line containing <code>B</code>.</p>
<p>After seeing the first example, I assumed that the documentation was out of date, and that I should fix it to read that <code>\t</code> would never be converted into space characters in order to remove leading whitespace. But after the second example, it seems like this is a bug in removing leading whitespace.</p>
<p>Can someone please explain what the rules should be on squiggly heredocs? I can implement a fix to adhere to the rules, or can update the documentation, I am just unsure of what the rules should be because the above two examples reflect unexpected behavior in two distinct ways.</p> Ruby master - Bug #18032 (Rejected): Openstruct is ~20..25x slower with Ruby 3.0.0 and 3.0.1 comp...https://redmine.ruby-lang.org/issues/180322021-07-09T05:04:48ZTiloS (Tilo S)
<p>Doing some timings with different Ruby versions, I noticed that when using Ruby 3.0.0 and 3.0.1<br>
the time to create OpenStruct instances has significantly increased by 20..25x</p>
<pre><code>
0.936016 seconds elapsed for Class.new (Ruby 2.7.2)
0.453067 seconds elapsed for Struct (Ruby 2.7.2)
1.016676 seconds elapsed for Hash (Ruby 2.7.2)
1.482318 seconds elapsed for OpenStruct (Ruby 2.7.2)
0.421272 seconds elapsed for Class.new (Ruby 3.0.0)
0.322617 seconds elapsed for Struct (Ruby 3.0.0)
0.719928 seconds elapsed for Hash (Ruby 3.0.0)
35.130777 seconds elapsed for OpenStruct (Ruby 3.0.0) (oops!)
</code></pre>
<p>see also: <a href="https://stackoverflow.com/questions/1177594/when-should-i-use-struct-vs-openstruct/5440064#5440064" class="external">https://stackoverflow.com/questions/1177594/when-should-i-use-struct-vs-openstruct/5440064#5440064</a></p>
<p>Can someone please look into this?</p> Ruby master - Bug #17731 (Closed): Integer downflow with inject/reducehttps://redmine.ruby-lang.org/issues/177312021-03-19T00:37:39Zgaojun (Jun Gao)
<p>Test case:<br>
[-2305843009213693953,-2305843009213693953,-2305843009213693953].inject(:+)<br>
or<br>
([-2**61-1] * 3).inject(:+)</p>
<p>Expected Result:<br>
-6917529027641081859</p>
<p>Actual Result:<br>
11529215046068469757</p>
<p>Some clues:</p>
<ul>
<li>Downflow seems not happen if there are only two elements in Array</li>
<li>The sample above works fine in <a href="https://try.ruby-lang.org/" class="external">https://try.ruby-lang.org/</a>
</li>
<li>[-2305843009213693953,-2305843009213693953,-2305843009213693953].sum can get the correct result</li>
<li>([-2**61] * 3).inject(:+) can get the correct result</li>
</ul>
<p>Affected Versions:</p>
<ul>
<li>ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]</li>
<li>ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-linux]</li>
<li>ruby 2.6.6p146 (2020-03-31 revision 67876) [x86_64-linux]</li>
</ul> Ruby master - Bug #17623 (Closed): irb starts with some local variables already definedhttps://redmine.ruby-lang.org/issues/176232021-02-12T09:27:23ZUlyssesZhan (Ulysses Zhan)ulysseszhan@pm.me
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">irb</span><span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mo">001</span><span class="p">:</span><span class="mi">0</span><span class="o">></span> <span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
<span class="o">=></span> <span class="mi">1</span>
<span class="n">irb</span><span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mo">002</span><span class="p">:</span><span class="mi">0</span><span class="o">></span> <span class="k">def</span> <span class="nf">f</span> <span class="o">=</span> <span class="n">a</span>
<span class="o">=></span> <span class="ss">:f</span>
<span class="n">irb</span><span class="p">(</span><span class="n">main</span><span class="p">):</span><span class="mo">003</span><span class="p">:</span><span class="mi">0</span><span class="o">></span> <span class="n">f</span>
<span class="o">=></span> <span class="s2">"D:/Ruby30-x64/lib/ruby/gems/3.0.0/gems/irb-1.3.0/exe/irb"</span>
</code></pre>
<p>I have not idea what it means.<br>
The codes just work fine outside irb.<br>
Maybe it is a bug.</p> Ruby master - Feature #17601 (Closed): lib/benchmark: adding `Benchmark::Tms#to_h`https://redmine.ruby-lang.org/issues/176012021-01-31T17:11:24Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>It seems useful to add <code>to_h</code> method to benchmark output.</p>
<p>I'll take care of that unless there's objection.</p>
<p>See <a href="https://github.com/ruby/benchmark/pull/4" class="external">https://github.com/ruby/benchmark/pull/4</a></p> Ruby master - Bug #17600 (Closed): lib/benchmark should use `$stdout` instead of `STDOUT`https://redmine.ruby-lang.org/issues/176002021-01-31T17:09:39Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Unless there is objection, I'll change all uses of <code>STDOUT</code> to <code>$stdout</code> in <code>lib/benchmark</code>, to allow redirection to other io.</p>
<p>See <a href="https://github.com/ruby/benchmark/issues/5" class="external">https://github.com/ruby/benchmark/issues/5</a></p> Ruby master - Bug #17521 (Closed): [Matrix stdlib] Zero matrix to the power of zerohttps://redmine.ruby-lang.org/issues/175212021-01-08T23:26:52ZKache (Kevin Cheng)
<p>Just like <code>0**0 == 1</code>, <code>Matrix.zero(n)**0 == Matrix.identity(n)</code> should be true for all <code>n</code>:</p>
<p><a href="https://math.stackexchange.com/questions/699740/zero-matrix-to-the-power-of-0" class="external">https://math.stackexchange.com/questions/699740/zero-matrix-to-the-power-of-0</a></p>
<p>However:</p>
<pre><code>$ ruby -e "require 'matrix'; Matrix.zero(1)**0"
Traceback (most recent call last):
5: from -e:1:in `<main>'
4: from /usr/lib/ruby/2.7.0/matrix.rb:1227:in `**'
3: from /usr/lib/ruby/2.7.0/matrix.rb:1165:in `inverse'
2: from /usr/lib/ruby/2.7.0/matrix.rb:1173:in `inverse_from'
1: from /usr/lib/ruby/2.7.0/matrix.rb:1173:in `upto'
/usr/lib/ruby/2.7.0/matrix.rb:1183:in `block in inverse_from': Not Regular Matrix (ExceptionForMatrix::ErrNotRegular)
</code></pre>
<p><code>Matrix.zero(n)**0.0</code> happens to work properly, but it should work for integers as well.<br>
Wasn't able to test in Ruby 3.0, but its source code suggests it also behaves this way.</p>
<p>For comparison, <a href="https://numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_power.html" class="external">Python's numpy</a>:</p>
<pre><code>Python 3.8.2 (default, Feb 26 2020, 02:56:10)
>> import numpy as np
>> np.linalg.matrix_power(np.array([[0,0],[0,0]]), 0)
array([[1, 0],
[0, 1]])
</code></pre> Ruby master - Bug #17512 (Closed): ostruct super regressionhttps://redmine.ruby-lang.org/issues/175122021-01-05T20:24:27ZHParker (Adam Hess)
<p>In ruby 3.0, Calling super on ostruct always returns nil. This is a regression in ruby 3.0 introduced when fixing another issue.</p>
<p>introduced by:</p>
<ul>
<li><a href="https://bugs.ruby-lang.org/issues/12136" class="external">https://bugs.ruby-lang.org/issues/12136</a></li>
<li><a href="https://github.com/ruby/ruby/commit/e026e186f4a01aa3f6cd02ae6ef33f44f129361c" class="external">https://github.com/ruby/ruby/commit/e026e186f4a01aa3f6cd02ae6ef33f44f129361c</a></li>
</ul>
<p>This unintentionally changed <code>super</code> behavior in classes that inherit from OpenStruct.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'ostruct'</span>
<span class="k">class</span> <span class="nc">Foo</span> <span class="o"><</span> <span class="no">OpenStruct</span>
<span class="k">def</span> <span class="nf">foo</span>
<span class="k">super</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="nb">p</span> <span class="no">Foo</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">foo: </span><span class="mi">123</span><span class="p">).</span><span class="nf">foo</span>
</code></pre>
<pre><code>Ruby 3.0:
=> nil
Ruby 2.7:
=> 123
</code></pre>
<p>Potential fix is to bring back some of the behavior reverted in issue <a class="issue tracker-1 status-5 priority-4 priority-default closed" title="Bug: OpenStruct.new(format: :bar).send :format # => too few arguments (Closed)" href="https://redmine.ruby-lang.org/issues/12136">#12136</a> to allow method missing to sometimes respond to methods with zero arguments.</p>
<p>This is implemented in: <a href="https://github.com/ruby/ruby/pull/4028" class="external">https://github.com/ruby/ruby/pull/4028</a> and included as a patch attached to this issue.</p> Ruby master - Feature #17277 (Closed): Make Enumerator#with_index yield row and col indices for M...https://redmine.ruby-lang.org/issues/172772020-10-21T10:07:09Zgreggzst (Grzegorz Jakubiak)
<p>Given a matrix:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">matrix</span> <span class="o">=</span> <span class="no">Matrix</span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">8</span><span class="p">]]</span>
</code></pre>
<p>You could get the row and col indices of a matrix using <code>Matrix#each_with_index</code>:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">matrix</span>
<span class="p">.</span><span class="nf">each_with_index</span> <span class="p">{</span> <span class="o">|</span><span class="n">e</span><span class="p">,</span> <span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="o">|</span> <span class="nb">p</span> <span class="p">[</span><span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">]</span> <span class="p">}</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
<span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</code></pre>
<p>You can chain it with other enumerators and access indices within them:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">matrix</span>
<span class="p">.</span><span class="nf">each_with_index</span>
<span class="p">.</span><span class="nf">filter_map</span> <span class="p">{</span> <span class="o">|</span><span class="n">e</span><span class="p">,</span> <span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="o">|</span> <span class="p">[</span><span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">]</span> <span class="k">if</span> <span class="n">e</span> <span class="o">%</span> <span class="mi">4</span> <span class="o">==</span> <span class="mi">0</span><span class="p">}</span>
<span class="c1"># => [[0, 0], [0, 3], [1, 2], [2, 1], [2, 3]]</span>
</code></pre>
<p>Meanwhile, <code>with_index</code> after <code>Matrix#each</code> returns flattened indices, not row or column indices, which does not look right:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">matrix</span>
<span class="p">.</span><span class="nf">each</span><span class="p">.</span><span class="nf">with_index</span> <span class="p">{</span> <span class="o">|</span><span class="n">e</span><span class="p">,</span> <span class="n">index</span><span class="o">|</span> <span class="nb">p</span> <span class="n">index</span> <span class="p">}</span>
<span class="mi">0</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="mi">3</span>
<span class="mi">4</span>
<span class="mi">5</span>
<span class="mi">6</span>
<span class="mi">7</span>
<span class="mi">8</span>
<span class="mi">9</span>
<span class="mi">10</span>
<span class="mi">11</span>
</code></pre>
<p>I feel we should override <code>with_index</code> for <code>Matrix</code> so it returns row and column indices.</p> Ruby master - Feature #15869 (Closed): Add abs to Matrixhttps://redmine.ruby-lang.org/issues/158692019-05-23T19:57:29Zbonafernando (Fernando Wolf Bona)ruby@fernandobona.com
<p>While I was studying Markov Chain I had to find the maximum absolute value of the Matrix to divide the matrix in numbers from 0 to 1 to be able to make further analysis. Like this:</p>
<pre><code>q = Matrix[ ... ]
max = q.to_a.flatten.map { |e| e.abs }.max
q = q / max
</code></pre>
<p>So this is the first of two features that I would like to contribute.</p>
<ol>
<li>Matrix.abs</li>
<li>Matrix.max</li>
</ol> Ruby master - Bug #15515 (Closed): OpenStruct raising NoMethodError instead of ArgumentErrorhttps://redmine.ruby-lang.org/issues/155152019-01-07T13:41:40Zlugray (Lisa Ugray)
<p>When an <code>OpenStruct</code> has some attribute <code>foo</code>, calling the <code>foo</code> method with an argument gives a no method error:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span> <span class="o">=</span> <span class="no">OpenStruct</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">bar: </span><span class="s1">'baz'</span><span class="p">)</span>
<span class="n">foo</span><span class="p">.</span><span class="nf">bar</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># => NoMethodError (undefined method `bar' for #<OpenStruct bar="baz">)</span>
</code></pre>
<p>This is confusing, since <code>foo.respond_to?(:bar) # => true</code>. I would expect:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">foo</span> <span class="o">=</span> <span class="no">OpenStruct</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">bar: </span><span class="s1">'baz'</span><span class="p">)</span>
<span class="n">foo</span><span class="p">.</span><span class="nf">bar</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># => ArgumentError (wrong number of arguments (given 1, expected 0))</span>
</code></pre>
<p>The included fixes this, and adjusts the arity <code>ArgumentError</code> for the setter to be in line with the default arity messaging too.</p> Ruby master - Feature #15451 (Closed): OpenStruct#to_h でブロックを許容するhttps://redmine.ruby-lang.org/issues/154512018-12-22T13:18:39Zshuujii (Shuji KOBAYASHI)shuujii@gmail.com
<p><code>Struct#to_h</code> がブロックを受け付けるようになったので、<code>OpenStruct#to_h</code><br>
も同様にしてはどうでしょうか。</p>
<p>パッチを添付します。</p> Ruby master - Bug #15409 (Closed): OpenStruct error when attribute is called 'method'https://redmine.ruby-lang.org/issues/154092018-12-13T03:25:26Zelioncho (Elías Orozco)
<p>The following error is shown when you try to access an OpenStruct with a property called method:</p>
<p>`method': wrong number of arguments (given 0, expected 1) (ArgumentError)</p>
<p>To replicate:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'ostruct'</span>
<span class="n">o</span> <span class="o">=</span> <span class="no">OpenStruct</span><span class="p">.</span><span class="nf">new</span><span class="p">({</span> <span class="ss">method: </span><span class="s1">'get'</span> <span class="p">})</span>
<span class="n">o</span><span class="p">.</span><span class="nf">method</span>
</code></pre>
<p>The expected behavior should be to return 'get'</p> Ruby master - Feature #15233 (Closed): Speeding Up Matrix Powershttps://redmine.ruby-lang.org/issues/152332018-10-18T00:59:15Zoctonion (Christopher Long)
<p>I've been looking at SymPy's slow matrix power speed, and noticed that replacing Ruby's matrix power code with the equivalent code from SymPy makes it significantly faster. As this is a recursively defined function, presumably it can be made even faster with a proper iterative version.</p>
<p>Base:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'matrix'</span>
<span class="no">Q</span> <span class="o">=</span> <span class="no">Matrix</span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]]</span>
<span class="n">r</span> <span class="o">=</span> <span class="no">Vector</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
<span class="nb">p</span> <span class="o">=</span> <span class="p">(</span><span class="no">Q</span><span class="o">**</span><span class="mi">100000000</span><span class="o">*</span><span class="n">r</span><span class="p">).</span><span class="nf">sum</span>
<span class="nb">puts</span> <span class="nb">p</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">size</span>
</code></pre>
<p>Output:</p>
<pre><code>time ruby main.rb
35950264
real 1m42.250s
user 1m41.050s
sys 0m1.184s
</code></pre>
<p>Modified:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'matrix'</span>
<span class="k">def</span> <span class="nf">pow</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">num</span><span class="p">)</span>
<span class="k">if</span> <span class="p">(</span><span class="n">num</span><span class="o">==</span><span class="mi">1</span><span class="p">)</span>
<span class="k">return</span> <span class="n">a</span>
<span class="k">end</span>
<span class="k">if</span> <span class="p">(</span><span class="n">num</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span><span class="o">==</span><span class="mi">1</span>
<span class="k">return</span> <span class="n">a</span><span class="o">*</span><span class="n">pow</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">num</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="k">end</span>
<span class="n">ret</span> <span class="o">=</span> <span class="n">pow</span><span class="p">(</span><span class="n">a</span><span class="p">,(</span><span class="n">num</span><span class="o">/</span><span class="mi">2</span><span class="p">))</span>
<span class="n">ret</span><span class="o">*</span><span class="n">ret</span>
<span class="k">end</span>
<span class="no">Q</span> <span class="o">=</span> <span class="no">Matrix</span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]]</span>
<span class="n">r</span> <span class="o">=</span> <span class="no">Vector</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
<span class="nb">p</span> <span class="o">=</span> <span class="p">(</span><span class="n">pow</span><span class="p">(</span><span class="no">Q</span><span class="p">,</span><span class="mi">100000000</span><span class="p">)</span><span class="o">*</span><span class="n">r</span><span class="p">).</span><span class="nf">sum</span>
<span class="nb">puts</span> <span class="nb">p</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">size</span>
</code></pre>
<p>Output:</p>
<pre><code>time ruby main.rb
35950264
real 1m9.489s
user 1m8.661s
sys 0m0.828s
</code></pre> Ruby master - Feature #14151 (Closed): Make Matrix#[]= public methodhttps://redmine.ruby-lang.org/issues/141512017-12-03T09:45:03Zgreggzst (Grzegorz Jakubiak)
<p>I don't even understand why this method hasn't been public since the beginning. I've come to a point when I have to create a matrix in a specific way using row and column indices and I can't use #build with a block because then indices go from the beginning of matrix whereas I have to from the center of the matrix. So what I wanted to do is to create a zero matrix and the fill it in a proper way but I can't without using #[]=. I know I can reopen class and that's what I'm doing but this just doesn't make sense. If we can change elements in an array like so using #[]= then why matrices can't use that as well?</p> Ruby master - Feature #14116 (Feedback): Add Matrix #exponentiate method as Matlab's exphttps://redmine.ruby-lang.org/issues/141162017-11-19T20:11:51Zgreggzst (Grzegorz Jakubiak)
<p>Add exponentiate method which results in returning a new matrix with each element being an exponent of the number e.<br>
Here is PR for that: <a href="https://github.com/ruby/ruby/pull/1762" class="external">https://github.com/ruby/ruby/pull/1762</a></p> Ruby master - Bug #14082 (Closed): Enumerator#size from Enumerable#cycle returns 0 when the objec...https://redmine.ruby-lang.org/issues/140822017-11-05T17:05:28Zkachick (Kenichi Kamiya)kachick1@gmail.com
<p>github: <a href="https://github.com/ruby/ruby/pull/1742" class="external">https://github.com/ruby/ruby/pull/1742</a></p>
<p>Is this an intentional behavior?</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span><span class="p">([].</span><span class="nf">cycle</span><span class="p">.</span><span class="nf">size</span><span class="p">)</span> <span class="c1">#=> 0</span>
<span class="nb">p</span><span class="p">({}.</span><span class="nf">cycle</span><span class="p">.</span><span class="nf">size</span><span class="p">)</span> <span class="c1">#=> Infinity </span>
</code></pre>
<p>Array#cycle already special handled empty arrays. So similar behavior in Enumerable#cycle with the #size sounds reasonable to me.</p> Ruby master - Bug #14074 (Closed): TracePoint#new without a block should not raise ThreadErrorhttps://redmine.ruby-lang.org/issues/140742017-11-01T13:54:57Zatul (Atul Bhosale)atul1bhosale@gmail.com
<p>While working on RubySpecs with Marc-Andre Lafortune, we discovered that TracePoint.new raises a ThreadError instead of ArgumentError.<br>
For example :</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">TracePoint</span><span class="p">.</span><span class="nf">new</span> <span class="o">=></span> <span class="c1"># => ThreadError: must be called with a block</span>
</code></pre> Ruby master - Bug #14057 (Closed): TracePoint#enable and disable should not yield argumentshttps://redmine.ruby-lang.org/issues/140572017-10-26T06:54:53Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>While working on RubySpecs with Atul Bhosale, we discovered that <code>TracePoint#enable</code> and <code>#disable</code> yield <code>nil</code> instead of not yielding any argument.</p>
<p>This is mostly harmless as we usually use blocks, but it could create issues for lambdas/methods, for example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">def</span> <span class="nf">handle_trace</span><span class="p">;</span> <span class="k">end</span>
<span class="no">TracePoint</span><span class="p">.</span><span class="nf">new</span><span class="p">{}.</span><span class="nf">enable</span><span class="p">(</span><span class="o">&</span><span class="nb">method</span><span class="p">(</span><span class="ss">:handle_trace</span><span class="p">))</span> <span class="c1"># => ArgumentError: wrong number of arguments (given 1, expected 0)</span>
</code></pre>
<p>I'm fixing in trunk, would be nice to backport.</p> Ruby master - Misc #14000 (Closed): OpenStruct with #frozen_string_literal: truehttps://redmine.ruby-lang.org/issues/140002017-10-11T09:00:38Zesparta (Espartaco Palma)
<p>The current implementation of OpenStruct needs minimal changes in order to support frozen strings.<br>
The mutable strings are only on inspect method.</p>
<p>IMO, we have two options:</p>
<p>a) leave the code as it is and just adding .dup where is needed<br>
b) Change to a functional style (map + join) instead of flags + concat.</p> Ruby master - Bug #13492 (Closed): Integer#prime? and Prime.each might produce false positiveshttps://redmine.ruby-lang.org/issues/134922017-04-21T19:06:31Zstomar (Marcus Stollsteimer)
<p>There is a bug in Integer#prime? that might result in the method returning <code>true</code> for (very big) numbers that are not prime. Similarly, Prime.each might yield numbers that are not prime.</p>
<p>Integer#prime? uses <code>Math.sqrt(self).to_i</code> to determine the upper limit up to which trial divisions are carried out. However, Math.sqrt uses floating point arithmetic, which might lead to considerable differences between its result and the correct integer sqrt.</p>
<p>In the case where Math.sqrt returns a number that is too low, the trial division aborts too early and might miss a higher prime factor. Therefore, a non-prime number might erroneously reported to be prime.</p>
<p>Note that this bug probably has very low impact for practical use cases. The affected numbers are very big, probably well beyond the range where calculating Integer#prime? in a reasonable amount of time is feasible. For double precision floats, Math.sqrt().to_i should produce wrong results for integers from around <code>10**30</code> or <code>10**31</code> upwards.</p>
<p>Example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">p</span> <span class="o">=</span> <span class="mi">150094635296999111</span> <span class="c1"># a prime number</span>
<span class="n">n</span> <span class="o">=</span> <span class="nb">p</span> <span class="o">*</span> <span class="nb">p</span> <span class="c1"># not prime</span>
<span class="n">n</span> <span class="c1"># => 22528399544939171409947441934790321</span>
</code></pre>
<p>n is not a prime number and has only one prime factor, namely p. n can only be identified correctly as non-prime when a trial division with p is carried out.</p>
<p>However, Integer#prime? stops testing before p is reached:</p>
<pre><code>Math.sqrt(n).to_i # => 150094635296999104 (!)
p # => 150094635296999111
</code></pre>
<p>It would therefore erroneously return <code>true</code> (after a very long time of waiting for the result).</p>
<p>(To be precise: the method tests in batches of 30, and the highest tested number in this case would actually be 150094635296999101; the remaining numbers up to the (wrong) limit are known to be multiples of 2 or 3, and need not be tested.)</p>
<p>Prime.each has the same problem. It uses Prime::EratosthenesGenerator by default, which calculates the upper limit with Math.sqrt().floor (via Prime::EratosthenesSieve).</p>
<p>For trunk, this bug can easily be fixed by using the (new) Integer.sqrt method, see attached patch.</p>
<p>I'm not sure whether a patch for Ruby 2.4 and 2.3 (where Integer.sqrt is not available) is necessary.</p> Ruby master - Feature #13208 (Closed): Vector.zero(n) and vector.zero?https://redmine.ruby-lang.org/issues/132082017-02-11T19:54:55Zqitar888 (Chia-sheng Chen)
<p>Found that I need this recently, and class <code>Matrix</code> has these two function while <code>Vector</code> not.<br>
So I add two function based on <code>Matrix</code> counterpart and also add test.</p>
<p>Usage</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'matrix'</span>
<span class="n">v</span> <span class="o">=</span> <span class="no">Vector</span><span class="p">.</span><span class="nf">zero</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># => Vector[0, 0, 0]</span>
<span class="n">v</span><span class="p">.</span><span class="nf">zero?</span> <span class="c1"># => true</span>
<span class="n">w</span> <span class="o">=</span> <span class="no">Vector</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">w</span><span class="p">.</span><span class="nf">zero?</span> <span class="c1"># => false</span>
</code></pre> Ruby master - Feature #12665 (Closed): Faster prime? method for prime.rb std libhttps://redmine.ruby-lang.org/issues/126652016-08-09T20:06:46Zjzakiya (Jabari Zakiya)
<p>The current version of the method <code>prime?</code> in the <code>prime.rb</code><br>
std lib replaced the older version starting with 2.3.0.</p>
<p>It uses an implementation of the P3 Strictly Prime, Prime Generator (SP PG).<br>
It can be simplified as shown below.</p>
<p>(see Primes-Utils Handbook for details )<br>
(<a href="https://www.scribd.com/doc/266461408/Primes-Utils-Handbook" class="external">https://www.scribd.com/doc/266461408/Primes-Utils-Handbook</a> )</p>
<p>A much faster version <code>primep5?</code> can replace it using the P5 SP PG.<br>
This allows it to be used with bigger numbers with much better performance.</p>
<pre><code>class Integer
def prime? # version now used in prime.rb since MRI 2.3.0
return self >= 2 if self <= 3
return false if self % 2 == 0 or self % 3 == 0
# return false unless 6.gcd(self) == 1 # simplification
(5..(self**0.5).floor).step(6).each do |i|
if self % i == 0 || self % (i + 2) == 0
return false
end
end
true
end
def primep5? # Uses P5 Strictly Prime PG
return false unless self > 1 and 30.gcd(self) == 1 or [2,3,5].include? self
(7..Math.sqrt(self).to_i).step(30) do |p|
return false if
self%(p) == 0 or self%(p+4) == 0 or self%(p+6) == 0 or self%(p+10) == 0 or
self%(p+12) == 0 or self%(p+16) == 0 or self%(p+22) == 0 or self%(p+24) == 0
end
true
end
end
``
Beloow are some timing comparisions for 3 progressively larger primes for 2.3.1.
System: System76 3.5GHz I7 cpu laptop, Linux 64-bit OS
</code></pre>
<p>n1 = 100_000_000_000_000_003<br>
n2 = 200_000_000_000_000_003<br>
n3 = 1_000_000_000_000_000_003</p>
<pre><code> n1 n2 n3
</code></pre>
<p>prime? 4.1 5.7 12.9<br>
primep5 2.5 3.6 7.9</p>
<p>def tm; s = Time.now; yield; Time.now - s end</p>
<p>irb(main):028:0> n = 100_000_000_000_000_003; tm{ n.prime? }<br>
=> 4.127392644<br>
irb(main):029:0> n = 100_000_000_000_000_003; tm{ n.primep5? }<br>
=> 2.539485672<br>
irb(main):030:0> n = 200_000_000_000_000_003; tm{ n.prime? }<br>
=> 5.721895509<br>
irb(main):031:0> n = 200_000_000_000_000_003; tm{ n.primep5? }<br>
=> 3.56925564<br>
irb(main):032:0> n = 1_000_000_000_000_000_003; tm{ n.prime? }<br>
=> 12.940908142<br>
irb(main):033:0> n = 1_000_000_000_000_000_003; tm{ n.primep5? }<br>
=> 7.920408959</p>
<pre><code></code></pre> Ruby master - Feature #12637 (Rejected): Unified and consistent method naming for safe and danger...https://redmine.ruby-lang.org/issues/126372016-07-29T19:04:11Zr.smitala (Radovan Smitala)
<p>Hello,</p>
<p>As a multi-paradign language allows programmers to code from imperative to functional style. This gives Ruby to be modern and wide used language in these days.<br>
Ruby is built on idea to be as fun, understandable and focused for people.</p>
<p>But i think it carry "complicated behaviour" in some method naming.</p>
<p>In this documentation is written: (<a href="http://docs.ruby-lang.org/en/trunk/syntax/methods_rdoc.html" class="external">http://docs.ruby-lang.org/en/trunk/syntax/methods_rdoc.html</a>)</p>
<blockquote>
<p>The bang methods (! at the end of method name) are called and executed just like any other method. However, by convention, a method with an exclamation point or bang is considered dangerous. In ruby core library the dangerous method implies that when a <strong>method ends with a bang (!), it indicates that unlike its non-bang equivalent, permanently modifies its receiver</strong>. <strong>Almost always</strong>, ruby core library will have a non-bang counterpart (method name which does NOT end with !) of every bang method (method name which does end with !) that does not modify the receiver. This convention is typically true for ruby core library but may or may not hold true for other ruby libraries.</p>
</blockquote>
<p>Hightlited part of citation talks about that method with exclamation mark modifies its receiver. What is good because i could choose between imperative habit and modify receiver, but i can also create new data and code in functional habit.</p>
<p>Eg: i can create new array with <strong>map</strong> method, but always i can modify existed object with <strong>map!</strong>. What is incredible and easy to understand.<br>
Or i want to get unique values from array by <strong>uniq</strong> assign into new variable. Still it is able to modify origin array with <strong>uniq!</strong></p>
<p>Second highlighted part is about confused part. It tells to programmer be careful. Not all methods follows this great design.<br>
In Ruby are methods which are "inconsistent" in naming.</p>
<p>Eg. Many built-in Array methods like</p>
<ul>
<li>clear</li>
<li>concat</li>
<li>delete</li>
<li>delete_at</li>
<li>delete_if</li>
<li>fill</li>
<li>insert</li>
<li>keep_if</li>
<li>pop</li>
<li>push</li>
<li>replace</li>
<li>shift</li>
<li>unshift<br>
are dangerous because modify its receiver. What is confusing for many programmers and it brings unexceptional behaviour without study documentation deeper.</li>
</ul>
<p>I think Ruby is popular for people because it communicate with programmer like in human language.<br>
Nowadays are getting functional programming languages high popularity and trend increase more and more.</p>
<p>It could be great to remove that one word ("Almost") and have Ruby as language more clear, unambiguous and brings more functional principles into language what we like and love.</p> Ruby master - Bug #12356 (Rejected): Vector covector incorrect multiplication with another vector.https://redmine.ruby-lang.org/issues/123562016-05-06T23:51:54Zedmorte (Rafael Silva)
<p>Version 2.2.4</p>
<p>v1 = Vector[2,3,4]<br>
v2 = Vector[4,5,6]<br>
v1.covector.row_size #1<br>
v1.covector.column_size #3<br>
v2.covector.row_size #1<br>
v2.covector.column_size #3</p>
<p>Vector does not have distinction between row and column, there's no column vector notion in the language.</p>
<p>v1 * v2.covector #Matrix[[8,10,12],[12,15,18],[16,20,24]]</p>
<a name="Should-be-illegal-But-works-like-if-v2covector-is-transposed-column-vector-which-its-clearly-not"></a>
<h1 >Should be illegal. But works like if v2.covector is transposed / column vector which it's clearly not.<a href="#Should-be-illegal-But-works-like-if-v2covector-is-transposed-column-vector-which-its-clearly-not" class="wiki-anchor">¶</a></h1>
<p>v1.covector * v2.covector #ExceptionForMatrix::ErrDimensionMismatch: Matrix dimension mismatch</p>
<a name="Expected"></a>
<h1 >Expected<a href="#Expected" class="wiki-anchor">¶</a></h1>
<p>v1 * v2 #ExceptionForMatrix::ErrOperationNotDefined: Operation(*) can't be defined: Vector op Vector</p>
<a name="No-comments-see-my-observation-below"></a>
<h1 >No comments, see my observation below.<a href="#No-comments-see-my-observation-below" class="wiki-anchor">¶</a></h1>
<p>v1.covector * v2 #Vector[47]<br>
#Again covector treated like transposed / column vector.</p>
<p>Personal observation: Terrible choice to represent Vector like an Array, Vector should be a shortcut to Matrix.</p> Ruby master - Bug #12044 (Closed): net/ftp.rb: add NullSocket#closed? to fix closing not yet open...https://redmine.ruby-lang.org/issues/120442016-02-01T22:52:37Zantstorm (Anthony Dmitriyev)
<p>Hi there,</p>
<p>I've opened a PR for this issue on GitHub: <a href="https://github.com/ruby/ruby/pull/1232" class="external">https://github.com/ruby/ruby/pull/1232</a></p>
<p>An instance of <code>NullSocket</code> is stored in a <code>@sock</code> variable of a new <code>Net::FTP</code>, it also has a <code>#close</code> method (that obviously does nothing), but it is never called, because a wrapping <code>Net::FTP#close</code> checks that <code>@sock and not @sock.closed?</code> which crashes with <code>FTPConnectionError</code> because there is no method <code>#closed?</code> on <code>NullSocket</code>. This PR adds it and a test to verify that it works.</p>
<p>Below is the way to reproduce the error in the IRB. As you can see it's quite confusing, you'd expect <code>#closed?</code> not to raise an error, but return <code>true</code> instead.</p>
<pre><code>>> ftp = Net::FTP.new
=> #<Net::FTP:0x007f90c38075e0 @mon_owner=nil, @mon_count=0, @mon_mutex=#<Thread::Mutex:0x007f90c3807590>, @binary=true, @passive=true, @debug_mode=false, @resume=false, @sock=#<Net::FTP::NullSocket:0x007f90c3807568>, @logged_in=false, @open_timeout=nil, @read_timeout=60>
>> ftp.close
Net::FTPConnectionError: not connected
from /usr/local/var/rbenv/versions/2.3.0/lib/ruby/2.3.0/net/ftp.rb:1277:in `method_missing'
from /usr/local/var/rbenv/versions/2.3.0/lib/ruby/2.3.0/net/ftp.rb:1168:in `close'
from (irb):6
from /usr/local/var/rbenv/versions/2.3.0/bin/irb:11:in `<main>'
>> ftp.closed?
Net::FTPConnectionError: not connected
from /usr/local/var/rbenv/versions/2.3.0/lib/ruby/2.3.0/net/ftp.rb:1277:in `method_missing'
from /usr/local/var/rbenv/versions/2.3.0/lib/ruby/2.3.0/net/ftp.rb:1184:in `closed?'
from (irb):7
from /usr/local/var/rbenv/versions/2.3.0/bin/irb:11:in `<main>'
</code></pre> Ruby master - Feature #12032 (Closed): Matrix.rb ruby documentationhttps://redmine.ruby-lang.org/issues/120322016-01-29T03:53:01ZOneill38 (Megan O'Neill)
<p>Added documentation for three methods within matrix.rb file: elements_to_f, elements_to_i, elements_to_r</p> Ruby master - Bug #11953 (Rejected): ThreadError in 2.3 on code that works on 2.2.4https://redmine.ruby-lang.org/issues/119532016-01-05T19:01:29Zclaytonflesher (Clayton Flesher)
<p>This is my first bug reporting, so I'm sorry if this isn't exactly correct format. I'll update my report accordingly if pointed in the right direction.</p>
<p>I ran into what appears to be a bug while doing a quiz.</p>
<p>I've included the breaking code, the test suite and the description of the quiz as attachments to this bug report.</p>
<p>The following code works fine on Ruby 2.2.4.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Prime</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">nth</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="n">error</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="n">primes</span> <span class="o">=</span> <span class="n">build_primes</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="n">primes</span><span class="p">.</span><span class="nf">last</span>
<span class="k">end</span>
<span class="kp">private</span>
<span class="k">def</span> <span class="nf">build_primes</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="n">primes</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span>
<span class="n">index</span> <span class="o">=</span> <span class="mi">3</span>
<span class="k">until</span> <span class="n">primes</span><span class="p">.</span><span class="nf">size</span> <span class="o">==</span> <span class="n">num</span>
<span class="k">if</span> <span class="n">example?</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">primes</span><span class="p">)</span>
<span class="n">primes</span> <span class="o"><<</span> <span class="n">index</span>
<span class="k">end</span>
<span class="n">index</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">end</span>
<span class="n">primes</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">error</span><span class="p">(</span><span class="n">num</span><span class="p">)</span>
<span class="k">unless</span> <span class="n">num</span> <span class="o">></span> <span class="mi">0</span>
<span class="k">raise</span> <span class="no">ArgumentError</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">example?</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">primes</span><span class="p">)</span>
<span class="n">primes</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">prime</span><span class="o">|</span>
<span class="k">if</span> <span class="n">index</span> <span class="o">%</span> <span class="n">prime</span> <span class="o">==</span> <span class="mi">0</span>
<span class="k">return</span> <span class="kp">false</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="kp">true</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>It raises this error in Ruby 2.3.0</p>
<pre><code>ThreadError: deadlock; recursive locking
/home/clayton/.rubies/ruby-2.3.0/lib/ruby/2.3.0/singleton.rb:140:in `synchronize'
/home/clayton/.rubies/ruby-2.3.0/lib/ruby/2.3.0/singleton.rb:140:in `instance'
/home/clayton/.rubies/ruby-2.3.0/lib/ruby/2.3.0/singleton.rb:142:in `block in instance'
/home/clayton/.rubies/ruby-2.3.0/lib/ruby/2.3.0/singleton.rb:140:in `synchronize'
/home/clayton/.rubies/ruby-2.3.0/lib/ruby/2.3.0/singleton.rb:140:in `instance'
/home/clayton/exercism/ruby/nth-prime/nth_prime.rb:3:in `nth'
nth_prime_test.rb:28:in `test_first'
</code></pre>
<p>If this is expected behavior, I'm sorry in advance for wasting your time.</p> Ruby master - Bug #11901 (Closed): Performance Issue with OpenStructhttps://redmine.ruby-lang.org/issues/119012015-12-27T15:37:20Zamcaplan (Ariel Caplan)ariel.caplan@mail.yu.edu
<p>After recent changes to define OpenStruct getter/setter methods lazily, there is a heavy performance impact for the use case where an attribute is assigned at initialization time (i.e. <code>Openstruct.new(foo: :bar)</code>). Once an attribute is stored in the internal hash, the appropriate singleton methods will never be defined, due to the recent changes to OpenStruct's <code>#respond_to_missing?</code> - meaning that every time I call <code>#foo</code> or <code>#foo=</code> it relies on <code>#method_missing</code>. Benchmark using benchmark-ips is attached.</p>
<p>I'm primarily concerned about the case of configuration objects, which may be populated at initialization time and then accessed many times throughout the life of the program.</p> Ruby master - Bug #11884 (Closed): Psych.load broken for OpenStruct in Ruby 2.3.0https://redmine.ruby-lang.org/issues/118842015-12-27T00:46:39Zkaikuchn (Kai Kuchenbecker)kuchenbecker.k@gmail.com
<p>Deserialising an OpenStruct through Psych::load results in a nil error since OpenStruct now has a respond_to_missing? method whose implementation references OpenStruct's @table instance variable.</p>
<p>To reproduce this issue simply use Psych to dump an OpenStruct and then load it again via Psych::load. I attached an example script that does exactly this. I have also attached the error output I get when running this script.</p>
<p>I'm not sure whether to assign marcandre or tenderlove... Please tell me if you need any further information.</p>
<p>Best regards,<br>
Kai</p> Ruby master - Feature #11708 (Closed): Specify a way to override Struct-subclass constructorhttps://redmine.ruby-lang.org/issues/117082015-11-18T14:02:13Zprijutme4ty (Ilya Vorontsov)prijutme4ty@gmail.com
<p>It's common to create simple data-object with some constraints. One can either implement custom class or use <code>Struct</code>. Struct is generally simpler and helps to avoid some mistakes as non-defined <code>#hash</code> and <code>#eql?</code>. But at the same time it's more difficult to make validation for <code>Struct</code> subclass.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Point</span> <span class="o">=</span> <span class="no">Struct</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">:x</span><span class="p">,</span> <span class="ss">:y</span><span class="p">)</span>
<span class="no">NonnegativePoint</span> <span class="o">=</span> <span class="no">Struct</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="ss">:x</span><span class="p">,</span><span class="ss">:y</span><span class="p">)</span> <span class="k">do</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="k">super</span>
<span class="k">raise</span> <span class="s1">'Negative coordinates are not allowed'</span> <span class="k">if</span> <span class="n">x</span> <span class="o"><</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">y</span> <span class="o"><</span> <span class="mi">0</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<p>Above written code solves the problem but has one flaw. <code>Struct.new</code> creates a subclass of <code>Struct</code> and defines some methods as <code>#x</code>, <code>#x=</code>. And there are no guarantees that <code>NonnegativePoint#initialize</code> wasn't redefined too.<br>
We can check that <code>Point.new</code> without explicitly defined <code>#initialize</code> actually hits <code>Struct#initialize</code> and <code>Point#initialize</code> not defined:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="no">Point</span><span class="p">.</span><span class="nf">instance_method</span><span class="p">(</span><span class="ss">:initialize</span><span class="p">)</span>
<span class="c1"># => #<UnboundMethod: Point(Struct)#initialize></span>
<span class="no">NonnegativePoint</span><span class="p">.</span><span class="nf">instance_method</span><span class="p">(</span><span class="ss">:initialize</span><span class="p">)</span>
<span class="c1"># => #<UnboundMethod: NonnegativePoint#initialize></span>
</code></pre>
<p>But nothing in <code>Struct</code> documentation or test suite states that this behavior can't be changed in newer ruby versions.</p>
<p>I propose either to declare in docs and test that initialize method can be safely overriden because <code>#initialize</code> is not defined in <code>Struct</code> subclasses.<br>
In you assume that one day current behavior can change (e.g. for perfomance reasons), then it's reasonable to create an extension point like '#after_initialize' which is called from <code>Struct</code>'s subclass <code>#initialize</code> method.</p> Ruby master - Bug #11564 (Third Party's Issue): Segementation fault while doing rake db:migratehttps://redmine.ruby-lang.org/issues/115642015-10-02T09:52:05Zritesh@blogvault.net (ritesh soni)ritesh@blogvault.net
<p>I am using ruby<br>
ruby 2.1.7p400 (2015-08-18 revision 51632) [x86_64-linux]<br>
rails: Rails 3.2.13</p>
<p>I recently upgraded from ruby 2.0.0 to ruby 2.1.7,<br>
now when I am trying to do rake db:migrate</p>
<p>I am getting a segmentation fault.</p> Ruby master - Bug #11385 (Rejected): `==` with bidirectional/cyclic dependencyhttps://redmine.ruby-lang.org/issues/113852015-07-22T02:54:11Zallenwq (Allen Wang)rovingbreeze@gmail.com
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="k">class</span> <span class="nc">Something</span>
<span class="nb">attr_accessor</span> <span class="ss">:friend</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">friend</span><span class="p">)</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">friend</span> <span class="o">=</span> <span class="n">friend</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">==</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="n">friend</span> <span class="o">==</span> <span class="n">other</span><span class="p">.</span><span class="nf">friend</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="n">a</span> <span class="o">=</span> <span class="no">Something</span><span class="p">.</span><span class="nf">new</span><span class="p">([])</span>
<span class="n">b</span> <span class="o">=</span> <span class="no">Something</span><span class="p">.</span><span class="nf">new</span><span class="p">([</span><span class="n">a</span><span class="p">])</span>
<span class="n">a</span><span class="p">.</span><span class="nf">friend</span> <span class="o">=</span> <span class="p">[</span><span class="n">b</span><span class="p">]</span>
<span class="n">a</span> <span class="o">==</span> <span class="n">b</span>
</code></pre>
<p>The above code returns true on OS X and Linux, by right it should give me a exception of stack level too deep.</p>
<p>( And on windows I can see the expected exception )</p> Ruby master - Bug #11341 (Third Party's Issue): Rails server command is not working finehttps://redmine.ruby-lang.org/issues/113412015-07-09T16:59:37ZEshVal (Esh Val)vallurupallieswar@gmail.com
<p>I wanted to run the rails server command and it's showing some log and it is crashed.</p> Ruby master - Bug #11303 (Third Party's Issue): [BUG] Segmentati on fault ruby 2.2.2p95 (2015-04-...https://redmine.ruby-lang.org/issues/113032015-06-24T08:25:20Zadrianpetrov (adrian petrov)iurca.adrian@live.com
<p>$ rails server<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/extensions/x64-mingw32/2.2.0/mysql-2.9.1/mysql/mysql_api.so: [BUG] Segmentati<br>
on fault<br>
ruby 2.2.2p95 (2015-04-13 revision 50295) [x64-mingw32]</p>
<p>-- Control frame information -----------------------------------------------<br>
c:0019 p:-11306334 s:0064 e:000063 TOP [FINISH]<br>
c:0018 p:---- s:0062 e:000061 CFUNC :require<br>
c:0017 p:0020 s:0058 e:000057 RESCUE c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/mysql-2.9.1/lib/mysql.rb:6<br>
c:0016 p:0032 s:0055 e:000054 TOP c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/mysql-2.9.1/lib/mysql.rb:2 [FINISH]</p>
<p>c:0015 p:---- s:0053 e:000052 CFUNC :require<br>
c:0014 p:0037 s:0049 e:000048 BLOCK c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.<br>
rb:76 [FINISH]<br>
c:0013 p:---- s:0046 e:000045 CFUNC :each<br>
c:0012 p:0053 s:0043 e:000042 BLOCK c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.<br>
rb:72 [FINISH]<br>
c:0011 p:---- s:0037 e:000036 CFUNC :each<br>
c:0010 p:0030 s:0034 e:000033 METHOD c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.<br>
rb:61<br>
c:0009 p:0017 s:0030 e:000029 METHOD c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler.rb:134<br>
c:0008 p:0049 s:0026 e:000025 TOP C:/Users/uidj5532/Downloads/resdb.git/config/application.rb:7 [FINISH]<br>
c:0007 p:---- s:0024 e:000023 CFUNC :require<br>
c:0006 p:0014 s:0020 e:000019 BLOCK c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.r<br>
b:74 [FINISH]<br>
c:0005 p:---- s:0017 e:000016 CFUNC :tap<br>
c:0004 p:0561 s:0014 e:000013 TOP c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.r<br>
b:71 [FINISH]<br>
c:0003 p:---- s:0008 e:000007 CFUNC :require<br>
c:0002 p:0034 s:0004 E:0024e0 EVAL bin/rails:4 [FINISH]<br>
c:0001 p:0000 s:0002 E:002060 TOP [FINISH]</p>
<p>-- Ruby level backtrace information ----------------------------------------<br>
bin/rails:4:in <code><main>' bin/rails:4:in </code>require'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.rb:71:in <code><top (required)>' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.rb:71:in </code>tap'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.rb:74:in <code>block in <top (required)>' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands.rb:74:in </code>require'<br>
C:/Users/uidj5532/Downloads/resdb.git/config/application.rb:7:in <code><top (required)>' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler.rb:134:in </code>require'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:61:in <code>require' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:61:in </code>each'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:72:in <code>block in require' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:72:in </code>each'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:76:in <code>block (2 levels) in require ' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb:76:in </code>require'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/mysql-2.9.1/lib/mysql.rb:2:in <code><top (required)>' c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/mysql-2.9.1/lib/mysql.rb:6:in </code>rescue in <top (required)>'<br>
c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/mysql-2.9.1/lib/mysql.rb:6:in `require'</p>
<p>-- C level backtrace information -------------------------------------------<br>
C:\Windows\SYSTEM32\ntdll.dll(NtWaitForSingleObject+0xa) [0x0000000076EEDC1A]<br>
C:\Windows\system32\KERNELBASE.dll(WaitForSingleObjectEx+0x9c) [0x000007FEFCE510DC]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_bugreport+0xa4) [0x00000000649A2624]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_bug_context+0x62) [0x000000006484BC22]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_check_safe_obj+0x3b2) [0x000000006491BB62]<br>
[0x0000000000401A85]<br>
C:\Windows\SYSTEM32\ntdll.dll(_C_specific_handler+0x9c) [0x0000000076EB7FA8]<br>
C:\Windows\SYSTEM32\ntdll.dll(RtlDecodePointer+0xad) [0x0000000076EC908D]<br>
C:\Windows\SYSTEM32\ntdll.dll(RtlUnwindEx+0xbbf) [0x0000000076EB8BAF]<br>
C:\Windows\SYSTEM32\ntdll.dll(KiUserExceptionDispatcher+0x2e) [0x0000000076EEDB38]<br>
c:\Ruby22-x64\lib\ruby\gems\2.2.0\extensions\x64-mingw32\2.2.0\mysql-2.9.1\mysql\mysql_api.so(Init_mysql_api+0x<br>
7790) [0x00000000667CDEE0]<br>
c:\Ruby22-x64\lib\ruby\gems\2.2.0\extensions\x64-mingw32\2.2.0\mysql-2.9.1\mysql\mysql_api.so(Init_mysql_api+0x<br>
d) [0x00000000667C675D]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(dln_load+0x1d6) [0x0000000064801646]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_call_cfunc+0x130) [0x000000006499EF50]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_require_internal+0x559) [0x0000000064857229]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_require+0x20) [0x0000000064857590]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_send+0x761) [0x000000006499C541]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1f7b) [0x0000000064990F7B]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_iseq_eval+0x183) [0x000000006499E8B3]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_rubylevel_errinfo+0x61c) [0x000000006485562C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_require_internal+0x593) [0x0000000064857263]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_require+0x20) [0x0000000064857590]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1f7b) [0x0000000064990F7B]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_funcall+0xa96) [0x000000006499A896]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_yield+0x7c) [0x000000006499B79C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_ary_each+0x51) [0x0000000064801971]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1ed7) [0x0000000064990ED7]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_funcall+0xa96) [0x000000006499A896]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_yield+0x7c) [0x000000006499B79C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_ary_each+0x51) [0x0000000064801971]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_send+0x761) [0x000000006499C541]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1ed7) [0x0000000064990ED7]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_iseq_eval+0x183) [0x000000006499E8B3]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_rubylevel_errinfo+0x61c) [0x000000006485562C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_require_internal+0x593) [0x0000000064857263]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_require+0x20) [0x0000000064857590]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_send+0x761) [0x000000006499C541]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1f7b) [0x0000000064990F7B]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_funcall+0xa96) [0x000000006499A896]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_yield+0x7c) [0x000000006499B79C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_obj_tap+0x16) [0x00000000648B19C6]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_send+0x761) [0x000000006499C541]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1ed7) [0x0000000064990ED7]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_iseq_eval+0x183) [0x000000006499E8B3]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_rubylevel_errinfo+0x61c) [0x000000006485562C]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_require_internal+0x593) [0x0000000064857263]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_require+0x20) [0x0000000064857590]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_error_arity+0x1e3) [0x000000006498BA93]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_f_send+0x761) [0x000000006499C541]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x1f7b) [0x0000000064990F7B]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_vm_localjump_error+0x607e) [0x000000006499507E]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_iseq_eval_main+0x1d0) [0x000000006499EAD0]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(rb_check_copyable+0x2fc1) [0x0000000064850AD1]<br>
c:\Ruby22-x64\bin\x64-msvcrt-ruby220.dll(ruby_run_node+0x51) [0x0000000064853C81]<br>
[0x0000000000402D14]<br>
[0x00000000004013D7]<br>
[0x00000000004014F8]<br>
C:\Windows\system32\kernel32.dll(BaseThreadInitThunk+0xd) [0x0000000076D959CD]</p>
<p>-- Other runtime information -----------------------------------------------</p>
<ul>
<li>
<p>Loaded script: bin/rails</p>
</li>
<li>
<p>Loaded features:</p>
<p>0 enumerator.so<br>
1 rational.so<br>
2 complex.so<br>
3 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/encdb.so<br>
4 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/trans/transdb.so<br>
5 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/iso_8859_1.so<br>
6 c:/Ruby22-x64/lib/ruby/2.2.0/unicode_normalize.rb<br>
7 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/rbconfig.rb<br>
8 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/compatibility.rb<br>
9 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/defaults.rb<br>
10 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/deprecate.rb<br>
11 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/errors.rb<br>
12 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/version.rb<br>
13 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/requirement.rb<br>
14 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/platform.rb<br>
15 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/basic_specification.rb<br>
16 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/stub_specification.rb<br>
17 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/util/stringio.rb<br>
18 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/specification.rb<br>
19 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/exceptions.rb<br>
20 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/defaults/operating_system.rb<br>
21 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/core_ext/kernel_gem.rb<br>
22 thread.rb<br>
23 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/thread.so<br>
24 c:/Ruby22-x64/lib/ruby/2.2.0/monitor.rb<br>
25 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/core_ext/kernel_require.rb<br>
26 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems.rb<br>
27 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/path_support.rb<br>
28 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/dependency.rb<br>
29 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/pathname.so<br>
30 c:/Ruby22-x64/lib/ruby/2.2.0/pathname.rb<br>
31 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/constants.rb<br>
32 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/io/console.so<br>
33 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/user_interaction.rb<br>
34 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/etc.so<br>
35 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/config_file.rb<br>
36 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/build_error.rb<br>
37 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/builder.rb<br>
38 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/configure_builder.rb<br>
39 c:/Ruby22-x64/lib/ruby/2.2.0/fileutils.rb<br>
40 c:/Ruby22-x64/lib/ruby/2.2.0/delegate.rb<br>
41 c:/Ruby22-x64/lib/ruby/2.2.0/tmpdir.rb<br>
42 c:/Ruby22-x64/lib/ruby/2.2.0/tempfile.rb<br>
43 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/ext_conf_builder.rb<br>
44 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/rake_builder.rb<br>
45 c:/Ruby22-x64/lib/ruby/2.2.0/optparse.rb<br>
46 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/command.rb<br>
47 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext/cmake_builder.rb<br>
48 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/ext.rb<br>
49 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/rubygems_integration.rb<br>
50 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/current_ruby.rb<br>
51 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/shared_helpers.rb<br>
52 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/gem_path_manipulation.rb<br>
53 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/gem_helpers.rb<br>
54 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/match_platform.rb<br>
55 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/rubygems_ext.rb<br>
56 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/version.rb<br>
57 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler.rb<br>
58 c:/Ruby22-x64/lib/ruby/2.2.0/uri/rfc2396_parser.rb<br>
59 c:/Ruby22-x64/lib/ruby/2.2.0/uri/rfc3986_parser.rb<br>
60 c:/Ruby22-x64/lib/ruby/2.2.0/uri/common.rb<br>
61 c:/Ruby22-x64/lib/ruby/2.2.0/uri/generic.rb<br>
62 c:/Ruby22-x64/lib/ruby/2.2.0/uri/ftp.rb<br>
63 c:/Ruby22-x64/lib/ruby/2.2.0/uri/http.rb<br>
64 c:/Ruby22-x64/lib/ruby/2.2.0/uri/https.rb<br>
65 c:/Ruby22-x64/lib/ruby/2.2.0/uri/ldap.rb<br>
66 c:/Ruby22-x64/lib/ruby/2.2.0/uri/ldaps.rb<br>
67 c:/Ruby22-x64/lib/ruby/2.2.0/uri/mailto.rb<br>
68 c:/Ruby22-x64/lib/ruby/2.2.0/uri.rb<br>
69 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/settings.rb<br>
70 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/strscan.so<br>
71 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/source.rb<br>
72 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/digest.so<br>
73 c:/Ruby22-x64/lib/ruby/2.2.0/digest.rb<br>
74 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/digest/sha1.so<br>
75 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/source/path.rb<br>
76 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/source/git.rb<br>
77 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/socket.so<br>
78 c:/Ruby22-x64/lib/ruby/2.2.0/socket.rb<br>
79 c:/Ruby22-x64/lib/ruby/2.2.0/timeout.rb<br>
80 c:/Ruby22-x64/lib/ruby/2.2.0/net/protocol.rb<br>
81 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/zlib.so<br>
82 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/stringio.so<br>
83 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/exceptions.rb<br>
84 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/header.rb<br>
85 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/windows_31j.so<br>
86 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/generic_request.rb<br>
87 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/request.rb<br>
88 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/requests.rb<br>
89 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/response.rb<br>
90 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/responses.rb<br>
91 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/proxy_delta.rb<br>
92 c:/Ruby22-x64/lib/ruby/2.2.0/net/http/backward.rb<br>
93 c:/Ruby22-x64/lib/ruby/2.2.0/net/http.rb<br>
94 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/date_core.so<br>
95 c:/Ruby22-x64/lib/ruby/2.2.0/date.rb<br>
96 c:/Ruby22-x64/lib/ruby/2.2.0/time.rb<br>
97 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/request.rb<br>
98 c:/Ruby22-x64/lib/ruby/2.2.0/cgi/core.rb<br>
99 c:/Ruby22-x64/lib/ruby/2.2.0/cgi/util.rb<br>
100 c:/Ruby22-x64/lib/ruby/2.2.0/cgi/cookie.rb<br>
101 c:/Ruby22-x64/lib/ruby/2.2.0/cgi.rb<br>
102 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/uri_formatter.rb<br>
103 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/openssl.so<br>
104 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/bn.rb<br>
105 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/cipher.rb<br>
106 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/config.rb<br>
107 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/digest.rb<br>
108 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/x509.rb<br>
109 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/buffering.rb<br>
110 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/fcntl.so<br>
111 c:/Ruby22-x64/lib/ruby/2.2.0/openssl/ssl.rb<br>
112 c:/Ruby22-x64/lib/ruby/2.2.0/openssl.rb<br>
113 c:/Ruby22-x64/lib/ruby/2.2.0/securerandom.rb<br>
114 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/fiddle.so<br>
115 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/function.rb<br>
116 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/closure.rb<br>
117 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle.rb<br>
118 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/value.rb<br>
119 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/pack.rb<br>
120 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/struct.rb<br>
121 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/cparser.rb<br>
122 c:/Ruby22-x64/lib/ruby/2.2.0/fiddle/import.rb<br>
123 c:/Ruby22-x64/lib/ruby/2.2.0/win32/importer.rb<br>
124 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/utf_16le.so<br>
125 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/trans/utf_16_32.so<br>
126 c:/Ruby22-x64/lib/ruby/2.2.0/win32/registry.rb<br>
127 c:/Ruby22-x64/lib/ruby/2.2.0/win32/resolv.rb<br>
128 c:/Ruby22-x64/lib/ruby/2.2.0/resolv.rb<br>
129 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/remote_fetcher.rb<br>
130 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/text.rb<br>
131 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/name_tuple.rb<br>
132 c:/Ruby22-x64/lib/ruby/site_ruby/2.2.0/rubygems/spec_fetcher.rb<br>
133 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/source/rubygems.rb<br>
134 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/lockfile_parser.rb<br>
135 c:/Ruby22-x64/lib/ruby/2.2.0/set.rb<br>
136 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/definition.rb<br>
137 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/dependency.rb<br>
138 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/ruby_dsl.rb<br>
139 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/dsl.rb<br>
140 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/source_list.rb<br>
141 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/lazy_specification.rb<br>
142 c:/Ruby22-x64/lib/ruby/2.2.0/tsort.rb<br>
143 c:/Ruby22-x64/lib/ruby/2.2.0/forwardable.rb<br>
144 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/spec_set.rb<br>
145 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/environment.rb<br>
146 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/runtime.rb<br>
147 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/dep_proxy.rb<br>
148 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/index.rb<br>
149 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/remote_specification.rb<br>
150 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/stub_specification.rb<br>
151 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/endpoint_specification.rb<br>
152 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/bundler-1.10.4/lib/bundler/setup.rb<br>
153 C:/Users/uidj5532/Downloads/resdb.git/config/boot.rb<br>
154 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe/version.rb<br>
155 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe/synchronized_delegator.rb<br>
156 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe.rb<br>
157 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/array/prepend_and_<br>
append.rb<br>
158 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/deep_merge.rb</p>
<p>159 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/except.rb<br>
160 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/slice.rb<br>
161 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/i18n-0.6.9/lib/i18n/version.rb<br>
162 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/i18n-0.6.9/lib/i18n/exceptions.rb<br>
163 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/i18n-0.6.9/lib/i18n/interpolate/ruby.rb<br>
164 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/i18n-0.6.9/lib/i18n.rb<br>
165 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/lazy_load_hooks.rb<br>
166 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/i18n-0.6.9/lib/i18n/config.rb<br>
167 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/i18n.rb<br>
168 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe/non_concurrent_cache_backend.rb<br>
169 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe/mri_cache_backend.rb<br>
170 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/thread_safe-0.3.3/lib/thread_safe/cache.rb<br>
171 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/inflector/inflections.rb<br>
172 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/inflections.rb<br>
173 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/inflector/methods.rb<br>
174 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/dependencies/autoload.rb<br>
175 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/version.rb<br>
176 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/array/extract_opti<br>
ons.rb<br>
177 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/class/attribute_ac<br>
cessors.rb<br>
178 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/concern.rb<br>
179 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/logger_silence.rb<br>
180 c:/Ruby22-x64/lib/ruby/2.2.0/logger.rb<br>
181 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/logger.rb<br>
182 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support.rb<br>
183 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/blank.rb<br>
184 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/kernel/singleton_c<br>
lass.rb<br>
185 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/remove_meth<br>
od.rb<br>
186 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/class/attribute.rb</p>
<p>187 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/delegation.<br>
rb<br>
188 c:/Ruby22-x64/lib/ruby/2.2.0/singleton.rb<br>
189 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation/instance_delega<br>
tor.rb<br>
190 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/notifications/instrumenter.<br>
rb<br>
191 c:/Ruby22-x64/lib/ruby/2.2.0/mutex_m.rb<br>
192 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/notifications/fanout.rb<br>
193 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/per_thread_registry.rb<br>
194 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/notifications.rb<br>
195 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation/behaviors.rb<br>
196 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation/reporting.rb<br>
197 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/aliasing.rb</p>
<p>198 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation/method_wrappers<br>
.rb<br>
199 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation/proxy_wrappers.<br>
rb<br>
200 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/deprecation<br>
.rb<br>
201 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/deprecation.rb<br>
202 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/rails.rb<br>
203 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/attribute_a<br>
ccessors.rb<br>
204 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_pack/version.rb<br>
205 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_pack.rb<br>
206 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/multipart.rb<br>
207 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/utils.rb<br>
208 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack.rb<br>
209 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch.rb<br>
210 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/server.rb<br>
211 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/commands/server.rb<br>
212 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/ruby_version_check.rb<br>
213 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/kernel/reporting.r<br>
b<br>
214 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/key_generator.rb<br>
215 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/initializable.rb<br>
216 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/ordered_options.rb<br>
217 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/acts_like.r<br>
b<br>
218 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/bigdecimal.so<br>
219 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/duplicable.<br>
rb<br>
220 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/deep_dup.rb</p>
<p>221 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/try.rb<br>
222 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/inclusion.r<br>
b<br>
223 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/to_param.rb</p>
<p>224 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/to_query.rb</p>
<p>225 c:/Ruby22-x64/lib/ruby/2.2.0/base64.rb<br>
226 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/multibyte.rb<br>
227 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/multibyte.r<br>
b<br>
228 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/inflector/transliterate.rb<br>
229 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/inflections<br>
.rb<br>
230 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_time/calculat<br>
ions.rb<br>
231 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/xml_mini/rexml.rb<br>
232 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/xml_mini.rb<br>
233 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/keys.rb<br>
234 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/array/conversions.<br>
rb<br>
235 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time/acts_like.rb<br>
236 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/proxy_object.rb<br>
237 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/duration.rb<br>
238 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/values/time_zone.rb<br>
239 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time/conversions.r<br>
b<br>
240 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/time_with_zone.rb<br>
241 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time/zones.rb<br>
242 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_and_time/calc<br>
ulations.rb<br>
243 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time/calculations.<br>
rb<br>
244 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time/marshal.rb<br>
245 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/time.rb<br>
246 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date/acts_like.rb<br>
247 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date/zones.rb<br>
248 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date/calculations.<br>
rb<br>
249 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date/conversions.r<br>
b<br>
250 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date.rb<br>
251 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_time/acts_lik<br>
e.rb<br>
252 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_time/conversi<br>
ons.rb<br>
253 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_time/zones.rb</p>
<p>254 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/date_time.rb<br>
255 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/numeric/time.rb<br>
256 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/integer/time.rb<br>
257 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/conversions<br>
.rb<br>
258 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/zones.rb<br>
259 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/time.rb<br>
260 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/array/wrap.rb<br>
261 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/reverse_merge<br>
.rb<br>
262 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/conversions.r<br>
b<br>
263 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/conversions<br>
.rb<br>
264 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/instance_va<br>
riables.rb<br>
265 c:/Ruby22-x64/lib/ruby/2.2.0/json/version.rb<br>
266 c:/Ruby22-x64/lib/ruby/2.2.0/ostruct.rb<br>
267 c:/Ruby22-x64/lib/ruby/2.2.0/json/generic_object.rb<br>
268 c:/Ruby22-x64/lib/ruby/2.2.0/json/common.rb<br>
269 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/utf_16be.so<br>
270 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/utf_32be.so<br>
271 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/enc/utf_32le.so<br>
272 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/json/ext/parser.so<br>
273 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/json/ext/generator.so<br>
274 c:/Ruby22-x64/lib/ruby/2.2.0/json/ext.rb<br>
275 c:/Ruby22-x64/lib/ruby/2.2.0/json.rb<br>
276 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/to_json.rb<br>
277 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/option_merger.rb<br>
278 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object/with_option<br>
s.rb<br>
279 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/object.rb<br>
280 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/paths.rb<br>
281 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/rack.rb<br>
282 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/configuration.rb<br>
283 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/inflector.rb<br>
284 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/introspecti<br>
on.rb<br>
285 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/railtie.rb<br>
286 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/engine/railties.rb<br>
287 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/engine.rb<br>
288 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/application.rb<br>
289 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/version.rb<br>
290 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/deprecation.rb<br>
291 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/file_update_checker.rb<br>
292 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/railtie/configurable.rb<br>
293 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/railtie/configuration.rb<br>
294 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/i18n_railtie.rb<br>
295 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/railtie.rb<br>
296 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/railtie.rb<br>
297 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails.rb<br>
298 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activemodel-4.0.4/lib/active_model/version.rb<br>
299 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activemodel-4.0.4/lib/active_model.rb<br>
300 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/crud.rb<br>
301 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/factory_methods.rb<br>
302 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/expressions.rb<br>
303 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/predications.rb<br>
304 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/window_predications.rb<br>
305 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/math.rb<br>
306 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/alias_predication.rb<br>
307 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/order_predications.rb<br>
308 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/table.rb<br>
309 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/attributes/attribute.rb<br>
310 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/attributes.rb<br>
311 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/compatibility/wheres.rb<br>
312 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/expression.rb<br>
313 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/visitor.rb<br>
314 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/depth_first.rb<br>
315 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/to_sql.rb<br>
316 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/sqlite.rb<br>
317 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/postgresql.rb<br>
318 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/mysql.rb<br>
319 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/mssql.rb<br>
320 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/oracle.rb<br>
321 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/join_sql.rb<br>
322 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/where_sql.rb<br>
323 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/order_clauses.rb<br>
324 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/dot.rb<br>
325 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/ibm_db.rb<br>
326 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors/informix.rb<br>
327 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/visitors.rb<br>
328 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/tree_manager.rb<br>
329 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/insert_manager.rb<br>
330 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/select_manager.rb<br>
331 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/update_manager.rb<br>
332 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/delete_manager.rb<br>
333 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/node.rb<br>
334 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/select_statement.rb<br>
335 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/select_core.rb<br>
336 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/insert_statement.rb<br>
337 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/update_statement.rb<br>
338 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/terminal.rb<br>
339 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/true.rb<br>
340 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/false.rb<br>
341 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/unary.rb<br>
342 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/grouping.rb<br>
343 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/ascending.rb<br>
344 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/descending.rb<br>
345 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/unqualified_column.rb<br>
346 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/with.rb<br>
347 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/binary.rb<br>
348 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/equality.rb<br>
349 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/in.rb<br>
350 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/join_source.rb<br>
351 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/delete_statement.rb<br>
352 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/table_alias.rb<br>
353 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/infix_operation.rb<br>
354 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/over.rb<br>
355 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/and.rb<br>
356 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/function.rb<br>
357 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/count.rb<br>
358 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/extract.rb<br>
359 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/values.rb<br>
360 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/named_function.rb<br>
361 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/window.rb<br>
362 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/inner_join.rb<br>
363 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/outer_join.rb<br>
364 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/string_join.rb<br>
365 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes/sql_literal.rb<br>
366 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/nodes.rb<br>
367 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/deprecated.rb<br>
368 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/sql/engine.rb<br>
369 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel/sql_literal.rb<br>
370 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/arel-4.0.2/lib/arel.rb<br>
371 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-deprecated_finders-1.0.3/lib/active_record/deprecated<br>
_finders/version.rb<br>
372 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-deprecated_finders-1.0.3/lib/active_record/deprecated<br>
<em>finders.rb<br>
373 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/version.rb<br>
374 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/enumerable.rb<br>
375 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activemodel-4.0.4/lib/active_model/attribute_methods.rb<br>
376 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/attribute_methods.rb<br>
377 c:/Ruby22-x64/lib/ruby/2.2.0/bigdecimal/util.rb<br>
378 c:/Ruby22-x64/lib/ruby/2.2.0/benchmark.rb<br>
379 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/benchmark.rb<br>
380 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/schema_ca<br>
che.rb<br>
381 c:/Ruby22-x64/lib/ruby/2.2.0/ipaddr.rb<br>
382 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
schema_dumper.rb<br>
383 c:/Ruby22-x64/lib/ruby/2.2.0/psych/exception.rb<br>
384 c:/Ruby22-x64/lib/ruby/2.2.0/psych/syntax_error.rb<br>
385 c:/Ruby22-x64/lib/ruby/2.2.0/x64-mingw32/psych.so<br>
386 c:/Ruby22-x64/lib/ruby/2.2.0/psych/omap.rb<br>
387 c:/Ruby22-x64/lib/ruby/2.2.0/psych/set.rb<br>
388 c:/Ruby22-x64/lib/ruby/2.2.0/psych/class_loader.rb<br>
389 c:/Ruby22-x64/lib/ruby/2.2.0/psych/scalar_scanner.rb<br>
390 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/node.rb<br>
391 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/stream.rb<br>
392 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/document.rb<br>
393 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/sequence.rb<br>
394 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/scalar.rb<br>
395 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/mapping.rb<br>
396 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes/alias.rb<br>
397 c:/Ruby22-x64/lib/ruby/2.2.0/psych/nodes.rb<br>
398 c:/Ruby22-x64/lib/ruby/2.2.0/psych/streaming.rb<br>
399 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/visitor.rb<br>
400 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/to_ruby.rb<br>
401 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/emitter.rb<br>
402 c:/Ruby22-x64/lib/ruby/2.2.0/psych/handler.rb<br>
403 c:/Ruby22-x64/lib/ruby/2.2.0/psych/tree_builder.rb<br>
404 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/yaml_tree.rb<br>
405 c:/Ruby22-x64/lib/ruby/2.2.0/psych/json/ruby_events.rb<br>
406 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/json_tree.rb<br>
407 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors/depth_first.rb<br>
408 c:/Ruby22-x64/lib/ruby/2.2.0/psych/visitors.rb<br>
409 c:/Ruby22-x64/lib/ruby/2.2.0/psych/parser.rb<br>
410 c:/Ruby22-x64/lib/ruby/2.2.0/psych/coder.rb<br>
411 c:/Ruby22-x64/lib/ruby/2.2.0/psych/core_ext.rb<br>
412 c:/Ruby22-x64/lib/ruby/2.2.0/psych/deprecated.rb<br>
413 c:/Ruby22-x64/lib/ruby/2.2.0/psych/stream.rb<br>
414 c:/Ruby22-x64/lib/ruby/2.2.0/psych/json/yaml_events.rb<br>
415 c:/Ruby22-x64/lib/ruby/2.2.0/psych/json/tree_builder.rb<br>
416 c:/Ruby22-x64/lib/ruby/2.2.0/psych/json/stream.rb<br>
417 c:/Ruby22-x64/lib/ruby/2.2.0/psych/handlers/document_stream.rb<br>
418 c:/Ruby22-x64/lib/ruby/2.2.0/psych.rb<br>
419 c:/Ruby22-x64/lib/ruby/2.2.0/yaml.rb<br>
420 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/big_decimal/conver<br>
sions.rb<br>
421 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
quoting.rb<br>
422 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
database_statements.rb<br>
423 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/errors.rb<br>
424 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/migration.rb<br>
425 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/migration/join_table.rb<br>
426 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
schema_statements.rb<br>
427 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
database_limits.rb<br>
428 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract/<br>
query_cache.rb<br>
429 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/descendants_tracker.rb<br>
430 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/callbacks.rb<br>
431 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/connection_adapters/abstract</em><br>
adapter.rb<br>
432 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/scoping.rb<br>
433 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record.rb<br>
434 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activemodel-4.0.4/lib/active_model/railtie.rb<br>
435 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/attr_intern<br>
al.rb<br>
436 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/anonymous.r<br>
b<br>
437 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/abstract_controller.rb<br>
438 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/request.rb<br>
439 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/response.rb<br>
440 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/filter_redirect.rb<br>
441 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/cache.rb<br>
442 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/response.rb<br>
443 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_controller/metal/live.rb<br>
444 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/hash_with_indifferent_acces<br>
s.rb<br>
445 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/indifferent_a<br>
ccess.rb<br>
446 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/rescuable.rb<br>
447 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/upload.rb<br>
448 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/mock_session.rb<br>
449 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test/cookie_jar.rb<br>
450 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test/mock_digest_request.rb<br>
451 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test/utils.rb<br>
452 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test/methods.rb<br>
453 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test/uploaded_file.rb<br>
454 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-test-0.6.2/lib/rack/test.rb<br>
455 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_controller/metal/strong_parameters.rb<br>
456 c:/Ruby22-x64/lib/ruby/2.2.0/erb.rb<br>
457 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/output_safe<br>
ty.rb<br>
458 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view.rb<br>
459 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/vendor/html-scanner.rb<br>
460 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/load_error.rb<br>
461 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/name_error.rb<br>
462 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/uri.rb<br>
463 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_controller.rb<br>
464 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/railtie.rb<br>
465 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/abstract_controller/railties/routes_helpers.r<br>
b<br>
466 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_controller/railties/helpers.rb<br>
467 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_controller/railtie.rb<br>
468 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activerecord-4.0.4/lib/active_record/railtie.rb<br>
469 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionmailer-4.0.4/lib/action_mailer/version.rb<br>
470 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/class/delegating_a<br>
ttributes.rb<br>
471 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/reachable.r<br>
b<br>
472 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/class/subclasses.r<br>
b<br>
473 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/class.rb<br>
474 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionmailer-4.0.4/lib/action_mailer.rb<br>
475 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionmailer-4.0.4/lib/action_mailer/railtie.rb<br>
476 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/test_unit/railtie.rb<br>
477 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/version.rb<br>
478 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike.rb<br>
479 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/template.rb<br>
480 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/string.rb<br>
481 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/erb.rb<br>
482 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/etanni.rb<br>
483 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/haml.rb<br>
484 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/css.rb<br>
485 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/csv.rb<br>
486 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/coffee.rb<br>
487 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/nokogiri.rb<br>
488 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/builder.rb<br>
489 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/markaby.rb<br>
490 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/liquid.rb<br>
491 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/radius.rb<br>
492 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/markdown.rb<br>
493 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/textile.rb<br>
494 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/rdoc.rb<br>
495 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/wiki.rb<br>
496 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/yajl.rb<br>
497 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/asciidoc.rb<br>
498 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt/plain.rb<br>
499 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/tilt-1.4.1/lib/tilt.rb<br>
500 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/eco_template.rb<br>
501 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/ejs_template.rb<br>
502 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/jst_processor.rb<br>
503 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/utils.rb<br>
504 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/engines.rb<br>
505 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rack-1.5.2/lib/rack/mime.rb<br>
506 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/mime.rb<br>
507 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/processor.rb<br>
508 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/processing.rb<br>
509 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/compressing.rb<br>
510 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/paths.rb<br>
511 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike/normalized_array.rb<br>
512 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike/extensions.rb<br>
513 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike/index.rb<br>
514 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike/paths.rb<br>
515 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/hike-1.2.3/lib/hike/trail.rb<br>
516 c:/Ruby22-x64/lib/ruby/2.2.0/shellwords.rb<br>
517 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/directive_processor.rb<br>
518 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/safety_colons.rb<br>
519 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/charset_normalizer.rb<br>
520 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/sass_compressor.rb<br>
521 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/yui_compressor.rb<br>
522 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/closure_compressor.rb<br>
523 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/uglifier_compressor.rb<br>
524 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/sass_template.rb<br>
525 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/scss_template.rb<br>
526 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets.rb<br>
527 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/benchmarkable.rb<br>
528 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/active_model_helper.rb<br>
529 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/asset_url_helper.rb<br>
530 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/capture_helper.rb<br>
531 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/tag_helper.rb<br>
532 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/asset_tag_helper.rb<br>
533 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/atom_feed_helper.rb<br>
534 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/cache_helper.rb<br>
535 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/controller_helper.rb<br>
536 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/csrf_helper.rb<br>
537 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/date_helper.rb<br>
538 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/debug_helper.rb<br>
539 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/javascript_helper.rb<br>
540 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/array/access.rb<br>
541 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/url_helper.rb<br>
542 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/filters.rb<br>
543 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/sanitize_helper.rb<br>
544 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/output_safety_helper.rb<br>
545 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/text_helper.rb<br>
546 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/form_tag_helper.rb<br>
547 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/tags.rb<br>
548 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/model_naming.rb<br>
549 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/form_helper.rb<br>
550 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/form_options_helper.rb<br>
551 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/number_helper.rb<br>
552 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/number_helper.rb<br>
553 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module/qualified_c<br>
onst.rb<br>
554 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/module.rb<br>
555 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/record_identifier.rb<br>
556 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/record_tag_helper.rb<br>
557 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/rendering_helper.rb<br>
558 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers/translation_helper.rb<br>
559 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/helpers.rb<br>
560 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-rails-2.0.1/lib/sprockets/rails/helper.rb<br>
561 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/engine/configuration.rb<br>
562 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/application/configuration.rb<br>
563 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-rails-2.0.1/lib/sprockets/railtie.rb<br>
564 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/railties-4.0.4/lib/rails/all.rb<br>
565 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/string_inquirer.rb<br>
566 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/version.rb<br>
567 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/root.rb<br>
568 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/util/subset_map.rb<br>
569 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/util/multibyte_string_scanner.rb<br>
570 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/util.rb<br>
571 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/version.rb<br>
572 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/logger/log_level.rb<br>
573 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/logger/base.rb<br>
574 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/logger.rb<br>
575 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/cache_stores/base.rb<br>
576 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/cache_stores/filesystem.rb<br>
577 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/cache_stores/memory.rb<br>
578 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/cache_stores/chain.rb<br>
579 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/cache_stores.rb<br>
580 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/node.rb<br>
581 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/root_node.rb<br>
582 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/rule_node.rb<br>
583 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/comment_node.rb<br>
584 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/prop_node.rb<br>
585 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/directive_node.rb<br>
586 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/media_node.rb<br>
587 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/supports_node.rb<br>
588 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/css_import_node.rb<br>
589 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/variable_node.rb<br>
590 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/mixin_def_node.rb<br>
591 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/mixin_node.rb<br>
592 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/trace_node.rb<br>
593 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/content_node.rb<br>
594 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/function_node.rb<br>
595 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/return_node.rb<br>
596 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/extend_node.rb<br>
597 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/if_node.rb<br>
598 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/while_node.rb<br>
599 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/for_node.rb<br>
600 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/each_node.rb<br>
601 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/debug_node.rb<br>
602 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/warn_node.rb<br>
603 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/import_node.rb<br>
604 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/charset_node.rb<br>
605 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/base.rb<br>
606 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/perform.rb<br>
607 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/cssize.rb<br>
608 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/extend.rb<br>
609 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/convert.rb<br>
610 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/to_css.rb<br>
611 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/deep_copy.rb<br>
612 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/set_options.rb<br>
613 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/tree/visitors/check_nesting.rb<br>
614 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector/simple.rb<br>
615 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector/abstract_sequence.rb<br>
616 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector/comma_sequence.rb<br>
617 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector/sequence.rb<br>
618 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector/simple_sequence.rb<br>
619 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/selector.rb<br>
620 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/environment.rb<br>
621 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/node.rb<br>
622 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/variable.rb<br>
623 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/functions.rb<br>
624 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/funcall.rb<br>
625 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/number.rb<br>
626 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/color.rb<br>
627 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/bool.rb<br>
628 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/null.rb<br>
629 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/list.rb<br>
630 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/arg_list.rb<br>
631 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/literal.rb<br>
632 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/string.rb<br>
633 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/unary_operation.rb<br>
634 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/interpolation.rb<br>
635 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/string_interpolation.rb<br>
636 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/operation.rb<br>
637 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/rx.rb<br>
638 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/lexer.rb<br>
639 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/parser.rb<br>
640 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script.rb<br>
641 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/script_lexer.rb<br>
642 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/script_parser.rb<br>
643 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/parser.rb<br>
644 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/css_lexer.rb<br>
645 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/script/css_parser.rb<br>
646 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/static_parser.rb<br>
647 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss/css_parser.rb<br>
648 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/scss.rb<br>
649 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/error.rb<br>
650 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/importers/base.rb<br>
651 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/importers/filesystem.rb<br>
652 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/importers.rb<br>
653 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/shared.rb<br>
654 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/media.rb<br>
655 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/supports.rb<br>
656 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/engine.rb<br>
657 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass/railtie.rb<br>
658 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-3.2.19/lib/sass.rb<br>
659 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/sass_functions.rb<br>
660 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/helpers.rb<br>
661 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sprockets-2.11.0/lib/sprockets/sass_importer.rb<br>
662 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/importer.rb<br>
663 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/template.rb<br>
664 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/logger.rb<br>
665 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails/railtie.rb<br>
666 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass/rails.rb<br>
667 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/sass-rails-4.0.3/lib/sass-rails.rb<br>
668 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/version.rb<br>
669 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/module.rb<br>
670 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/encoding.rb<br>
671 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/runtime.rb<br>
672 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/disabled_runtime.rb<br>
673 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/external_runtime.rb<br>
674 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/johnson_runtime.rb<br>
675 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/mustang_runtime.rb<br>
676 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/ruby_racer_runtime.rb<br>
677 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/ruby_rhino_runtime.rb<br>
678 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs/runtimes.rb<br>
679 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/execjs-2.0.2/lib/execjs.rb<br>
680 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/uglifier-2.5.0/lib/uglifier/version.rb<br>
681 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/uglifier-2.5.0/lib/uglifier.rb<br>
682 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-script-source-1.7.0/lib/coffee_script/source.rb<br>
683 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-script-2.2.0/lib/coffee_script.rb<br>
684 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-script-2.2.0/lib/coffee-script.rb<br>
685 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-rails-4.0.1/lib/coffee/rails/engine.rb<br>
686 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-rails-4.0.1/lib/coffee/rails/template_handler.rb<br>
687 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-rails-4.0.1/lib/coffee/rails/version.rb<br>
688 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/coffee-rails-4.0.1/lib/coffee-rails.rb<br>
689 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jquery-rails-3.1.0/lib/jquery/rails/engine.rb<br>
690 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jquery-rails-3.1.0/lib/jquery/rails/railtie.rb<br>
691 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jquery-rails-3.1.0/lib/jquery/rails/version.rb<br>
692 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jquery-rails-3.1.0/lib/jquery/rails.rb<br>
693 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jquery-rails-3.1.0/lib/jquery-rails.rb<br>
694 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/version.rb<br>
695 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/xhr_headers.rb<br>
696 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/xhr_url_for.rb<br>
697 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/cookies.rb<br>
698 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/x_domain_blocker.rb<br>
699 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks/redirection.rb<br>
700 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/turbolinks-2.2.2/lib/turbolinks.rb<br>
701 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/ordered_hash.rb<br>
702 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash/diff.rb<br>
703 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/hash.rb<br>
704 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/numeric/bytes.rb<br>
705 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/cache.rb<br>
706 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/multi_json-1.9.3/lib/multi_json/options.rb<br>
707 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/multi_json-1.9.3/lib/multi_json/version.rb<br>
708 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/multi_json-1.9.3/lib/multi_json/adapter_error.rb<br>
709 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/multi_json-1.9.3/lib/multi_json/parse_error.rb<br>
710 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/multi_json-1.9.3/lib/multi_json.rb<br>
711 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/activesupport-4.0.4/lib/active_support/core_ext/string/starts_ends<br>
_with.rb<br>
712 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/mime_types.rb<br>
713 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_dispatch/http/mime_type.rb<br>
714 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/template/handlers.rb<br>
715 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/util.rb<br>
716 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/generator.rb<br>
717 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/converter.rb<br>
718 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/error.rb<br>
719 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/context.rb<br>
720 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/evaluator.rb<br>
721 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/engine.rb<br>
722 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/helper.rb<br>
723 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/enhancer.rb<br>
724 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/engine/eruby.rb<br>
725 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis/local-setting.rb<br>
726 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/erubis-2.7.0/lib/erubis.rb<br>
727 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/template/handlers/erb.rb<br>
728 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/template/handlers/builder.rb<br>
729 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/template/handlers/raw.rb<br>
730 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/actionpack-4.0.4/lib/action_view/template.rb<br>
731 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jbuilder-1.5.3/lib/jbuilder/jbuilder_template.rb<br>
732 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jbuilder-1.5.3/lib/jbuilder/railtie.rb<br>
733 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/jbuilder-1.5.3/lib/jbuilder.rb<br>
734 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/configuration.rb<br>
735 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/constraints/root_route.rb<br>
736 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/page_finder.rb<br>
737 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/route_drawers/default.rb<br>
738 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/route_drawers/root.rb<br>
739 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/version.rb<br>
740 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage/engine.rb<br>
741 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/high_voltage-2.1.0/lib/high_voltage.rb<br>
742 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rails-erd-1.1.0/lib/rails_erd/railtie.rb<br>
743 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rails-erd-1.1.0/lib/rails_erd.rb<br>
744 c:/Ruby22-x64/lib/ruby/gems/2.2.0/gems/rails-erd-1.1.0/lib/rails-erd.rb</p>
</li>
</ul>
<p>[NOTE]<br>
You may have encountered a bug in the Ruby interpreter or extension libraries.<br>
Bug reports are welcome.<br>
For details: <a href="http://www.ruby-lang.org/bugreport.html" class="external">http://www.ruby-lang.org/bugreport.html</a></p>
<p>This application has requested the Runtime to terminate it in an unusual way.<br>
Please contact the application's support team for more information.</p> Ruby master - Feature #11141 (Rejected): new syntax suggestion for abbreviate definition on bloc...https://redmine.ruby-lang.org/issues/111412015-05-12T00:45:57Zneohunter (Arnold Roa)manolet@gmail.com
<p>One of the most commons things I do in Ruby are small block definitions:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">x</span><span class="p">.</span><span class="nf">each</span><span class="p">{</span><span class="o">|</span><span class="n">a</span><span class="o">|</span> <span class="n">a</span><span class="p">}</span>
</code></pre>
<p>One useful syntax introduced was the <strong><code>&:method</code></strong> that allows calling a method on a block if only one param is expected. It's a shortcut for <strong><code>a.each{|x|x.method}</code></strong>. I think it would be nice if Ruby had a syntax that allows me to not define the params that block would receive, but instead access them in order. For example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">x</span><span class="p">.</span><span class="nf">each</span> <span class="p">{</span> <span class="vg">$1</span> <span class="p">}</span>
</code></pre>
<p>Let's suppose the block is waiting for two params, I normally do:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">x</span><span class="p">.</span><span class="nf">method</span> <span class="p">{</span><span class="o">|</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="o">|</span> <span class="n">a</span> <span class="o">-</span> <span class="n">b</span> <span class="p">}</span>
</code></pre>
<p>This syntax will allow us to use:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="n">x</span><span class="p">.</span><span class="nf">method</span><span class="p">{</span> <span class="vg">$1</span> <span class="o">-</span> <span class="vg">$2</span> <span class="p">}</span>
</code></pre>
<p>So:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"> <span class="n">x</span><span class="p">.</span><span class="nf">each</span> <span class="p">{</span> <span class="n">p1</span><span class="p">.</span><span class="nf">stg</span> <span class="p">}</span>
<span class="n">x</span><span class="p">.</span><span class="nf">each</span> <span class="p">{</span><span class="o">|</span><span class="n">p1</span><span class="o">|</span> <span class="n">p1</span><span class="p">.</span><span class="nf">stg</span><span class="p">}</span>
<span class="n">x</span><span class="p">.</span><span class="nf">each</span> <span class="o">&</span><span class="ss">:stg</span>
</code></pre>
<p>would be the same.</p>
<p>Please consider <code>$1</code> and <code>$2</code> just as an example. I don't like the fact that they are global variables. It could be <code>_1</code> or <code>p1</code>, for example:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="n">x</span><span class="p">.</span><span class="nf">method</span><span class="p">{</span> <span class="n">p1</span> <span class="o">-</span> <span class="n">p2</span> <span class="p">}</span>
<span class="n">x</span><span class="p">.</span><span class="nf">each</span><span class="p">{</span> <span class="n">p1</span> <span class="o">-</span> <span class="n">p2</span> <span class="p">}</span> <span class="o">==</span> <span class="n">x</span><span class="p">.</span><span class="nf">each</span> <span class="p">{</span><span class="o">|</span><span class="n">p1</span><span class="p">,</span> <span class="n">p2</span><span class="o">|</span> <span class="n">p1</span> <span class="o">-</span> <span class="n">p2</span> <span class="p">}</span>
</code></pre>
<p>Or, as blocks already uses <strong><code>&:method</code></strong> it could be <strong><code>&:1</code></strong>. Or any other thing that you may consider more appropriated.</p>
<p>I think this syntax would be very nice for short block definitions, the downside is that it allows for bad practice on longer methods, but in the end, that's a decision that a programer should make.</p>
<p>Maybe this is not a valid reason, but I would like to point out that Regex is actually creating global vars as the results of match: $x vars. (for perl's historical reasons)</p>
<p>So why not introduce this into Ruby's syntax?</p>
<p>Personally I don't like either <code>$1</code> nor <code>p1</code>. They are just the first quick things that come to my mind.</p> Ruby master - Bug #11109 (Third Party's Issue): Crash of irb.https://redmine.ruby-lang.org/issues/111092015-04-30T13:51:36Zyangzhijava (Jeffrey Yang)yangzhijava@outlook.com
<p>ENV:<br>
Mac OS X 10.10.3<br>
ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]</p>
<p>HOW TO COMPILE:</p>
<ol>
<li>cd to the dir of ruby 2.2.2.</li>
<li>./configure</li>
<li>make</li>
<li>make install as root.</li>
</ol>
<p>STEPS:</p>
<ol>
<li>
<p>Start the irb on console.</p>
</li>
<li>
<p>Type the following code lines in irb:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="nb">require</span> <span class="s1">'stringio'</span>
<span class="nb">require</span> <span class="s1">'bson'</span>
<span class="n">sio</span> <span class="o">=</span> <span class="no">StringIO</span><span class="p">.</span><span class="nf">new</span> <span class="mi">1</span><span class="p">.</span><span class="nf">to_bson</span>
<span class="no">BSON</span><span class="o">::</span><span class="no">Int64</span><span class="p">.</span> <span class="nf">from_bson</span> <span class="n">sio</span>
</code></pre>
</li>
<li>
<p>The crash happens.</p>
</li>
</ol>
<p>Please see also the attached file for all details.</p> Ruby master - Feature #11007 (Closed): Prime.each.with_index should accept offsethttps://redmine.ruby-lang.org/issues/110072015-03-27T15:10:44Zciel (T Yamada)
<p>I'd like to execute following code:</p>
<pre><code>Prime.each(10).with_index(1){|e,i|
print i,' ',e,"\n"
}
</code></pre>
<p>Expected output:</p>
<pre><code>1 2
2 3
3 5
4 7
</code></pre>
<p>I have attached a patch.</p> Ruby master - Feature #10903 (Closed): [PATCH] Matrix#zip returns a matrixhttps://redmine.ruby-lang.org/issues/109032015-02-25T04:44:01ZLitoNico (Lito Nicolai)lito.nicolai@gmail.com
<p>Currently:<br>
> x = Matrix.I 2<br>
> x.zip x<br>
=> [[1, 1], [0, 0], [0, 0], [1, 1]] # It's an array!</p>
<p>With the patch:<br>
> x.zip x<br>
=> Matrix[[1, 1], [0, 0], [0, 0], [1, 1]]</p>
<p>And also:<br>
> x.zip x, x # and so on<br>
=> Matrix[[1, 1, 1], [0, 0, 0], [0, 0, 0], [1, 1, 1]]</p> Ruby master - Bug #10855 (Third Party's Issue): [PATCH] Matrix#inverse returns matrix of integers...https://redmine.ruby-lang.org/issues/108552015-02-15T19:08:15ZLitoNico (Lito Nicolai)lito.nicolai@gmail.com
<p>Currently, Matrix#inverse returns a matrix of Rationals, even when each<br>
element has a denominator of 1. This leads to</p>
<pre><code>> x = Matrix.identity 3
=> Matrix[[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]
> x.inverse
=> Matrix[[(1/1), (0/1), (0/1)],
[(0/1), (1/1), (0/1)],
[(0/1), (0/1), (1/1)]]
</code></pre>
<p>Even though <code>Matrix.identity.inverse</code> should be identical to <code>Matrix.identity</code>.</p>
<p>This patch guarantees that Matrix#inverse will return a matrix of integers<br>
whenever it can. To maintain uniform types across a matrix, the conversion<br>
is only performedif <em>every</em> element can be converted to an integer.</p> Ruby master - Bug #10850 (Rejected): BigDecimal division incorrecthttps://redmine.ruby-lang.org/issues/108502015-02-13T11:14:06ZElyasin (Elyasin Shaladi)Elyas.Shaladi@gmail.com
<p>I tried this in Ruby 2.1.4, 2.1.5 and 2.2.0, but in none of the versions it seems correct to me.</p>
<p>irb(main):041:0* amount1 = BigDecimal("241.3")<br>
=> #<a href="BigDecimal:7f49bcb03558,'0.2413E3',18(18)" class="external">BigDecimal:7f49bcb03558,'0.2413E3',18(18)</a></p>
<p>irb(main):042:0> amount2 = BigDecimal("1800")<br>
=> #<a href="BigDecimal:7f49bcaf3400,'0.18E4',9(18)" class="external">BigDecimal:7f49bcaf3400,'0.18E4',9(18)</a></p>
<p>irb(main):043:0> rate = amount1 / amount2<br>
=> #<BigDecimal:7f49bcae8398,'0.1340555555 5555555555 5555556E0',27(45)></p>
<p>irb(main):044:0> rate * amount2 #should return amount1 = 241.3 in BigDecimal, but it does not<br>
=> #<BigDecimal:7f49bcad6a30,'0.2413000000 0000000000 00000008E3',36(45)></p>
<p>My guess is that there is a bug in the BigDecimal implementation.</p> Ruby master - Feature #10833 (Third Party's Issue): getting argument error in rails productionhttps://redmine.ruby-lang.org/issues/108332015-02-06T12:05:27Zraja (narasinga raja)raja.narasinga2@gmail.com
<ol>
<li>I deployed my rails application using passenger + nginx<br>
2.data base is postgresql</li>
<li>when i am creating a new issue its showing Sorry, the page you are looking for is currently unavailable.<br>
Please try again later.<br>
plz help me out to get out of this problen</li>
</ol>
<p>4.in my nginx error log goy this error "App 22249 stderr: [ 2015-02-06 14:20:36.5094 22323/0x0000000690c1c0(Worker 1) utils.rb:72 ]: *** Exception ArgumentError in Rack application object (could not find a temporary directory) (process 22323, thread 0x0000000690c1c0(Worker 1)):"</p> Ruby master - Bug #10630 (Third Party's Issue): ERB tags nested in escaped blocks are skippedhttps://redmine.ruby-lang.org/issues/106302014-12-22T09:48:36Ztonci (Tonči Damjanić)tonci.damjanic@gmail.com
<p>Hello,</p>
<p>First of all, is this a good place to report Erubis bugs? Their GitHub repo is stale (no action since 2011) and I was suggested by the Rails team to try here.</p>
<p>GitHub ticket: <a href="https://github.com/kwatch/erubis/issues/6" class="external">https://github.com/kwatch/erubis/issues/6</a><br>
Repro example: <a href="https://github.com/rails/rails/issues/18098#issuecomment-67667400" class="external">https://github.com/rails/rails/issues/18098#issuecomment-67667400</a></p>
<hr>
<p>It seems that ERB (Erubis) doesn't handle well tags embedded within another tag. My goal is to produce ERB code with some values prefilled in the first pass.</p>
<p>Input ERB code:</p>
<pre><code> <div>
<%%= Results: <%= 'first' %> | <%= 'second' %> | <%= 'third' %> %>
</div>
</code></pre>
<p>Produces the following output:</p>
<pre><code> <div>
<%= Results: <%= 'first' %> | second | third %>
</div>
</code></pre>
<p>Expected output is:</p>
<pre><code> <div>
<%= Results: first | second | third %>
</div>
</code></pre>
<p>The first nested ERB tag is skipped. The same happens when there is just one block nested.</p>
<p>This is reproducible in Rails v4.1.8, which is using Erubis v2.7.0.</p> Ruby master - Bug #10525 (Rejected): SegFault with mysql2 gemhttps://redmine.ruby-lang.org/issues/105252014-11-19T04:02:47Ztadlambjr (Tad Lamb)
<p>I received this segfault when executing the command<br>
<code>bundle exec rake db:migrate</code></p> Ruby master - Feature #10451 (Closed): [PATCH 3/3] Implement Vector.independent? and Vector#indep...https://redmine.ruby-lang.org/issues/104512014-10-29T18:56:22Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Hi, Marc-André Lafortune.</p>
<p>I'm sorry for sending a bit lot of patches for the last few days.</p>
<p>This time, I've implemented check if vectors are linearly independent or not.<br>
Please feel free to point out or reject when you have time.</p>
<p>Thanks.</p> Ruby master - Feature #10445 (Rejected): [PATCH 3/3] Extend Matrix#[]https://redmine.ruby-lang.org/issues/104452014-10-29T08:30:57Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>I've made patches which Matrix#[] returns new vector if either arguments is range,<br>
and returns new matrix, if both arguments are range.</p>
<p>Like below.</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="c1"># matrix[row, column] -> obj or nil</span>
<span class="c1"># matrix[row, col_range] -> new_vector or nil</span>
<span class="c1"># matrix[row_range, column] -> new_vector or nil</span>
<span class="c1"># matrix[row_range, col_range] -> new_matrix or nil</span>
<span class="no">Matrix</span><span class="p">.</span><span class="nf">diagonal</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="o">-</span><span class="mi">3</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
<span class="o">=></span> <span class="mi">5</span>
<span class="no">Matrix</span><span class="p">.</span><span class="nf">diagonal</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="o">-</span><span class="mi">3</span><span class="p">)[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="o">..</span><span class="mi">1</span><span class="p">]</span>
<span class="o">=></span> <span class="no">Vector</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="no">Matrix</span><span class="p">.</span><span class="nf">diagonal</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="o">-</span><span class="mi">3</span><span class="p">)[</span><span class="mi">0</span><span class="o">..</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="o">=></span> <span class="no">Vector</span><span class="p">[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span>
<span class="no">Matrix</span><span class="p">.</span><span class="nf">diagonal</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="o">-</span><span class="mi">3</span><span class="p">)[</span><span class="mi">0</span><span class="o">..</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="o">..</span><span class="mi">1</span><span class="p">]</span>
<span class="o">=></span> <span class="no">Matrix</span><span class="p">[[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">]]</span>
</code></pre>
<p>I'm not sure <code>matrix[row, col_range] </code> should return <code>vector</code> or <code>matrix</code><br>
But from my view, it's fine.</p>
<p>I'm not in a hurry. Take your time.</p> Ruby master - Feature #10444 (Rejected): [PATCH 3/3] Vector#[] returns new vector if argument is ...https://redmine.ruby-lang.org/issues/104442014-10-29T08:16:06Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Hi, it's incompatible change little bit.</p>
<p>Before</p>
<pre><code>Vector[1,2,3][0..1]
=> [1, 2]
</code></pre>
<p>After</p>
<pre><code>Vector[1,2,3][0..1]
=> Vector[1, 2]
</code></pre>
<p>I'm not in a hurry. Take your time.</p> Ruby master - Feature #10442 (Closed): Helper methods to Vector classhttps://redmine.ruby-lang.org/issues/104422014-10-28T14:07:39ZClamoris (Egunov Dmitriy)soul.amd@gmail.com
<p>Vector class missed some very helpful methods like angle between another vector and vector projection.</p>
<p>Patch attached. Please advice if more unit tests are needed.</p> Ruby master - Feature #10352 (Closed): Give alias Vector#inner_product and Vector#cross_producthttps://redmine.ruby-lang.org/issues/103522014-10-09T19:44:50Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Give alias Vector#inner_product and Vector#cross_product which are of two method used frequently.</p>
<p>Vector#inner_product is aliased to Vector#dot.</p>
<p>Vector#cross_product is aliased to Vector#cross.</p>
<p>Take your time.</p> Ruby master - Bug #10162 (Closed): Error while installing ruby 2.1.2 on freebsd https://redmine.ruby-lang.org/issues/101622014-08-22T08:06:01Zyogesh (yogesh yadav)yogesh.yadav2912@gmail.com
<p>Below is error while doing make install.</p>
<p>rm -f probes.o<br>
linking miniruby<br>
/usr/bin/ld: probes.o: relocation R_X86_64_32 can not be used when making a shared object; recompile with -fPIC<br>
probes.o: could not read symbols: Bad value<br>
*** Error code 1</p>
<p>Stop in /root/ruby-2.1.2.</p> Ruby master - Bug #10113 (Rejected): Ruby memoization behaving oddly when using hash keys with sp...https://redmine.ruby-lang.org/issues/101132014-08-06T10:11:24Zronald05arias (Ron Arias)ronald05arias@gmail.com
<p>Trying to use simple Hash memoization with a ruby hash in a class method, it "fails" when having spaces as the hash key. Example code is attached.<br>
When calling the memoization method, it fails to maintain the instance variable. It resets the variable every time the method is called.<br>
When not having spaces in the key of the Hash, it works as it should, memoizing the variable.</p>
<p>P.S. Despite my ruby version indicated bellow, it fails in the newest as well.</p> Ruby master - Feature #10083 (Rejected): String.to_i unexpected behaviorhttps://redmine.ruby-lang.org/issues/100832014-07-23T02:15:29Zjosecastro (joseph castro)joseph.castro.riquelme@gmail.com
<p>Hi</p>
<p>There's the issue:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="s2">"String"</span><span class="p">.</span><span class="nf">to_i</span> <span class="o">=></span> <span class="mi">0</span>
</code></pre>
<p>This must be NIL or at least error, but no 0, because the string is not a number, also:</p>
<pre><code class="ruby syntaxhl" data-language="ruby"><span class="s2">"10String"</span><span class="p">.</span><span class="nf">to_i</span> <span class="o">=></span> <span class="mi">10</span>
</code></pre>
<p>Is not 10, because "10String" is not a number, maybe is necessary a new method to get a number from any string, because to_i is to convert into a Integer and that should return an error.</p>
<p>Greetings everyone</p> Ruby master - Feature #10077 (Closed): [PATCH] Implement Matrix#row_merge and Matrix#column_mergehttps://redmine.ruby-lang.org/issues/100772014-07-21T02:55:49Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Merge matrices horizontally and vertically.</p>
<p>It is useful and important when we handle linear equations, statistics and so on.</p>
<pre><code>Matrix[[1, 2], [3, 4]].row_merge(Matrix[[5], [6]])
=> 1 2 5
3 4 6
Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]])
=> 1 2
3 4
5 6
# accept more than two matrices as an argument.
Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]], Matrix[[7, 8]])
=> 1 2
3 4
5 6
7 8
</code></pre>
<ul>
<li>Matrix#row_merge needs Matrix#column</li>
</ul> Ruby master - Feature #10074 (Closed): [PATCH] generalize Vector#cross_producthttps://redmine.ruby-lang.org/issues/100742014-07-19T07:47:25Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Usually We use cross_product in only 3 dimensions.</p>
<p>Sometimes we want to handle cross_product in n-dimensions.</p>
<p>But I recognize Ruby should be not for mathematician but rubyist.</p>
<p>Ruby doesn't need too academic method.</p>
<p>So If you think it is too academic you can ignore my patches.</p> Ruby master - Feature #10073 (Closed): [PATCH] Implement Laplace expansion for matrix.https://redmine.ruby-lang.org/issues/100732014-07-19T07:41:33Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Laplace expansion has really important mathematical property.</p>
<p>We can handle many thing with this (determinant, cross product)</p>
<p>So I'm confident that this method is necessary.</p>
<p>But I recognize Ruby should be not for mathematician but rubyist.</p>
<p>Ruby doesn't need too academic method.</p>
<p>So If you think it is too academic you can ignore my patches.</p>
<p>gogo.</p> Ruby master - Feature #10072 (Closed): [PATCH] Implement Vector.basishttps://redmine.ruby-lang.org/issues/100722014-07-19T07:39:29Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Standard basis vectors are really important in linear algebra.</p>
<p>And we usually need this when we use matrix or vector. (base conversion, principal component analysis...</p>
<p>This is why I implemented.</p>
<p>But I recognize Ruby should be not for mathematician but rubyist.</p>
<p>Ruby doesn't need too academic method.</p>
<p>So If you think it is too academic you can ignore my patches.</p>
<p>gogo.</p> Ruby master - Feature #10070 (Closed): [PATCH] About comments, fix typo and add info.https://redmine.ruby-lang.org/issues/100702014-07-19T07:11:01Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>When I read codes, I notice some mistakes about comments.</p>
<p>It have nothing to do with ruby's performance.</p>
<p>If you don't mind that or are busy, you can ignore my patches.</p>
<p>gogo.</p> Ruby master - Feature #10069 (Closed): [PATCH] Implement monadic operator for Matrixhttps://redmine.ruby-lang.org/issues/100692014-07-19T02:08:03Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Before</p>
<pre><code>m = Matrix[[1,2,3], [4,5,6]]
+ m
NoMethodError: undefined method `+@' for Matrix[[1, 2, 3], [4, 5, 6]]:Matrix
- m
NoMethodError: undefined method `-@' for Matrix[[1, 2, 3], [4, 5, 6]]:Matrix
</code></pre>
<p>After</p>
<pre><code>m = Matrix[[1,2,3], [4,5,6]]
+ m
=> Matrix[[1, 2, 3], [4, 5, 6]]
- m
=> Matrix[[-1, -2, -3], [-4, -5, -6]]
</code></pre>
<p>I think monadic operator for Matrix is important, when I use operator as block. like that</p>
<pre><code>matrix_ary.inject(:+)
</code></pre> Ruby master - Feature #10068 (Closed): [PATCH] Implement monadic operator for Vectorhttps://redmine.ruby-lang.org/issues/100682014-07-19T01:57:17Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Before</p>
<pre><code>v = Vector[1, 2, 3]
+ v
=> NoMethodError: undefined method `+@' for Vector[1, 2, 3]:Vector
- v
=> NoMethodError: undefined method `-@' for Vector[1, 2, 3]:Vector
</code></pre>
<p>After</p>
<pre><code>v = Vector[1, 2, 3]
+ v
=> Vector[1, 2, 3]
- v
=> Vector[-1, -2, -3]
</code></pre> Ruby master - Feature #10058 (Closed): [PATCH] Fix some coding styleshttps://redmine.ruby-lang.org/issues/100582014-07-18T08:13:34Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>When I read codes, I notice some issues about coding style.</p>
<p>If you don't mind that, you can ignore my patches. It's just coding style problem.</p>
<p>コードを読んでいる中でコーディングスタイルに関して気になる事があったのでPATCHを投げますが、</p>
<p>こちら(redmine, rubyコミュニティ)のコーディングスタイルに対する温度感が掴めてないので</p>
<p>気にする事でなければ、無視してください.</p>
<p>あげると切りがないので今回は特に気になる以下の三点に絞りました.</p>
<ul>
<li>
<p>There are both <code>&&</code> and <code>and</code>. So, I Unify with <code>&&</code></p>
</li>
<li>
<p>There are both <code>send :xxx</code> and <code>send(:xxx)</code> expressions. So, I Unify with <code>send(:xxx)</code></p>
</li>
<li>
<p>I reorder methods. I think Matrix#real should be upon Matrix#imaginary(From what I see complex.c)</p>
</li>
</ul> Ruby master - Feature #10056 (Closed): [PATCH 0/1]Add #adjugate method to matrix classhttps://redmine.ruby-lang.org/issues/100562014-07-18T01:21:09Zgogotanaka (Kazuki Tanaka)mail@tanakakazuki.com
<p>Add Matrix#adjugate to make a matrix adjugate.</p>
<p>Adjugate is really important operator to handle matrix (especially Exploring Data with ruby)</p>
<pre><code data-language="ruby:"># Property
* Any n-th matrix `m`(object of Matrix class) Satisfy the following conditions
Matrix.identity(n) == (m.adjugate * m) / m.det
# Differential vector or matrix
Let A = (a(i, j)) is n-th matrix, A(i, j) is adjugate matrix excluding the j and column i row A.
def. ∂det(A)/∂a(i,j) = (-1) ** (i + j) * det(A(i, j))
</code></pre>
<p>Some people regards adjugate matrix as Hermitian adjoint.</p>
<p>I regard adjuate matrix as transpose of the cofactor matrix by referencing <a href="http://en.wikipedia.org/wiki/Adjugate_matrix" class="external">http://en.wikipedia.org/wiki/Adjugate_matrix</a>.</p> Ruby master - Bug #9723 (Rejected): #size does not trigger evaluation of lazy enumerator.https://redmine.ruby-lang.org/issues/97232014-04-10T09:46:36Zzekefast (Zeke Fast)zekefast@gmail.com
<p>Here is the code which shows weird behariour</p>
<a name="Steps-to-reproduce"></a>
<h3 >Steps to reproduce<a href="#Steps-to-reproduce" class="wiki-anchor">¶</a></h3>
<p><code>$ irb 2.1.1 :001 > [1, 2, 3].lazy.select{ |e| e%2 == 1}.size => nil 2.1.1 :002 > [1, 2, 3].lazy.select{ |e| e%2 == 1}.to_a => [1, 3] 2.1.1 :003 > [1, 2, 3].lazy.size => 3</code></p>
<a name="Expected"></a>
<h3 >Expected<a href="#Expected" class="wiki-anchor">¶</a></h3>
<p><code>[1, 2, 3].lazy.select{ |e| e%2 == 1}.size</code><br>
to return number of elements like <code>[1, 2, 3].lazy.size</code> did.</p>
<a name="Actual"></a>
<h3 >Actual<a href="#Actual" class="wiki-anchor">¶</a></h3>
<p><code>[1, 2, 3].lazy.select{ |e| e%2 == 1}.size</code> returns <strong>nil</strong>.</p>
<a name="Environment"></a>
<h3 >Environment<a href="#Environment" class="wiki-anchor">¶</a></h3>
<p>Ruby: ruby 2.0.0p457 (2014-03-03) [x86_64-linux-gnu]<br>
RVM: rvm 1.25.22 (stable) by Wayne E. Seguin <a href="mailto:wayneeseguin@gmail.com" class="email">wayneeseguin@gmail.com</a>, Michal Papis <a href="mailto:mpapis@gmail.com" class="email">mpapis@gmail.com</a> [https://rvm.io/]<br>
OS: Linux xxxxxx 3.13-1-amd64 #1 SMP Debian 3.13.7-1 (2014-03-25) x86_64 GNU/Linux</p> Ruby master - Bug #9570 (Closed): Something wrong with Enumerator#size ?https://redmine.ruby-lang.org/issues/95702014-02-26T10:11:07Ztaroxd (东 许)taroxd@outlook.com
<p>enum = 2.step(1, 3)<br>
enum.size #=> 1</p>
<p>It should be 0, shouldn't it? ( Windows )</p> Ruby master - Bug #9499 (Closed): The Vector.cross_product function returns the opposite vector o...https://redmine.ruby-lang.org/issues/94992014-02-07T15:46:11Zdodo (Deyan Hadzhiev)deyan.z.hadzhiev@gmail.com
<p>The member function of class Vector returns the opposite vector of the expected result. The function calculates the resulting vector as if the cross_product is v X self instead of self X v. Just to be sure I tried running the exact example from the 2.1.0 documentation, where is specified:<br>
Vector[1, 0, 0].cross_product Vector[0, 1, 0] => Vector[0, 0, 1]<br>
The documentation is right, but running the example produces Vector[0, 0, -1].<br>
The fix is just to swap the two arguments of the '-' operator.<br>
The implementation is in matrix.rb line:1764</p> Ruby master - Bug #9458 (Rejected): File write modehttps://redmine.ruby-lang.org/issues/94582014-01-28T17:42:19Zpradeek (pradeek kyahvi)pradeek.k@gmail.com
<p>As i am working ruby 2.1.0p0,it is found that File write mode is pushing the data in to file with out calling the close method on File Oject.When i quit the irb enviroment with out calling the close method,the data is wrote to the file.</p> Ruby master - Bug #9048 (Closed): Remove legacy ±(binary) special cases.https://redmine.ruby-lang.org/issues/90482013-10-24T00:30:13Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Is there any reason not to get rid of the following special cases?</p>
<pre><code>'+(binary)'.to_sym # => :+ when expected :"+(binary)"
</code></pre>
<p>The following patch didn't reveal any failure in make test:</p>
<p>diff --git a/parse.y b/parse.y<br>
index 76fc9e7..6550235 100644<br>
--- a/parse.y<br>
+++ b/parse.y<br>
@@ -10045,8 +10045,6 @@ static const struct {<br>
} op_tbl[] = {<br>
{tDOT2, ".."},<br>
{tDOT3, "..."},</p>
<ul>
<li>{'+', "+(binary)"},</li>
<li>{'-', "-(binary)"},<br>
{tPOW, "<strong>"},<br>
{tDSTAR, "</strong>"},<br>
{tUPLUS, "+@"},<br>
diff --git a/test/ruby/test_m17n.rb b/test/ruby/test_m17n.rb<br>
index 7c37c8a..3ea346f 100644<br>
--- a/test/ruby/test_m17n.rb<br>
+++ b/test/ruby/test_m17n.rb<br>
@@ -1230,7 +1230,7 @@ class TestM17N < Test::Unit::TestCase</li>
</ul>
<p>def test_symbol_op<br>
ops = %w"</p>
<ul>
<li>
<pre><code> .. ... + - +(binary) -(binary) * / % ** +@ -@ | ^ & ! <=> > >= < <= ==
</code></pre>
</li>
</ul>
<ul>
<li>
<pre><code> .. ... + - * / % ** +@ -@ | ^ & ! <=> > >= < <= ==
=== != =~ !~ ~ ! [] []= << >> :: `
</code></pre>
"<br>
ops.each do |op|</li>
</ul> Ruby master - Bug #8641 (Closed): Enumerator size argument is either mis-documented or should acc...https://redmine.ruby-lang.org/issues/86412013-07-16T09:10:31Zavdi (Avdi Grimm)avdi@avdi.codes
<p>I ran into this while wrapping Enumerators around Queues. The Enumerator docs state:</p>
<ul>
<li>The optional parameter can be used to specify how to calculate the size</li>
<li>in a lazy fashion (see Enumerator#size). It can either be a value or</li>
<li>a callable object.</li>
</ul>
<p>However:</p>
<p>require 'thread'<br>
q = Queue.new<br>
eq = Enumerator.new(q.method(:size)) do |y|<br>
loop do<br>
y << q.pop<br>
end<br>
end<br>
eq.size # =></p>
<a name="gt-3in-initialize-no-implicit-conversion-of-Method-into-Integer-TypeError"></a>
<h1 >~> -:3:in `initialize': no implicit conversion of Method into Integer (TypeError)<a href="#gt-3in-initialize-no-implicit-conversion-of-Method-into-Integer-TypeError" class="wiki-anchor">¶</a></h1>
<a name="gt-from-3in-new"></a>
<h1 >~> from -:3:in `new'<a href="#gt-from-3in-new" class="wiki-anchor">¶</a></h1>
<a name="gt-from-3in-"></a>
<h1 >~> from -:3:in `'<a href="#gt-from-3in-" class="wiki-anchor">¶</a></h1>
<p>It looks like the size can't be any callable; it must be Proc a or an Integer. The code uses rb_obj_is_proc().</p>
<p>Instinctively I'd say that the documentation has it right and it ought to take any callable. But if there's some reason it's limited to Procs, the docs should be changed.</p>
<p>If anyone can point me in the right direction I'm happy to do the legwork on this.</p> Ruby master - Feature #8382 (Closed): Format OpenStruct YAML dump and create getters and setters...https://redmine.ruby-lang.org/issues/83822013-05-08T13:07:27Zpietro (Pietro Monteiro)pietro@riseup.net
<p>=begin<br>
Currently Open Struct doesn't format it's YAML output exposing ((|@table|)). It also doesn't create setters and getter like (({#marshal_load})). This patch does both.<br>
=end</p> Ruby master - Bug #8242 (Closed): Fix rdoc of Range#bsearchhttps://redmine.ruby-lang.org/issues/82422013-04-09T23:35:02Zyhara (Yutaka HARA)
<p>rdoc of Range#bsearch states "the elements must be sorted", but it does not make sense for Range.</p>
<p>Patch:</p>
<p>diff --git a/range.c b/range.c<br>
index 1e4347e..fab0718 100644<br>
--- a/range.c<br>
+++ b/range.c<br>
@@ -512,11 +512,10 @@ is_integer_p(VALUE v)</p>
<ul>
<li>
<pre><code>rng.bsearch {|obj| block } -> value
</code></pre>
</li>
<li>
<li>By using binary search, finds a value in range which meets the given</li>
</ul>
<ul>
<li>
<ul>
<li>condition in O(log n) where n is the size of the array.</li>
</ul>
</li>
</ul>
<ul>
<li>
<ul>
<li>condition in O(log n) where n is the size of the range.</li>
<li>
<li>You can use this method in two use cases: a find-minimum mode and</li>
</ul>
</li>
</ul>
<ul>
<li>
<ul>
<li>a find-any mode. In either case, the elements of the array must be</li>
</ul>
</li>
<li>
<ul>
<li>monotone (or sorted) with respect to the block.</li>
</ul>
</li>
</ul>
<ul>
<li>
<ul>
<li>a find-any mode.</li>
<li>
<li>In find-minimum mode (this is a good choice for typical use case),</li>
<li>the block must return true or false, and there must be a value x<br>
@@ -524,7 +523,7 @@ is_integer_p(VALUE v)</li>
<li>
<li>
<ul>
<li>the block returns false for any value which is less than x, and</li>
</ul>
</li>
<li>
<ul>
<li>the block returns true for any value which is greater than or</li>
</ul>
</li>
</ul>
</li>
</ul>
<ul>
<li>
<ul>
<li>equal to i.</li>
</ul>
</li>
</ul>
<ul>
<li>
<ul>
<li>equal to x.</li>
<li>
<li>If x is within the range, this method returns the value x.</li>
<li>Otherwise, it returns nil.</li>
</ul>
</li>
</ul> Ruby master - Feature #8223 (Third Party's Issue): Make Matrix more omnivorous.https://redmine.ruby-lang.org/issues/82232013-04-05T20:55:59ZAnonymous
<p>Let's imagine a class Metre, whose instances represent physical magnitudes in metres.</p>
<pre><code>class Metre
attr_reader :magnitude
def initialize magnitude; @magnitude = magnitude end
def to_s; magnitude.to_s + ".m" end
end
</code></pre>
<p>Let's say that metres can be multiplied by a number:</p>
<pre><code>class Metre
def * multiplicand
case multiplicand
when Numeric then Metre.new( magnitude * multiplicand )
else
raise "Metres can only be multiplied by numbers, multiplication by #{multiplicand.class} attempted!"
end
end
end
</code></pre>
<p>And that they can be summed up with other magnitudes in metres, but, as a feature,<br>
not with numbers (apples, pears, seconds, kelvins...).</p>
<pre><code>class Metre
def + summand
case summand
when Metre then Metre.new( magnitude + summand.magnitude )
else
raise "Metres can only be summed with metres, summation with #{summand.class} attempted!"
end
end
end
</code></pre>
<p>Now with one more convenience constructor Numeric#m:</p>
<pre><code>class Numeric
def m; Metre.new self end
end
</code></pre>
<p>We can write expressions such as</p>
<pre><code>3.m + 5.m
#=> 8.m
3.m * 2
#=> 6.m
</code></pre>
<p>And with defined #coerce:</p>
<pre><code>class Metre
def coerce other; [ self, other ] end
end
</code></pre>
<p>Also this expression is valid:</p>
<pre><code>2 * 3.m
#=> 6.m
</code></pre>
<p>Before long, the user will want to make a matrix of magnitudes:</p>
<pre><code>require 'matrix'
mx = Matrix.build 2, 2 do 1.m end
#=> Matrix[[1.m, 1.m], [1.m, 1.m]]
</code></pre>
<p>It works, but the joy does not last long. The user will fail miserably if ze wants to perform matrix multiplication:</p>
<pre><code>cv = Matrix.column_vector [1, 1]
mx * cv
#=> RuntimeError: Metres can only be summed with metres, summation with Fixnum attempted!
# where 2.m would be expected
</code></pre>
<p>In theory, everything should be O.K., since Metre class has both metre summation and multiplication by a number defined. The failure happens due to the internal workings of the Matrix class, which assumes that the elements can be summed together with numeric 0. But it is a feature of metres, that they are picky and allow themselves to be summed only with other Metre instances.</p>
<p>In my real physical units library that I have written, I have solved this problem by<br>
defining an über zero object that produces the expected result, when summed with objects, that would otherwise not lend themselves to summation with ordinary numeric 0,<br>
and patching the Matrix class so that it uses this über zero instead of the ordinary one.</p>
<p>But this is not a very systematic solution. Actually, I think that the Matrix class would be more flexible, if, instead of simply using 0, it asked the elements of the matrix what their zero is, as in:</p>
<pre><code>class << Metre
def zero; new 0 end
end
</code></pre>
<p>But of course, that would also require that ordinary numeric classes can tell what their zero is, as in:</p>
<pre><code>def Integer.zero; 0 end
def Float.zero; 0.0 end
def Complex.zero; Complex 0.0, 0.0 end
# etc.
</code></pre>
<p>I think that this way of doing things (that is, having #zero methods in numeric classes and making Matrix actually require the class of the objects in it to have public class method #zero defined) would make everything more consistent and more algebra-like. I am having this problem for already almost half a year, but I only gathered courage today to encumber you guys with this proposal. Please don't judge me harshly for it. I have actually already seen something like this, in particular with bigdecimal's Jacobian (<a href="http://ruby-doc.org/stdlib-2.0/libdoc/bigdecimal/rdoc/Jacobian.html" class="external">http://ruby-doc.org/stdlib-2.0/libdoc/bigdecimal/rdoc/Jacobian.html</a>), which requires that the object from which the Jacobian is computed implements methods #zero, #one, #two etc. Sorry again.</p> Backport21 - Backport #8072 (Closed): Method#arity for keyword argumentshttps://redmine.ruby-lang.org/issues/80722013-03-11T10:18:49Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>I would expect the following two methods to have the same arity:</p>
<pre><code>def old_way(req, options = {}); end
def new_way(req, **options); end
method(:new_way).arity # => 1, should be -2
</code></pre> Ruby master - Bug #7777 (Closed): wrong use of "Raise" method in matrix.rbhttps://redmine.ruby-lang.org/issues/77772013-02-04T00:28:22Zpypypy567 (py _)
<p>=begin<br>
"Raise" method added by e2mmap library shows customized error messages according to pre-registered formats:</p>
<p>$ irb<br>
irb(main):001:0> require 'matrix'<br>
=> true<br>
irb(main):002:0> Matrix.Raise ArgumentError, 2, 3 rescue $!<br>
=> #<ArgumentError: Wrong # of arguments(2 for 3)></p>
<p>However it's not needed if we make messages by hand.</p>
<p>irb(main):003:0> Matrix.Raise ArgumentError, "One size must be 0"<br>
ArgumentError: invalid value for Integer(): "One size must be 0"<br>
from C:/ruby200/lib/ruby/2.0.0/e2mmap.rb:144:in <code>sprintf' from C:/ruby200/lib/ruby/2.0.0/e2mmap.rb:144:in </code>Raise'<br>
from C:/ruby200/lib/ruby/2.0.0/e2mmap.rb:78:in <code>Raise' from (irb):3 from C:/ruby200/bin/irb.bat:19:in </code>'<br>
irb(main):004:0> raise ArgumentError, "One size must be 0" rescue $!<br>
=> #<ArgumentError: One size must be 0><br>
=end</p> Ruby master - Bug #7765 (Closed): Proc#arity bug with optional argumenthttps://redmine.ruby-lang.org/issues/77652013-02-01T05:38:17Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>We have:</p>
<pre><code>Proc.new{|a, b, c, d, e|}.arity # => 5
</code></pre>
<p>Matz decided <a href="/issues/5694">[ruby-core:46515]</a> we also have:</p>
<pre><code>Proc.new{|a, b, c, d, e=0|}.arity # => 4
</code></pre>
<p>It looks like we currently have:</p>
<pre><code>Proc.new{|a, b=0, c, d, e|}.arity # => 1, should be same as above
</code></pre>
<p>Hopefully there won't be disagreement that this is a bug?</p>
<p>I'm asking in particular because there was a specific test committed by Yui to that effect. I hope this was just an oversight?</p>
<pre><code>assert_equal(0, proc{|x=0, y|}.arity) # Should be 1, not 0. test/ruby/test_proc.rb:67
</code></pre>
<p>My patch is ready and I will commit it unless there is objection.</p>
<p><a href="https://github.com/marcandre/ruby/compare/marcandre:trunk...marcandre:proc_curry" class="external">https://github.com/marcandre/ruby/compare/marcandre:trunk...marcandre:proc_curry</a></p> Ruby master - Bug #7728 (Closed): Range#bsearch on other Numerics?https://redmine.ruby-lang.org/issues/77282013-01-23T03:12:30Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Range#bsearch attempts to do something on generic Numeric classes.</p>
<p>I feel it is both useless and buggy:</p>
<pre><code>(Rational(-1,2)..Rational(9,4)).bsearch{|x| true} # => yields with 7/8 and 33/16
(Rational(-1,2)..Rational(9,4)).bsearch{|x| false} # => loops forever
(BigDecimal('0.5')..BigDecimal('2.25'))... # => same
</code></pre>
<p>I feel the current implementation (aside from the bugs) only makes sense on Integers.</p>
<p>Possible approaches:</p>
<ul>
<li>Rational</li>
</ul>
<ol>
<li>convert to float, or</li>
<li>bsearch accepts a "max iterations" parameter (which would be required for Rational), or</li>
<li>forbid altogether</li>
</ol>
<ul>
<li>BigDecimal</li>
</ul>
<ol>
<li>convert to float, or</li>
<li>look at the space of decimal numbers in the range without a higher precision than begin or end.</li>
</ol>
<p>Given the timeframe though, I recommend we raise a TypeError for both in 2.0.0 (or a NotImplemented if we decide what should be done).</p> Ruby master - Bug #7726 (Closed): bsearch should handle block result in a consistent wayhttps://redmine.ruby-lang.org/issues/77262013-01-22T18:52:35Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>The documentation states that the block of bsearch must<br>
return either true/false or a number.</p>
<p>If the block returns another object (other than nil), I feel that either</p>
<ol>
<li>It should be considered as 'truthy'</li>
<li>It should raise a TypeError</li>
</ol>
<p>Currently it does not raise an error and returns a result different than if <code>true</code> was passed:</p>
<p>(1..3).bsearch{ 'x' } == (1..3).bsearch{ true } # => false</p> Ruby master - Bug #7725 (Closed): bsearch should return enumerator when called without a blockhttps://redmine.ruby-lang.org/issues/77252013-01-22T18:48:44Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>bsearch should return enumerator when called without a block</p>
<p>This would allow, for example</p>
<p>values.bsearch.with_index{|val, index| val >= some_array[index]} # => a value</p>
<p>Otherwise, one must use zip/each_with_index and will get an array returned, not just the value seeked:</p>
<p>r = values.zip(some_array).bsearch{|val, other_val| val >= other_val}<br>
a_value = r.first</p> Ruby master - Bug #7724 (Closed): 6 bugs with Range#bsearch over floatshttps://redmine.ruby-lang.org/issues/77242013-01-22T18:47:35Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Take the following code, with from, to and search all Integer or all Float:</p>
<p>(from...to).bsearch{|f| f >= search}</p>
<p>I expected it to:<br>
0) never yield and return nil if range is empty, i.e. from >= to ("trivial test")</p>
<ol>
<li>never yield more than 65 times for floats<br>
or Math.log(to-from, 2)+1 for Integer ("log test")</li>
<li>return search if from <= search < to, nil otherwise ("coverage test")</li>
<li>never yield the same <code>f</code> ("uniqueness test")</li>
<li>if range is exclusive, never yield <code>to</code> nor return <code>to</code>; if range is inclusive and block returns false always yield <code>to</code> ("end of range test")</li>
<li>never yield a number < from or > to ("out of range test")</li>
</ol>
<p>These conditions are all respected for Integers but all can be broken for Floats<br>
Test 0, 1, 3, 4 & 5 fail even for small ordinary float values, while test 2 requires some larger floats, say 1e100 to fail.<br>
For example bsearch can yield over 2000 times (instead of at most 65).</p>
<p>These tests and a correct Ruby implementation of bsearch can be found here: <a href="https://github.com/marcandre/backports/compare/marcandre:master...marcandre:bsearch" class="external">https://github.com/marcandre/backports/compare/marcandre:master...marcandre:bsearch</a><br>
My implementation also passes the MRI tests.</p> Ruby master - Bug #7715 (Closed): Lazy enumerators should want to stay lazy.https://redmine.ruby-lang.org/issues/77152013-01-19T02:33:26Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>I'm just waking up to the fact that many methods turn a lazy enumerator in a non-lazy one.</p>
<p>Here's an example from Benoit Daloze in <a href="/issues/6261">[ruby-core:44151]</a>:</p>
<p>lines = File.foreach('a_very_large_file').lazy<br>
.select {|line| line.length < 10 }<br>
.map {|line| line.chomp!; line }<br>
.each_slice(3)<br>
.map {|lines| lines.join(';').downcase }<br>
.take_while {|line| line.length > 20 }</p>
<p>That code will produce the right result but <em>will read the whole file</em>, which is not what is desired</p>
<p>Indeed, <code>each_slice</code> currently does not return a lazy enumerator :-(</p>
<p>To make the above code as intended, one must call <code>.lazy</code> right after the <code>each_slice(3)</code>. I feel this is dangerous and counter intuitive.</p>
<p>Is there a valid reason for this behavior? Otherwise, I would like us to consider returning a lazy enumerator for the following methods:<br>
(when called without a block)<br>
each_with_object<br>
each_with_index<br>
each_slice<br>
each_entry<br>
each_cons<br>
(always)<br>
chunk<br>
slice_before</p>
<p>The arguments are:</p>
<ul>
<li>fail early (much easier to realize one needs to call a final <code>force</code>, <code>to_a</code> or <code>each</code> than realizing that a lazy enumerator chain isn't actually lazy)</li>
<li>easier to remember (every method normally returning an enumerator returns a lazy enumerator). basically this makes Lazy covariant</li>
<li>I'd expect that if you get lazy at some point, you typically want to remain lazy until the very end</li>
</ul> Ruby master - Bug #7706 (Closed): Lazy#zip should not call `lazy`https://redmine.ruby-lang.org/issues/77062013-01-17T03:27:36Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Current implementation of Lazy#zip has problems:</p>
<ol>
<li>
<p>calls <code>lazy</code> when this is not excepted, necessary nor documented. Any reason to not call <code>each</code> instead?</p>
</li>
<li>
<p>calls <code>lazy</code> without checking previously for type:</p>
<p>[1].lazy.zip(42) # =>NoMethodError: undefined method `lazy' for 42:Fixnum</p>
<a name="expected-same-as-1zip42-ie-a-TypeError"></a>
<h1 >expected same as [1].zip(42), i.e. a TypeError<a href="#expected-same-as-1zip42-ie-a-TypeError" class="wiki-anchor">¶</a></h1>
</li>
<li>
<p>inefficient in the case where all arguments are arrays</p>
</li>
</ol>
<p>I'll address these when I get a chance. I don't understand why <code>lazy</code> is called instead of <code>each</code> though. Anyone?</p> Ruby master - Bug #7692 (Closed): Enumerator::Lazy#drop_while and take_while should require a block.https://redmine.ruby-lang.org/issues/76922013-01-14T16:33:07Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Enumerator::Lazy#drop_while and take_while should require a block.</p>
<p>Currently:</p>
<pre><code>[1].lazy.drop_while.force # => LocalJumpError: no block given
[1].lazy.take_while.force # => LocalJumpError: no block given
</code></pre>
<p>After patch, these will raise an ArgumentError "tried to call lazy drop_while without a block"</p> Ruby master - Bug #7620 (Closed): Incorrect exception for non-square matrix in Matrix::LUPDecompo...https://redmine.ruby-lang.org/issues/76202012-12-25T07:39:58Zpypypy567 (py _)
<p>If m is a non-square matrix , m.lup.det should raise Matrix::ErrDimensionMismatch, but it raises NoMethodError.</p>
<blockquote>
<p>ruby -rmatrix -e 'Matrix[[0, 0]].lup.det'<br>
C:/ruby200/lib/ruby/2.0.0/matrix/lup_decomposition.rb:80:in <code>det': undefined method </code>square?' for #<a href="Matrix::LUPDecomposition:0xbb4284" class="external">Matrix::LUPDecomposition:0xbb4284</a> (NoMethodError)<br>
from -e:1:in `'</p>
</blockquote> Ruby master - Bug #7539 (Closed): Misleading error message "can't convert nil into string"https://redmine.ruby-lang.org/issues/75392012-12-10T21:29:10Zconnec (Chris Connelly)chris@connec.co.uk
<p>When trying to call <code>String#+</code> with <code>nil</code> as an argument, you get the error "can't convert nil into String", which does not make sense (in fact seeming blatantly false) as <code>nil.to_s</code>, <code>String(nil)</code> etc. all return <code>''</code> without errors.</p>
<p>Ideally, this method should use <code>to_s</code> to convert the argument, or else report an error along the lines of "can't append nil to string".</p>
<p>Minimal test case:</p>
<p>Actual:<br>
> '' + nil<br>
TypeError: can't convert nil into String</p>
<p>Expected:<br>
> '' + nil<br>
''</p> Ruby master - Bug #7437 (Closed): Array#delete(obj) should return obj when there is an object tha...https://redmine.ruby-lang.org/issues/74372012-11-26T13:00:08Zhasari (Hiro Asari)asari.ruby@gmail.com
<p>According to <a href="http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-delete" class="external">http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-delete</a>, Array#delete(obj) should return "obj" when there are objects in the array that are "equal to obj" (internally, "==" is used, it seems).</p>
<p>Notice that the documentation does not state that the return value is an element of the array itself. However, 1.9.3 and trunk both return a member of the Array, rather than the argument.</p>
<p>This issue was raised in <a href="https://github.com/jruby/jruby/issues/411" class="external">https://github.com/jruby/jruby/issues/411</a></p>
<p>#!/usr/bin/env ruby</p>
<p>class Foo<br>
attr_reader :name, :age</p>
<p>def initialize name, age<br>
@name = name<br>
@age = age<br>
end</p>
<p>def == other<br>
other.name == name<br>
end<br>
end</p>
<p>foo1 = Foo.new "John Shahid", 27<br>
foo2 = Foo.new "John Shahid", 28<br>
array = [foo1]<br>
temp = array.delete foo2 # => foo1, not foo2</p> Ruby master - Bug #7369 (Closed): Matrix #row_size, #column_size methodshttps://redmine.ruby-lang.org/issues/73692012-11-16T16:08:29ZAnonymous
<p>I believe these methods should be renamed. "row_size" is confusing, because it can be intuitively understood as both "number of rows", and "size along a row" (or size of a matrix row). Same goes for "column size". I would like these methods renamed to unambigous, mnemonic names, such as</p>
<p>#number_of_rows alias #height<br>
#number_of_columns alias #width</p>
<p>I do not insist on the above names. They are just examples of unambigous, mnemonic names. But I insist that "row_size" and "column_size" method names impress me as ambiguous.</p> Ruby master - Bug #7313 (Closed): test_initialize(TestEnumerator) failshttps://redmine.ruby-lang.org/issues/73132012-11-09T00:43:04Zvo.x (Vit Ondruch)v.ondruch@tiscali.cz
<p>=begin<br>
test_initialize(TestEnumerator):<br>
TypeError: can't convert Array into Integer<br>
/builddir/build/BUILD/ruby-2.0.0-r37564/test/ruby/test_enumerator.rb:72:in <code>initialize' /builddir/build/BUILD/ruby-2.0.0-r37564/test/ruby/test_enumerator.rb:72:in </code>new'<br>
/builddir/build/BUILD/ruby-2.0.0-r37564/test/ruby/test_enumerator.rb:72:in `test_initialize'<br>
=end</p> Ruby master - Bug #7302 (Closed): r37497 changes rb_enumeratorize without NEWShttps://redmine.ruby-lang.org/issues/73022012-11-07T19:53:08Znaruse (Yui NARUSE)naruse@airemix.jp
<p>r37497 [Feature <a class="issue tracker-2 status-5 priority-4 priority-default closed" title="Feature: Enumerable#size (Closed)" href="https://redmine.ruby-lang.org/issues/6636">#6636</a>] changed the prototype of rb_enumeratorize.<br>
It is public Ruby CAPI.</p>
<p>I think it shouldn't be changed and add another CAPI like rb_enumeratorize_with_size.<br>
At least a description should be add to NEWS</p> Ruby master - Feature #7292 (Closed): Enumerable#to_hhttps://redmine.ruby-lang.org/issues/72922012-11-07T02:53:45Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Now that #to_h is the official method for explicit conversion to Hash, we should also add</p>
<pre><code>Enumerable#to_h: Returns a hash for the yielded key-value pairs.
[[:name, 'Joe Smith'], [:age, 42]].to_h # => {name: 'Joe Smith', age: 42}
</code></pre>
<p>With the Ruby tradition of succint documentation I suggest the documentation talk about key-value pairs and there is no need to be explicit about the uninteresting cases like:</p>
<pre><code>(1..3).to_h # => {1 => nil, 2 => nil, 3 => nil}
[[1, 2], [1, 3]].to_h # => {1 => 3}
[[1, 2], []].to_h # => {1 => 2, nil => nil}
</code></pre>
<p>I see some reactions of people reading about the upcoming 2.0 release like this one:<br>
<a href="http://globaldev.co.uk/2012/11/ruby-2-0-0-preview-features/#dsq-comment-body-700242476" class="external">http://globaldev.co.uk/2012/11/ruby-2-0-0-preview-features/#dsq-comment-body-700242476</a></p> Ruby master - Bug #7248 (Closed): Shouldn't Enumerator::Lazy.new be private?https://redmine.ruby-lang.org/issues/72482012-10-31T13:23:13Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Is there a reason why Enumerator::Lazy.new is not private?</p>
<p>Lazy enumerators should be created with <code>Enumerable#lazy</code>. Moreover, there is no doc, and it can give unexpected results too.</p> Ruby master - Bug #7208 (Closed): 複素固有値を持つ行列に対する Matrix#eigensystem の返り値が正しくないhttps://redmine.ruby-lang.org/issues/72082012-10-23T21:28:36Zpypypy567 (py _)
<p>=begin<br>
概要:<br>
Matrix[[0, 1], [-1, 0]] などのように対角化可能だが固有値に複素数を含む行列に対して Matrix#eigensystem が正しい結果を返さないようです。</p>
<p>再現手順:<br>
irb(main):001:0> RUBY_DESCRIPTION<br>
=> "ruby 1.9.3p286 (2012-10-12 revision 37165) [i386-mswin32_100]"<br>
irb(main):002:0> require 'matrix'<br>
=> true<br>
irb(main):003:0> m = Matrix[[0, 1], [-1, 0]]<br>
=> Matrix[[0, 1], [-1, 0]]<br>
irb(main):004:0> v, d, v_inv = m.eigensystem<br>
ExceptionForMatrix::ErrNotRegular: Not Regular Matrix<br>
from C:/ruby193/lib/ruby/1.9.1/matrix.rb:930:in <code>block in inverse_from' from C:/ruby193/lib/ruby/1.9.1/matrix.rb:920:in </code>upto'<br>
from C:/ruby193/lib/ruby/1.9.1/matrix.rb:920:in <code>inverse_from' from C:/ruby193/lib/ruby/1.9.1/matrix.rb:912:in </code>inverse'<br>
from C:/ruby193/lib/ruby/1.9.1/matrix/eigenvalue_decomposition.rb:51:in<br>
<code>eigenvector_matrix_inv' from C:/ruby193/lib/ruby/1.9.1/matrix/eigenvalue_decomposition.rb:80:in </code>to_ary'<br>
from (irb):4<br>
from C:/ruby193/bin/irb.bat:19:in `'</p>
<p>説明:<br>
実行列 m が対角化可能なら m.eigensystem は以下のような分解を与えます。<br>
(Float で計算されるので誤差により等しくならないことがあります。)<br>
v * d * v_inv == m<br>
しかし固有値に複素数を含む場合は上記のように上手くいかないようです。<br>
最初は単にそういうのは非対応なのかと思いましたがそういうわけではなさそうです。</p>
<p>エラーの出所を追ってみたところ Matrix::EigenvalueDecomposition#build_eigenvectors が不正な値を返しているように思えました。<br>
ソースコード: <a href="http://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/32355/entry/lib/matrix/eigenvalue_decomposition.rb#L85" class="external">http://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/32355/entry/lib/matrix/eigenvalue_decomposition.rb#L85</a><br>
コードのコメントに有る URL の説明を読んでみると、正直仕組みはまったく分かってないのですが、添付したパッチのようにするのが正しいような気がしました。<br>
試しに手元の ruby の該当部分を同じように書きかえてみたら期待通りの結果が返りました。<br>
=end</p> Ruby master - Bug #6967 (Closed): Vector#inner_product は複素数ベクトルのとき不適切https://redmine.ruby-lang.org/issues/69672012-09-03T17:28:56Z5.5 (5 5)
<p><a class="issue tracker-1 status-5 priority-4 priority-default closed" title="Bug: Vector#norm は複素数ベクトルの正しいノルムを返さない (Closed)" href="https://redmine.ruby-lang.org/issues/6966">#6966</a> に関連して,Vector#inner_product は成分の単なる積和ですが,複素数ベクトル v については v.inner_product(v) が非負性を破るので,内積の定義に当てはまりません。</p>
<p>複素数ベクトルでは内積といえばエルミート内積(<u,v> = Σ u_i v_i*)なので(* は複素共役),inner_product の定義を</p>
<pre><code>p = 0
each2(v) {|v1, v2|
p += v1 * v2.conj
}
p
</code></pre>
<p>のようにするか,あるいは self や引数が実でないときは例外を出すことにし,inner_product とは別に hermitian_inner_product を導入しては如何でしょうか。</p> Ruby master - Feature #6636 (Closed): Enumerable#sizehttps://redmine.ruby-lang.org/issues/66362012-06-24T02:49:38Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Now that it has been made clear that <code>Enumerable#count</code> never calls <code>#size</code> and that we have <code>Enumerable#lazy</code>, let me propose again an API for a lazy way to get the size of an Enumerable: <code>Enumerable#size</code>.</p>
<ul>
<li>call-seq:</li>
<li>enum.size # => nil, Integer or Float::INFINITY</li>
<li>
<li>Returns the number of elements that will be yielded, without going through</li>
<li>the iteration (i.e. lazy), or +nil+ if it can't be calculated lazily.</li>
<li>
<li>perm = (1..100).to_a.permutation(4)</li>
<li>perm.size # => 94109400</li>
<li>perm.each_cons(2).size # => 94109399</li>
<li>loop.size # => Float::INFINITY</li>
<li>[42].drop_while.size # => nil</li>
</ul>
<p>About 66 core methods returning enumerators would have a lazy <code>size</code>, like <code>each_slice</code>, <code>permutation</code> or <code>lazy.take</code>.</p>
<p>A few would have <code>size</code> return <code>nil</code>:<br>
Array#{r}index, {take|drop}_while<br>
Enumerable#find{_index}, {take|drop}_while<br>
IO: all methods</p>
<p>Sized enumerators can also be created naturally by providing a block to <code>to_enum</code>/<code>enum_for</code> or a lambda to <code>Enumerator.new</code>.</p>
<p>Example for <code>to_enum</code>:</p>
<pre><code>class Integer
def composition
return to_enum(:composition){ 1 << (self - 1) } unless block_given?
yield [] if zero?
downto(1) do |i|
(self - i).composition do |comp|
yield [i, *comp]
end
end
end
end
4.composition.to_a
# => [[4], [3, 1], [2, 2], [2, 1, 1], [1, 3], [1, 2, 1], [1, 1, 2], [1, 1, 1, 1]]
42.composition.size # => 2199023255552
</code></pre>
<p>Example for <code>Enumerator.new</code>:</p>
<pre><code>def lazy_product(*enums)
sizer = ->{
enums.inject(1) do |product, e|
break if (size = e.size).nil?
product * size
end
}
Enumerator.new(sizer) do |yielder|
# ... generate combinations
end
end
lazy_product(1..4, (1..3).each_cons(2)).size # => 8
lazy_product(1..4, (1..3).cycle).size # => Float::INFINITY
</code></pre> Ruby master - Bug #6120 (Closed): Float and BigDecimal bug in remainder in corner caseshttps://redmine.ruby-lang.org/issues/61202012-03-07T14:51:41Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Currently:</p>
<pre><code>4.2.remainder(+Float::INFINITY) # => 4.2, ok
4.2.remainder(-Float::INFINITY) # => NaN, should be 4.2
# (same with all signs reversed)
</code></pre>
<p>Reasons the remainder should be 4.2 and not NaN:</p>
<ol>
<li>foo.remainder(bar) == foo.remainder(-bar)</li>
<li>foo.remainder(bar) == foo when bar.abs > foo.abs</li>
</ol>
<p>Similarly:<br>
require 'bigdecimal'<br>
bd = BigDecimal.new("4.2")<br>
bd.remainder(BigDecimal.new("+Infinity")) # => NaN, should be bd<br>
bd.remainder(BigDecimal.new("-Infinity")) # => NaN, should be bd<br>
# (same with all signs reverse)</p>
<p>Reasons: same as float.</p>
<p>Finally:<br>
bd = BigDecimal.new("4.2")<br>
bd.modulo(BigDecimal.new("0")) # => ZeroDivisionError, probably ok?<br>
bd.remainder(BigDecimal.new("0")) # => NaN, should be probably raise a ZeroDivisionError?</p>
<p>Like in <a class="issue tracker-4 status-5 priority-4 priority-default closed" title="Backport: Float#% bug in cornercases (Closed)" href="https://redmine.ruby-lang.org/issues/6044">#6044</a>, this could be decided either way, as long as there is consistency. Anyone prefer NaN to raising a ZeroDivisionError?</p> Ruby master - Bug #5747 (Closed): Proc#curry doesn't always detect too many arguments https://redmine.ruby-lang.org/issues/57472011-12-12T09:30:21Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Currently, Proc#curry checks the validity of the <code>arity</code> argument and will raise an error if:</p>
<ol>
<li>arity is less than the number of required arguments or</li>
<li>arity is more than the maximum number of arguments<br>
Note that simple Procs always accept any number of arguments (even though they may be ignored), so (2) doesn't applies to them, only to lambda's and procs made from methods.</li>
</ol>
<p>#2 isn't done as well as it could in case of limited optional parameters:</p>
<pre><code>def Object.foo(a, b=42); end
def Object.bar(a, b); end
Object.method(:foo).to_proc.curry(3) # => curried proc which will raise an error only when passed it's 3rd parameter
Object.method(:bar).to_proc.curry(3) # => ArgumentError: wrong number of arguments (3 for 2)
Same thing with lambdas
</code></pre>
<p>My proposed fix passes SST:<br>
a) usefulness: "fail-early" principle <a href="https://blade.ruby-lang.org/ruby-core/24130">[ruby-core:24130]</a><br>
b) consistency: both methods can only accept a maximum of 2 parameters and are thus treated consistently when attempting to curry with more than 2 arguments<br>
c) intuitiveness and d) performance: similar</p>
<p>It is straightforward (but not obvious), as it passes NIT (but not ODT).</p> Ruby master - Bug #5746 (Closed): Proc#curry too strict about lambda's arity.https://redmine.ruby-lang.org/issues/57462011-12-12T02:08:08Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Currently, Proc#curry raises an error when you attempt to curry a lambda with optional (but limited) arguments:</p>
<pre><code>l = ->(arg = 42) {}
l.curry(1) # => ArgumentError: wrong number of arguments (1 for 0)
</code></pre>
<p>Note that Proc#curry behaves correctly if the Proc was created from a method, even though arguments are treated the same way:</p>
<pre><code>def Object.foo(arg = 42); end
m = Object.method(:foo).to_proc
m.class # => Proc, same as 'l'
m.lambda? # => true, same as 'l'
m.curry(1) # => curried proc
</code></pre>
<p>Referring to my evaluation method, my proposed fix passes SST:<br>
a) usefulness: way more useful, as it makes it possible to do something that is not currently possible<br>
b) consistency: makes it consistent with equivalent method<br>
c) intuitiveness and d) performance: similar</p>
<p>It is straightforward (but not obvious), as it passes NIT (but not ODT).</p>
<p>This bug is a consequence of the redmine issue 5694; this will be fixed automatically when 5694 is fixed.</p> Ruby master - Bug #5715 (Closed): +/-1 ** Bignum returns different results than +/-1 ** Fixnumhttps://redmine.ruby-lang.org/issues/57152011-12-06T13:26:25Zjohn_firebaugh (John Firebaugh)john.firebaugh@gmail.com
<p>=begin<br>
Consider (({1 ** expt})) and (({(-1) ** expt})).</p>
<p>When ((|expt|)) is a Fixnum, the result is always 1, -1, Rational(1/1), or Rational(-1,1) depending on the signs of the operands and parity of the exponent.</p>
<p>When ((|expt|)) is a Bignum, Float 1.0 is always returned. Either the behavior for Fixnum exponents should be followed exactly (preferred), or at the very least -1.0 should be returned when the base is -1 and the exponent is odd.</p>
<p>$VERBOSE = nil</p>
<p>wordsize = 8 * 1.size<br>
fixnum_max = 2 ** (wordsize - 2) - 1<br>
fixnum_min = -2 ** (wordsize - 2)</p>
<p>[1, -1].each do |a|<br>
[ 1, 2, fixnum_max, fixnum_max + 1, fixnum_max + 2,<br>
-1, -2, fixnum_min, fixnum_min - 1, fixnum_min - 2].each do |b|<br>
puts "%5s ** %20s (%s) == %5s" % [a, b, b.class, a ** b]<br>
end<br>
end</p>
<p>Output:<br>
1 ** 1 (Fixnum) == 1<br>
1 ** 2 (Fixnum) == 1<br>
1 ** 4611686018427387903 (Fixnum) == 1<br>
1 ** 4611686018427387904 (Bignum) == 1<br>
1 ** 4611686018427387905 (Bignum) == 1<br>
1 ** -1 (Fixnum) == 1/1<br>
1 ** -2 (Fixnum) == 1/1<br>
1 ** -4611686018427387904 (Fixnum) == 1/1<br>
1 ** -4611686018427387905 (Bignum) == 1.0 # Bug<br>
1 ** -4611686018427387906 (Bignum) == 1.0 # Bug<br>
-1 ** 1 (Fixnum) == -1<br>
-1 ** 2 (Fixnum) == 1<br>
-1 ** 4611686018427387903 (Fixnum) == -1<br>
-1 ** 4611686018427387904 (Bignum) == 1<br>
-1 ** 4611686018427387905 (Bignum) == -1<br>
-1 ** -1 (Fixnum) == -1/1<br>
-1 ** -2 (Fixnum) == 1/1<br>
-1 ** -4611686018427387904 (Fixnum) == 1/1<br>
-1 ** -4611686018427387905 (Bignum) == 1.0 # Bug<br>
-1 ** -4611686018427387906 (Bignum) == 1.0 # Bug<br>
=end</p> Ruby master - Bug #5713 (Closed): Fixnum#** returns Infinity for 0 ** negative Bignumhttps://redmine.ruby-lang.org/issues/57132011-12-06T12:36:58Zjohn_firebaugh (John Firebaugh)john.firebaugh@gmail.com
<p>=begin<br>
Instead it should raise ZeroDivisionError, the same as negative Fixnums.</p>
<p>wordsize = 8 * 1.size<br>
fixnum_min = -2 ** (wordsize - 2)</p>
<p>def zero_power(exp)<br>
0 ** exp<br>
rescue ZeroDivisionError<br>
"ZeroDivisionError"<br>
end</p>
<p>[-1, fixnum_min, (fixnum_min-1)].each {|i| puts zero_power(i)}<br>
=end</p> Ruby master - Bug #5273 (Closed): Float#round returns the wrong floats for higher precisionhttps://redmine.ruby-lang.org/issues/52732011-09-05T05:43:55Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>Float#round returns the wrong floats for higher precision.</p>
<p>Rounding can be off:<br>
2.5e-22.round(22) # => 2.0e-22</p>
<p>It can also return values that have extra decimals:<br>
2.5e-31.round(31) # => 3.0000000000000003e-31<br>
2.5e-36.round(36) # => 2.9999999999999998e-36</p>
<p>Both errors can occur at the same time too:<br>
2.5e-39.round(39) # => 2.0000000000000002e-39</p>
<p>I believe these errors occur only for ndigits >= 22. For ndigits > 22, 10**(-ndigits) is not an exact Float (as 5 ** 23 won't fit in the 53 bits of a double's mantissa). For ndigits < 22, there should be enough bits left to avoid rounding errors.</p>
<p>For ndigits >= 22, the algorithm to use should be similar to the one used to convert doubles to string.</p>
<p>Hopefully, this is the last bug for #round with a given precision.</p> Ruby master - Bug #3434 (Closed): Specs for coercion?https://redmine.ruby-lang.org/issues/34342010-06-13T15:29:24Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>=begin<br>
What are the official specs of coercion for mathematical classes?</p>
<p>I will take Matrix as an example, but my questions are meant to be for the general case.</p>
<p>My understanding is that for a <code>obj.coerce(obj_2)</code> should return <code>[compatible_2, compatible]</code> such that <code>compatible2.send(some_operation, compatible)</code> returns (if possible) a meaningful result.</p>
<p>Can we assume anything more about coercion? I'm asking because I find in test_matrix (@m1 being a Matrix):</p>
<p>def test_scalar_mul<br>
s1 = @m1.coerce(1).first<br>
assert_equal(Matrix[[1]], (s1 * 1) * Matrix[[1]])<br>
assert_equal(Vector[2], s1 * Vector[2])<br>
assert_equal(Matrix[[2]], s1 * Matrix[[2]])<br>
o = Object.new<br>
def o.coerce(x)<br>
[1, 1]<br>
end<br>
assert_equal(1, s1 * o)<br>
end</p>
<ol>
<li>Should the first and last assert work? Are implementers of other mathematical classes mandated/encouraged to provide that level of compatibility? Are users of <code>coerce</code> encouraged (or guaranteed success) when doing any other operation than <code>compatible2 * compatible</code> or similar?</li>
</ol>
<p>My feeling is that the only thing one should do with the results of coerce is to call an operation on the first element and pass the second element. Doing operations using only one of the two returned elements with another new object should yield undetermined results.</p>
<p>If this is the case, I feel the Matrix library would be best to assume that Scalar#* is called with a Matrix or Vector (remember that the Scalar is not meant to be used directly by anybody else than the Matrix lib), and these two assert would <em>not</em> work.</p>
<ol start="2">
<li>
<p>The second assert is clearly implementation dependant. In the current implementation, both Vector and Matrix use Matrix::Scalar as a temporary class, but that could change.</p>
</li>
<li>
<p>I am assuming that compatible doesn't have to be equal?, eql? or == to obj nor of the same class, and the same is true for compatible_2 vs obj_2, right? Thus the third assert isn't a spec guaranteed for all implementations.</p>
</li>
<li>
<p>Finally, a somewhat trivial question: should <code>obj.coerce(obj_2)</code> succeed if <code>obj</code> and <code>obj_2</code> are of the same class (and presumably return <code>[obj_2, obj]</code>)? Clearly this is not very useful, but the specs should be made precise.</p>
</li>
</ol>
<p>This is the case for Numeric and is explicit in the documentation but fails for Matrix:</p>
<pre><code> Matrix.I(2).coerce(Matrix.I(2)) # => TypeError: Matrix can't be coerced into Matrix
</code></pre>
<p>Coercion should always work for the trivial case of two objects of the same class, right?</p>
<a name="Thanks"></a>
<h2 >Thanks.<a href="#Thanks" class="wiki-anchor">¶</a></h2>
<p>Marc-André<br>
=end</p> Ruby master - Feature #2832 (Closed): Vector#each and Enumerablehttps://redmine.ruby-lang.org/issues/28322010-03-02T18:04:44Zmarcandre (Marc-Andre Lafortune)marcandre-ruby-core@marc-andre.ca
<p>=begin<br>
Vector should implement #each and include Enumerable, since it is so Array-like.</p>
<p>Enumerable methods that return an array should probably be specialized to return a Vector (e.g. map, first, ...)</p>
<p>See also <a href="https://blade.ruby-lang.org/ruby-core/28403">[ruby-core:28403]</a>, [redmine:2831]<br>
=end</p> Ruby master - Feature #1400 (Closed): Please add a method to enumerate fields in OpenStructhttps://redmine.ruby-lang.org/issues/14002009-04-23T22:34:13Ztpo (Tomas Pospisek)tpo_deb@sourcepole.ch
<p>=begin<br>
There are two ways to find out what fields an OpenStruct instance has. One is through inspect,<br>
however that returns a String that needs to be parsed.</p>
<p>The second is by white box engineering, looking at OpenStructs source code and seeing that in<br>
fact, it has a hash and getting the keys of that hash...</p>
<p>The second way is faster, more robust, but will break once OpenStruct will be re-engineered...</p>
<p>So I suggest to add an explicit method to return a list of fields in an OpenStruct instance:</p>
<p>--- ostruct.rb.old 2009-04-23 15:26:45.000000000 +0200<br>
+++ ostruct.rb 2009-04-23 15:32:41.000000000 +0200<br>
@@ -110,6 +110,15 @@<br>
@table.delete name.to_sym<br>
end</p>
<ul>
<li>
<h1></h1>
</li>
<li>
<a name="Returns-an-Array-containing-the-fields-of-an-OpenStruct-instance"></a>
<h1 >Returns an Array containing the fields of an OpenStruct instance<a href="#Returns-an-Array-containing-the-fields-of-an-OpenStruct-instance" class="wiki-anchor">¶</a></h1>
</li>
<li>
<h1></h1>
</li>
<li>
<a name="p-recordfields-gt-age-pension-name"></a>
<h1 >p record.fields # -> [:age, :pension, :name]<a href="#p-recordfields-gt-age-pension-name" class="wiki-anchor">¶</a></h1>
</li>
<li>
<h1></h1>
</li>
<li>
<p>def fields</p>
</li>
<li>
<p>@table.keys</p>
</li>
<li>
<p>end</p>
</li>
<li>
<p>InspectKey = :<strong>inspect_key</strong> # :nodoc:</p>
<h1></h1>
</li>
</ul>
<p>=end</p>