jira-slurper 1.3.1

data/lib/jira.rb

@@ -0,0 +1,113 @@
+require 'faraday'
+require 'configliere'
+require 'base64'
+require 'json'
+
+# Jira handler
+class Jira
+
+  def initialize(jira_mapper = nil, jira_api = nil)
+    @mapper = jira_mapper || JiraStoryMapper.new
+    @api = jira_api || JiraApi.new
+  end
+
+  def supports?(config)
+    config.fetch('tracker', '').downcase == 'jira'
+  end
+
+  def configure!(config)
+    settings = Configliere::Param.new
+
+    settings.define :username, :required => true, :env_var => 'JIRA_USERNAME'
+    settings.define :password, :required => true, :env_var => 'JIRA_PASSWORD'
+    settings.define :url, :required => true
+    settings.define :project, :required => true
+
+    settings.defaults api_version: 'latest', default_labels: ''
+
+    settings.use(config)
+    settings.resolve!
+
+    @config = settings
+  end
+
+  def handle(yaml_story)
+    @api.configure!(@config[:url], @config[:username], @config[:password], @config[:api_version])
+
+    issue = @mapper.map(yaml_story, @config[:project])
+
+    success, response_body = @api.create_issue(issue)
+    response = JSON.parse response_body
+
+    if success
+      message = "Issue key = #{response['key']}, #{@config[:url]}/browse/#{response['key']}"
+    else
+      message = JSON.pretty_generate response
+    end
+
+    yield success, message
+  end
+
+end
+
+class JiraApi
+
+  def configure!(url, username, password, api_version = 'latest')
+    @url = url
+    @username = username
+    @password = password
+    @api_version = api_version
+  end
+
+  def create_issue(jira_story)
+    response = post(url, jira_story.to_json, headers)
+    return response.success?, response.body
+  end
+
+  protected
+
+  def headers
+    {'Content-Type' => 'application/json', 'Authorization' => auth_header}
+  end
+
+  def post(issues_url, json_data, headers)
+
+    conn = Faraday.new do |faraday|
+      faraday.headers = headers
+      faraday.adapter  Faraday.default_adapter
+    end
+
+    conn.post do |req|
+      req.url issues_url
+      req.body = json_data
+    end
+
+  end
+
+  def url
+    "#{@url}/rest/api/#{@api_version}/issue/"
+  end
+
+  def auth_header
+    login = Base64.encode64 @username + ':' + @password
+    "Basic #{login}"
+  end
+
+end
+
+class JiraStoryMapper
+
+  def map(story, project)
+    hash = {}
+    hash[:project] = {:key => project}
+    hash[:summary] = story.name
+    hash[:description] = story.description
+    hash[:issuetype] = {:name => story.story_type}
+
+    if story.labels
+      hash[:labels] = story.labels.map {|label| label.gsub(' ', '_')}
+    end
+
+    { :fields => hash }
+  end
+end

data/lib/pivotal.rb

@@ -0,0 +1,115 @@
+require 'json'
+
+# Pivotal handler
+class Pivotal
+
+  def initialize(pivotal_api = nil)
+    @api = pivotal_api || PivotalApi.new
+  end
+
+  def supports?(config)
+    (config['tracker'] == nil && config['project_id'] != nil) || config.fetch('tracker', '').downcase == 'pivotal'
+  end
+
+  def configure!(config)
+    settings = Configliere::Param.new
+
+    settings.define :project_id, :required => true
+    settings.define :token, :required => true, :env_var => 'PIVOTAL_TOKEN'
+
+    settings.use(config)
+    settings.resolve!
+
+    @config = settings
+  end
+
+  def handle(yaml_story)
+    @api.configure!(@config.project_id, @config.token)
+
+    success, response_body = @api.create_story(yaml_story)
+    response = JSON.parse response_body
+
+    if success
+      message = "Issue ID = #{response['id']}, #{response['url']}"
+    else
+      message = JSON.pretty_generate response
+    end
+
+    yield success, message
+  end
+
+  def dump(filter)
+    @api.configure!(@config.project_id, @config.token)
+    @api.stories(filter).each do |story|
+      yield YamlStory.new(
+          name: story['name'],
+          description: story['description'],
+          story_type: story['story_type'],
+          labels: story['labels'].map{|l| l['name']}.join(', ')
+      )
+    end
+  end
+
+end
+
+class PivotalApi
+
+  def configure!(project, token)
+    @token = token
+    @project = project
+  end
+
+  def create_story(yaml_story)
+    story = {
+        story_type: yaml_story.story_type,
+        name: yaml_story.name,
+        description: yaml_story.description,
+        labels: yaml_story.labels.map { |label| {:name => label} },
+        #requested_by_id: yaml_story.requested_by
+    }
+
+    response = post(url('stories'), story.to_json, headers)
+    return response.success?, response.body
+  end
+
+  def stories(filter)
+    response = get(url('stories'), filter, headers)
+    unless response.success?
+      raise Exception.new "#{response.status} #{response.body}"
+    end
+
+    JSON.parse(response.body.encode('ASCII', :invalid => :replace, :undef => :replace, :replace => '?'))
+  end
+
+  protected
+
+  def headers
+    {'Content-Type' => 'application/json', 'X-TrackerToken' => @token}
+  end
+
+  def get(issues_url, filter, headers)
+    conn = Faraday.new(ssl={:verify => false}) do |faraday|
+      faraday.headers = headers
+      faraday.adapter Faraday.default_adapter
+    end
+
+    conn.get issues_url, {filter: filter, limit: 1000}
+  end
+
+  def post(issues_url, json_data, headers)
+    conn = Faraday.new(ssl={:verify => false}) do |faraday|
+      faraday.headers = headers
+      faraday.adapter Faraday.default_adapter
+    end
+
+    conn.post do |req|
+      req.url issues_url
+      req.body = json_data
+    end
+
+  end
+
+  def url(resource)
+    "https://www.pivotaltracker.com/services/v5/projects/#{@project}/#{resource}"
+  end
+end

