report_logic 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af450b5d734ada4dd2dc96785aa307b71f772d47
-  data.tar.gz: 6c59231be591478bef3921a3a946eee9185eba5d
+  metadata.gz: 0cb5c7c667ee0a5c8228b50f6ee901af04bafd30
+  data.tar.gz: 48a9eb686cd2018e8ca6303e59901457f25424ac
 SHA512:
-  metadata.gz: 3684b23a5b2f11e95dfc7a10de0cd0981c7915d837416dc21df5ef3ef91032b38f0e7b727f6d23ae43df833e1e768e6507364d76644ad1cca03c1e49837171db
-  data.tar.gz: 984b3b63965d5dc82086538a47fada270405a0b16f64b39592c614a0c40ee49bc52317a7c93c1edc4aa226903afdf15e5088031d7a411e2dd039f070c4a61217
+  metadata.gz: 1bae0ce482ce7f60035008fc8cac709b12286a1ad29b8ce6f6bc8258be9d4b14a164e5eb7b6616107afb8767eefb83b0a7283deaaca00b42949335ef5d3669a1
+  data.tar.gz: cbd54520a0457b2373af13adeedbf5e386842c9eca9f91cb5b477aa40f22df5b7df7cd7fe8755dab61fff7f5418abb68ed1c587526ef6fb325a2efee27b00027

data/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.2.2

data/README.md

@@ -1,7 +1,10 @@
 # ReportLogic
 
 This gem provides an easy way to generate reports' logic.
-Using this, you can so export this report to any format you want.
+You can organize the way your data needs to be grouped, converted and organized,
+regardless how you are going to display it afterwards. I use this to export
+the same report in various formats, like XLS and PDF, using the same Report
+object.
 
 ## Installation
 
@@ -12,37 +15,34 @@ gem install report_logic
 Using Bundler:
 
 ```ruby
-gem 'report_logic', '~> 0.1.1'
+gem 'report_logic'
 ```
 
 ## Usage
 
 The goal here is to provide an easy way to extract report's logic to a Plain Old
-Ruby Object. With this extraction, it's easy to use the same report class to
-render reports in different formats. The report is defined by doing this:
+Ruby Object. The report is defined by doing this:
 
 ```ruby
 # Create a class inheriting from ReportLogic::Base
 class MyReport < ReportLogic::Base
 
-  # Override this method to define your report
-  def build
-    # Create as many sessions as you need. Sessions group fields that you can
-    # then display later.
-    session(:header) do
-      field 'ID'    # `field` creates a ReportLogic::Field in the session,
-                    # which `name` will be the value passed to it.
-      field 'Name'
-    end
-
-    # If you pass a collection to a session, it will become a matrix, instead of
-    # an array of Field. For each object in the collection, the block will be
-    # yielded with it so you can define what Fields will compose this matrix.
-    session(:row, collection) do |record|
-      value record.id     # `value` creates a ReportLogic::Field in the session,
-                          # which `value` will be the value passed to it.
-      value record.name
-    end
+  # Create as many sessions as you need. Sessions group fields that you can
+  # then display later.
+  session :header do
+    field 'ID'    # `field` creates a ReportLogic::Field in the session,
+                  # which `name` will be the value passed to it.
+    field 'Name'
+  end
+
+  # If you call `collection_session`, it will become a matrix, instead of
+  # an array of Field. For each object in the collection given to the
+  # constructor, the block will be yielded with it so you can define what Fields
+  # will compose the matrix.
+  collection_session :row do |record|
+    value record.id     # `value` creates a ReportLogic::Field in the session,
+                        # which `value` will be the value passed to it.
+    value record.name
   end
 end
 ```
@@ -56,14 +56,14 @@ report = MyReport.new(MyModel.all)
 puts 'MY REPORT'
 
 # Printing the headers
-report.each(:header) do |field|
+report.header.each do |field|
   print field.name
   print ' | '
 end
 puts
 
 # Printing the rows
-report.each(:row) do |row|
+report.row.each do |row|
   row.each do |field|
     print field.value
     print ' | '
