Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: master
Commits on Aug 2, 2015
  1. @kaspth

    Merge pull request #21093 from vngrs/fix_ambiguous_argument_warning

    kaspth authored
    Fix ambiguous argument warning
  2. @meinac

    Fix ambiguous argument warning

    meinac authored
    encapsulate all arguments
  3. @schneems

    Merge pull request #21100 from bquorning/route-set

    schneems authored
    Use #start_with? and #[] for speed
  4. @schneems

    Merge pull request #21098 from bquorning/shovel-twice-and-save-a-string

    schneems authored
    Save a string allocation inside loop
  5. @bquorning

    Save a string allocation inside loop

    bquorning authored
    In the `tag_options` method, strings are continuously added to the
    `output` string. Previously, we concatenated two strings and added the
    generated string to `output`. By adding each of the strings to
    `output`, one after the other, we will save the allocation of that
    concatenated string.
    
    Benchmark:
    
        require 'benchmark/ips'
    
        sep = " ".freeze
    
        Benchmark.ips do |x|
          x.report("string +") {
            output = ""
            output << sep + "foo"
          }
          x.report("string <<") {
            output = ""
            output << sep
            output << "foo"
          }
          x.compare!
        end
    
    Results (Ruby 2.2.2):
    
        Calculating -------------------------------------
                    string +    88.086k i/100ms
                   string <<    94.287k i/100ms
        -------------------------------------------------
                    string +      2.407M (± 5.8%) i/s -     12.068M
                   string <<      2.591M (± 7.0%) i/s -     12.917M
    
        Comparison:
                   string <<:  2591482.4 i/s
                    string +:  2406883.7 i/s - 1.08x slower
  6. @bquorning

    Use #start_with? and #[] for speed

    bquorning authored
    While the readability may be slightly worse, the speed improvement is
    significant: Twice as fast when there's no leading "/" to remove, and
    over 4 times as fast when there is a leading "/".
    
    Benchmark:
    
        require 'benchmark/ips'
    
        def match(controller)
          if controller
            if m = controller.match(/\A\/(?<controller_without_leading_slash>.*)/)
              m[:controller_without_leading_slash]
            else
              controller
            end
          end
        end
    
        def start_with(controller)
          if controller
            if controller.start_with?('/'.freeze)
              controller[1..-1]
            else
              controller
            end
          end
        end
    
        Benchmark.ips do |x|
          x.report("match") { match("no_leading_slash") }
          x.report("start_with") { start_with("no_leading_slash") }
    
          x.compare!
        end
    
        Benchmark.ips do |x|
          x.report("match") { match("/a_leading_slash") }
          x.report("start_with") { start_with("/a_leading_slash") }
    
          x.compare!
        end
    
    Result (Ruby 2.2.2):
    
        Calculating -------------------------------------
                       match    70.324k i/100ms
                  start_with   111.264k i/100ms
        -------------------------------------------------
                       match      1.468M (± 7.1%) i/s -      7.314M
                  start_with      3.787M (± 3.5%) i/s -     18.915M
    
        Comparison:
                  start_with:  3787389.4 i/s
                       match:  1467636.4 i/s - 2.58x slower
    
        Calculating -------------------------------------
                       match    36.694k i/100ms
                  start_with    86.071k i/100ms
        -------------------------------------------------
                       match    532.795k (± 4.7%) i/s -      2.679M
                  start_with      2.518M (± 5.8%) i/s -     12.566M
    
        Comparison:
                  start_with:  2518366.8 i/s
                       match:   532794.5 i/s - 4.73x slower
  7. @arunagw

    Merge pull request #21097 from y-yagi/fix_button_to_example

    arunagw authored
    correct example of button_tag [ci skip]
  8. @y-yagi

    correct example of button_tag [ci skip]

    y-yagi authored
    wrapper div has been removed in cbb9174
  9. @sgrif

    Fix test failures caused by #20884

    sgrif authored
    PostgreSQL is strict about the usage of `DISTINCT` and `ORDER BY`, which
    one of the tests demonstrated. The order clause is never going to be
    relevant in the query we're performing, so let's just remove it
    entirely.
  10. @sgrif

    Merge pull request #20884

    sgrif authored
    Add #cache_key to ActiveRecord::Relation.
Commits on Aug 1, 2015
  1. @schneems
  2. @yui-knk

    [ci skip]

    yui-knk authored
    Add descriptions about `ActiveRecord::Base#to_param` to
    
    * `ActionDispatch::Routing::Base#match`
    * Overriding Named Route Parameters (guide)
    
    When passes `:param` to route definision, always `to_param` method of
    related model is overridden to constructe an URL by passing these
    model instance to named_helper.
  3. @senny
  4. @senny

    Merge pull request #21008 from svenwin/patch-1

    senny authored
    Add documentation to get a running custom base controller [ci skip]
  5. @senny
Commits on Jul 31, 2015
  1. @senny

    Merge pull request #21063 from cmisenas/fix-guides-warning-env

    senny authored
    Fix WARNINGS flag inside guides/Rakefile
  2. @senny

    Merge pull request #20992 from JuanitoFatas/fix/bin-setup-script

    senny authored
    Don't fail when checking dependencies in bin/setup script
