redmine-api 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c822179cddb921fe6c543449ca43b7291b41df6d
+  data.tar.gz: 42c89075ee550c5512ab6095bf3aa3f29796c894
+SHA512:
+  metadata.gz: 68c19e628b931f63bd86cf420761a624fda5455078b9ad5088aad97cd9a9a47490590a55e6b98d6be831d0a76882040239ead45a0371c56a174eebdb5ad879d6
+  data.tar.gz: 787a81963065b3b7f01d57cc847da8595cd9aecbf38c12d2d6bcc7931e42fdb8a46a357de87d3b6ef8dd023ed5c0fab61776cf39b475590f96b0fb9beb2f5c15

data/.gitignore

@@ -0,0 +1,4 @@
+*.pstore
+.redmine.yml
+doc
+pkg

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/.travis.yml

@@ -0,0 +1,2 @@
+---
+language: ruby

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at arjan@arjanvandergaag.nl. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    redmine-api (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.8.4)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.11)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  redmine-api!
+
+BUNDLED WITH
+   1.11.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Arjan van der Gaag
+
+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/README.md

@@ -0,0 +1,59 @@
+# Redmine API [![Build Status](https://travis-ci.org/avdgaag/redmine-api.svg?branch=master)](https://travis-ci.org/avdgaag/redmine-api)
+
+This is a command-line interface to the popular Redmine issue tracking system, based on its REST API. Use it to quickly get the information you need without taking your hands off the keyboard to open a browser.
+
+This is a simple pure-Ruby gem with no additional runtime dependencies. It is as much an exercise in using the Ruby standard library as it is meant to be useful.
+
+## Installation
+
+You can install this gem using Rubygems:
+
+    $ gem install redmine-api
+
+## Usage
+
+To use this gem, invoke its executable from the command line:
+
+    % redmine --version
+    0.1.0
+
+This program consists of several subcommands, which you can see listed when you print the help information:
+
+    % redmine --help
+
+For example, to list all available projects in your Redmine installation, use the `projects` subcommand:
+
+    % redmine projects
+
+For more information, read the docs or the inline help.
+
+## Authentication
+
+In order to access your Redmine data, you need to configure the gem to point to the right Redmine installation and provide proper credentials. You can do so by creating a configuration file in your project directory containing that information. Such a configuration file would be named `.redmine.yml` and might look like this:
+
+    ---
+    api_token: '14acda31941e8c5dc3be12d1a5d108311b7da3eb'
+    base_uri: 'http://redmine.mydomain.tld'
+    http_cache: 'redmine.cache'
+
+Using the API token is currently the only supported way to authenticate against Redmine. Since your API token is private, make sure you make your configuration file only accessible to yourself. This program will look for a `.redmine.yml` file in the current directory its ancestor directories, merging all of them together into one final configuration (with the first file to be encountered taking precedence over later files).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/avdgaag/redmine-api. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Credits
+
+* **Author**: Arjan van der Gaag <arjan@arjanvandergaag.nl>
+* **URL**: arjanvandergaag.nl
+* **Homepage**: https://github.com/avdgaag/redmine-api
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rdoc/task'
+
+RDoc::Task.new do |t|
+  t.main = 'README.md'
+  t.rdoc_files.include(
+    'README.md',
+    'CODE_OF_CONDUCT.md',
+    'LICENSE.txt',
+    'lib/**/*.rb'
+  )
+  t.rdoc_dir = 'doc'
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'bundler/setup'
+require 'redmine'
+
+begin
+  require 'pry'
+  Pry.start
+rescue LoadError
+  require 'irb'
+  IRB.start
+end

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/exe/redmine

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby -w
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'redmine'
+Redmine.cli(ARGV)

data/lib/redmine.rb

@@ -0,0 +1,42 @@
+require 'pstore'
+require 'uri'
+
+require 'redmine/configuration'
+require 'redmine/cli'
+require 'redmine/client'
+require 'redmine/accept_json'
+require 'redmine/http_caching'
+require 'redmine/rest_client'
+
+# = Redmine command line API
+#
+# This gem provides a command-line API to the popular Redmine issue tracking
+# system, using its REST API.
+module Redmine
+  module_function
+
+  def configuration
+    @configuration ||= Configuration.autoload
+  end
+
+  def configure
+    @configuration = Configuration.autoload
+    yield @configuration
+    @configuration.freeze
+  end
+
+  def cli(args)
+    cache = PStore.new(configuration.http_cache)
+    base_uri = URI.parse(configuration.base_uri)
+    rest_client = RestClient.new(
+      base_uri: base_uri,
+      default_headers: {
+        'X-Redmine-Api-Key' => configuration.api_token
+      }
+    )
+    rest_client = AcceptJson.new(HttpCaching.new(rest_client, cache))
+    Cli.new(
+      redmine_client: Client.new(rest_client: rest_client)
+    ).call(args)
+  end
+end