@@ -72,102 +72,44 @@ report.each(:row) do |row|
 end
 ```
 
-This output sucks, but it shows how simple it is to read a report
+This output is not pretty, but it shows how simple it is to read a report
 and output it in any ways you want. You could use ERB to generate HTML or XLS
 outputs in Rails, or even Prawn to generate PDF's.
 
 ## Decorators
 
-This gem uses the Decorator pattern to allow you to modify a Field before
-printing. To do so, you just need to inherit from `ReportLogic::Decorator`,
-like so:
+This gem uses the Decorator Pattern to allow you to modify a Field before
+printing. To do so, pass the decorator as a parameter to the field. It can be
+any object, it just needs to respond to `call`. It can be a simple block.
 
 ```ruby
-class MyDecorator < ReportLogic::Decorator
-  # This method is invoked when the report is built. Override this if you
-  # want to customize the whole behaviour of your decorator.
-  def decorate(field)
-    decorate_name(field)
-    decorate_value(field)
+class MyDecorator
+  def call(name)
+    "=> #{name}"
   end
-
-  # This method is called by default from ReportLogic::Decorator, as
-  # you can see above. Override this if you just want to decorate the name
-  # attribute of your fields.
-  def decorate_name(field); end
-
-  # This method is called by default from ReportLogic::Decorator as well.
-  # Override this if you just want to decorate the value attribute of your fields.
-  def decorate_value(field); end
 end
-```
-
-This sample decorator is, in fact, pretty much the same as
-`ReportLogic::Decorator`. For more details, take a look at the class itself.
-
-You can then apply a decorator in many ways:
 
-```ruby
 class MyReport < ReportLogic::Base
-  def build
-    session(:row, collection) do |record|
-      field 'Name', record.name
-      field 'Gender', record.gender
-
-      decorate_with MyDecorator.new    # This decorator applies to this session
-    end
-
-    decorate_with AnotherDecorator.new # This decorator applies to the whole report
+  collection_session :row do |record|
+    field 'Name', record.name, decorate_name: MyDecorator.new,
+                               decorate_value: ->(value) { " - #{value}" }
   end
 end
-```
 
-You can apply a decorator to a specific field. To do so, you need to:
-
-```ruby
-field 'Name', record.name, decorate_with: SpecificDecorator.new
-```
+MyModel = Struct.new(:name)
+collection = [MyModel.new('John')]
 
-## I18n Support
-
-There is a built-in decorator that handles internationalization for you. To use
-it, you need to do this:
-
-```ruby
-class MyReport < ReportLogic::Base
-  include ReportLogic::I18nSupport  # Include de module
-
-  def build
-    i18n_decorate                   # Invoke the decorator to be added
-
-    session(:row, collection) do |record|
-      field 'Name', record.name
-      field 'Gender', record.gender
-    end
+MyReport.new(collection).row.each do |row|
+  row.each do |field|
+    puts field.name
+    puts field.value
   end
 end