Commits on Jul 30, 2015
  1. @rafaelfranca

    Merge pull request #21075 from byroot/not-empty-vs-any

    rafaelfranca authored
    Array#any? is slower and not the inverse of Array#empty?
  2. @byroot

    Array#any? is slower and not the inverse of Array#empty?

    byroot authored
    ```
    empty_array = []
    small_array = [1] * 30
    bigger_array = [1] * 300
    
    Benchmark.ips do |x|
      x.report('empty !empty?') { !empty_array.empty? }
      x.report('small !empty?') { !small_array.empty? }
      x.report('bigger !empty?') { !bigger_array.empty? }
    
      x.report('empty any?') { empty_array.any? }
      x.report('small any?') { small_array.any? }
      x.report('bigger any?') { bigger_array.any? }
    end
    ```
    
    ```
    Calculating -------------------------------------
           empty !empty?   132.059k i/100ms
           small !empty?   133.974k i/100ms
          bigger !empty?   133.848k i/100ms
              empty any?   106.924k i/100ms
              small any?    85.525k i/100ms
             bigger any?    86.663k i/100ms
    -------------------------------------------------
           empty !empty?      8.522M (± 7.9%) i/s -     42.391M
           small !empty?      8.501M (± 8.5%) i/s -     42.202M
          bigger !empty?      8.434M (± 8.6%) i/s -     41.894M
              empty any?      4.161M (± 8.3%) i/s -     20.743M
              small any?      2.654M (± 5.2%) i/s -     13.256M
             bigger any?      2.642M (± 6.4%) i/s -     13.173M
    ```
    
    Ref: #21057 (comment)
  3. @schneems

    Merge pull request #21057 from schneems/schneems/journey-formatter-ob…

    schneems authored
    …jects
    
    Beyond Ludicrous Speed
  4. @schneems

    Use delete_if instead of each; delete(key)

    schneems authored
    It is slightly faster:
    
    ```
    Calculating -------------------------------------
            each; delete    35.166k i/100ms
               delete_if    36.416k i/100ms
    -------------------------------------------------
            each; delete    478.026k (± 8.5%) i/s -      2.391M
               delete_if    485.123k (± 7.9%) i/s -      2.440M
    ```
  5. @schneems

    Remove (another) array allocation

    schneems authored
    We don't always need an array when generating a url with the formatter. We can be lazy about allocating the `missing_keys` array. This saves us:
    
    35,606 bytes and 889 objects per request
  6. @schneems

    Remove array allocation

    schneems authored
    THe only reason we were allocating an array is to get the "missing_keys" variable in scope of the error message generator. Guess what? Arrays kinda take up a lot of memory, so by replacing that with a nil, we save:
    
    35,303 bytes and 886 objects per request
  7. @schneems

    zOMG 37 objects saved

    schneems authored
  8. @schneems

    Don't allocate array when not necessary

    schneems authored
    In the `tag_options` method an array is used to build up elements, then `Array#*` (which is an alias for `Array#join` is called to turn the array into a string. Instead of allocating an array to build a string, we can build the string we want from the beginning.
    
    Saved: 121,743 bytes 893 objects
  9. @schneems

    String#freeze optimizations

    schneems authored
  10. @schneems

    Decrease allocations in transliterate

    schneems authored
    We can save a few objects by freezing the `replacement` string. We save a few more by down-casing the string in memory instead of allocating a new one. We save far more objects by checking for the default separator `"-"`, and using pre-generated regular expressions.
    
    We will save 209,231 bytes and 1,322 objects.
  11. @schneems

    Avoid hash duplication by skipping mutation

    schneems authored
    If we don't mutate the `recall` hash, then there's no reason to duplicate it. While this change doesn't get rid of that many objects, each hash object it gets rid of was massive.
    
    Saves 888 string objects per request, 206,013 bytes (thats 0.2 mb which is kinda a lot).
  12. @schneems

    Only allocate new string when needed

    schneems authored
    Instead of calling `sub` on every link_to call for controller, we can detect when the string __needs__ to be allocated and only then create a new string (without the leading slash), otherwise, use the string that is given to us.
    
    Saves 888 string objects per request, 35,524 bytes.
  13. @schneems

    Freeze a string in comparator

    schneems authored
    Saves 888 string objects per request.
  14. @schneems

    Avoid calling to_s on nil in journey/formatter

    schneems authored
    When `defaults[key]` in `generate` in the journey formatter is called, it often returns a `nil` when we call `to_s` on a nil, it allocates an empty string. We can skip this check when the default value is nil.
    
    This change buys us 35,431 bytes of memory and 887 fewer objects per request.
    
    Thanks to @matthewd for help with the readability
  15. @kaspth

    Merge pull request #21071 from hedgesky/remove_yepnope_mention_from_f…

    kaspth authored
    …orm_helpers_guide
    
    Remove yepnope mention from form helpers guide because it's deprecated
  16. @hedgesky
  17. @schneems

    Cut string allocations in content_tag_string

    schneems authored
    content_tag's first argument is will generate a string with an html tag so `:a` will generate: `<a></a>`. When this happens, the symbol is implicitly `to_s`-d so a new string is allocated. We can get around that by using a frozen string instead which
    
    This change buys us 74,236 bytes of memory and 1,855 fewer objects per request.
  18. @schneems

    Cut string ActionView template allocations

    schneems authored
    The instrument method creates new strings, the most common action to instrument is "!render_template` so we can detect when that action is occurring and use a frozen string instead.
    
    This change buys us 113,714 bytes of memory and 1,790 fewer objects per request.
Something went wrong with that request. Please try again.