data/lib/redmine/accept_json.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'delegate'
+
+module Redmine
+  # A decorator object for RestClient that provides immediate JSON-parsing
+  # capabilities. Rather than dealing with raw response objects, this decorator
+  # helps us get at parsed JSON data immediately.
+  #
+  # This decorator works by intercepting outgoing requests and adding an
+  # +Accept+ header to indicate we would like to receive JSON data
+  # back. Responses will then be parsed, given they actually are JSON, and both
+  # the parsed response body and the original response are returned.
+  class AcceptJson < SimpleDelegator
+    # Value of the outgoing +Accept+ header.
+    ACCEPT = 'application/json'.freeze
+
+    # Matcher for recognizing response content types.
+    CONTENT_TYPE = %r{application/json}
+
+    # Wrap requests to add an `Accept` header to ask for JSON, and parse
+    # response bodies as JSON data.
+    def get(path, headers = {})
+      response = super(path, { 'Accept' => ACCEPT }.merge(headers.to_h))
+      case response.content_type
+      when CONTENT_TYPE then [parse_response(response), response]
+      else raise "Unknown content type #{response.content_type.inspect}"
+      end
+    end
+
+    private
+
+    def parse_response(response)
+      JSON.parse(response.body)
+    rescue JSON::ParserError => e
+      # TODO: log output here
+      p response
+      p response.to_hash
+      raise e
+    end
+  end
+end

data/lib/redmine/cli.rb

@@ -0,0 +1,67 @@
+require 'redmine/issue'
+require 'redmine/commands'
+
+module Redmine
+  # Command line interface dispatcher: invoke subcommands based on incoming
+  # command line switches.
+  class Cli
+    def initialize(redmine_client:)
+      @redmine = redmine_client
+    end
+
+    def call(arguments)
+      subcommand, *other_args = arguments
+      if subcommand =~ /^\d+$/
+        call_issue_command(subcommand, other_args)
+      elsif subcommand =~ /^\w/
+        call_subcommand(subcommand, other_args)
+      else
+        option_parser.parse(arguments)
+      end
+    end
+
+    private
+
+    def call_subcommand(cmd, args)
+      command_name_to_class(cmd).new(redmine: @redmine).call(args)
+    end
+
+    def command_name_to_class(cmd)
+      Commands.const_get(cmd.split('_').map(&:capitalize).join)
+    end
+
+    def call_issue_command(cmd, args)
+      Commands::Issue.new(issue_id: cmd, redmine: @redmine).call(args)
+    end
+
+    def option_parser # rubocop:disable Metrics/MethodLength
+      OptionParser.new do |o|
+        o.banner = <<~EOS
+        redmine [SUBCOMMAND] [OPTIONS]
+
+        Perform common operations in a Redmine issue tracker from the command
+        line.
+
+        Available subcommands:
+
+        projects
+        issues
+        show
+        activity
+        lead_times
+
+        Generic options:
+        EOS
+        o.separator ''
+        o.on_tail '-h', '--help', 'Show this message' do
+          puts o
+          exit
+        end
+        o.on_tail '-v', '--version', 'Display version number' do
+          puts Redmine::VERSION
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/redmine/client.rb