data/lib/slurper.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+require 'story'
+
+class Slurper
+  attr_accessor :story_file, :stories, :handlers
+
+  def self.dump(config_file, filter, handlers, reverse)
+    config = self.load_config(config_file)
+    slurper = new(config)
+    slurper.handlers = handlers
+    slurper.dump_stories(filter)
+  end
+
+  def self.slurp(story_file, config_file, handlers, reverse)
+    config = self.load_config(config_file)
+
+    stories = self.load_stories(story_file, config)
+    stories.reverse! unless reverse
+
+    slurper = new(config, stories)
+    slurper.handlers = handlers
+    slurper.create_stories
+  end
+
+  def initialize(config, stories=[])
+    @config = config
+    @stories = stories
+    @handlers = []
+  end
+
+  def self.load_stories(story_file, defaults = {})
+    stories = []
+    yamlize_story_file(story_file).each do |story|
+      begin
+         story_hash = YAML.load(story)
+         stories << story_hash if story_hash.is_a?(Hash)
+      rescue
+        puts 'Error encountered when trying to parse the following story'
+        puts '-' * 10
+        puts story
+        puts '-' * 10
+        return []
+      end
+    end
+    stories.map { |story_hash| YamlStory.new(story_hash, defaults) }
+  end
+
+  def self.load_config(config_file)
+    YAML.load_file(config_file)
+  end
+
+  def dump_stories(filter)
+    handler.dump(filter) do |story|
+      puts story.to_yaml
+    end
+  end
+
+  def create_stories
+    puts "Preparing to slurp #{stories.size} stories into #{handler.class.name}..."
+
+    @stories.each_with_index do |story, index|
+      puts "#{index+1}. #{story.name}"
+
+      begin
+        handler.handle(story) do |status, message|
+          if status then
+            puts "Success: #{message}"
+          else
+            puts "Failed: #{message}"
+          end
+        end
+
+      rescue Exception => ex
+        puts "Failed: #{ex.message}"
+      end
+    end
+  end
+
+  protected
+
+  def handler
+    return @handler if @handler
+
+    config = @config
+    handler = @handlers.detect { |handler| handler.supports? config }
+
+    unless handler
+      error = "No handler found for the given configuration: #{config}"
+      raise error
+    end
+
+    handler.configure! config
+    @handler = handler
+  end
+
+  def self.yamlize_story_file(story_file)
+    IO.read(story_file).
+      gsub(/description:$/, 'description: |').
+      gsub(/\t/, '  ').
+      split(/==.*/)
+  end
+
+end

data/lib/story.rb

@@ -0,0 +1,48 @@
+# Simple value object for a story
+# It's only concern is to store and format yaml data from stories
+class YamlStory
+
+  attr_reader :name, :story_type, :requested_by
+
+  def initialize(attributes = {}, defaults = {})
+    # delete empty values (otherwise the default_proc bellow won't be called)
+    attributes.delete_if { |key, val| val == '' }
+
+    attributes.default_proc = proc do |hash, key|
+        defaults[key]
+      end
+
+    @name = attributes['name']
+    @description = attributes['description']
+    @story_type = attributes['story_type']
+    @labels = attributes['labels']
+    @requested_by = attributes['requested_by']
+  end
+
+  def labels
+    return [] if not @labels
+    @labels.split(',').map { |label| label.strip }
+  end
+
+  def description
+    return nil if @description == nil || @description == ''
+
+    @description.gsub('  ', '').gsub(" \n", "\n")
+  end
+
+  def yaml_description
+    return '' if @description == nil || @description == ''
+    return @description.gsub(/^/, '  ')
+  end
+
+  def to_yaml
+    return "==
+story_type: #{story_type}
+name: \"#{name.gsub('"', "'")}\"
+description:
+#{yaml_description}
+labels: #{labels.join(', ')}
+"
+  end
+
+end

data/spec/jira_spec.rb

@@ -0,0 +1,137 @@
+require 'rubygems'
+require 'slurper'
+require 'story'
+require 'jira'
+
+describe JiraStoryMapper do
+  before do
+    @story = YamlStory.new('name' => 'Story name', 'story_type' => 'Feature',
+                           'description' => 'Story desc', 'labels' => 'a, b')
+    @mapper = JiraStoryMapper.new
+  end
+
+  it 'should take the project key from config' do
+    result = @mapper.map(@story, 'AB')
+    result[:fields][:project][:key].should == 'AB'
+  end
+
+  it 'should set the issuetype field with the story_type' do
+    result = @mapper.map(@story, 'AB')
+    result[:fields][:issuetype][:name].should == 'Feature'
+  end
+
+  it 'should split and trim labels' do
+    result = @mapper.map(@story, 'AB')
+    result[:fields][:labels].should == ['a', 'b']
+  end
+end
+
+describe JiraApi do
+  it 'should post with correctly configured the url' do
+    good_response = double(success?: true, body: '{"id": 1, "key": "TEST-1", "self":"http://localhost:8090/rest/api/2/issue/1"}')
+
+    api = JiraApi.new
+    api.configure!('http://server', 'user', 'pass', '2')
+
+    api.should_receive(:post).with('http://server/rest/api/2/issue/', 'json', kind_of(Hash)).and_return good_response
+
+    api.create_issue(double(to_json: 'json'))
+
+  end
+
+  it 'should raise error if the issue was not saved' do
+    bad_response = double(success?: false, status: 401)
+    issue = double(to_json: 'json')
+
+    api = JiraApi.new
+    api.configure!('http://server', 'user', 'pass', '2')
+    api.should_receive(:post).and_return(bad_response)
+
+    expect { api.create_issue(issue) }.to raise_error Exception
+
+  end
+
+end
+
+describe Jira do
+
+  before do
+    @jira = Jira.new
+  end
+
+  context '#supports' do
+    it 'should support the jira config if tracker is given' do
+      @jira.supports?('tracker' => 'jira').should == true
+    end
+
+    it 'should not support if tracker is missing' do
+      @jira.supports?({}).should == false
+    end
+
+    it 'should not support if tracker is anything else' do
+      @jira.supports?('tracker' => 'pivotal').should == false
+    end
+  end
+
+  context "#configure" do
+    it 'should fail if a required field is missing' do
+      expect {
+        @jira.configure!(:project => 'a project').should be_false
+      }.to raise_error 'Missing values for: password, url, username'
+    end
+
+    context 'good config provided' do
+      before do
+        required = [:username, :password, :project, :url]
+        @raw_config = Hash[required.map {|v| [v, 'value']} ]
+      end
+
+      it 'should pass if the required fields are present' do
+        config = @jira.configure! @raw_config
+        config.username.should == 'value'
+      end
+
+      it 'should return the default api version' do
+        config = @jira.configure! @raw_config
+        config[:api_version].should == 'latest'
+      end
+
+      it 'should overwrite the default api_version' do
+        @raw_config[:api_version] = '2'
+        config = @jira.configure! @raw_config
+        config[:api_version].should == '2'
+      end
+    end
+  end
+
+  context '#handle' do
+
+    before do
+      @config = {
+          :project => 'AB',
+          :username => 'user',
+          :password => 'pass',
+          :url => 'http://host'
+      }
+      @story = YamlStory.new(:description => 'description', :name => 'A story', :story_type => 'New Feature', :labels => 'a,b')
+    end
+
+    it 'should create a json issue using the api' do
+      issue = double(to_json: 'json')
+      mapper = double(map: issue)
+
+      api = double()
+      api.should_receive(:configure!).with('http://host', 'user', 'pass', 'latest')
+      api.should_receive(:create_issue).with(issue).and_return([true, '{"id": 1, "key": "TEST-1", "self":"http://localhost:8090/rest/api/2/issue/1"}'])
+
+      handler = Jira.new(mapper, api)
+      handler.configure! @config
+      handler.handle @story do |status, response|
+        expect(status).to be_true
+        expect(response).to include('TEST-1')
+      end
+    end
+
+  end
+
+end