active_model_serializers 0.10.0 → 0.10.13

data/active_model_serializers.gemspec

@@ -1,66 +0,0 @@
-# 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'
-  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.0.0'
-
-  rails_versions = '>= 4.0'
-  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_runtime_dependency 'railties', rails_versions
-    # 'activesupport', rails_versions
-    # 'actionpack', rails_versions
-    # 'rake', '>= 0.8.7'
-
-  # 'activesupport', rails_versions
-    # 'i18n,
-    # 'tzinfo'
-    # 'minitest'
-    # 'thread_safe'
-
-  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', '< 1.0']
-  spec.add_development_dependency 'json_schema'
-  spec.add_development_dependency 'rake', ['>= 10.0', '< 12.0']
-
-  spec.post_install_message = <<-EOF
-NOTE: The default key case for the JsonApi adapter has changed to dashed.
-See https://github.com/rails-api/active_model_serializers/blob/master/docs/general/key_transforms.md
-for more information on configuring this behavior.
-EOF
-end

data/appveyor.yml

@@ -1,24 +0,0 @@
-version: '{build}'
-
-skip_tags: true
-
-environment:
-  JRUBY_OPTS: "--dev -J-Xmx1024M --debug"
-  matrix:
-    - ruby_version: "Ruby21"
-    - ruby_version: "Ruby21-x64"
-    - ruby_version: "jruby-9.0.0.0"
-
-cache:
-  - vendor/bundle
-
-install:
-  - SET PATH=C:\%ruby_version%\bin;%PATH%
-  - gem install bundler
-  - bundle env
-  - bundle install --path=vendor/bundle --retry=3 --jobs=3
-
-test_script:
-  - bundle exec rake ci
-
-build: off

data/bin/bench

@@ -1,171 +0,0 @@
-#!/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

@@ -1,316 +0,0 @@
-#!/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

data/bin/serve_benchmark

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-case "$1" in
-
-  start)
-  config="${CONFIG_RU:-test/benchmark/config.ru}"
-  bundle exec ruby -Ilib -S rackup "$config" --daemonize --pid tmp/benchmark_app.pid --warn --server webrick
-  until [ -f 'tmp/benchmark_app.pid' ]; do
-    sleep 0.1 # give it time to start.. I don't know a better way
-  done
-  cat tmp/benchmark_app.pid
-  true
-  ;;
-
-  stop)
-  if [ -f 'tmp/benchmark_app.pid' ]; then
-    kill -TERM $(cat tmp/benchmark_app.pid)
-  else
-    echo 'No pidfile'
-    false
-  fi
-  ;;
-
-  status)
-  if [ -f 'tmp/benchmark_app.pid' ]; then
-    kill -0 $(cat tmp/benchmark_app.pid)
-    [ "$?" -eq 0 ]
-  else
-    echo 'No pidfile'
-    false
-  fi
-  ;;
-
-  *)
-  echo "Usage: $0 [start|stop|status]"
-  ;;
-
-esac