@@ -0,0 +1,54 @@
+require 'redmine/project'
+require 'redmine/issue'
+
+module Redmine
+  # The client is a Redmine-aware REST API client that maps remote resources
+  # into local methods and data. It uses the RestClient under the hood and
+  # outputs our own domain objects.
+  class Client
+    def initialize(rest_client:)
+      @rest_client = rest_client
+    end
+
+    def issue(issue_id)
+      data = @rest_client.get("/issues/#{issue_id}.json?include=journals").first
+      Issue.new(data.fetch('issue'))
+    end
+
+    def projects
+      @rest_client
+        .get('/projects.json')
+        .first
+        .fetch('projects')
+        .map { |p| Project.new(p) }
+    end
+
+    def project(id)
+      @rest_client
+        .get("/projects/#{id}.json?include=trackers")
+        .fetch('project')
+    end
+
+    def issue_statuses
+      @rest_client
+        .get('/issue_statuses.json')
+        .first
+        .fetch('issue_statuses')
+    end
+
+    def issues(options = {}) # rubocop:disable Metrics/AbcSize
+      options = { limit: 10, offset: 0, sort: :asc }.merge(options.to_h)
+      Enumerator.new do |yielder|
+        loop do
+          result, _response = @rest_client.get(
+            '/issues.json?' + URI.encode_www_form(options)
+          )
+          result.fetch('issues').each { |issue| yielder << Issue.new(issue) }
+          position = result.fetch('limit') + result.fetch('offset')
+          raise StopIteration unless result.fetch('total_count').to_i > position
+          options.merge!(offset: options.fetch(:limit) + options.fetch(:offset))
+        end
+      end
+    end
+  end
+end

data/lib/redmine/command.rb

@@ -0,0 +1,81 @@
+require 'optparse'
+
+module Redmine
+  # The Command mixin helps define command objects used in the command line
+  # interface.  Classes can mix in this behaviour to make it easier to take
+  # command line arguments, parse them and use the resulting options in the
+  # command execution.
+  #
+  # Usage example:
+  #
+  #   class MyCommand
+  #     extend Command
+  #
+  #     usage 'greet [OPTIONS]' do |o|
+  #       o.on '-n', '--name', 'Provide the name to be used' do |name|
+  #         options[:name] = name
+  #       end
+  #     end
+  #
+  #     def call(arguments)
+  #       puts "Hello, #{options[:name]}!"
+  #     end
+  #   end
+  module Command
+    def self.extended(base) # :nodoc:
+      base.send(:prepend, InstanceMethods)
+    end
+
+    # Define the command line options available to this command. This is a
+    # wrapper around Ruby's own +OptionParser+. Options defined here will be
+    # parsed out of incoming arguments, and what remains will be passed to
+    # #call. Within this block, you have access to an +options+ hash that
+    # is also available in the #call method.
+    def usage(description, &block)
+      @usage_description = description
+      @usage_options = block
+    end
+
+    # Get the usage description set with #usage.
+    def usage_description
+      @usage_description ||= ''
+    end
+
+    # Get the +OptionParser+ definition block set with #usage.
+    def usage_options
+      @usage_options ||= ->(opts) {}
+    end
+
+    # Special instance methods for Command objects that define a common
+    # interface:
+    #
+    # * #options can hold options parsed from command-line switches
+    # * #call can be invoked to run the command.
+    module InstanceMethods
+      # An generic +options+ hash that can be used to store preferences in from
+      # command line options, available in both the #usage block and the #call
+      # method.
+      def options
+        @otions ||= {}
+      end
+
+      # Override #call to provide your custom logic for a command object. The
+      # #call in this module will be prepended to #call in your own objects,
+      # ensuring that when invoked, all options will first be parsed. All
+      # non-recognized options will be passed as-is to the original #call
+      # method.
+      def call(arguments)
+        OptionParser.new do |o|
+          o.banner = 'Usage: ' + self.class.usage_description
+          o.separator ''
+          instance_exec o, &self.class.usage_options
+          o.on_tail '-h', '--help', 'Show this message' do
+            puts o
+            exit
+          end
+        end.parse!(arguments)
+        super(arguments)
+      end
+    end
+  end
+end

data/lib/redmine/commands.rb

@@ -0,0 +1,10 @@
+require 'redmine/commands/issue'
+require 'redmine/commands/projects'
+require 'redmine/commands/issues'
+require 'redmine/commands/lead_times'
+
+module Redmine
+  # Wrapper module for command objects.
+  module Commands
+  end
+end

data/lib/redmine/commands/issue.rb

@@ -0,0 +1,22 @@
+require 'redmine/commands/issue/show'
+require 'redmine/commands/issue/activity'
+
+module Redmine
+  module Commands
+    # Dispatcher for issue-related subcommands.
+    class Issue
+      def initialize(issue_id:, redmine:)
+        @issue_id = issue_id
+        @redmine = redmine
+      end
+
+      def call(arguments)
+        subcommand, *other_args = arguments
+        command = self.class.const_get(
+          subcommand.split('_').map(&:capitalize).join
+        )
+        command.new(issue_id: @issue_id, redmine: @redmine).call(other_args)
+      end
+    end
+  end
+end

