tagfish 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 801be00ea36e0cc2c98c535546c45f1025768ca0
+  data.tar.gz: 9ce46a51783f66f42f9da2f4d5a5cebc6e459fd4
+SHA512:
+  metadata.gz: ad70b423105855d754bed1ad62d9291dbc18ac4ce113e38e3825aa72765d792572767a6f3df90f2c20c0af5677358cc9281f6499dbb49fb303e5ca312740c182
+  data.tar.gz: 33dbd5a8faf479d8a10364b7980731bb9c1823915d4aab0d08a4ac6d3a018fde857b22c22c950359bce3c2086fb9fd58eb92dafc358bb3580a753b5bc2ce6efe

data/.gitignore

@@ -0,0 +1,14 @@
+*.swp
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/tmp/
+/*.gem
+/compiled-gem
+/tests

data/Dockerfile

@@ -0,0 +1,23 @@
+FROM alpine:edge
+MAINTAINER Clement Labbe <clement.labbe@rea-group.com>
+
+RUN apk add --update ruby=2.2.3-r1 \
+    ruby-dev=2.2.3-r1 \
+    ruby-io-console=2.2.3-r1 \
+    diffutils \
+    linux-headers \
+    build-base \
+    ca-certificates=20150426-r3 && \
+    rm /var/cache/apk/* && \
+    rm -rf /usr/share/ri
+
+RUN echo -e 'gem: --no-rdoc --no-ri' > /etc/gemrc \
+    gem update --system 2.4.8 && \
+    gem install bundler -v 1.10.6 && \
+    rm -rf /usr/share/ri
+
+COPY pkg/tagfish-latest.gem /cwd/
+WORKDIR /cwd
+RUN gem install tagfish-latest.gem
+
+ENTRYPOINT ["tagfish"]

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tagfish.gemspec
+gemspec

data/README.md

@@ -0,0 +1,178 @@
+# Tagfish 
+
+![Tagfish logo](logo.jpg)
+
+Tagfish is a CLI tool to interact with Docker registries. 
+
+Features include:
+
+- List all the tags of a given Docker repository
+- Return the most recent explicit tag of a repository
+- Update a file with the newest tags
+- Search for a repository
+- Authenticate by reading native Docker config file 
+- Works against hub.docker.com and private registries
+- Supports Docker Registry/Distribution API v1 and v2 
+
+To use Tagfish against a registry requiring authentication, you first need to authenticate to the given registry using `docker login <REGISTRY>`.
+
+## Table of contents
+
+<!-- MarkdownTOC autolink=true bracket=round depth=4 -->
+
+- [Usage](#usage)
+  - [`tagfish tags`](#tagfish-tags)
+    - [Example](#example)
+  - [`tagfish search`](#tagfish-search)
+    - [Example](#example-1)
+  - [`tagfish update`](#tagfish-update)
+    - [Example](#example-2)
+    - [Official repositories](#official-repositories)
+- [Installation](#installation)
+  - [Gem](#gem)
+    - [Limitations](#limitations)
+  - [Docker image](#docker-image)
+- [Contributing](#contributing)
+- [Licence](#licence)
+
+
+<!-- /MarkdownTOC -->
+
+## Usage
+The Tagfish CLI tool has different subcommands for interacting with Docker registries.
+
+### `tagfish tags`
+The `tags` subcommands is used to retrieve tags from a given repository:
+
+    Usage:
+        tagfish tags [OPTIONS] REPOSITORY
+
+    Parameters:
+        REPOSITORY                    docker repository
+
+    Options:
+        -l, --latest                  only return latest explicitly tagged image
+        -s, --short                   only return tag, not full image path
+        -h, --help                    print help
+
+Where `repository` is a docker repository path, including the docker registry. The tags are returned in alphabetical order.
+
+The `--latest` option gets the image ID of the docker image tagged `latest` in the repository, finds a matching image with a tag set manually (e.g: date, version number), and returns that tag. This option will not work if there is no image tagged `latest` in your repository.
+
+#### Example
+```
+$ tagfish tags alpine
+alpine:2.6
+alpine:2.7
+alpine:3.1
+alpine:3.2
+alpine:edge
+alpine:latest
+```
+
+### `tagfish search`
+The `search` command is used to search for a repository in a given registry.
+
+    Usage:
+        tagfish search [OPTIONS] [KEYWORD]
+
+    Parameters:
+        [KEYWORD]                     object to search
+
+    Options:
+        -r, --registry REGISTRY       Docker registry (default: "index.docker.io")
+        -h, --help                    print help
+
+Note: `search` will not work if the search API is disabled on the registry side. 
+
+#### Example
+```
+$ tagfish search alpine
+alpine
+1science/alpine
+webhippie/alpine
+anapsix/alpine-java
+colstrom/alpine
+appelgriebsch/alpine
+[...]
+```
+
+### `tagfish update`
+The `update` subcommand is used to update a file with the latest tags available:
+
+    Usage:
+        tagfish update [OPTIONS] FILE
+    
+    Parameters:
+        FILE                          file to update
+    
+    Options:
+        -d, --dry-run                 enable dry run
+        --only PATTERN                Only update repositories matching pattern. Wildcards `*` may be used.
+        -h, --help                    print help
+
+#### Example
+```
+$ tagfish update --dry-run Dockerfile
+-FROM docker-registry.delivery.realestate.com.au/gpde/ubuntu-ruby2.2:201508191500
++FROM docker-registry.delivery.realestate.com.au/gpde/ubuntu-ruby2.2:201511261833
+```
+
+#### Official repositories
+`tagfish update` will update repositories such as:
+```
+private.registry/namespace/repository:tag
+namespace/repository:tag
+```
+However, it will not update the tag of official repositories, such as:
+```
+ubuntu:tag
+```
+This is because updating to a new OS automatically might be something you want to avoid, and because it is hard to match a repository without a namespace.
+
+## Installation
+### Gem
+Tagfish is packaged as a Ruby gem. Install it from the command line:
+
+```
+$ gem install tagfish
+```
+
+#### Limitations
+Tagfish requires Ruby 2.2 or newer if the registry you are accessing restricts TLS to v1.2.
+
+### Docker image
+Tagfish is released as a Docker image as well, and can be run with:
+
+```
+docker run --rm \
+  -v ~/.docker/config.json:/root/.docker/config.json:ro \
+  -v ${PWD}:/cwd \
+  cowbell/tagfish
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/realestate-com-au/tagfish .
+
+## Licence
+
+Copyright (c) 2015 REA Group Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,39 @@
+require "bundler/gem_tasks"
+require "fileutils"
+
+spec = Gem::Specification::load(Dir.glob("*.gemspec").first)
+gem_file = "pkg/#{spec.name}-#{spec.version}.gem"
+docker_uri = "cowbell/#{spec.name}"
+tag = "#{spec.version}"
+
+desc "build docker image locally"
+task build_docker_image: [:build] do
+  FileUtils.copy(gem_file, "pkg/tagfish-latest.gem")
+  sh "docker build -t #{docker_uri}:#{tag} ."
+  sh "docker tag -f #{docker_uri}:#{tag} #{docker_uri}:latest"
+  puts "Built image #{docker_uri}"
+end
+
+desc "Release docker image"
+task release_docker_image: [:build_docker_image] do
+  sh "docker push #{docker_uri}:#{tag}"
+  sh "docker push #{docker_uri}:latest"
+end
+
+desc "Check for git sync"
+task :no_local_changes do
+  sh "git pull"
+  sh "git diff HEAD --exit-code"
+end
+
+desc "Tag version into git repo"
+task git_tag: [:no_local_changes] do
+  puts "blah"
+  sh "git tag #{tag}"
+  sh "git push origin --tags"
+end
+
+desc "Release gem and docker image"
+task release_all: [:git_tag, :release, :release_docker_image] do
+  puts "Released all"
+end

data/bin/tagfish

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
+require 'clamp'
+require 'tagfish/tags_command'
+require 'tagfish/update/update_command'
+require 'tagfish/search_command'
+require "tagfish/version"
+
+module Tagfish
+  class MainCommand < Clamp::Command
+    option ["-v", "--version"], :flag, "display version" do
+        puts "tagfish-#{Tagfish::VERSION}"
+        exit 0
+    end
+  end
+
+  class MainCommand < Clamp::Command
+    subcommand "tags", "find tags for a repository", TagsCommand
+  end
+
+  class MainCommand < Clamp::Command
+    subcommand "update", "inspect files for outdated dependencies", Update::UpdateCommand
+  end
+  
+  class MainCommand < Clamp::Command
+    subcommand "search", "search a registry for repositories", SearchCommand
+  end
+  
+  MainCommand.run
+end

data/lib/tagfish.rb

@@ -0,0 +1,5 @@
+require "tagfish/version"
+
+module Tagfish
+  # do nothing here
+end

data/lib/tagfish/api_call.rb

@@ -0,0 +1,41 @@
+module Tagfish
+  class APICall
+    attr_accessor :uri
+    attr_accessor :http
+    attr_accessor :request
+  
+    def initialize(uri_string) 
+      @uri = URI.parse(uri_string)
+      @http = Net::HTTP.new(uri.host, uri.port)
+      @http.use_ssl = true if uri.port == 443
+      @request = Net::HTTP::Get.new(uri.request_uri)
+    end
+        
+    def get_json(http_auth=nil)
+      begin
+        auth(http_auth) if http_auth
+        response = http.request(request)
+        if response.code == "200"
+          return JSON.parse(response.body)
+        else
+          abort("Call to the registry API failed, the following resource might not exist:\n#{uri.to_s}")
+        end
+      rescue SocketError
+        puts "ERROR: SocketError"
+      end
+    end
+
+    def response_code(http_auth=nil)
+      auth(http_auth) if http_auth
+      begin
+        http.request(request).code.to_i
+      rescue SocketError
+        abort("Call to the registry API failed, the following resource might not exist:\n#{uri.to_s}")
+      end
+    end
+
+    def auth(http_auth)
+      @request.basic_auth(http_auth.username, http_auth.password)
+    end
+  end
+end

data/lib/tagfish/docker_api.rb

@@ -0,0 +1,113 @@
+require 'net/http'
+require 'json'
+require 'tagfish/docker_uri'
+require 'tagfish/api_call'
+
+module Tagfish
+  class DockerAPI
+
+    attr_accessor :docker_uri
+    attr_accessor :api_version
+    attr_accessor :http_auth
+
+    def initialize(docker_uri)
+      @docker_uri = docker_uri
+      retrieve_api_version_and_auth()
+    end
+    
+    def retrieve_api_version_and_auth
+      code = try_api('v1')
+      if code != 200 
+        code = try_api('v2')
+      end
+      if code == 401
+        abort("Authentication failed, please `docker login <REGISTRY>` and try again.")
+      elsif code != 200
+        abort("API version not recognized")
+      end
+    end
+    
+    def try_api(version)
+      code = APICall.new(ping_uri(version)).response_code
+      if code == 200
+        @api_version = version
+      elsif code == 401
+        code = init_auth(version)
+        if code == 200
+          @api_version = version
+        end
+      end
+      return code
+    end
+    
+    def init_auth(api_version)
+      @http_auth = DockerHttpAuth.new(docker_uri.registry)
+      if api_version == 'v2'
+        code = APICall.new(ping_v2_uri).response_code(http_auth)
+      elsif api_version == 'v1'
+        code = APICall.new(ping_v1_uri).response_code(http_auth)
+      end
+    end
+    
+    def tags_v1
+      APICall.new(tags_v1_uri).get_json(http_auth)
+    end
+    
+    def tags_v2
+      APICall.new(tags_v2_uri).get_json(http_auth)
+    end
+    
+    def hash_v2(tag)
+      APICall.new(hash_v2_uri(tag)).get_json(http_auth)
+    end
+    
+    def catalog_v2
+      APICall.new(catalog_v2_uri).get_json(http_auth)
+    end
+    
+    def search_v1(keyword)
+      APICall.new(search_v1_uri(keyword)).get_json(http_auth)
+    end
+    
+    def base_uri
+      "#{docker_uri.protocol}#{docker_uri.registry}"
+    end
+    
+    def ping_uri(version)
+      if version == 'v1'
+        ping_v1_uri
+      elsif version == 'v2'
+        ping_v2_uri
+      end
+    end
+    
+    def ping_v2_uri
+      "#{base_uri}/v2/"
+    end
+    
+    def ping_v1_uri
+      "#{base_uri}/v1/_ping"
+    end
+    
+    def catalog_v2_uri
+      "#{base_uri}/v2/_catalog"
+    end
+    
+    def search_v1_uri(keyword)
+      "#{base_uri}/v1/search?q=#{keyword}"  
+    end
+    
+    def tags_v1_uri
+      "#{base_uri}/v1/repositories/#{docker_uri.repository}/tags"
+    end
+    
+    def tags_v2_uri
+      "#{base_uri}/v2/#{docker_uri.repository}/tags/list"  
+    end
+    
+    def hash_v2_uri(tag)
+      "#{base_uri}/v2/#{docker_uri.repository}/manifests/#{tag}"
+    end
+    
+  end
+end

data/lib/tagfish/docker_http_auth.rb

@@ -0,0 +1,31 @@
+require 'json'
+require 'base64'
+
+module Tagfish
+  class DockerHttpAuth
+
+    attr_accessor :username
+    attr_accessor :password
+
+    def initialize(registry)
+       file_path = '~/.docker/config.json'
+
+       begin
+         config = File.open(File.expand_path(file_path), 'r')
+       rescue Exception => e
+         abort("Tried to get a SLiP but the file #{file_path} does not exist")
+       end
+
+       json_config = JSON.parse(config.read())
+       config.close()
+       if json_config['auths'].length == 0
+         @username, @password = nil, nil 
+       else
+         b64_auth = json_config['auths'][registry]['auth']
+         auth = Base64.decode64(b64_auth)
+         @username, @password = auth.split(':')
+       end
+    end
+
+  end
+end

data/lib/tagfish/docker_uri.rb

@@ -0,0 +1,64 @@
+require 'tagfish/docker_http_auth'
+require 'tagfish/docker_api'
+
+module Tagfish
+  class DockerURI
+    URI_PARSER = %r{
+      (https?:\/\/)?                # Optional protocol
+      (?:([\w.\-]+\.[\w.\-]+)\/)?   # Optional registry
+      ([\w\-]*\/?[\w\-.]+)          # Optional namespace, mandatory repository
+      :?                            # Optional delimiter between repository and tag
+      ([\w.\-]+)?                   # Optional tag
+    }x
+
+    def self.parse(docker_string)
+      match = docker_string.match(URI_PARSER)
+      new(*match.captures)
+    end
+
+    attr_accessor :protocol
+    attr_accessor :registry
+    attr_accessor :repository
+    attr_accessor :tag
+
+    def initialize(protocol, registry, repository, tag)
+      @protocol = protocol
+      @registry = registry
+      @repository = repository
+      @tag = tag
+
+      if registry.nil?
+        @protocol = "https://"
+        @registry = "index.docker.io"
+      elsif protocol.nil?
+        @protocol = "https://"
+      end
+    end
+    
+    def repo_and_tag
+      tag.nil? ? "#{repository}" : "#{repository}:#{tag}"
+    end
+
+    def tag?
+      not tag.nil?
+    end
+
+    def tagged_latest?
+      tag == 'latest'
+    end
+
+    def with_tag(new_tag)
+      self.class.new(protocol, registry, repository, new_tag)
+    end
+
+    def to_s
+      reg_sep = registry.nil? ? nil : "/"
+      tag_sep = tag.nil? ? nil : ":"
+      if registry == "index.docker.io"
+        "#{repository}#{tag_sep}#{tag}"
+      else
+        "#{registry}#{reg_sep}#{repository}#{tag_sep}#{tag}"
+      end
+    end
+  end
+end

data/lib/tagfish/search_command.rb

@@ -0,0 +1,32 @@
+require 'tagfish/docker_uri'
+
+module Tagfish
+  class SearchCommand < Clamp::Command
+    parameter "[KEYWORD]", "object to search"
+    option ["-r", "--registry"], "REGISTRY", "Docker registry", :default => "index.docker.io"
+
+    def execute
+      if not registry and not keyword
+        abort("You need to specify a REGISTRY and/or a KEYWORD")
+      end
+      
+      docker_uri = DockerURI.parse(registry + "/" + "dummy")
+      docker_api = DockerAPI.new(docker_uri)
+      
+      if docker_api.api_version == 'v2'
+        repos = docker_api.catalog_v2["repositories"]
+        if keyword
+          repos.select! {|repo| repo.include? keyword}
+        end
+        repos.each {|repo| puts "#{docker_uri.registry}/#{repo}"} 
+      else # 'v1'
+        if not keyword
+          abort("You need to specify a keyword to search a Registry V1")
+        end
+        repos_raw = docker_api.search_v1(keyword)
+        repos = repos_raw["results"].map {|result| result["name"]}
+        puts repos
+      end
+    end
+  end
+end

data/lib/tagfish/tags.rb

@@ -0,0 +1,26 @@
+require 'net/http'
+require 'json'
+
+module Tagfish
+  class Tags
+
+    def initialize(tags)
+      @tags = tags
+    end
+
+    def tag_names
+      @tags.keys.sort
+    end
+
+    def latest_tag
+      tag_names.select do |tag_name|
+        (@tags[tag_name] == @tags["latest"]) && (tag_name != 'latest')
+      end
+    end
+
+    def latest_tag_to_s
+      latest_tag.empty? ? nil : latest_tag[0]
+    end
+
+  end
+end

data/lib/tagfish/tags_command.rb

@@ -0,0 +1,37 @@
+require "tagfish/tags_logic"
+require "tagfish/docker_uri"
+
+module Tagfish
+  class TagsCommand < Clamp::Command
+    parameter "REPOSITORY", "docker repository"
+    option ["-l", "--latest"], :flag, "only return latest explicitly tagged image"
+    option ["-s", "--short"], :flag, "only return tag, not full image path"
+
+    def execute
+      tags_only = latest? ? false : true
+      
+      docker_uri = DockerURI.parse(repository)
+      docker_api = DockerAPI.new(docker_uri)
+      tags = TagsLogic.find_tags_by_repository(docker_api, tags_only)
+
+      begin
+       tags_found = latest? ? tags.latest_tag : tags.tag_names
+      rescue Exception => e
+        puts e.message
+        return
+      end
+
+      if tags_found.size == 0
+        puts "ERROR: No image explicitly tagged in this Repository, " +
+                "only `latest` tag available."
+        return
+      end
+
+      pretty_tags = tags_found.map do |tag_name|
+        short? ? tag_name : docker_uri.with_tag(tag_name).to_s
+      end
+
+      puts pretty_tags
+    end
+  end
+end

data/lib/tagfish/tags_logic.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'tagfish/tags'
+
+module Tagfish
+  class TagsLogic
+    def self.find_tags_by_repository(docker_api, tags_only=false)
+      if docker_api.api_version == 'v2'
+        tags_list = tags_v2(docker_api, tags_only)
+      else
+        tags_list = tags_v1(docker_api)
+      end
+      Tagfish::Tags.new(tags_list)
+    end
+
+    private
+
+    def self.tags_v1(docker_api)
+      tags_json = docker_api.tags_v1
+      tags_v1_api(tags_json)
+    end
+
+    def self.tags_v1_api(api_response_data)
+      case api_response_data
+      when Hash
+        api_response_data
+      when Array
+        api_response_data.reduce({}) do |images, tag|
+          images.merge({tag["name"] => tag["layer"]})
+        end
+      else
+        raise "unexpected type #{api_response_data.class}"
+      end
+    end
+
+    def self.tags_v2(docker_api, tags_only)
+      tags = docker_api.tags_v2["tags"]
+      if tags.nil?
+        abort("No Tags found for this repository")
+      end
+      
+      tags_with_hashes = tags.inject({}) do |dict, tag|
+        if tags_only
+          dict[tag] = "dummy_hash"
+        else
+          dict[tag] = docker_api.hash_v2(tag)["fsLayers"][0]["blobSum"]
+        end
+        dict
+      end
+    end
+    
+  end
+end

data/lib/tagfish/tokeniser.rb

@@ -0,0 +1,37 @@
+module Tagfish
+  class Tokeniser
+
+    class Text < String
+      def is_a_uri_token?
+        false
+      end
+    end
+
+    class URI < String
+      def is_a_uri_token?
+        true
+      end
+    end
+
+    def self.tokenise(rest)
+      tokens = []
+      while true
+        match = rest.match /[\w\/:.-]+\/[\w.-]+:[\w.-]+/
+        if match.nil?
+          tokens << Text.new(rest)
+          break
+        else
+          tokens << Text.new(match.pre_match)
+          tokens << URI.new(match.to_s)
+          rest = match.post_match
+        end
+      end
+
+      tokens
+    end
+
+    def self.dump(tokens)
+      tokens.join('')
+    end
+  end
+end

data/lib/tagfish/update/differ.rb

@@ -0,0 +1,13 @@
+require 'diffy'
+
+module Tagfish
+  module Update
+    class Differ
+      def self.diff(original_string, updated_string)
+        diffy_diff = Diffy::Diff.new(original_string, updated_string, context: 2)
+        colour_diff = diffy_diff.to_s(:color).chomp
+        colour_diff.empty? ? "Nothing to update here" : colour_diff
+      end
+    end
+  end
+end

data/lib/tagfish/update/update_command.rb

@@ -0,0 +1,31 @@
+require 'tagfish/update/updater'
+require 'tagfish/update/differ'
+require 'tagfish/update/uri_filters'
+require 'tagfish/tokeniser'
+
+module Tagfish
+  module Update
+    class UpdateCommand < Clamp::Command
+      parameter "FILE", "file to update"
+      option ["-d", "--dry-run"], :flag, "enable dry run"
+      option "--only", "PATTERN", "Only update repositories matching pattern. Wildcards (*) may be used."
+
+      def execute
+        filters = [
+          URIFilters.must_be_tagged,
+          URIFilters.must_not_be_tagged_latest,
+          URIFilters.must_match_repository(only)
+        ]
+        updater = Updater.new(filters)
+        original = File.read(file)
+        updated = Tokeniser.dump(updater.update(Tokeniser.tokenise(original)))
+
+        puts Differ.diff(original, updated)
+        
+        if not dry_run? 
+          File.write(file, updated)
+        end
+      end
+    end
+  end
+end

data/lib/tagfish/update/updater.rb

@@ -0,0 +1,53 @@
+require 'tagfish/tokeniser'
+require 'tagfish/docker_uri'
+require 'tagfish/tags_logic'
+
+module Tagfish
+  module Update
+    class Updater
+      def initialize(filters)
+        @filters = filters
+      end
+
+      def update(tokens)
+        tokens.map do |token|
+          if token.is_a_uri_token?
+            update_uri_token(token)
+          else
+            token
+          end
+        end
+      end
+
+      private
+
+      def update_uri_token(token)
+        original_uri = DockerURI.parse(token)
+        if updatable?(original_uri)
+          updated_uri = update_uri(original_uri)
+          Tokeniser::URI.new(updated_uri.to_s)
+        else
+          token
+        end
+      end
+
+      def updatable?(uri)
+        @filters.all? do |filter|
+          filter.call uri
+        end
+      end
+
+      def update_uri(docker_uri)
+        docker_api = DockerAPI.new(docker_uri)
+        tags = TagsLogic.find_tags_by_repository(docker_api)
+        newest_tag_name = tags.latest_tag_to_s
+        if newest_tag_name.nil?
+          docker_uri
+        else
+          docker_uri.with_tag(newest_tag_name)
+        end
+      end
+
+    end
+  end
+end

data/lib/tagfish/update/uri_filters.rb

@@ -0,0 +1,20 @@
+module Tagfish
+  module Update
+    class URIFilters
+      def self.must_be_tagged
+        lambda do |uri| uri.tag? end
+      end
+
+      def self.must_not_be_tagged_latest
+        lambda do |uri| not uri.tagged_latest? end
+      end
+
+      def self.must_match_repository(pattern)
+        starts_with_pattern = "#{pattern}*"
+        lambda do |uri| 
+          File.fnmatch(starts_with_pattern, uri.with_tag(nil).to_s)
+        end
+      end
+    end
+  end
+end

data/lib/tagfish/version.rb

@@ -0,0 +1,3 @@
+module Tagfish
+  VERSION = "1.0.1"
+end

data/tagfish.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tagfish/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tagfish"
+  spec.version       = Tagfish::VERSION
+  spec.authors       = ["Clement Labbe"]
+  spec.email         = ["clement.labbe@rea-group.com"]
+  spec.summary       = %q{Command line utility for docker registries}
+  spec.description   = "Retrieve repository tags, update dockerfiles, and more!"
+  spec.homepage      = "https://github.com/realestate-com-au/tagfish"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = ["tagfish"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3.0"
+  spec.add_dependency "clamp", "~> 1.0.0"
+  spec.add_dependency "diffy", "~> 3.0.0"
+  spec.add_dependency "json", "~> 1.8.0"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: tagfish
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Clement Labbe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: Retrieve repository tags, update dockerfiles, and more!
+email:
+- clement.labbe@rea-group.com
+executables:
+- tagfish
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Dockerfile
+- Gemfile
+- README.md
+- Rakefile
+- bin/tagfish
+- lib/tagfish.rb
+- lib/tagfish/api_call.rb
+- lib/tagfish/docker_api.rb
+- lib/tagfish/docker_http_auth.rb
+- lib/tagfish/docker_uri.rb
+- lib/tagfish/search_command.rb
+- lib/tagfish/tags.rb
+- lib/tagfish/tags_command.rb
+- lib/tagfish/tags_logic.rb
+- lib/tagfish/tokeniser.rb
+- lib/tagfish/update/differ.rb
+- lib/tagfish/update/update_command.rb
+- lib/tagfish/update/updater.rb
+- lib/tagfish/update/uri_filters.rb
+- lib/tagfish/version.rb
+- logo.jpg
+- tagfish.gemspec
+homepage: https://github.com/realestate-com-au/tagfish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Command line utility for docker registries
+test_files: []