active_model_serializers_custom 0.10.90

data/Rakefile

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'simplecov'
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+end
+import('lib/tasks/rubocop.rake')
+
+Bundler::GemHelper.install_tasks
+
+require 'yard'
+
+namespace :yard do
+  YARD::Rake::YardocTask.new(:doc) do |t|
+    t.stats_options = ['--list-undoc']
+  end
+
+  desc 'start a gem server'
+  task :server do
+    sh 'bundle exec yard server --gems'
+  end
+
+  desc 'use Graphviz to generate dot graph'
+  task :graph do
+    output_file = 'doc/erd.dot'
+    sh "bundle exec yard graph --protected --full --dependencies > #{output_file}"
+    puts 'open doc/erd.dot if you have graphviz installed'
+  end
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.ruby_opts = ['-r./test/test_helper.rb']
+  t.ruby_opts << ' -w' unless ENV['NO_WARN'] == 'true'
+  t.verbose = true
+end
+
+desc 'Run isolated tests'
+task isolated: ['test:isolated']
+namespace :test do
+  task :isolated do
+    desc 'Run isolated tests for Railtie'
+    require 'shellwords'
+    dir = File.dirname(__FILE__)
+    dir = Shellwords.shellescape(dir)
+    isolated_test_files = FileList['test/**/*_test_isolated.rb']
+    # https://github.com/rails/rails/blob/3d590add45/railties/lib/rails/generators/app_base.rb#L345-L363
+    _bundle_command = Gem.bin_path('bundler', 'bundle')
+    require 'bundler'
+    Bundler.with_clean_env do
+      isolated_test_files.all? do |test_file|
+        command = "-w -I#{dir}/lib -I#{dir}/test #{Shellwords.shellescape(test_file)}"
+        full_command = %("#{Gem.ruby}" #{command})
+        system(full_command)
+      end or fail 'Failures' # rubocop:disable Style/AndOr
+    end
+  end
+end
+
+if ENV['RAILS_VERSION'].to_s > '4.0' && RUBY_ENGINE == 'ruby'
+  task default: [:isolated, :test, :rubocop]
+else
+  task default: [:test, :rubocop]
+end
+
+desc 'CI test task'
+task ci: [:default]

data/active_model_serializers.gemspec

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_model/serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active_model_serializers_custom'
+  spec.version       = ActiveModel::Serializer::VERSION
+  spec.platform      = Gem::Platform::RUBY
+  spec.authors       = ['Steve Klabnik']
+  spec.email         = ['steve@steveklabnik.com']
+  spec.summary       = 'Conventions-based JSON generation for Rails.'
+  spec.description   = 'ActiveModel::Serializers allows you to generate your JSON in an object-oriented and convention-driven manner.'
+  spec.homepage      = 'https://github.com/rails-api/active_model_serializers'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.executables   = []
+
+  spec.required_ruby_version = '>= 2.1'
+
+  rails_versions = ['>= 4.1', '< 6']
+  spec.add_runtime_dependency 'activemodel', rails_versions
+  # 'activesupport', rails_versions
+  # 'builder'
+
+  spec.add_runtime_dependency 'actionpack', rails_versions
+  # 'activesupport', rails_versions
+  # 'rack'
+  # 'rack-test', '~> 0.6.2'
+
+  spec.add_development_dependency 'railties', rails_versions
+  # 'activesupport', rails_versions
+  # 'actionpack', rails_versions
+  # 'rake', '>= 0.8.7'
+
+  # 'activesupport', rails_versions
+  # 'i18n,
+  # 'tzinfo'
+  spec.add_development_dependency 'minitest', ['~> 5.0', '< 5.11']
+  # 'thread_safe'
+
+  spec.add_runtime_dependency 'jsonapi-renderer', ['>= 0.1.1.beta1', '< 0.3']
+  spec.add_runtime_dependency 'case_transform', '>= 0.2'
+
+  spec.add_development_dependency 'activerecord', rails_versions
+  # arel
+  # activesupport
+  # activemodel
+
+  # Soft dependency for pagination
+  spec.add_development_dependency 'kaminari', ' ~> 0.16.3'
+  spec.add_development_dependency 'will_paginate', '~> 3.0', '>= 3.0.7'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'simplecov', '~> 0.11'
+  spec.add_development_dependency 'timecop', '~> 0.7'
+  spec.add_development_dependency 'grape', ['>= 0.13', '< 0.19.1']
+  spec.add_development_dependency 'json_schema'
+  spec.add_development_dependency 'rake', ['>= 10.0', '< 12.0']
+end

data/appveyor.yml

@@ -0,0 +1,28 @@
+version: 1.0.{build}-{branch}
+
+skip_tags: true
+
+environment:
+  JRUBY_OPTS: "--dev -J-Xmx1024M --debug"
+  matrix:
+    - ruby_version: "Ruby23"
+    - ruby_version: "Ruby23-x64"
+
+cache:
+  - vendor/bundle
+
+install:
+  - SET PATH=C:\%ruby_version%\bin;%PATH%
+  - bundle env
+  - bundle check || bundle install --path=vendor/bundle --retry=3 --jobs=3
+  - bundle clean --force
+
+before_test:
+  - ruby -v
+  - gem -v
+  - bundle -v
+
+test_script:
+  - bundle exec rake ci
+
+build: off

data/bin/bench

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+# ActiveModelSerializers Benchmark driver
+# Adapted from
+# https://github.com/ruby-bench/ruby-bench-suite/blob/8ad567f7e43a044ae48c36833218423bb1e2bd9d/rails/benchmarks/driver.rb
+require 'bundler'
+Bundler.setup
+require 'json'
+require 'pathname'
+require 'optparse'
+require 'digest'
+require 'pathname'
+require 'shellwords'
+require 'logger'
+require 'English'
+
+class BenchmarkDriver
+  ROOT = Pathname File.expand_path(File.join('..', '..'), __FILE__)
+  BASE = ENV.fetch('BASE') { ROOT.join('test', 'benchmark') }
+  ESCAPED_BASE = Shellwords.shellescape(BASE)
+
+  def self.benchmark(options)
+    new(options).run
+  end
+
+  def self.parse_argv_and_run(argv = ARGV, options = {})
+    options = {
+      repeat_count: 1,
+      pattern: [],
+      env: 'CACHE_ON=on'
+    }.merge!(options)
+
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: bin/bench [options]'
+
+      opts.on('-r', '--repeat-count [NUM]', 'Run benchmarks [NUM] times taking the best result') do |value|
+        options[:repeat_count] = value.to_i
+      end
+
+      opts.on('-p', '--pattern <PATTERN1,PATTERN2,PATTERN3>', 'Benchmark name pattern') do |value|
+        options[:pattern] = value.split(',')
+      end
+
+      opts.on('-e', '--env <var1=val1,var2=val2,var3=vale>', 'ENV variables to pass in') do |value|
+        options[:env] = value.split(',')
+      end
+    end.parse!(argv)
+
+    benchmark(options)
+  end
+
+  attr_reader :commit_hash, :base
+
+  # Based on logfmt:
+  # https://www.brandur.org/logfmt
+  # For more complete implementation see:
+  # see https://github.com/arachnid-cb/logfmtr/blob/master/lib/logfmtr/base.rb
+  # For usage see:
+  # https://blog.codeship.com/logfmt-a-log-format-thats-easy-to-read-and-write/
+  # https://engineering.heroku.com/blogs/2014-09-05-hutils-explore-your-structured-data-logs/
+  # For Ruby parser see:
+  # https://github.com/cyberdelia/logfmt-ruby
+  def self.summary_logger(device = 'output.txt')
+    require 'time'
+    logger = Logger.new(device)
+    logger.level = Logger::INFO
+    logger.formatter = proc { |severity, datetime, progname, msg|
+      msg = "'#{msg}'"
+      "level=#{severity} time=#{datetime.utc.iso8601(6)} pid=#{Process.pid} progname=#{progname} msg=#{msg}#{$INPUT_RECORD_SEPARATOR}"
+    }
+    logger
+  end
+
+  def self.stdout_logger
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    logger.formatter = proc { |_, _, _, msg| "#{msg}#{$INPUT_RECORD_SEPARATOR}" }
+    logger
+  end
+
+  def initialize(options)
+    @writer       = ENV['SUMMARIZE'] ? self.class.summary_logger : self.class.stdout_logger
+    @repeat_count = options[:repeat_count]
+    @pattern      = options[:pattern]
+    @commit_hash  = options.fetch(:commit_hash) { `git rev-parse --short HEAD`.chomp }
+    @base         = options.fetch(:base) { ESCAPED_BASE }
+    @env          = Array(options[:env]).join(' ')
+    @rubyopt = options[:rubyopt] # TODO: rename
+  end
+
+  def run
+    files.each do |path|
+      next if !@pattern.empty? && /#{@pattern.join('|')}/ !~ File.basename(path)
+      run_single(Shellwords.shellescape(path))
+    end
+  end
+
+  private
+
+  def files
+    Dir[File.join(base, 'bm_*')]
+  end
+
+  def run_single(path)
+    script = "RAILS_ENV=production #{@env} ruby #{@rubyopt} #{path}"
+    environment = `ruby -v`.chomp.strip[/\d+\.\d+\.\d+\w+/]
+
+    runs_output = measure(script)
+    if runs_output.empty?
+      results = { error: :no_results }
+      return
+    end
+
+    results = {}
+    results['commit_hash'] = commit_hash
+    results['version'] = runs_output.first['version']
+    results['rails_version'] = runs_output.first['rails_version']
+    results['benchmark_run[environment]'] = environment
+    results['runs'] = []
+
+    runs_output.each do |output|
+      results['runs'] << {
+        'benchmark_type[category]' => output['label'],
+        'benchmark_run[result][iterations_per_second]' => output['iterations_per_second'].round(3),
+        'benchmark_run[result][total_allocated_objects_per_iteration]' => output['total_allocated_objects_per_iteration']
+      }
+    end
+  ensure
+    results && report(results)
+  end
+
+  def report(results)
+    @writer.info { 'Benchmark results:' }
+    @writer.info { JSON.pretty_generate(results) }
+  end
+
+  def summarize(result)
+    puts "#{result['label']} #{result['iterations_per_second']}/ips; #{result['total_allocated_objects_per_iteration']} objects"
+  end
+
+  # FIXME: ` provides the full output but it'll return failed output as well.
+  def measure(script)
+    results = Hash.new { |h, k| h[k] = [] }
+
+    @repeat_count.times do
+      output = sh(script)
+      output.each_line do |line|
+        next if line.nil?
+        begin
+          result = JSON.parse(line)
+        rescue JSON::ParserError
+          result = { error: line } # rubocop:disable Lint/UselessAssignment
+        else
+          summarize(result)
+          results[result['label']] << result
+        end
+      end
+    end
+
+    results.map do |_, bm_runs|
+      bm_runs.sort_by do |run|
+        run['iterations_per_second']
+      end.last
+    end
+  end
+
+  def sh(cmd)
+    `#{cmd}`
+  end
+end
+
+BenchmarkDriver.parse_argv_and_run if $PROGRAM_NAME == __FILE__

data/bin/bench_regression

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'pathname'
+require 'shellwords'
+require 'English'
+
+############################
+# USAGE
+#
+# bundle exec bin/bench_regression <ref1> <ref2>
+#   <ref1> defaults to the current branch
+#   <ref2> defaults to the master branch
+# bundle exec bin/bench_regression current                    # will run on the current branch
+# bundle exec bin/bench_regression revisions 792fb8a90 master # every revision inclusive
+# bundle exec bin/bench_regression           792fb8a90 master --repeat-count 2 --env CACHE_ON=off
+# bundle exec bin/bench_regression vendor
+###########################
+
+class BenchRegression
+  ROOT = Pathname File.expand_path(File.join(*['..', '..']), __FILE__)
+  TMP_DIR_NAME = File.join('tmp', 'bench')
+  TMP_DIR = File.join(ROOT, TMP_DIR_NAME)
+  E_TMP_DIR = Shellwords.shellescape(TMP_DIR)
+  load ROOT.join('bin', 'bench')
+
+  attr_reader :source_stasher
+
+  def initialize
+    @source_stasher = SourceStasher.new
+  end
+
+  class SourceStasher
+    attr_reader :gem_require_paths, :gem_paths
+    attr_writer :vendor
+
+    def initialize
+      @gem_require_paths = []
+      @gem_paths = []
+      refresh_temp_dir
+      @vendor = false
+    end
+
+    def temp_dir_empty?
+      File.directory?(TMP_DIR) &&
+        Dir[File.join(TMP_DIR, '*')].none?
+    end
+
+    def empty_temp_dir
+      return if @vendor
+      return if temp_dir_empty?
+      FileUtils.mkdir_p(TMP_DIR)
+      Dir[File.join(TMP_DIR, '*')].each do |file|
+        if File.directory?(file)
+          FileUtils.rm_rf(file)
+        else
+          FileUtils.rm(file)
+        end
+      end
+    end
+
+    def fill_temp_dir
+      vendor_files(Dir[File.join(ROOT, 'test', 'benchmark', '*.{rb,ru}')])
+      # vendor_file(File.join('bin', 'bench'))
+      housekeeping { empty_temp_dir }
+      vendor_gem('benchmark-ips')
+    end
+
+    def vendor_files(files)
+      files.each do |file|
+        vendor_file(file)
+      end
+    end
+
+    def vendor_file(file)
+      FileUtils.cp(file, File.join(TMP_DIR, File.basename(file)))
+    end
+
+    def vendor_gem(gem_name)
+      directory_name = `bundle exec gem unpack benchmark-ips --target=#{E_TMP_DIR}`[/benchmark-ips.+\d/]
+      gem_paths << File.join(TMP_DIR, directory_name)
+      gem_require_paths << File.join(TMP_DIR_NAME, directory_name, 'lib')
+      housekeeping { remove_vendored_gems }
+    end
+
+    def remove_vendored_gems
+      return if @vendor
+      FileUtils.rm_rf(*gem_paths)
+    end
+
+    def refresh_temp_dir
+      empty_temp_dir
+      fill_temp_dir
+    end
+
+    def housekeeping
+      at_exit { yield }
+    end
+  end
+
+  module RevisionMethods
+    module_function
+    def current_branch
+      @current_branch ||= `cat .git/HEAD | cut -d/ -f3,4,5`.chomp
+    end
+
+    def current_revision
+      `git rev-parse --short HEAD`.chomp
+    end
+
+    def revision_description(rev)
+      `git log --oneline -1 #{rev}`.chomp
+    end
+
+    def revisions(start_ref, end_ref)
+      cmd = "git rev-list --reverse #{start_ref}..#{end_ref}"
+      `#{cmd}`.chomp.split("\n")
+    end
+
+    def checkout_ref(ref)
+      `git checkout #{ref}`.chomp
+      if $CHILD_STATUS
+        STDERR.puts "Checkout failed: #{ref}, #{$CHILD_STATUS.exitstatus}" unless $CHILD_STATUS.success?
+        $CHILD_STATUS.success?
+      else
+        true
+      end
+    end
+
+    def clean_head
+      system('git reset --hard --quiet')
+    end
+  end
+  module ShellMethods
+
+    def sh(cmd)
+      puts cmd
+      # system(cmd)
+      run(cmd)
+      # env = {}
+      # # out = STDOUT
+      # pid = spawn(env, cmd)
+      # Process.wait(pid)
+      # pid = fork do
+      #   exec cmd
+      # end
+      # Process.waitpid2(pid)
+      # puts $CHILD_STATUS.exitstatus
+    end
+
+    require 'pty'
+    # should consider trapping SIGINT in here
+    def run(cmd)
+      puts cmd
+      child_process = ''
+      result = ''
+      # http://stackoverflow.com/a/1162850
+      # stream output of subprocess
+      begin
+        PTY.spawn(cmd) do |stdin, _stdout, pid|
+          begin
+            # Do stuff with the output here. Just printing to show it works
+            stdin.each do |line|
+              print line
+              result << line
+            end
+            child_process = PTY.check(pid)
+          rescue Errno::EIO
+            puts 'Errno:EIO error, but this probably just means ' \
+                  'that the process has finished giving output'
+          end
+        end
+      rescue PTY::ChildExited
+        puts 'The child process exited!'
+      end
+      unless (child_process && child_process.success?)
+        exitstatus = child_process.exitstatus
+        puts "FAILED: #{child_process.pid} exited with status #{exitstatus.inspect} due to failed command #{cmd}"
+        exit exitstatus || 1
+      end
+      result
+    end
+
+    def bundle(ref)
+      system("rm -f Gemfile.lock")
+      # This is absolutely critical for bundling to work
+      Bundler.with_clean_env do
+        system("bundle check ||
+          bundle install --local ||
+          bundle install ||
+          bundle update")
+      end
+
+      # if $CHILD_STATUS
+      #   STDERR.puts "Bundle failed at: #{ref}, #{$CHILD_STATUS.exitstatus}" unless $CHILD_STATUS.success?
+      #   $CHILD_STATUS.success?
+      # else
+      #   false
+      # end
+    end
+  end
+  include ShellMethods
+  include RevisionMethods
+
+  def benchmark_refs(ref1: nil, ref2: nil, cmd:)
+    checking_out = false
+    ref0 = current_branch
+    ref1 ||= current_branch
+    ref2 ||= 'master'
+    p [ref0, ref1, ref2, current_revision]
+
+    run_benchmark_at_ref(cmd, ref1)
+    p [ref0, ref1, ref2, current_revision]
+    run_benchmark_at_ref(cmd, ref2)
+    p [ref0, ref1, ref2, current_revision]
+
+    checking_out = true
+    checkout_ref(ref0)
+  rescue Exception # rubocop:disable Lint/RescueException
+    STDERR.puts "[ERROR] #{$!.message}"
+    checkout_ref(ref0) unless checking_out
+    raise
+  end
+
+  def benchmark_revisions(ref1: nil, ref2: nil, cmd:)
+    checking_out = false
+    ref0 = current_branch
+    ref1 ||= current_branch
+    ref2 ||= 'master'
+
+    revisions(ref1, ref2).each do |rev|
+      STDERR.puts "Checking out: #{revision_description(rev)}"
+
+      run_benchmark_at_ref(cmd, rev)
+      clean_head
+    end
+    checking_out = true
+    checkout_ref(ref0)
+  rescue Exception # rubocop:disable Lint/RescueException
+    STDERR.puts "[ERROR]: #{$!.message}"
+    checkout_ref(ref0) unless checking_out
+    raise
+  end
+
+  def run_benchmark_at_ref(cmd, ref)
+    checkout_ref(ref)
+    run_benchmark(cmd, ref)
+  end
+
+  def run_benchmark(cmd, ref = nil)
+    ref ||= current_revision
+    bundle(ref) &&
+      benchmark_tests(cmd, ref)
+  end
+
+  def benchmark_tests(cmd, ref)
+    base = E_TMP_DIR
+    # cmd.sub('bin/bench', 'tmp/revision_runner/bench')
+    # bundle = Gem.bin('bunle'
+    # Bundler.with_clean_env(&block)
+
+    # cmd = Shellwords.shelljoin(cmd)
+    # cmd = "COMMIT_HASH=#{ref} BASE=#{base} bundle exec ruby  -rbenchmark/ips #{cmd}"
+    # Add vendoring benchmark/ips to load path
+
+    # CURRENT THINKING: IMPORTANT
+    # Pass into require statement as RUBYOPTS i.e. via env rather than command line argument
+    # otherwise, have a 'fast ams benchmarking' module that extends benchmarkings to add the 'ams'
+    # method but doesn't depend on benchmark-ips
+    options = {
+      commit_hash: ref,
+      base: base,
+      rubyopt: Shellwords.shellescape("-Ilib:#{source_stasher.gem_require_paths.join(':')}")
+    }
+    BenchmarkDriver.parse_argv_and_run(ARGV.dup, options)
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  benchmarking = BenchRegression.new
+
+  case ARGV[0]
+  when 'current'
+    # Run current branch only
+
+    # super simple command line parsing
+    args = ARGV.dup
+    _    = args.shift # remove 'current' from args
+    cmd  = args
+    benchmarking.run_benchmark(cmd)
+  when 'revisions'
+    # Runs on every revision
+
+    # super simple command line parsing
+    args = ARGV.dup
+    _         = args.shift
+    ref1      = args.shift # remove 'revisions' from args
+    ref2      = args.shift
+    cmd       = args
+    benchmarking.benchmark_revisions(ref1: ref1, ref2: ref2, cmd: cmd)
+  when 'vendor'
+    # Just prevents vendored files from being cleaned up
+    # at exit. (They are vendored at initialize.)
+    benchmarking.source_stasher.vendor = true
+  else
+    # Default: Compare current_branch to master
+    # Optionally: pass in two refs as args to `bin/bench_regression`
+    # TODO: Consider checking across more revisions, to automatically find problems.
+
+    # super simple command line parsing
+    args = ARGV.dup
+    ref1      = args.shift
+    ref2      = args.shift
+    cmd       = args
+    benchmarking.benchmark_refs(ref1: ref1, ref2: ref2, cmd: cmd)
+  end
+end