data/lib/redmine/commands/issue/activity.rb

@@ -0,0 +1,32 @@
+require 'redmine/command'
+
+module Redmine
+  module Commands
+    class Issue
+      # Sub-subcommand to show activity (comments, changes) on a given issue.
+      class Activity
+        extend Command
+
+        usage 'redmine [ISSUE] activity'
+
+        def initialize(issue_id:, redmine:)
+          @issue_id = issue_id
+          @redmine = redmine
+        end
+
+        def call(_args)
+          issue_statuses = @redmine.issue_statuses
+          issue = @redmine.issue(@issue_id)
+          issue.activity.each do |event|
+            puts "* #{event.user} on #{event.created_on}"
+            event.issue_changes.each do |change|
+              puts "  #{change.with_statuses(issue_statuses)}"
+            end
+            puts "  #{event.notes}"
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/issue/show.rb

@@ -0,0 +1,28 @@
+require 'redmine/command'
+
+module Redmine
+  module Commands
+    class Issue
+      # Sub-subcommand to show general information about a given issue.
+      class Show
+        extend Command
+
+        usage 'redmine [ISSUE] show'
+
+        def initialize(issue_id:, redmine:)
+          @issue_id = issue_id
+          @redmine = redmine
+        end
+
+        def call(_args)
+          issue = @redmine.issue(@issue_id)
+          puts "#{issue.tracker} #{issue.id} " \
+            "(#{issue.status}): #{issue.subject}"
+          puts "Author: #{issue.author}"
+          puts "Assigned to: #{issue.assigned_to}"
+          puts "\n#{issue.description}"
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/issues.rb

@@ -0,0 +1,44 @@
+require 'redmine/command'
+
+module Redmine
+  module Commands
+    # Command to list issues from Redmine.
+    class Issues
+      extend Command
+
+      # rubocop:disable Metrics/LineLength
+      usage 'redmine issues [options]' do |op|
+        op.on '--mine', 'Limit results to issues assigned to me' do
+          options[:assigned_to_id] = 'me'
+        end
+
+        op.on '-p', '--project ID', Integer, 'Limit results to the given project' do |id|
+          options[:project_id] = id
+        end
+
+        op.on '-s', '--status STATUS', %i(open closed), 'Show only open or closed issues', '(open, closed)' do |status|
+          options[:status_id] = status
+        end
+
+        op.on '-o', '--offset N', Integer, 'Skip the first N issues' do |n|
+          options[:offset] = n
+        end
+
+        op.on '-l', '--limit N', Integer, 'Limit the total number of issues' do |_n|
+          options[:total]
+        end
+      end
+
+      def initialize(redmine:)
+        @redmine = redmine
+      end
+
+      def call(_args)
+        total = options.delete(:total) || 10
+        @redmine.issues(options).first(total).each do |issue|
+          puts "#{issue.id} #{issue.subject}"
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/lead_times.rb

@@ -0,0 +1,62 @@
+require 'redmine/command'
+require 'json'
+require 'csv'
+
+module Redmine
+  module Commands
+    # Command to calculate lead times for one or more tickets in Redmine.
+    class LeadTimes
+      extend Command
+
+      def initialize(redmine:)
+        @redmine = redmine
+      end
+
+      # rubocop:disable Metrics/LineLength
+      usage 'redmine lead_times [OPTIONS] [ISSUE_ID...]' do |o|
+        o.on '-f', '--format FORMAT', %w(text csv json), 'Output format to use', '(text, csv, json)' do |format|
+          options[:format] = format
+        end
+      end
+
+      def call(arguments)
+        case options[:format]
+        when 'json' then generate_json(arguments)
+        when 'csv' then generate_csv(arguments)
+        when 'text' then generate_text(arguments)
+        else raise ArgumentError, "Unknown format #{options[:format].inspect}"
+        end
+      end
+
+      private
+
+      def generate_json(arguments)
+        lead_times = to_enum(:each_issue_lead_time, arguments).inject({}) do |output, (issue_id, lead_time)|
+          output.merge issue_id => lead_time
+        end
+        puts JSON.dump(lead_times)
+      end
+
+      def generate_csv(arguments)
+        csv_output = CSV.generate do |csv|
+          each_issue_lead_time(arguments) do |issue_id, lead_time|
+            csv << [issue_id, lead_time]
+          end
+        end
+        puts csv_output
+      end
+
+      def generate_text
+        each_issue_lead_time(arguments) do |issue_id, lead_time|
+          puts "#{issue_id}\t#{lead_time}"
+        end
+      end
+
+      def each_issue_lead_time(ids)
+        ids.each do |id|
+          yield id, @redmine.issue(id).lead_time
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/projects.rb

