Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: master
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.
  19. @schneems

    Optimize hash key

    schneems authored
    No idea why on earth this hash key isn't already optimized by MRI, but it isn't. :shit:
    
    This change buys us 74,077 bytes of memory and 1,852 fewer objects per request.
  20. @schneems

    Decrease string allocation in content_tag_string

    schneems authored
    When an unknonwn key is passed to the hash in `PRE_CONTENT_STRINGS` it returns nil, when you call "#{nil}" it allocates a new empty string. We can get around this allocation by using a default value `Hash.new { "".freeze }`. We can avoid the `to_sym` call by pre-populating the hash with a symbol key in addition to a string key.
    
    We can freeze some strings when using Array#* to reduce allocations.
    
    Array#join can take frozen strings.
    
    This change buys us 86,600 bytes of memory and 1,857 fewer objects per request.
  21. @schneems

    Reduce hash allocations in route_set

    schneems authored
    When generating a url with `url_for` the hash of arguments passed in, is dup-d and merged a TON. I wish I could clean this up better, and might be able to do it in the future. This change removes one dup, since it's literally right after we just dup-d the hash to pass into this constructor.
    
    This may be a breaking, change but the tests pass...so :shipit: we can revert if it causes problems
    
    This change buys us 205,933 bytes of memory and 887 fewer objects per request.
  22. @schneems

    Decrease route_set allocations

    schneems authored
    In handle_positional_args `Array#-=` is used which allocates a new array. Instead we can iterate through and delete elements, modifying the array in place.
    
    Also `Array#take` allocates a new array. We can build the same by iterating over the other element.
    
    This change buys us 106,470 bytes of memory and 2,663 fewer objects per request.
  23. @schneems

    Speed up journey missing_keys

    schneems authored
    Most routes have a `route.path.requirements[key]` of `/[-_.a-zA-Z0-9]+\/[-_.a-zA-Z0-9]+/` yet every time this method is called a new regex is generated on the fly with `/\A#{DEFAULT_INPUT}\Z/`. OBJECT ALLOCATIONS BLERG!
    
    This change uses a special module that implements `===` so it can be used in a case statement to pull out the default input. When this happens, we use a pre-generated regex.
    
    This change buys us 1,643,465 bytes of memory and 7,990 fewer objects per request.
  24. @schneems

    Speed up journey extract_parameterized_parts

    schneems authored
    Micro optimization: `reverse.drop_while` is slower than `reverse_each.drop_while`. This doesn't save any object allocations.
    
    Second, `keys_to_keep` is typically a very small array. The operation `parameterized_parts.keys - keys_to_keep` actually allocates two arrays. It is quicker (I benchmarked) to iterate over each and check inclusion in array manually.
    
    This change buys us 1774 fewer objects per request
  25. @schneems

    Decrease string allocations in url_options

    schneems authored
    The request.script_name is dup-d which allocates an extra string. It is most commonly an empty string "". We can save a ton of string allocations by checking first if the string is empty, if so we can use a frozen empty string instead of duplicating an empty string.
    
    This change buys us 35,714 bytes of memory and 893 fewer objects per request.
  26. @schneems

    Decrease string allocations in apply_inflections

    schneems authored
    In `apply_inflections` a string is down cased and some whitespace stripped in the front (which allocate strings). This would normally be fine, however `uncountables` is a fairly small array (10 elements out of the box) and this method gets called a TON. Instead we can keep an array of valid regexes for each uncountable so we don't have to allocate new strings.
    
    This change buys us 325,106 bytes of memory and 3,251 fewer objects per request.
  27. @schneems

    Decrease string allocations on AR#respond_to?

    schneems authored
    When a symbol is passed in, we call `to_s` on it which allocates a string. The two hardcoded symbols that are used internally are `:to_partial_path` and `:to_model`.
    
    This change buys us 71,136 bytes of memory and 1,777 fewer objects per request.
  28. @schneems

    Merge pull request #21065 from rails/schneems/fix-assets_test

    schneems authored
    Fix tests on master
Something went wrong with that request. Please try again.