+#=> => Name
+#=>  - John
 ```
 
-This way, your fields' names and values will be translated **if they are symbols**.
-So, to make it work, you need to use symbols:
-
-```ruby
-class MyReport < ReportLogic::Base
-  include ReportLogic::I18nSupport
-
-  def build
-    i18n_decorate
-
-    session(:filter) do
-      field :name  , 'Test'   # The field's name will be translated using
-                              # 'report.names.name'
-      field :gender, :male    # The field's name will be translated using
-                              # 'report.names.gender' and the value will use
-                              # 'report.values.male'.
-    end
-  end
-end
-```
+If you need to apply multiple decorators on the same field, just pass an array.
 
 ## Contributing
 

data/lib/report_logic/base.rb

@@ -1,70 +1,61 @@
 module ReportLogic
   class Base
-    include Decorable
-
     attr_reader :collection
 
     def initialize(collection = nil)
       @collection = collection
     end
 
-    def each(key)
-      return to_enum(__callee__, key) unless block_given?
-      ensure_built_and_decorated
-      sessions[key] and sessions[key].fields.each { |field| yield field }
-    end
-
-    def session(key, collection = nil, &block)
-      @current_session = sessions[key] ||= Session.new(key, self)
-      @current_session.process(collection, &block)
-    ensure
-      @current_session = nil
+    def fields(&block)
+      @current = []
+      instance_exec &block
+      @current
     end
 
-    def count
-      @collection.size
+    def collection_fields(&block)
+      collection.map do |record|
+        fields do
+          instance_exec record, &block
+        end
+      end
     end
 
-    def method_missing(method_name, *args, &block)
-      if @current_session && @current_session.public_methods.include?(method_name)
-        @current_session.public_send(method_name, *args, &block)
-      else
-        super
+    def self.session(key, &block)
+      define_method key do
+        @current = []
+        instance_eval &block
+        @current
       end
     end
 
-    def decorate_with(*args)
-      if @current_session
-        @current_session.decorate_with(*args)
-      else
-        super
+    def self.collection_session(key, &block)
+      define_method key do
+        collection_fields &block
       end
     end
 
-    protected
-
-    def ensure_built_and_decorated
-      build    unless @built
-      decorate unless @decorated
-      @built     = true
-      @decorated = true
+    def each(key)
+      fail '`each` is not used anymore. Please, refer to the project\'s '\
+           ' documentation on Github for more details.'
     end
 
-    def build
-      raise NotImplementedError
+    def session(key, collection = nil, &block)
+      fail '`session` is not used anymore. Please, refer to the project\'s '\
+           ' documentation on Github for more details.'
     end
 
-    def decorate
-      sessions.values.each do |sess|
-        sess.decorate(@decorators)
-      end
+    def count
+      collection.size
     end
 
-    private
+    protected
 
-    def sessions
-      @sessions ||= {}
+    def field(name, value = nil, **options)
+      @current << Field.new(name, value, **options)
     end
 
+    def value(val, **options)
+      field(nil, val, **options)
+    end
   end
 end

data/lib/report_logic/field.rb

@@ -1,16 +1,22 @@
 module ReportLogic
   class Field
-    include Decorable
+    attr_reader :type, :config
 
-    attr_accessor :key, :value, :type, :name, :config
-
-    def initialize(name, value=nil, type: nil, key: nil, decorate_with: nil, **config)
-      @name   = name
-      @value  = value
-      @type   = type
+    def initialize(name, value = nil, **config)
+      @name = name
+      @value = value
+      @type = config.delete :type
+      @decorate_name = config.delete :decorate_name
+      @decorate_value = config.delete :decorate_value
       @config = config
-      @key    = key || (name.is_a?(Symbol) ? name : nil)
-      self.decorate_with(decorate_with)
+    end
+
+    def name
+      apply_decorators @name, @decorate_name
+    end
+
+    def value
+      apply_decorators @value, @decorate_value
     end
 
     def type
@@ -21,16 +27,17 @@ module ReportLogic
       @value.class
     end
 
-    def decorate(master_decorators = nil)
-      apply_decorators(master_decorators) if master_decorators
-      apply_decorators(decorators)
-    end
+    private
 
-    def apply_decorators(decorators)
-      decorators.each do |dec|
-        dec.decorate_if_matches(self)
+    def apply_decorators(str, decorators)
+      return str unless decorators
+      if decorators.respond_to? :each
+        decorators.each do |dec|
+          str = dec.call str
+        end
+        return str
       end
-      self
+      decorators.call str
     end
   end
 end

data/lib/report_logic.rb

@@ -1,10 +1,4 @@
 module ReportLogic
-  autoload :Base         , 'report_logic/base'
-  autoload :Decorable    , 'report_logic/decorable'
-  autoload :Decorator    , 'report_logic/decorator'
-  autoload :Field        , 'report_logic/field'
-  autoload :Session      , 'report_logic/session'
-  autoload :I18nDecorator, 'report_logic/i18n_decorator'
-  autoload :I18nSupport  , 'report_logic/i18n_support'
-  autoload :I18nHelper   , 'report_logic/i18n_helper'
+  autoload :Base,  'report_logic/base'
+  autoload :Field, 'report_logic/field'
 end

data/report_logic.gemspec

@@ -1,15 +1,15 @@
 Gem::Specification.new do |s|
   s.name        = 'report_logic'
-  s.version     = '0.1.1'
-  s.date        = '2014-11-18'
-  s.summary     = "Generating report logic."
-  s.description = "This gem provides an easy way to generate reports' logic. "\
-    "Using this, you can so export this report to any format you want."
-  s.authors     = ["Diego Aguir Selzlein"]
+  s.version     = '1.0.0'
+  s.date        = '2015-09-09'
+  s.summary     = 'Generating report logic.'
+  s.description = 'This gem provides an easy way to generate reports\' logic. '\
+    'Using this, you can so export this report to any format you want.'
+  s.authors     = ['Diego Aguir Selzlein']
   s.email       = 'diegoselzlein@gmail.com'
 
   s.files         = `git ls-files`.split("\n")
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
   s.homepage    = 'https://github.com/nerde/report_logic'
   s.license     = 'MIT'

data/spec/app/my_report.rb

@@ -1,31 +1,34 @@
 Record = Struct.new(:id, :name)
 
-class MyReport < ReportLogic::Base
-  def build
-    session(:header) do
-      field 'ID'
-      field 'Name'
-    end
+FIRST_DECORATOR = ->(value) { value + 3 }
+SECOND_DECORATOR = ->(value) { value / 2 }
 
-    session(:rows, collection) do |record|
-      value record.id
-      value record.name
-    end
+class MyReport < ReportLogic::Base
+  session :header do
+    field 'ID'
+    field 'Name'
+  end
 
-    session(:test_context) do
-      context_value
-    end
+  collection_session :rows do |record|
+    value record.id
+    value record.name
+  end
 
-    session(:test_master_decorator) do
-      field :decorable, 2
+  def my_own_rows
+    collection.map do |record|
+      fields do
+        value record.id
+      end
     end
+  end
 
-    session(:exclusive_decorator) do
-      value 2
-      decorate_with MyDecorator.new
-    end
+  session :test_context do
+    value context_value
+  end
 
-    decorate_with MyDecorator.new(key: :decorable)
+  session :decorated do
+    field 'A', 1, decorate_name: ->(name) { name + 'B' },
+                  decorate_value: [FIRST_DECORATOR, SECOND_DECORATOR]
   end
 
   def context_value

data/spec/report_logic/base_spec.rb

@@ -6,35 +6,38 @@ describe ReportLogic::Base do
 
   let(:report) { MyReport.new([rec1, rec2]) }
 
-  let(:headers) { report.each(:header) }
-  let(:rows)    { report.each(:rows) }
+  let(:headers) { report.header }
+  let(:rows)    { report.rows }
+  let(:decorated) { report.decorated }
 
-  it "generates grouped fields" do
-    expect(headers.count    ).to eql(2)
-    expect(headers.next.name).to eql('ID')
-    expect(headers.next.name).to eql('Name')
+  it 'generates grouped fields' do
+    expect(headers.count).to eql(2)
+    expect(headers.first.name).to eql('ID')
+    expect(headers.last.name).to eql('Name')
 
+    expect(rows.count).to eql(2)
 
-    expect(rows.count    ).to eql(2)
-
-    first_row = rows.next
+    first_row = rows.first
     expect(first_row.first.value).to eql(1)
     expect(first_row.last.value ).to eql('Diego')
 
-    last_row = rows.next
+    last_row = rows.last
     expect(last_row.first.value ).to eql(2)
     expect(last_row.last.value  ).to eql('Andressa')
   end
 
-  it "counts records" do
-    expect(report.count).to eq 2
+  it 'allows to define methods directly' do
+    expect(report.my_own_rows.size).to eq 2
+    expect(report.my_own_rows.first.map(&:value)).to eq [1]
+    expect(report.my_own_rows.last.map(&:value)).to eq [2]
   end
 
-  it "scopes decorators" do
-    s1 = report.each(:test_master_decorator).to_a
-    s2 = report.each(:exclusive_decorator  ).to_a
+  it 'decorates names and values' do
+    expect(decorated.first.name).to eql('AB')
+    expect(decorated.first.value).to eql(2)
+  end
 
-    expect(s1.first.value).to eq(3)
-    expect(s2.first.value).to eq(3)
+  it 'counts records' do
+    expect(report.count).to eq 2
   end
 end

data/spec/spec_helper.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../lib/report_logic', __FILE__)
 Dir[File.expand_path('../app/*.rb', __FILE__)].each { |f| require f }
 
 RSpec.configure do |config|
-  config.order = "random"
+  config.order = 'random'
   config.before(:each) { GC.disable }
   config.after(:each)  { GC.enable }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: report_logic
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Diego Aguir Selzlein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2015-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -37,23 +37,12 @@ files:
 - deploy
 - lib/report_logic.rb
 - lib/report_logic/base.rb
-- lib/report_logic/decorable.rb
-- lib/report_logic/decorator.rb
 - lib/report_logic/field.rb
-- lib/report_logic/i18n_decorator.rb
-- lib/report_logic/i18n_helper.rb
-- lib/report_logic/i18n_support.rb
-- lib/report_logic/session.rb
 - report_logic.gemspec
 - script/console
-- spec/app/my_decorator.rb
-- spec/app/my_i18n_report.rb
 - spec/app/my_report.rb
 - spec/report_logic/base_spec.rb
-- spec/report_logic/decorator_spec.rb
 - spec/report_logic/field_spec.rb
-- spec/report_logic/i18n_support_spec.rb
-- spec/report_logic/session_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/nerde/report_logic
 licenses:
@@ -75,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Generating report logic.

data/lib/report_logic/decorable.rb

@@ -1,17 +0,0 @@
-module ReportLogic
-  module Decorable
-    def decorators
-      @decorators ||= []
-    end
-
-    def decorate_with(dec)
-      if dec
-        if dec.respond_to?(:each)
-          dec.each { |dec| decorators << dec }
-        else
-          decorators << dec
-        end
-      end
-    end
-  end
-end

data/lib/report_logic/decorator.rb

@@ -1,26 +0,0 @@
-module ReportLogic
-  class Decorator
-    attr_accessor :key
-
-    def initialize(key: nil)
-      @key = key
-    end
-
-    def decorate(field)
-      decorate_name(field)
-      decorate_value(field)
-    end
-
-    def decorate_name(field); end
-
-    def decorate_value(field); end
-
-    def decorate_if_matches(field)
-      decorate(field) if matches?(field)
-    end
-
-    def matches?(field)
-      key.nil? || key == field.key || Array === key && key.include?(field.key)
-    end
-  end
-end

data/lib/report_logic/i18n_decorator.rb

@@ -1,13 +0,0 @@
-module ReportLogic
-  class I18nDecorator < Decorator
-    include I18nHelper
-
-    def decorate_name(field, name=field.name, **options)
-      field.name  = i18n_lookup(:names , name, **options) if Symbol === name
-    end
-
-    def decorate_value(field, value=field.value, **options)
-      field.value  = i18n_lookup(:values , value, **options) if Symbol === value
-    end
-  end
-end

data/lib/report_logic/i18n_helper.rb

@@ -1,14 +0,0 @@
-require 'i18n'
-
-module ReportLogic
-  module I18nHelper
-    def i18n_lookup(scope, key, default: key.to_sym, resource_class: nil, **options)
-      lookup = if resource_class
-        :"#{resource_class.to_s.downcase.underscore}.#{key}"
-      else
-        key
-      end
-      I18n.t(lookup, scope: [:report, scope], default: default, **options)
-    end
-  end
-end

data/lib/report_logic/i18n_support.rb

@@ -1,7 +0,0 @@
-module ReportLogic
-  module I18nSupport
-    def i18n_decorate
-      decorators << I18nDecorator.new
-    end
-  end
-end

data/lib/report_logic/session.rb

@@ -1,51 +0,0 @@
-module ReportLogic
-  class Session
-    include Decorable
-
-    attr_accessor :key, :report
-
-    def initialize(key = nil, report = nil)
-      @key, @report = key, report
-    end
-
-    def fields
-      @fields ||= []
-    end
-
-    def current_row
-      @current_row ||= fields
-    end
-
-    def field(name, value = nil, **options)
-      current_row << Field.new(name, value, **options)
-    end
-
-    def value(val, **options)
-      field(nil, val, **options)
-    end
-
-    def process(collection = nil)
-      if collection.respond_to?(:each)
-        collection.each do |record|
-          @current_row = []
-          yield record
-          fields.push current_row
-          @current_row = nil
-        end
-      else
-        yield
-      end
-    end
-
-    def decorate(master_decorators = nil)
-      master_decorators ||= []
-      fields.each do |field_or_row|
-        if field_or_row.respond_to?(:each)
-          field_or_row.each { |f| f.decorate(master_decorators + decorators) }
-        else
-          field_or_row.decorate(master_decorators + decorators)
-        end
-      end
-    end
-  end
-end

data/spec/app/my_decorator.rb

@@ -1,5 +0,0 @@
-class MyDecorator < ReportLogic::Decorator
-  def decorate(field)
-    field.value = 3
-  end
-end

data/spec/app/my_i18n_report.rb

@@ -1,12 +0,0 @@
-class MyI18nReport < ReportLogic::Base
-  include ReportLogic::I18nSupport
-
-  def build
-    i18n_decorate
-
-    session(:header) do
-      field 'ID'
-      field :name, :test
-    end
-  end
-end

data/spec/report_logic/decorator_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe ReportLogic::Decorator do
-  let(:decorator) { MyDecorator.new }
-  let(:field)     { ReportLogic::Field.new(1, 2, key: :first) }
-
-  describe "#decorate_if_matches" do
-
-    it "decorates object" do
-      decorator.decorate_if_matches(field)
-
-      expect(field.value).to eql(3)
-    end
-
-    context "decorator does not match" do
-      it "doesn't decorate" do
-        decorator.stub(:matches?).and_return(false)
-
-        decorator.decorate_if_matches(field)
-
-        expect(field.value).to eql(2)
-      end
-    end
-
-    context "key doesn't match" do
-      let(:decorator) { ReportLogic::Decorator.new key: :second }
-
-      it "doesn't decorate" do
-        decorator.decorate_if_matches(field)
-
-        expect(field.value).to eql(2)
-      end
-    end
-
-    context "key is an array" do
-      let(:decorator) { MyDecorator.new key: [:second] }
-
-      it "checks inclusion" do
-        f2 = ReportLogic::Field.new(1, 2, key: :second)
-
-        decorator.decorate_if_matches(field)
-        decorator.decorate_if_matches(f2)
-
-        expect(field.value).to eql(2)
-        expect(f2   .value).to eql(3)
-      end
-    end
-  end
-end

data/spec/report_logic/i18n_support_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'i18n'
-
-describe ReportLogic::I18nSupport do
-  let(:report) { MyI18nReport.new }
-
-  let(:headers) { report.each(:header).to_a }
-
-  before(:all) do
-    I18n.enforce_available_locales = false
-    I18n.backend.store_translations(:es, report: { names: { name: 'Nombre' },
-      values: { test: 'This is translated too' } })
-    I18n.default_locale = :es
-  end
-
-  after(:all) do
-    I18n.backend = nil
-    I18n.default_locale = nil
-  end
-
-  it "translates key fields" do
-    expect(headers.size      ).to eql(2)
-    expect(headers.first.name).to eql('ID')
-    expect(headers.last .name).to eql('Nombre')
-    expect(headers.last.value).to eql('This is translated too')
-  end
-end

data/spec/report_logic/session_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe ReportLogic::Session do
-  let(:session) { ReportLogic::Session.new }
-  let(:fields)  { session.fields }
-  let(:field)   { session.fields.first }
-
-  it "generates fields with name" do
-    session.field 'Test Field'
-
-    expect(fields.size).to eq(1)
-    expect(field.key  ).to be_nil
-    expect(field.name ).to eq('Test Field')
-    expect(field.value).to be_nil
-  end
-
-  it "generates fields with value" do
-    session.value 'Test Field'
-
-    expect(fields.size).to eq(1)
-    expect(field.key  ).to be_nil
-    expect(field.name ).to be_nil
-    expect(field.value).to eq('Test Field')
-  end
-
-  it "generates fields with name and value" do
-    session.field 'Test Field', 'Value'
-
-    expect(fields.size).to eq(1)
-    expect(field.key  ).to be_nil
-    expect(field.name ).to eq('Test Field')
-    expect(field.value).to eq('Value')
-  end
-
-  it "generates fields with key" do
-    session.field 'Test Field', 'Value', key: :sparta
-
-    expect(fields.size).to eq(1)
-    expect(field.key  ).to eq(:sparta)
-    expect(field.name ).to eq('Test Field')
-    expect(field.value).to eq('Value')
-  end
-
-  it "uses name as key when it's a symbol" do
-    session.field :name
-
-    expect(fields.size).to eq(1)
-    expect(field.key  ).to eq(:name)
-    expect(field.name ).to eq(:name)
-    expect(field.value).to be_nil
-  end
-
-  it "decorates fields" do
-    session.field 'First Field' , 1
-    session.field 'Second Field', 2
-    session.decorate_with MyDecorator.new
-
-    session.decorate
-
-    expect(fields.first.value).to eq(3)
-    expect(fields.last .value).to eq(3)
-  end
-
-  it "can decorate a single field" do
-    session.field 'First Field' , 1
-    session.field 'Second Field', 2, decorate_with: MyDecorator.new
-
-    session.decorate
-
-    expect(fields.first.value).to eq(1)
-    expect(fields.last .value).to eq(3)
-  end
-end