@@ -0,0 +1,20 @@
+require 'redmine/command'
+
+module Redmine
+  module Commands
+    # Command to list projects in Redmine.
+    class Projects
+      extend Command
+
+      def initialize(redmine:)
+        @redmine = redmine
+      end
+
+      def call(_arguments)
+        @redmine.projects.each do |project|
+          puts "#{project.id} #{project.name}"
+        end
+      end
+    end
+  end
+end

data/lib/redmine/configuration.rb

@@ -0,0 +1,27 @@
+require 'ostruct'
+require 'pathname'
+require 'yaml'
+
+module Redmine
+  # Container for library-level configuration, acting like an OpenStruct.
+  class Configuration < OpenStruct
+    # Filename of configuration files to look for.
+    CONFIG_FILENAME = '.redmine.yml'.freeze
+
+    # Load configuration from special YAML config files on disk, looking into
+    # the current directory and upwards, merging all together.
+    def self.autoload
+      new(Pathname
+        .pwd
+        .ascend
+        .lazy
+        .map { |p| p.join(CONFIG_FILENAME) }
+        .select(&:exist?)
+        .map { |p| YAML.load_file(p) }
+        .to_a
+        .reverse
+        .inject(:merge)
+         )
+    end
+  end
+end

data/lib/redmine/http_caching.rb

@@ -0,0 +1,63 @@
+require 'delegate'
+
+module Redmine
+  # A decorator object for RestClient that adds caching capabilities to regular
+  # RestClient objects. It wraps normal request methods and uses the +Etag+ and
+  # +If-None-Match+ headers to locally store responses. On subsequent requests
+  # for the same resource, we can skip downloading the entire body when the
+  # server indicates nothing has changed (Not Modified).
+  #
+  # A cache is used to keep track of responses. This is assumed to support the
+  # +Pstore+ interface, responding to +#transaction+, +#[]+ and +#[]=+ methods.
+  #
+  # Usage example:
+  #
+  #   require 'pstore'
+  #   cache = PStore.new('cache.pstore')
+  #   rest_client = RestClient.new
+  #   caching_rest_client = HttpCaching.new(rest_client, cache)
+  #   caching_rest_client.get('/path')
+  class HttpCaching < SimpleDelegator
+    def initialize(http, cache)
+      @cache = cache
+      super(http)
+    end
+
+    # Wrap RestClient#get to provide HTTP caching.
+    #
+    # New requests are stored in a cache if they have an +Etag+ header. On
+    # subsequent requests to the same resource, a +If-None-Match+ header is sent
+    # along, using the original Etag value. The server can then indicate that
+    # nothing has changed, which will trigger this decorator to return the
+    # cached response -- rather than downloading a whole new copy of the same
+    # data.
+    def get(path, headers = {})
+      cached_response = fetch_cached_response(path)
+      if cached_response
+        headers = headers.merge 'If-None-Match' => cached_response['Etag']
+      end
+      response = super(path, headers)
+      case response
+      when Net::HTTPNotModified then cached_response
+      else
+        cache_response(path, response)
+        response
+      end
+    end
+
+    private
+
+    def fetch_cached_response(path)
+      @cache.transaction do
+        @cache[URI(path).path]
+      end
+    end
+
+    def cache_response(path, response)
+      return unless response['Etag']
+      @cache.transaction do
+        @cache[path] = response
+      end
+    end
+  end
+end

data/lib/redmine/issue.rb

@@ -0,0 +1,42 @@
+require 'time'
+require 'redmine/value'
+require 'redmine/issue_event'
+
+module Redmine
+  # Represents a single issue (ticket) in the Redmine system.
+  class Issue < Value
+    attribute :id, type: Integer
+    attribute :subject
+    attribute :description
+    attribute :done_ratio, type: Integer
+    attribute :start_date, type: DateTime
+    attribute :created_on, type: DateTime
+    attribute :updated_on, type: DateTime
+    attribute :closed_on, type: DateTime
+    attribute :project, path: 'name'
+    attribute :tracker, path: 'name'
+    attribute :status, path: 'name'
+    attribute :priority, path: 'name'
+    attribute :author, path: 'name'
+    attribute :assigned_to, path: 'name'
+    attribute :fixed_version, path: 'name'
+    attribute :journals, type: Array
+    attribute :spent_hours, type: Integer
+
+    # List event history for this Issue as IssueEvent objects.
+    def activity
+      journals.map do |event|
+        IssueEvent.new(event)
+      end
+    end
+
+    # Calculate the lead time for this ticket.
+    #
+    # This returns the difference in days between the closed date and the start
+    # date.
+    def lead_time
+      return Float::INFINITY unless closed_on
+      (closed_on - [created_on, start_date].max).to_i
+    end
+  end
+end

