cutting_edge 0.0.1

data/lib/cutting_edge/versions.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+
+module VersionRequirementComparator
+
+  # Operators that require the checked version to be higher than the required version
+  HIGHER_THAN = ['>', '>=']
+
+  def version_requirement_diff(requirement, latest_version)
+    segments = latest_version.canonical_segments
+
+    # Since we know `latest_version` is higher than the requirement, we can and must ignore cases where the constraint fails because `check_version` is lower
+    # Such cases would be caused by the fact that we are generating `check_version` below by chopping off the version decimals after `position`
+    # For example: `latest_version` is 3.5. On the first pass of this loop, we will thus be checking version 3.0.
+    # This would fail a ~> 3.2 requirement on the first pass, falsely yielding an `:outdated_major`.
+    # Therefore, filter out the HIGHER_THAN operators
+    constraints = requirement.requirements.map do |comparator, version|
+      if comparator == '~>'
+        Gem::Requirement.new("< #{version.bump.to_s}") # Use only the upper bound requirement of a ~> comparison
+      elsif !HIGHER_THAN.include?(comparator)
+        Gem::Requirement.new("#{comparator} #{version.to_s}")
+      end
+    end
+    constraints.compact!
+
+    segments.each_with_index do |_v, position|
+      check_version = Gem::Version.new(segments[0..position].join('.'))
+      constraints.each do |constraint|
+        unless constraint.satisfied_by?(check_version)
+          return version_difference_type(position)
+        end
+      end
+    end
+    return :unknown # This can occur if latest_version is actually lower than the requirement (e.g., when a newer version of a gem has been yanked)
+  end
+
+  def version_difference_type(position)
+    case position
+    when 0
+      :outdated_major
+    when 1
+      :outdated_minor
+    else
+      :outdated_patch
+    end
+  end
+end

data/lib/cutting_edge/workers/badge.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../badge.rb', __FILE__)
+require File.expand_path('../helpers.rb', __FILE__)
+
+class BadgeWorker < GenericWorker
+
+  def perform(identifier)
+    log_info 'Running Worker!'
+    dependencies = get_from_store(identifier)
+    if dependencies
+      status = generate_status(dependencies[:outdated])
+      add_to_store("svg-#{identifier}", Badge.build_badge(status, dependencies[:outdated_total]))
+    end
+    GC.start
+  end
+
+  private
+
+  def generate_status(status)
+    # status is more specific than Badge.build_badge currently expects, so make it a bit less so
+    status == :up_to_date ? status : :out_of_date
+  end
+end

data/lib/cutting_edge/workers/dependency.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'http'
+require 'moneta'
+require File.expand_path('../../versions.rb', __FILE__)
+require File.expand_path('../../langs.rb', __FILE__)
+require File.expand_path('../helpers.rb', __FILE__)
+
+class DependencyWorker < GenericWorker
+  include VersionRequirementComparator
+
+  # Order is significant for purposes of calculating results[:outdated]
+  STATUS_TYPES = [:outdated_major, :outdated_minor, :outdated_patch, :ok, :no_requirement, :unknown]
+  OUTDATED_TYPES = STATUS_TYPES[0..-3]
+
+  def perform(identifier, lang, locations, dependency_types)
+    log_info 'Running Worker!'
+    dependencies = {}
+    locations.each do |name, url|
+      contents = http_get(url)
+      dependencies[name] = get_results(get_lang(lang).parse_file(name, contents), dependency_types)
+    end
+    dependencies.merge!(generate_stats(dependencies))
+    add_to_store(identifier, dependencies)
+    GC.start
+  end
+
+  private
+
+  def get_results(dependencies, dependency_types)
+    results = {}
+    STATUS_TYPES.each {|type| results[type] = []}
+    if dependencies
+      dependencies.select! {|dep| dependency_types.include?(dep.first.type)}
+      dependencies.each do |dep, latest_version|
+        dependency_hash = dependency(dep.name, dep.requirement.to_s, latest_version.to_s, dep.type)
+        if dependency_hash[:required] == 'unknown'
+          results[:no_requirement] << dependency_hash
+        elsif latest_version.nil?
+          results[:unknown] << dependency_hash
+        elsif is_outdated?(dep, latest_version)
+          outdated = version_requirement_diff(dep.requirement, latest_version.respond_to?(:last) ? latest_version.last : latest_version)
+          results[outdated] << dependency_hash
+        else
+          results[:ok] << dependency_hash
+        end 
+      end
+    end
+    results
+  end
+
+  def generate_stats(locations)
+    results = {}
+    STATUS_TYPES.each do |type|
+      num = stats(type, locations)
+      results[type] = num
+      if OUTDATED_TYPES.include?(type)
+        results[:outdated_total] = results[:outdated_total].to_i + num
+        results[:outdated] = type unless results[:outdated] || num == 0
+      end
+    end
+    results[:outdated] = :unknown if results[:outdated_total] == 0 && results[:ok] == 0
+    results[:outdated] = :up_to_date unless results[:outdated]
+    results
+  end
+
+  def stats(stat, locations)
+    sum = 0
+    locations.each do |name, dependencies|
+      sum = sum + dependencies[stat].length
+    end
+    sum
+  end
+
+  def dependency(name, requirement, latest, type)
+    {
+      :name => name,
+      :required => requirement,
+      :latest => latest,
+      :type => type
+    }
+  end
+
+  def get_lang(lang)
+    Object.const_get("#{lang.capitalize}Lang")
+  end
+
+  def http_get(url)
+    begin
+      response = HTTP.get(url)
+      response.status == 200 ? response.to_s : nil
+    rescue HTTP::TimeoutError => e
+      log_info("Encountered error when fetching latest version of #{name}: #{e.class} #{e.message}")
+    end
+  end
+
+  def is_outdated?(dependency, latest_version)
+    !dependency.requirement.satisfied_by?(latest_version)
+  end
+
+end

data/lib/cutting_edge/workers/helpers.rb

@@ -0,0 +1,24 @@
+require 'sinatra/logger'
+require 'sucker_punch'
+
+module WorkerHelpers
+
+  def log_info(message)
+    logger.info(message) if ::CuttingEdge::App.enable_logging
+  end
+
+  def add_to_store(identifier, dependencies)
+    ::CuttingEdge::App.store[identifier] = dependencies
+  end
+
+  def get_from_store(identifier)
+    ::CuttingEdge::App.store[identifier]
+  end
+
+end
+
+class GenericWorker
+  include ::SuckerPunch::Job
+  include ::WorkerHelpers
+  include ::SemanticLogger::Loggable
+end

data/spec/langs/python_spec.rb

@@ -0,0 +1,89 @@
+REQUIREMENT_TXT = <<EOF
+requests>=2.0
+oauthlib
+requests-oauthlib>=1.0.0 [PDF]
+-e svn+http://myrepo/svn/MyApp#egg=MyApp
+Flask>=0.7
+urlobject==1.0
+six
+EOF
+
+# See https://www.python.org/dev/peps/pep-0440/#version-exclusion
+# And https://github.com/pypa/pipfile
+PIPFILE = <<EOF
+[[source]]
+url = 'https://pypi.python.org/simple'
+verify_ssl = true
+name = 'pypi'
+
+[requires]
+python_version = '2.7'
+
+[packages]
+requests = { extras = ['socks'] }
+records = '>0.5.0'
+foo = '!= 0.5.*'
+bar = '~=0.2'
+baz = '=0.3.*'
+django = { git = 'https://github.com/django/django.git', ref = '1.11.4', editable = true }
+"e682b37" = {file = "https://github.com/divio/django-cms/archive/release/3.4.x.zip"}
+"e1839a8" = {path = ".", editable = true}
+pywinusb = { version = "*", os_name = "=='nt'", index="pypi"}
+
+[dev-packages]
+nose = '*'
+unittest2 = {version = ">=1.0,<3.0", markers="python_version < '2.7.9' or (python_version >= '3.0' and python_version < '3.4')"}
+EOF
+
+describe PythonLang do
+  context 'requirements.txt' do
+    it 'expects the default dependency files to be requirements.txt and Pipfile' do
+      expect(PythonLang.locations).to eq ['requirements.txt', 'Pipfile']
+    end
+
+    it 'parses requirements.txt' do
+      result = PythonLang.parse_file('requirements.txt', REQUIREMENT_TXT)
+      expect(result).to be_a Array
+      expect(result.length).to eq 6
+      result.each do |dep, version|
+        expect(dep).to be_a Gem::Dependency
+        expect(dep.type).to eq :runtime
+        expect(version.version).to match /\d\.\d.*/
+      end
+    end
+  end
+
+  context 'pipfile' do
+    it 'fails softly on invalid Pipfile' do
+      expect(PythonLang.parse_file('Pipfile', 'waa')).to eq []
+    end
+
+    it 'parses Pipefile' do
+      result = PythonLang.parse_file('Pipfile', PIPFILE)
+      expect(result).to be_a Array
+
+      dev = result.select {|r| r.first.type == :development}
+      run = result.select {|r| r.first.type == :runtime}
+      expect(dev.length).to eq 2
+      expect(run.length).to eq 9
+
+      expect(run.first.first).to be_a OpenStruct
+      expect(run.first.first.requirement).to eq 'unknown'
+      expect(run.first.last).to be_nil
+      expect(dev.first.first.requirement.to_s).to eq '>= 0'
+      expect(dev.first.last.version).to match /\d\.\d.*/
+
+      foo = result.find {|r| r.first.name == 'foo'}
+      bar = result.find {|r| r.first.name == 'bar'}
+      baz = result.find {|r| r.first.name == 'baz'}
+
+      foo_req = foo.first.requirement.to_s.split(',')
+      foo_req.map! {|r| r.strip}
+      expect(foo_req).to include('< 0.5.0')
+      expect(foo_req).to include('>= 0.6')
+
+      expect(bar.first.requirement.to_s).to eq '~> 0.2'
+      expect(baz.first.requirement.to_s).to eq '~> 0.3.0'
+    end
+  end
+end

data/spec/langs/rust_spec.rb

@@ -0,0 +1,81 @@
+CARGO = <<EOF
+[dependencies]
+log = { version = "0.4.*", features = ["std"] }
+regex = { version = "1.0.3", optional = true }
+termcolor = { version = "^1.0.2", optional = true }
+humantime = { version = "~1.3", optional = true }
+atty = { version = "0.2.5", optional = true }
+my-library = { git = 'https://example.com/git/my-library' }
+uuid = "1.0"
+
+[dev-dependencies]
+tempdir = "0.3"
+
+[build-dependencies]
+cc = "1.0.3"
+EOF
+
+def translate_req(str)
+  RustLang.send(:translate_requirement, str)
+end
+
+describe RustLang do
+  it 'expects the default dependency files to be Cargo.toml' do
+    expect(RustLang.locations).to eq ['Cargo.toml']
+  end
+
+  it 'parses Cargo.toml' do
+    results = RustLang.parse_file('Cargo.toml', CARGO)
+    expect(results.length).to eq 9
+
+    dev = results.select {|r| r.first.type == :development}
+    run = results.select {|r| r.first.type == :runtime}
+    build = results.select {|r| r.first.type == :build}
+
+    expect(dev.length).to eq 1
+    expect(run.length).to eq 7
+    expect(build.length).to eq 1
+
+    expect(run[5].first).to be_a OpenStruct
+    expect(run[5].first.requirement).to eq 'unknown'
+    expect(run[5].last).to be_nil
+    expect(dev.first.first.requirement.to_s).to match />= 0\.3/
+    expect(dev.first.first.requirement.to_s).to match /< 0\.4/
+    expect(dev.first.last.version).to match /\d\.\d.*/
+  end
+
+  context 'translates Rust version requirements to Gem:: compatible requirements' do
+    # See https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+    it 'for the caret operator' do
+      # ^1.2.3  :=  >=1.2.3, <2.0.0
+      # ^1.2    :=  >=1.2.0, <2.0.0
+      # ^1      :=  >=1.0.0, <2.0.0
+      # ^0.2.3  :=  >=0.2.3, <0.3.0
+      # ^0.2    :=  >=0.2.0, <0.3.0
+      # ^0.0.3  :=  >=0.0.3, <0.0.4
+      # ^0.0    :=  >=0.0.0, <0.1.0
+      # ^0      :=  >=0.0.0, <1.0.0
+      expect(translate_req('^1.2.3')).to eq ['>= 1.2.3', '< 2']
+      expect(translate_req('^1.2')).to eq ['>= 1.2', '< 2']
+      expect(translate_req('^1')).to eq ['>= 1', '< 2']
+      expect(translate_req('^0.2.3')).to eq ['>= 0.2.3', '< 0.3']
+      expect(translate_req('^0.2')).to eq ['>= 0.2', '< 0.3']
+      expect(translate_req('^0.0.3')).to eq ['>= 0.0.3', '< 0.0.4']
+      expect(translate_req('^0.0')).to eq ['>= 0.0', '< 0.1']
+      expect(translate_req('^0')).to eq ['>= 0', '< 1']
+    end
+
+    it 'for the ~ operator' do
+      expect(translate_req('~1.2.3')). to eq '~>1.2.3'
+    end
+
+    it 'for the * operator' do
+      # *     := >=0.0.0         := >= 0
+      # 1.*   := >=1.0.0, <2.0.0 := ~> 1.0
+      # 1.2.* := >=1.2.0, <1.3.0 := ~> 1.2.0
+      expect(translate_req('*')).to eq '>= 0'
+      expect(translate_req('1.*')).to eq '~> 1.0'
+      expect(translate_req('1.2.*')).to eq '~> 1.2.0'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,111 @@
+require 'simplecov'
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+require File.expand_path('../../lib/cutting_edge/app.rb', __FILE__)
+CuttingEdge::App.set(:enable_logging, false)
+::SemanticLogger.add_appender(io: STDOUT)
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end