jira-slurper 1.3.1 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6ad181f2dca8798ddadff89769d39844986dd03
-  data.tar.gz: d797ec588af063f63d4bcee2065b5cf833fb0cb0
+  metadata.gz: 8fe9b95e6287faca051d81a53b31a96dc83bcc97
+  data.tar.gz: be88e9ef68afb38a263592a8305d2264762b47e2
 SHA512:
-  metadata.gz: 82041d79a329dfd4db59771b6e35c1571c8bbf45a0dd814ab466cf7847d4c40d078e114eb0cc04a0ba44c9c806966544773840c87cb612cbef1e2912de957961
-  data.tar.gz: 9c02687fb906ffde1115e8d3f00437f02fe14fca41d5c3bbadc563bbf13b5d2797e3102ef9ffc3086f9c65ab4689307ecbb16b94a36d952799d810dc00a88d93
+  metadata.gz: 19d143ebdf7583731ba5d8bdfb1e566bc23f535ffb1793e6d9f0bbe8ddfda09e314314812d86b77cb35a9a0c08c7aa53c2b8910e470b07a3c78d7d2cb6da205b
+  data.tar.gz: a755f9a35edfd10c66b3b8702222278c88656b7c869a714a528b2bb3f72201b8dd6352a6328dc8d3cb84e72cc9b6eeabe6f41ef0519857b89386f4ec4ad853b7

data/README.rdoc

@@ -1,12 +1,12 @@
-= slurper gem
+= jira-slurper gem
 
-Slurper allows you to quickly compose your stories in a text file and import them into Pivotal Tracker.
+Slurper allows you to quickly compose your stories in a text file and import them into Jira or Pivotal Tracker.
 
 Works great with slurper.vim! (http://github.com/adamlowe/vim-slurper)
 
 == Install
 
-    gem install slurper
+    gem install jira-slurper
 
 == Config
 

data/bin/slurp

@@ -41,10 +41,10 @@ end.parse!
 
 story_file = ARGV.empty? ? "stories.slurper" : ARGV[0]
 
-handlers = [Jira.new, Pivotal.new]
+handlers = [Jira::Handler.new, Pivotal.new]
 
-raise "Stories file not found: '#{story_file}'" if not File::exists? story_file
-raise "Config file not found: '#{options[:config_file]}'" if not File::exists? options[:config_file]
+raise "Stories file not found: '#{story_file}'" unless File::exists? story_file
+raise "Config file not found: '#{options[:config_file]}'" unless File::exists? options[:config_file]
 
 if options[:dump]
   Slurper.dump(options[:config_file], options[:filter], handlers, options[:reverse])

data/lib/jira/inflectors.rb

@@ -0,0 +1,108 @@
+module Jira
+  module Inflectors
+
+    class BaseInflector
+      def initialize(value)
+        @value = value
+      end
+
+      def value
+        @value
+      end
+    end
+
+    class StringInflector < BaseInflector
+      def initialize(value)
+        super(value.to_s)
+      end
+
+      def value
+        super.strip
+      end
+    end
+
+    class NumberFieldInflector < BaseInflector
+      def value
+        @value.to_f
+      end
+    end
+
+    class LabelInflector < StringInflector
+      def value
+        super.gsub(' ', '_')
+      end
+    end
+
+    class IndexedValueInflector < BaseInflector
+      def initialize(value, key=nil)
+        super(value)
+        if key.nil?
+          key = :id if value.is_a?(Fixnum) or (value.is_a?(String) && value[/^[0-9]+$/])
+        end
+        @key = key || :value
+      end
+
+      def value
+        {@key.to_sym => super}
+      end
+    end
+
+    class CompositeInflector < BaseInflector
+      def initialize(*inflectors)
+        @inflectors = inflectors
+      end
+
+      def value
+        @inflectors.map(&:value)
+      end
+    end
+
+    def self.factory(type, value)
+      case type.to_s
+        when 'FreeTextField', 'TextField', 'URLField'
+          StringInflector.new(value)
+        when 'GroupPicker', 'UserPicker', 'SingleVersionPicker', 'SingleSelect'
+          IndexedValueInflector.new(value, :name)
+        when 'MultiUserPicker', 'MultiGroupPicker', 'MultiSelect'
+          inner = ensure_list(value) do |value|
+            value.map do |v|
+              begin
+                factory(type.sub('Multi', ''), v)
+              rescue
+                factory(type.sub('Multi', 'Single'), v)
+              end
+            end
+          end
+          CompositeInflector.new(*inner)
+        when 'Labels'
+          ensure_list(value) do |value|
+            CompositeInflector.new(*(value.map { |v| LabelInflector.new(v) }))
+          end
+        when 'SelectList'
+          IndexedValueInflector.new(value, :value)
+        when 'ProjectPicker'
+          IndexedValueInflector.new(value, :key)
+        else
+          inflector = "#{type}Inflector".to_sym
+          unless const_defined?(inflector)
+            raise "Unrecognized field type \"#{type}\""
+          end
+          const_get(inflector).new(value)
+      end
+    end
+
+    private
+
+    def self.ensure_list(value)
+      value = case value
+                when String
+                  value.split(',').map(&:strip)
+                when Enumerable
+                  value
+                else
+                  raise('Expected enumerable value')
+              end
+      yield value if block_given?
+    end
+  end
+end

data/lib/jira.rb

@@ -2,112 +2,162 @@ require 'faraday'
 require 'configliere'
 require 'base64'
 require 'json'
+require 'jira/inflectors'
 
-# Jira handler
-class Jira
+module Jira
+  class Handler
 
-  def initialize(jira_mapper = nil, jira_api = nil)
-    @mapper = jira_mapper || JiraStoryMapper.new
-    @api = jira_api || JiraApi.new
-  end
+    def initialize(jira_mapper = nil, jira_api = nil)
+      @mapper = jira_mapper || StoryMapper.new
+      @api = jira_api || ApiConsumer.new
+    end
 
-  def supports?(config)
-    config.fetch('tracker', '').downcase == 'jira'
-  end
+    def supports?(config)
+      config.fetch('tracker', '').downcase == 'jira'
+    end
 
-  def configure!(config)
-    settings = Configliere::Param.new
+    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.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.define :mappings, :required => false
 
-    settings.defaults api_version: 'latest', default_labels: ''
+      settings.defaults api_version: 'latest', default_labels: '', mappings: {}
 
-    settings.use(config)
-    settings.resolve!
+      settings.use(config)
+      settings.resolve!
 
-    @config = settings
-  end
+      @mapper.configure!(settings)
+      @config = settings
+    end
+
+    def handle(yaml_story)
+      @api.configure!(@config[:url], @config[:username], @config[:password], @config[:api_version])
 
-  def handle(yaml_story)
-    @api.configure!(@config[:url], @config[:username], @config[:password], @config[:api_version])
+      yaml_story['project'] = @config[:project]
+      yaml_story['reporter'] = @config[:username] unless yaml_story.key?('reporter')
 
-    issue = @mapper.map(yaml_story, @config[:project])
+      issue = @mapper.map(yaml_story)
 
-    success, response_body = @api.create_issue(issue)
-    response = JSON.parse response_body
+      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
+      if success
+        message = "Issue key = #{response['key']}, #{@config[:url]}/browse/#{response['key']}"
+      else
+        message = JSON.pretty_generate response
+      end
+
+      yield success, message
     end
 
-    yield success, message
   end
 
-end
+  class ApiConsumer
 
-class JiraApi
+    def configure!(url, username, password, api_version = 'latest')
+      @url = url
+      @username = username
+      @password = password
+      @api_version = api_version
+    end
 
-  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
 
-  def create_issue(jira_story)
-    response = post(url, jira_story.to_json, headers)
-    return response.success?, response.body
-  end
+    protected
 
-  protected
+    def headers
+      {'Content-Type' => 'application/json', 'Authorization' => auth_header}
+    end
 
-  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
 
-  def post(issues_url, json_data, headers)
+      conn.post do |req|
+        req.url issues_url
+        req.body = json_data
+      end
 
-    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
+    def url
+      "#{@url}/rest/api/#{@api_version}/issue/"
     end
 
-  end
+    def auth_header
+      login = Base64.encode64 @username + ':' + @password
+      "Basic #{login}"
+    end
 
-  def url
-    "#{@url}/rest/api/#{@api_version}/issue/"
   end
 
-  def auth_header
-    login = Base64.encode64 @username + ':' + @password
-    "Basic #{login}"
-  end
+  class StoryMapper
 
-end
+    def initialize
+      @map = default_mapping
+    end
 
-class JiraStoryMapper
+    def configure!(config)
+      config[:mappings].each do |mapping|
+        field, map = mapping
+        @map[field] = map.to_hash
+      end
+    end
 
-  def map(story, project)
-    hash = {}
-    hash[:project] = {:key => project}
-    hash[:summary] = story.name
-    hash[:description] = story.description
-    hash[:issuetype] = {:name => story.story_type}
+    def map(story)
+      fields = story.to_hash.inject({}) do |hash, (key, value)|
+        hash.merge!(do_map(key, value))
+        hash
+      end
+      {:fields => fields}
+    end
 
-    if story.labels
-      hash[:labels] = story.labels.map {|label| label.gsub(' ', '_')}
+    private
+
+    def default_mapping
+      {
+          :project => {
+              :type => 'ProjectPicker'
+          },
+          :name => {
+              :field_name => :summary,
+              :type => 'TextField'
+          },
+          :description => {
+              :type => 'FreeTextField'
+          },
+          :story_type => {
+              :field_name => :issuetype,
+              :type => 'SingleSelect'
+          },
+          :labels => {
+              :type => 'Labels'
+          },
+          :reporter => {
+              :type => 'SingleSelect'
+          },
+          :assignee => {
+              :type => 'SingleSelect'
+          }
+      }
     end
 
-    { :fields => hash }
+    def do_map(key, value)
+      map = @map[key.to_sym].tap do |m|
+        raise "I don't know how to map '#{key}' to request. Please add it to your mappings config." if m.nil?
+      end
+
+      {map.fetch(:field_name, key).to_sym => Inflectors.factory(map.fetch(:type), value).value}
+    end
   end
 end

data/lib/slurper.rb

@@ -2,6 +2,9 @@ require 'yaml'
 require 'story'
 
 class Slurper
+
+  GLOBAL_STORY_ATTRIBUTES = ['project']
+
   attr_accessor :story_file, :stories, :handlers
 
   def self.dump(config_file, filter, handlers, reverse)
@@ -14,7 +17,7 @@ class Slurper
   def self.slurp(story_file, config_file, handlers, reverse)
     config = self.load_config(config_file)
 
-    stories = self.load_stories(story_file, config)
+    stories = self.load_stories(story_file, config.select {|k, _| GLOBAL_STORY_ATTRIBUTES.include?(k)})
     stories.reverse! unless reverse
 
     slurper = new(config, stories)
@@ -63,7 +66,7 @@ class Slurper
 
       begin
         handler.handle(story) do |status, message|
-          if status then
+          if status
             puts "Success: #{message}"
           else
             puts "Failed: #{message}"

data/lib/story.rb

@@ -2,47 +2,75 @@
 # 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']
+    # delete empty values
+    attributes.delete_if do |key, val|
+      val == '' && defaults.key?(key)
+    end
+    @attributes = defaults.merge(attributes)
   end
 
   def labels
-    return [] if not @labels
-    @labels.split(',').map { |label| label.strip }
+    (@attributes['labels'] || '').split(',').map(&:strip)
   end
 
   def description
-    return nil if @description == nil || @description == ''
+    description = @attributes['description'] || ''
+    if description == ''
+      nil
+    else
+      description.gsub('  ', '').gsub(" \n", "\n")
+    end
+  end
+
+  def key?(key)
+    @attributes.key?(key.to_s)
+  end
+
+  def [](key)
+    raise "Attribute #{key} not defined" unless @attributes.key?(key.to_s)
+
+    if respond_to?(key.to_sym)
+      send(key.to_sym)
+    else
+      @attributes[key.to_s] == '' ? nil : @attributes[key.to_s]
+    end
+  end
+
+  def []=(key, value)
+    @attributes[key.to_s] = value
+  end
+
+  def method_missing(symbol)
+    self[symbol]
+  end
 
-    @description.gsub('  ', '').gsub(" \n", "\n")
+  def to_hash
+    @attributes.keys.inject({}) do |hash, key|
+      hash[key] = self[key]
+      hash
+    end
   end
 
   def yaml_description
-    return '' if @description == nil || @description == ''
-    return @description.gsub(/^/, '  ')
+    description = @attributes['description']
+    if description.nil? || description.empty?
+      ''
+    else
+      description.gsub(/^/, '  ')
+    end
   end
 
   def to_yaml
-    return "==
+    <<-yaml
+==
 story_type: #{story_type}
-name: \"#{name.gsub('"', "'")}\"
+name: "#{name.gsub('"', "'")}"
 description:
 #{yaml_description}
 labels: #{labels.join(', ')}
-"
+==
+    yaml
   end
 
-end
+end

data/spec/jira_spec.rb

@@ -3,37 +3,72 @@ 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'
+describe Jira::StoryMapper do
+  let(:story) do
+    YamlStory.new('project' => 'Test', 'name' => 'Story name', 'story_type' => 'Feature',
+                  'description' => 'Story desc', 'labels' => 'a, b',
+                  'reporter' => 'User', 'assignee' => 'A guy')
   end
+  let(:mapper) { described_class.new }
+
+  describe '#map' do
+    subject { mapper.map(story) }
+
+    context 'default mappings' do
+      it do
+        should == {
+            :fields => {
+                project: {key: 'Test'},
+                summary: 'Story name',
+                issuetype: {name: 'Feature'},
+                description: 'Story desc',
+                labels: %w(a b),
+                reporter: {name: 'User'},
+                assignee: {name: 'A guy'},
+            }
+        }
+      end
+    end
 
-  it 'should set the issuetype field with the story_type' do
-    result = @mapper.map(@story, 'AB')
-    result[:fields][:issuetype][:name].should == 'Feature'
-  end
+    context 'extra mappings' do
+      before do
+        mapper.configure!(:mappings => {
+            test: {:type => 'TextField'},
+            something: {:field_name => 'Cici', :type => 'TextField'}
+        })
+        story.tap do |s|
+          s['test'] = 'Hello'
+          s['something'] = 'World!'
+        end
+      end
 
-  it 'should split and trim labels' do
-    result = @mapper.map(@story, 'AB')
-    result[:fields][:labels].should == ['a', 'b']
+      it do
+        should == {
+            :fields => {
+                project: {key: 'Test'},
+                summary: 'Story name',
+                issuetype: {name: 'Feature'},
+                description: 'Story desc',
+                labels: %w(a b),
+                reporter: {name: 'User'},
+                assignee: {name: 'A guy'},
+                test: 'Hello',
+                Cici: 'World!'
+            }
+        }
+      end
+    end
   end
 end
 
-describe JiraApi do
+describe Jira::ApiConsumer 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 = described_class.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
+    expect(api).to receive(:post).with('http://server/rest/api/2/issue/', 'json', kind_of(Hash)).and_return good_response
 
     api.create_issue(double(to_json: 'json'))
 
@@ -43,33 +78,32 @@ describe JiraApi do
     bad_response = double(success?: false, status: 401)
     issue = double(to_json: 'json')
 
-    api = JiraApi.new
+    api = described_class.new
     api.configure!('http://server', 'user', 'pass', '2')
-    api.should_receive(:post).and_return(bad_response)
 
+    expect(api).to receive(:post).and_return(bad_response)
     expect { api.create_issue(issue) }.to raise_error Exception
-
   end
 
 end
 
-describe Jira do
+describe Jira::Handler do
 
   before do
-    @jira = Jira.new
+    @jira = described_class.new
   end
 
   context '#supports' do
     it 'should support the jira config if tracker is given' do
-      @jira.supports?('tracker' => 'jira').should == true
+      expect(@jira.supports?('tracker' => 'jira')).to be true
     end
 
     it 'should not support if tracker is missing' do
-      @jira.supports?({}).should == false
+      expect(@jira.supports?({})).to be false
     end
 
     it 'should not support if tracker is anything else' do
-      @jira.supports?('tracker' => 'pivotal').should == false
+      expect(@jira.supports?('tracker' => 'pivotal')).to be false
     end
   end
 
@@ -83,23 +117,23 @@ describe Jira do
     context 'good config provided' do
       before do
         required = [:username, :password, :project, :url]
-        @raw_config = Hash[required.map {|v| [v, 'value']} ]
+        @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'
+        expect(config[:username]).to eq 'value'
       end
 
       it 'should return the default api version' do
         config = @jira.configure! @raw_config
-        config[:api_version].should == 'latest'
+        expect(config[:api_version]).to eq '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'
+        expect(config[:api_version]).to eq '2'
       end
     end
   end
@@ -118,16 +152,16 @@ describe Jira do
 
     it 'should create a json issue using the api' do
       issue = double(to_json: 'json')
-      mapper = double(map: issue)
+      mapper = double(map: issue, configure!: true)
 
       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"}'])
+      expect(api).to receive(:configure!).with('http://host', 'user', 'pass', 'latest')
+      expect(api).to 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 = described_class.new(mapper, api)
       handler.configure! @config
       handler.handle @story do |status, response|
-        expect(status).to be_true
+        expect(status).to be true
         expect(response).to include('TEST-1')
       end
     end

data/spec/pivotal_spec.rb

@@ -10,48 +10,12 @@ describe Pivotal do
 
   describe '#supports?' do
     it 'should support pivotal if project_id exists' do
-      @tracker.supports?({'project_id' => 12345}).should be_true
+      expect(@tracker.supports?({'project_id' => 12345})).to be true
     end
 
     it 'should support pivotal if specified' do
-      @tracker.supports?({'tracker' => 'pivotal'}).should be_true
+      expect(@tracker.supports?({'tracker' => 'pivotal'})).to be true
     end
   end
 
 end
-
-#describe Story do
-#
-#  before do
-#    fixture = File.join(File.dirname(__FILE__), "fixtures", "slurper_config_pivotal.yml")
-#    Story.configure(YAML.load_file fixture)
-#  end
-#
-#  context "#prepare" do
-#
-#    it "uses http by default" do
-#      Story.scheme.should == "http"
-#      Story.config['ssl'].should be_nil
-#    end
-#
-#    it "uses https if set in the config" do
-#      Story.configure({"ssl" => true})
-#
-#      Story.config['ssl'].should be_true
-#      Story.scheme.should == "https"
-#      Story.ssl_options[:verify_mode].should == 1
-#
-#      # Not sure what this next line is testing
-#      File.open(File.expand_path('lib/cacert.pem')).readlines.find_all{ |l| l.starts_with?("Equifax") }.count.should == 4
-#    end
-#
-#    it "sets the api token from config" do
-#      Story.headers.should == {"X-TrackerToken"=>"123abc123abc123abc123abc"}
-#    end
-#  end
-#
-#
-#
-#
-#
-#end

data/spec/slurper_spec.rb

@@ -4,7 +4,7 @@ require 'slurper'
 describe Slurper do
 
   context "#create_stories" do
-    let(:stories) { [YamlStory.new(:name => 'A story')] }
+    let(:stories) { [YamlStory.new('name' => 'A story')] }
     let(:config) { {:tracker => 'jira'} }
     let(:slurper) { Slurper.new(config, stories) }
     let(:handler) { double('handler') }
@@ -19,37 +19,37 @@ describe Slurper do
     end
 
     it "should detect the handler by checking the config" do
-      handler.should_receive(:supports?).with(config).and_return(true)
-      handler.should_receive(:configure!).and_return(true)
-      handler.should_receive(:handle)
+      expect(handler).to receive(:supports?).with(config).and_return(true)
+      expect(handler).to receive(:configure!).and_return(true)
+      expect(handler).to receive(:handle)
 
       slurper.create_stories
     end
 
     it "should call configure on the handler" do
-      handler.should_receive(:supports?).with(config).and_return(true)
-      handler.should_receive(:configure!).with(config)
+      expect(handler).to receive(:supports?).with(config).and_return(true)
+      expect(handler).to receive(:configure!).with(config)
 
       slurper.create_stories
     end
 
     it "should delegate to the proper handler" do
       jira = double
-      jira.should_receive(:supports?).with(config).and_return(false)
+      expect(jira).to receive(:supports?).with(config).and_return(false)
 
       pivotal = double
-      pivotal.should_receive(:supports?).with(config).and_return(true)
-      pivotal.should_receive(:configure!).and_return(true)
-      pivotal.should_receive(:handle).with(stories[0])
+      expect(pivotal).to receive(:supports?).with(config).and_return(true)
+      expect(pivotal).to receive(:configure!).and_return(true)
+      expect(pivotal).to receive(:handle).with(stories[0])
 
       slurper.handlers = [jira, pivotal]
       slurper.create_stories
     end
 
     it "should fail gracefully on handler exceptions" do
-      handler.stub(:supports?).and_return(true)
-      handler.should_receive(:configure!).and_return(true)
-      handler.stub(:handle).and_raise('An error')
+      allow(handler).to receive(:supports?).and_return(true)
+      expect(handler).to receive(:configure!).and_return(true)
+      allow(handler).to receive(:handle).and_raise('An error')
 
       expect { slurper.create_stories }.not_to raise_error
     end
@@ -61,9 +61,9 @@ describe Slurper do
       config_file = File.join(File.dirname(__FILE__), "fixtures", "slurper_config_pivotal.yml")
 
       handler = double
-      handler.stub(:supports?).and_return true
-      handler.stub(:configure!).and_return true
-      handler.should_receive(:handle).once()
+      allow(handler).to receive(:supports?).and_return true
+      allow(handler).to receive(:configure!).and_return true
+      expect(handler).to receive(:handle).once
 
       Slurper.slurp(story_file, config_file, [handler], false)
     end
@@ -80,7 +80,7 @@ describe Slurper do
       let(:config) { {'requested_by' => 'John Doe'} }
 
       it 'should load default values' do
-        story.requested_by.should == 'John Doe'
+        expect(story.requested_by).to eq 'John Doe'
       end
     end
 
@@ -88,7 +88,7 @@ describe Slurper do
       let(:story_file) { 'whitespacey_story.slurper' }
 
       it "strips whitespace from the name" do
-        story.name.should == "Profit"
+        expect(story.name).to eq "Profit"
       end
     end
 
@@ -96,15 +96,15 @@ describe Slurper do
       let(:story_file) { 'full_story.slurper' }
 
       it "parses the name correctly" do
-        story.name.should == 'Profit'
+        expect(story.name).to eq 'Profit'
       end
 
       it "parses the label correctly" do
-        story.labels.should == ['money','power','fame']
+        expect(story.labels).to eq ['money','power','fame']
       end
 
       it "parses the story type correctly" do
-        story.story_type.should == 'feature'
+        expect(story.story_type).to eq 'feature'
       end
     end
 
@@ -113,7 +113,7 @@ describe Slurper do
       let(:story_file) { 'name_only.slurper' }
 
       it "should parse the name correctly" do
-        story.name.should == "Profit"
+        expect(story.name).to eq "Profit"
       end
 
     end
@@ -123,11 +123,11 @@ describe Slurper do
       let(:story_file) { 'empty_attributes.slurper' }
 
       it "should not set any name" do
-        story.name.should be_nil
+        expect(story.name).to be_nil
       end
 
       it "should not set any labels" do
-        story.labels.should == []
+        expect(story.labels).to eq []
       end
     end
   end

data/spec/story_spec.rb

@@ -6,28 +6,27 @@ describe YamlStory do
     it "should return a default value if it's set" do
       story = YamlStory.new({}, 'description' => 'Fill description', 'requested_by' => 'John Doe')
 
-      story.description.should == 'Fill description'
-      story.requested_by.should == 'John Doe'
+      expect(story.description).to eq 'Fill description'
+      expect(story.requested_by).to eq 'John Doe'
     end
   end
 
   context "#requested_by" do
     it "should return nil when value is blank" do
       story = YamlStory.new('requested_by' => '')
-      story.requested_by.should be_nil
+      expect(story.requested_by).to be_nil
     end
-
   end
 
   context "#description" do
     it "when the description is blank" do
       story = YamlStory.new('description' => '', 'name' => 'test')
-      story.description.should be_nil
+      expect(story.description).to be_nil
     end
 
     it "when there is no description given" do
       story = YamlStory.new
-      story.description.should be_nil
+      expect(story.description).to be_nil
     end
 
     it "when it contains quotes" do
@@ -35,7 +34,7 @@ describe YamlStory do
         I have a "quote"
       STRING
       story = YamlStory.new('description' => desc)
-      story.description.should == "I have a \"quote\"\n"
+      expect(story.description).to eq "I have a \"quote\"\n"
     end
 
     it "when it is full of whitespace" do
@@ -45,7 +44,7 @@ describe YamlStory do
         I want to click a thingy
       STRING
       story = YamlStory.new('description' => desc)
-      story.description.should == "In order to do something\nAs a role\nI want to click a thingy\n"
+      expect(story.description).to eq "In order to do something\nAs a role\nI want to click a thingy\n"
     end
 
     it "when it contains acceptance criteria" do
@@ -59,24 +58,76 @@ describe YamlStory do
         - don't forget the other thing
       STRING
       story = YamlStory.new('description' => desc)
-      story.description.should == "In order to do something\nAs a role\nI want to click a thingy\n\nAcceptance:\n- do the thing\n- don't forget the other thing\n"
+      expect(story.description).to eq "In order to do something\nAs a role\nI want to click a thingy\n\nAcceptance:\n- do the thing\n- don't forget the other thing\n"
     end
   end
 
   context 'default attributes' do
     it 'uses the default if not given one' do
       story = YamlStory.new({}, {'requested_by' => 'Mr. Client'})
-      story.requested_by.should == 'Mr. Client'
+      expect(story.requested_by).to eq 'Mr. Client'
     end
 
     it 'uses the default if given a blank requested_by' do
       story = YamlStory.new({'requested_by' => ''}, {'requested_by' => 'Mr. Client'})
-      story.requested_by.should == 'Mr. Client'
+      expect(story.requested_by).to eq 'Mr. Client'
     end
 
     it 'uses the name given in the story file if there is one' do
       story = YamlStory.new({'requested_by' => 'Mr. Stakeholder'}, {'requested_by' => 'Mr. Client'})
-      story.requested_by.should == 'Mr. Stakeholder'
+      expect(story.requested_by).to eq 'Mr. Stakeholder'
+    end
+  end
+
+  context '#key?' do
+    subject { YamlStory.new({'name' => 'Test', 'description' => 'Desc', 'requested_by' => 'Mr. Client'}).key?(key) }
+
+    context 'with existing key' do
+      let(:key) { 'name' }
+      it { should be true }
+    end
+
+    context 'with other key' do
+      let(:key) { 'missing' }
+      it { should be false }
+    end
+  end
+
+  context '#[]' do
+    subject { YamlStory.new({'name' => 'Test', 'description' => 'Desc', 'requested_by' => 'Mr. Client'}) }
+
+    it 'return defined attributes' do
+      expect(subject['name']).to eq 'Test'
+      expect(subject['description']).to eq 'Desc'
+      expect(subject['requested_by']).to eq 'Mr. Client'
+    end
+
+    it 'raise exception for undefined attributes' do
+      expect { subject['something'] }.to raise_exception
+    end
+  end
+
+  context 'attributes accessed as methods' do
+    subject { YamlStory.new({'name' => 'Test', 'description' => 'Desc', 'requested_by' => 'Mr. Client'}) }
+
+    it 'return defined attributes' do
+      expect(subject.name).to eq 'Test'
+      expect(subject.description).to eq 'Desc'
+      expect(subject.requested_by).to eq 'Mr. Client'
+    end
+
+    it 'raise exception for undefined attributes' do
+      expect { subject.somethig }.to raise_exception
+    end
+  end
+
+  context '#to_hash' do
+    let(:attrs) do
+      {'name' => 'Test', 'description' => 'Desc', 'requested_by' => 'Mr. Client'}
     end
+
+    subject { YamlStory.new(attrs).to_hash }
+
+    it { should == attrs }
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jira-slurper
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.6
 platform: ruby
 authors:
 - Wes Gibbs
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -62,14 +62,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.14.0
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
 description: "\n      Slurps stories from the given file (stories.slurper by default)
   and creates Pivotal Tracker stories from them. Useful during story carding sessions
   when you want to capture a number of stories quickly without clicking your way through
@@ -85,6 +99,7 @@ files:
 - bin/slurp
 - lib/cacert.pem
 - lib/jira.rb
+- lib/jira/inflectors.rb
 - lib/pivotal.rb
 - lib/slurper.rb
 - lib/story.rb