data/lib/redmine/issue_change.rb

@@ -0,0 +1,40 @@
+require 'redmine/value'
+
+module Redmine
+  # An IssueChange is a change in the history of an Issue, such as assigning it
+  # to a different user, or changing its state.
+  class IssueChange < Value
+    attribute :id, type: Integer
+    attribute :name
+    attribute :property
+    attribute :old_value
+    attribute :new_value
+
+    # Provide a human-readable description of the change that this object
+    # represents.
+    def to_s
+      format '%s: %s => %s', name, old_value, new_value
+    end
+
+    # Like #to_s, but use a given map of IDs to human-readable statuses to
+    # provide more meaningful information.
+    def with_statuses(issue_statuses)
+      if name == 'status_id'
+        format 'Status: %s => %s',
+               find_issue_status(issue_statuses, old_value),
+               find_issue_status(issue_statuses, new_value)
+      else
+        to_s
+      end
+    end
+
+    private
+
+    def find_issue_status(issue_statuses, value)
+      issue_status = issue_statuses.find do |is|
+        is.fetch('id').to_i == value.to_i
+      end
+      issue_status.fetch('name')
+    end
+  end
+end

data/lib/redmine/issue_event.rb

@@ -0,0 +1,23 @@
+require 'time'
+require 'redmine/value'
+require 'redmine/issue_change'
+
+module Redmine
+  # An IssueEvent is a set of changes by a user to an Issue in the system,
+  # optionally with some notes. A user might change several properties of a
+  # ticket at once, as represented by IssueChange.
+  class IssueEvent < Value
+    attribute :id, type: Integer
+    attribute :user, path: 'name'
+    attribute :notes
+    attribute :created_on, type: DateTime
+    attribute :details, type: Array
+
+    # List of all changes introduced by this event as IssueChange objects.
+    def issue_changes
+      @details.map do |change|
+        IssueChange.new(change)
+      end
+    end
+  end
+end

data/lib/redmine/project.rb

@@ -0,0 +1,16 @@
+require 'time'
+require 'redmine/value'
+
+module Redmine
+  # A project is a container of issues.
+  class Project < Value
+    attribute :id, type: Integer
+    attribute :name
+    attribute :identifier
+    attribute :description
+    attribute :status
+    attribute :parent
+    attribute :created_on, type: DateTime
+    attribute :updated_on, type: DateTime
+  end
+end

data/lib/redmine/rest_client.rb

@@ -0,0 +1,33 @@
+require 'redmine/accept_json'
+require 'redmine/http_caching'
+require 'net/http'
+
+module Redmine
+  # Simple REST-aware HTTP client that uses +Net::HTTP+ under the hood to make
+  # external requests. Most of its functionality comes from decorators, such as
+  # AcceptJson and HttpCaching.
+  class RestClient
+    # Initialize a new RestClient using default headers to be included in all
+    # requests, and optionally a customized HTTP client. If not providing a
+    # custom +http+ option, you can provide a +base_uri+ that will be used to
+    # create a new Net::HTTP instance.
+    def initialize(
+      default_headers: {},
+      base_uri: nil,
+      http: Net::HTTP.new(base_uri.host, base_uri.port)
+    )
+      @http = http
+      @default_headers = default_headers
+    end
+
+    # Perform a GET requests to a given path, optionally with additional
+    # headers. Returns raw Net::HTTPResponse objects.
+    def get(path, headers = {})
+      request = Net::HTTP::Get.new(path)
+      @default_headers.merge(headers).each do |key, value|
+        request[key] = value
+      end
+      @http.request(request)
+    end
+  end
+end

data/lib/redmine/value.rb

@@ -0,0 +1,88 @@
+module Redmine
+  # Base class for immutable value objects.
+  #
+  # Value objects with the same attributes are considered equal. Value objects
+  # cannot be modified, but new values can be constructed by applying new
+  # attribute values to existing values.
+  class Value
+    attr_reader :hash
+
+    # List of all known attributes supported by this Value.
+    def self.attributes
+      @attributes ||= []
+    end
+
+    # @param [Object] value raw data to be tranformed into `type`.
+    # @param [Object, #parse] type
+    # @return [Object] value parsed to `type`
+    def self.parse_value(value, type = nil)
+      case type
+      when ->(t) { t.nil? } then value
+      when ->(t) { t === value } then value
+      when ->(t) { t.respond_to?(:parse) } then type.parse(value)
+      when ->(t) { Kernel.respond_to?(t.to_s) }
+        Kernel.send(type.to_s, value)
+      else raise ArgumentError, "Invalid type #{type.inspect}"
+      end
+    end
+
+    # Define a new attribute for this value. Attributes can be casted
+    # into a specific type, and can optionally be read from a path
+    # inside a nested structure (see Rubys `dig` method).
+    #
+    # @param [Symbol, #to_sym] name
+    # @param [Class, #parse] type conversion method or class that can be
+    #   used to parse the incoming values.
+    # @param [Array] path for `dig` to retrieve nested values
+    # @return [nil]
+    def self.attribute(name, type: nil, path: nil)
+      attributes << name.to_sym
+      attr_reader name
+
+      define_method :"#{name}=" do |value|
+        value = value.dig(*Array(path)) if path && value.respond_to?(:dig)
+        parsed_value = self.class.parse_value(value, type)
+        instance_variable_set(:"@#{name}", parsed_value)
+      end
+
+      private :"#{name}="
+      nil
+    end
+
+    # @param [Hash] attrs
+    def initialize(attrs = {})
+      attrs.to_h.each do |name, value|
+        send(:"#{name}=", value)
+      end
+      @hash = self.class.hash ^ to_a.hash
+      freeze
+    end
+
+    # Create a new value based on the current value, but with the incoming
+    # attributes assigned. This "changes" the value, but leaves the original
+    # value intact -- as you'll get a new instance instead.
+    #
+    # @param [Hash] attrs new attributes to be merged with this value's
+    #   attributes.
+    # @return [Value]
+    def with(attrs = {})
+      self.class.new(to_h.merge(attrs))
+    end
+
+    # @return [Bool]
+    def eql?(other)
+      hash == other.hash
+    end
+    alias == eql?
+
+    # @return [Hash]
+    def to_h
+      Hash[to_a]
+    end
+
+    # @return [Array]
+    def to_a
+      self.class.attributes.map { |attr| [attr, send(attr)] }
+    end
+  end
+end

data/lib/redmine/version.rb

@@ -0,0 +1,3 @@
+module Redmine
+  VERSION = '0.1.1'.freeze
+end

data/redmine_api.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redmine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'redmine-api'
+  spec.version       = Redmine::VERSION
+  spec.authors       = ['Arjan van der Gaag']
+  spec.email         = ['arjan@arjanvandergaag.nl']
+
+  spec.summary       = 'Work with Redmine from the command line.'
+  spec.homepage      = 'https://avdgaag.github.io/redmine-api'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f|
+    f.match(%r{^(test|spec|features)/})
+  }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: redmine-api
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Arjan van der Gaag
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- arjan@arjanvandergaag.nl
+executables:
+- redmine
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rake
+- bin/setup
+- exe/redmine
+- lib/redmine.rb
+- lib/redmine/accept_json.rb
+- lib/redmine/cli.rb
+- lib/redmine/client.rb
+- lib/redmine/command.rb
+- lib/redmine/commands.rb
+- lib/redmine/commands/issue.rb
+- lib/redmine/commands/issue/activity.rb
+- lib/redmine/commands/issue/show.rb
+- lib/redmine/commands/issues.rb
+- lib/redmine/commands/lead_times.rb
+- lib/redmine/commands/projects.rb
+- lib/redmine/configuration.rb
+- lib/redmine/http_caching.rb
+- lib/redmine/issue.rb
+- lib/redmine/issue_change.rb
+- lib/redmine/issue_event.rb
+- lib/redmine/project.rb
+- lib/redmine/rest_client.rb
+- lib/redmine/value.rb
+- lib/redmine/version.rb
+- redmine_api.gemspec
+homepage: https://avdgaag.github.io/redmine-api
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Work with Redmine from the command line.
+test_files: []
+has_rdoc: