ruby_diff 0.1

data/.gitignore

@@ -0,0 +1,6 @@
+# Ignore gedit backup files
+*~
+# Ignore rubygems pkg dir
+/pkg
+# Ignore MacOSX .DS_Store
+.DS_Store

data/History.txt

@@ -0,0 +1,2 @@
+=== 0.0.1 / 2008-06-03
+ Initial verison of RubyDiff

data/Manifest.txt

@@ -0,0 +1,19 @@
+.gitignore
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/ruby_diff
+lib/ruby_diff.rb
+lib/ruby_diff/code_comparison.rb
+lib/ruby_diff/file_feeder.rb
+lib/ruby_diff/git_feeder.rb
+lib/ruby_diff/patterns.rb
+lib/ruby_diff/structure_processor.rb
+ruby_diff.gemspec
+test/file_feeder_test.rb
+test/git_feeder_test.rb
+test/git_sample/README
+test/git_sample/book.rb
+test/git_sample/lib/chapter.rb
+test/structure_processor_test.rb

data/README.txt

@@ -0,0 +1,37 @@
+= RubyDiff
+
+RubyDiff does higher level comparisons of ruby code.
+
+When looking at large sets of changes between versions of files, it is 
+important to get an idea of what classes, modules, and methods change.
+RubyDiff aims to reveal substantive changes to code, and let you ignore
+trivial changes like whitespace being added to a document.
+
+Code and Releases:
+  http://rubyforge.org/projects/rubydiff
+  
+Browse or Branch:
+  http://github.com/adamsanderson/ruby_diff/tree/master
+
+RDoc for internals (a bit sparse at the moment)
+  http://rubydiff.rubyforge.org/
+
+== Requirements
+RubyDiff depends on ParseTree, the easiest way to get it is via ruby gems:
+  gem install ParseTree
+  
+== Caveats
+This is just the beginnings of an experiment, so all that is captured are
+changes to instance methods.  The API is likely to change drastically.
+
+== Usage
+This is likely to change a bunch, but for the moment:
+  ruby_diff old_file new_file
+Or for git repositories, etc.
+  ruby_diff --git HEAD --file ./
+
+See help for more information.
+
+== Contact
+Feel free to get in touch with me:
+  netghost@gmail.com

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'hoe'
+require './lib/ruby_diff.rb'
+
+task :default => "git:changed"
+task :release => "git:push"
+
+HOE = Hoe.new('ruby_diff', RubyDiff::VERSION) do |p|
+  p.rubyforge_name = 'rubydiff'
+  p.developer('Adam Sanderson', 'netghost@gmail.com')
+  p.remote_rdoc_dir = '' # Release to root
+  p.test_globs = ['test/*_test.rb']
+  p.summary = "a higher level diff application for analyzing changes to ruby code"
+  p.extra_deps << ['ParseTree', '>= 2.0.2']
+end
+SPEC = HOE.spec
+
+
+# Add some more dependencies to packaging:
+task :package => ['git:update_manifest','git:update_manifest']
+
+desc "Shows what has changed since the last commit"
+namespace :git do
+  task :changed do |t|
+    _divider
+    puts "Changes since last commit:"
+    puts `./bin/ruby_diff --git HEAD --file ./`
+    _divider
+  end
+   
+  desc "Updates the manifest to match the git repository"
+  task :update_manifest do |t|
+    `git-ls-files > Manifest.txt`
+  end
+  
+  desc "Pushes git repository out"
+  task :push do |t|
+    ['origin', 'rubyforge'].each do |source|
+      puts "Pushing to #{source}..."
+      puts `git push #{source}`
+    end
+  end
+  
+end
+
+desc "Exports the gemspec for this project"
+task :gemspec do |t|
+  open("ruby_diff.gemspec",'w'){|io| io << SPEC.to_ruby}
+end
+
+namespace :github do
+  desc "Simulates loading the Gem on GitHub"
+  task :simulate_gem => :gemspec do |t|
+    require 'rubygems/specification'
+    data = File.read('ruby_diff.gemspec')
+    spec = nil
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    puts spec
+  end
+end
+
+private
+def _divider
+  puts "-"*(ENV['COLUMNS'] || 80).to_i
+end

data/bin/ruby_diff

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'ruby_diff'
+require 'optparse' 
+
+@options = {}
+
+feeder_mapping = {
+  :file =>  FileFeeder,
+  :git  =>  GitFeeder
+}
+
+feeders = []
+
+opts = OptionParser.new   
+opts.banner = "Usage: ruby_diff.rb [options]"
+
+opts.separator ""
+opts.separator "Specific options:"
+
+opts.define_head <<-HEAD
+
+Examples:
+Changes between git HEAD and current file system:
+ruby_diff --git HEAD --file ./
+
+Changes between HEAD and previous revision:
+ruby_diff --git HEAD~1 --git HEAD
+HEAD
+
+opts.on('--sexp', "Show the s expressions for each input"){ 
+  @options[:sexp] = true 
+}
+
+opts.on('--git PATH', "Use a git repository as a code source"){|path| 
+  feeders << feeder_mapping[:git].new(path) 
+}
+opts.on('--file PATH', "Use a file system path as a code source"){|path| 
+  feeders << feeder_mapping[:file].new(path) 
+}
+
+opts.on_tail('-v', '--version')    { puts "ruby_diff v:0" ; exit }
+opts.on_tail('-h', '--help')       { puts opts; exit }
+
+opts.parse!(ARGV)
+
+# Map remaining options as file feeders
+ARGV.each do |path|
+  feeders << feeder_mapping[:file].new(path)
+end
+
+if feeders.length > 2
+  puts opts
+  puts "Too many code sources (#{feeders.length})"
+  exit 1
+elsif feeders.length < 2
+  puts opts
+  puts "Must supply least 2 code sources (#{feeders.length})"
+  exit 1
+end
+
+processors = feeders.map do |feeder|
+  puts "#{feeder.class}: #{feeder.path}" if @options[:sexp]
+  processor = StructureProcessor.new
+  feeder.each do |code|
+    sexp = ParseTree.new.parse_tree_for_string(code)
+    if @options[:sexp]
+      pp sexp
+      puts "--"
+    end
+    
+    processor.process(*sexp)
+  end
+  
+  processor
+end
+
+ 
+old_processor, new_processor = *processors
+
+changes = old_processor.diff(new_processor).sort_by{|c| c.signature}
+changes.each do |change|
+  puts change.to_s
+end

data/lib/ruby_diff.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+# ParseTree
+require 'parse_tree'
+require 'sexp_processor'
+require 'unified_ruby'
+require 'fileutils'
+
+# Standard library
+require 'set'
+require 'pp'
+
+module RubyDiff
+  VERSION = "0.1"
+end
+
+# RubyDiff
+%w(code_comparison structure_processor file_feeder git_feeder).each do |name|
+  require File.expand_path(File.dirname(__FILE__) + "/ruby_diff/#{name}")
+end

data/lib/ruby_diff/code_comparison.rb

@@ -0,0 +1,70 @@
+class CodeChange
+  attr_reader :signature
+  attr_reader :operation
+  attr_reader :changes
+  
+  OPERATION_CHARS = {
+    :added   => "+",
+    :removed => "-",
+    :changed => "c",
+    :moved   => "m"   #Not used yet
+  }
+  
+  def initialize(signature, operation, changes=[])
+    @signature = signature
+    @operation = operation
+    @changes   = changes
+  end
+  
+  def to_s(depth=1)
+    this_change = "#{OPERATION_CHARS[self.operation]}#{"  "*depth}#{signature}"
+    sub_changes = changes.map{|c| c.to_s(depth+1)}
+    [this_change, sub_changes].flatten.join("\n")
+  end
+end
+
+class CodeComparison
+  def initialize(old_signatures, new_signatures)
+    @old = old_signatures
+    @new = new_signatures
+  end
+  
+  def changes
+    changes = []
+    seen = Set.new
+    @old.each do |sig, code_object|
+      seen << sig
+      if other_code_object = @new[sig]
+        if code_object != other_code_object
+          changes << changed(sig, code_object, sig, other_code_object)
+        end
+      else
+        changes << removal(sig, code_object)
+      end
+    end
+    
+    @new.each do |sig, code_object|
+      if !seen.include?(sig)
+        changes << addition(sig, code_object)
+      end
+    end
+    
+    changes
+  end
+  
+protected
+  def addition(sig, code_object)
+    CodeChange.new(sig, :added)
+  end
+  
+  def removal(sig, code_object)
+    CodeChange.new(sig, :removed)
+  end
+  
+  def changed(old_sig, old_code_object, new_sig, new_code_object)
+    CodeChange.new(old_sig, :changed, CodeComparison.new(
+      old_code_object.child_signatures,
+      new_code_object.child_signatures
+    ).changes)
+  end
+end

data/lib/ruby_diff/file_feeder.rb

@@ -0,0 +1,28 @@
+class FileFeeder
+  attr_accessor :files
+  attr_accessor :path
+  
+  include Enumerable
+  
+  # Expects something in the form of PATH
+  #   --file [PATH]
+  def initialize(path)
+    @path = path
+    
+    if path =~ /^\s+$/
+      @file_pattern = "**/*.rb"
+    elsif File.file? path
+      @file_pattern = path
+    else
+      @file_pattern = File.join(path, "**/*.rb")
+    end
+    @files = Dir[@file_pattern]
+  end
+    
+  def each
+    @files.each do |file|
+      yield(open(file, 'r'){|io| io.read})      
+    end
+  end
+
+end

data/lib/ruby_diff/git_feeder.rb

@@ -0,0 +1,77 @@
+GitFile = Struct.new :access, :type, :hash, :name
+class GitFeeder
+  attr_accessor :files
+  attr_accessor :path
+  
+  include Enumerable
+  
+  # Expects something in the form of REV:PATH
+  #   --git REV:[PATH]
+  def initialize(path)
+    @path = path
+    
+    rev,path = path.split(":",2)
+    raise ArgumentError.new("Must supply a git revision") unless rev
+    path = File.expand_path(path) if path
+    init_git(path || '.')
+    @file_pattern = if @search_path == ''
+      "**.rb"
+    elsif @search_path =~ /\.rb#{File::SEPARATOR}$/
+      # So appending each piece into the search path during init_git
+      # causes the search path to always end with a /
+      @search_path[0...-1]
+    else
+      File.join(@search_path,"**.rb")
+    end
+    
+    @files = []
+          
+    FileUtils.cd(@working_dir) do
+      git_list = git "git-ls-tree -r #{rev}"
+      git_list.each_line do |line|
+        file = GitFile.new(*line.chomp.split(/\s+/,4))
+        
+        if file.type == 'blob' and File.fnmatch(@file_pattern, file.name)
+          @files << file        
+        end
+      end
+    end
+    
+  end
+    
+  def each
+    FileUtils.cd(@working_dir) do
+      @files.each do |file|
+        code = git "git-show #{file.hash}"
+        yield(code)      
+      end
+    end
+  end
+    
+  def init_git(path, search_path='')
+    if File.exist?(File.join(path, ".git"))
+      # If this is the git repository
+      @working_dir = path
+      @search_path = search_path
+      
+    else
+      next_search = File.join( File.split(path).last, search_path )
+      next_path = File.dirname(path)
+      
+      if next_path == path # We have reached the root, and can go no further
+        raise "Could not find a git working directory"
+      else
+        init_git(next_path, next_search)
+      end
+    end
+  end
+  
+  def git command
+    output = `#{command} 2>&1`.chomp
+    unless $?.success?
+      raise RuntimeError, output
+    end
+    output
+  end
+  
+end

data/lib/ruby_diff/patterns.rb

@@ -0,0 +1,29 @@
+class SexpWildCard < SexpMatchSpecial
+  def === (o)
+    return true
+  end
+  
+  def == (o)
+    return true
+  end
+  
+end
+
+def _?
+  SexpWildCard.new
+end
+
+class Sexp
+  def match(pattern, &block)
+    if pattern == self
+      block.call(self)
+    end
+
+    self.each do |subset|
+      case subset
+      when Sexp then
+        subset.match(pattern, &block)
+      end
+    end
+  end
+end

data/lib/ruby_diff/structure_processor.rb

@@ -0,0 +1,144 @@
+class CodeObject
+  attr_reader :name
+  attr_reader :parent
+  attr_reader :children
+  attr_reader :sexp
+  
+  def initialize(name, parent, sexp)
+    @name = name
+    @parent = parent
+    @sexp = sexp.deep_clone
+    @children = []
+    if parent
+      parent.children << self
+    end
+  end
+  
+  def signature
+    self.name
+  end
+  
+  def child_signatures
+    h = {}
+    self.children.each{|c| h[c.signature] = c}
+    h
+  end
+  
+  def to_s
+    signature
+  end
+  
+  def ==(other)
+    return false unless other.class == self.class
+    (other.signature == self.signature) and (other.sexp == self.sexp)
+  end
+end
+
+class ModuleCode < CodeObject
+  def signature
+    parent_signature = self.parent ? self.parent.signature : nil
+    [parent_signature,self.name].compact.join('::')
+  end
+end
+
+class ClassCode < ModuleCode
+end
+
+class MethodCode < CodeObject
+  def initialize(name, parent, instance, sexp)
+    super(name, parent, sexp)
+    @instance = instance
+  end
+  
+  def signature
+    parent_signature = self.parent ? self.parent.signature : ""
+    [parent_signature,self.name].join( @instance ? '#' : ".")
+  end
+end
+
+class StructureProcessor < SexpProcessor
+  attr_accessor :code_objects
+  attr_accessor :root_objects
+  
+  attr_accessor :scope_stack
+  
+  def initialize
+    super
+    self.strict = false
+    self.auto_shift_type = true
+    
+    @instance_scope = true
+    @code_objects = {}
+    @root_objects = {}
+    @scope_stack = []
+  end
+  
+  def process_class(exp)
+    name = exp.shift
+    super_class = exp.shift #?
+    body = exp.shift
+    
+    record ClassCode.new(name, self.scope, body) do
+      s(:class, name, process(super_class), process(body))
+    end
+  end
+  
+  def process_module(exp)
+    name = exp.shift
+    body = exp.shift
+    
+    record ModuleCode.new(name, self.scope, body) do
+      s(:class, name, process(body))
+    end
+  end
+  
+  def process_defn(exp)
+    name = exp.shift
+    body = process exp.shift
+    
+    record MethodCode.new(name, self.scope, @instance_scope, body) do
+      s(:defn, name, body)
+    end
+  end
+  
+  def process_defs(exp)
+    exp_scope = process exp.shift
+    name = exp.shift
+    body = process exp.shift
+    
+    record MethodCode.new(name, self.scope, false, body) do
+      s(:defs, exp_scope, name, body)
+    end
+  end
+  
+  def process_sclass(exp)
+    @instance_scope = false
+    exp_scope = process exp.shift
+    body = process exp.shift
+    @instance_scope = true
+    
+    s(:sclass, exp_scope, body)
+  end
+  
+  def diff(other_processor)
+    method_diff = CodeComparison.new(self.root_objects, other_processor.root_objects).changes
+  end
+  
+  protected
+  def record obj
+    signature = obj.signature
+    if !self.code_objects[signature]
+      self.code_objects[signature] = obj
+      self.root_objects[signature] = obj if obj.parent == nil
+    end
+    
+    self.scope_stack << self.code_objects[signature]
+    result = yield if block_given?
+    self.scope_stack.pop
+    result
+  end
+  
+  def scope
+    self.scope_stack.last
+  end
+end

data/ruby_diff.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = %q{ruby_diff}
+  s.version = "0.0.1"
+  s.date = %q{2008-06-03}
+  s.summary = %q{a higher level diff application for analyzing changes to ruby code}
+  s.email = ["netghost@gmail.com"]
+  s.homepage = %q{RubyDiff does higher level comparisons of ruby code.}
+  s.rubyforge_project = %q{rubydiff}
+  s.description = %q{}
+  s.default_executable = %q{ruby_diff}
+  s.has_rdoc = true
+  s.authors = ["Adam Sanderson"]
+  s.files = [".gitignore", "README.txt", "Rakefile", "bin/ruby_diff", "lib/ruby_diff.rb", "lib/ruby_diff/code_comparison.rb", "lib/ruby_diff/file_feeder.rb", "lib/ruby_diff/git_feeder.rb", "lib/ruby_diff/patterns.rb", "lib/ruby_diff/structure_processor.rb", "ruby_diff.gemspec", "test/file_feeder_test.rb", "test/git_feeder_test.rb", "test/git_sample/README", "test/git_sample/book.rb", "test/git_sample/lib/chapter.rb", "test/structure_processor_test.rb"]
+  s.test_files = ["test/git_feeder_test.rb", "test/file_feeder_test.rb", "test/structure_processor_test.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["README.txt"]
+  s.executables = ["ruby_diff"]
+  s.add_dependency(%q<ParseTree>, [">= 2.0.2"])
+  s.add_dependency(%q<hoe>, [">= 1.5.3"])
+end

data/test/file_feeder_test.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require "ruby_diff"
+
+DIR = File.join(File.dirname(__FILE__), "git_sample")
+
+class FileFeederTestCase < Test::Unit::TestCase  
+  
+  def test_find_all_files
+    assert File.exist?(DIR)
+    feeder = FileFeeder.new DIR
+    assert_equal 2, feeder.files.length
+  end
+  
+  def test_find_single_file
+    assert File.exist?(DIR)
+    feeder = FileFeeder.new(File.join(DIR,'lib','chapter.rb'))
+    assert_equal 1, feeder.files.length
+  end
+  
+  def test_find_files_in_sub_dir
+    feeder = FileFeeder.new(File.join(DIR,'lib'))
+    assert_equal 1, feeder.files.length
+  end
+  
+  def test_files_are_suitable_for_processing
+    feeder = FileFeeder.new DIR
+    assert_nothing_raised do
+      sexps = feeder.map{|code| ParseTree.new.parse_tree_for_string(code)}
+
+      sexps.each do |sexp|
+        assert sexp.length > 0, "Parsed code should not be empty"
+      end
+    end
+  end
+  
+end

data/test/git_feeder_test.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require "ruby_diff"
+
+GIT_REPO = File.join(File.dirname(__FILE__), "git_sample")
+
+class GitFeederTestCase < Test::Unit::TestCase  
+  
+  def test_find_all_files
+    assert File.exist?(GIT_REPO)
+    feeder = GitFeeder.new "HEAD:#{GIT_REPO}"
+    assert_equal 2, feeder.files.length
+  end
+  
+  def test_find_single_file
+    assert File.exist?(GIT_REPO)
+    feeder = GitFeeder.new(File.join("HEAD:#{GIT_REPO}",'lib','chapter.rb'))
+    assert_equal 1, feeder.files.length
+  end
+  
+  def test_find_files_in_sub_dir
+    feeder = GitFeeder.new(File.join("HEAD:#{GIT_REPO}",'lib'))
+    assert_equal 1, feeder.files.length
+  end
+  
+  def test_files_are_suitable_for_processing
+    feeder = GitFeeder.new "HEAD:#{GIT_REPO}"
+    assert_nothing_raised do
+      sexps = feeder.map{|code| ParseTree.new.parse_tree_for_string(code)}
+
+      sexps.each do |sexp|
+        assert sexp.length > 0, "Parsed code should not be empty"
+      end
+    end
+  end
+  
+  def test_revsision_required
+    assert_raise RuntimeError do
+      GitFeeder.new "hello"
+    end
+  end
+  
+  
+end

data/test/git_sample/README

@@ -0,0 +1 @@
+This is just a fake git repository

data/test/git_sample/book.rb

@@ -0,0 +1,5 @@
+class Book
+  def chapter
+    # this is a silly sample
+  end
+end

data/test/git_sample/lib/chapter.rb

@@ -0,0 +1,11 @@
+module Sample
+  class Chapter
+    def name= new_name
+      @name = new_name
+    end
+    
+    def name
+      @name
+    end
+  end
+end

data/test/structure_processor_test.rb

@@ -0,0 +1,75 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require "ruby_diff"
+
+class StructureProcessorTestCase < Test::Unit::TestCase  
+  def setup
+    
+  end
+  
+  def test_instance_method
+    assert_signatures <<-CODE, ["A#method_1"]
+      class A
+        def method_1
+        end
+      end
+    CODE
+  end
+  
+  def test_instance_method_with_module
+    assert_signatures <<-CODE, ["B::A#method_1"]
+      module B
+        class A
+          def method_1
+          end
+        end
+      end
+    CODE
+  end
+  
+  def test_unscoped_method
+    assert_signatures <<-CODE, ["#method_1"]    
+      def method_1
+      end
+    CODE
+  end
+  
+  def test_class_method_self
+    assert_signatures <<-CODE, ["A.method_1"]
+      class A
+        def self.method_1
+        end
+      end
+    CODE
+  end
+  
+  def test_class_method_self_explicit
+    assert_signatures <<-CODE, ["A.method_1"]
+      class A
+        def A.method_1
+        end
+      end
+    CODE
+  end
+  
+  def test_class_method_append_self
+    assert_signatures <<-CODE, ["A.method_1"]
+      class A
+        class << self
+          def method_1
+          end
+        end
+      end
+    CODE
+  end
+  
+  def assert_signatures(code, signatures, types=[MethodCode])
+    sexp = ParseTree.new.parse_tree_for_string(code)
+    processor = StructureProcessor.new()
+    processor.process(* sexp)
+    
+    found_signatures = processor.code_objects.values.select{|co| types.include?(co.class)}.map{|key| key.signature }.sort
+    assert_equal signatures.sort, found_signatures
+  end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: ruby_diff
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2008-06-04 00:00:00 -07:00
+summary: a higher level diff application for analyzing changes to ruby code
+require_paths: 
+- lib
+email: 
+- netghost@gmail.com
+homepage: RubyDiff does higher level comparisons of ruby code.
+rubyforge_project: rubydiff
+description: ""
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Adam Sanderson
+files: 
+- .gitignore
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/ruby_diff
+- lib/ruby_diff.rb
+- lib/ruby_diff/code_comparison.rb
+- lib/ruby_diff/file_feeder.rb
+- lib/ruby_diff/git_feeder.rb
+- lib/ruby_diff/patterns.rb
+- lib/ruby_diff/structure_processor.rb
+- ruby_diff.gemspec
+- test/file_feeder_test.rb
+- test/git_feeder_test.rb
+- test/git_sample/README
+- test/git_sample/book.rb
+- test/git_sample/lib/chapter.rb
+- test/structure_processor_test.rb
+test_files: 
+- test/git_feeder_test.rb
+- test/file_feeder_test.rb
+- test/structure_processor_test.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- ruby_diff
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.3
+    version: