hammer_cli 3.6.0 → 3.8.0

data/test/unit/output/definition_test.rb

@@ -15,19 +15,19 @@ describe HammerCLI::Output::Definition do
   describe "empty?" do
 
     it "returns true for empty definition" do
-      definition.empty?.must_equal true
+      _(definition.empty?).must_equal true
     end
 
     it "returns false for definition with fields" do
       definition.fields << Fields::Field.new
-      definition.empty?.must_equal false
+      _(definition.empty?).must_equal false
     end
 
   end
 
   it "should be able to add field" do
     definition.fields << Fields::Field.new
-    field_count.must_equal 1
+    _(field_count).must_equal 1
   end
 
   it "append should allow to add data from another definition" do
@@ -36,14 +36,14 @@ describe HammerCLI::Output::Definition do
     another_def.fields << Fields::Field.new
 
     definition.append another_def.fields
-    field_count.must_equal another_def.fields.length
-    definition.fields.must_equal another_def.fields
+    _(field_count).must_equal another_def.fields.length
+    _(definition.fields).must_equal another_def.fields
   end
 
   it 'clear should delete all fields' do
     definition.fields << Fields::Field.new
     definition.clear
-    definition.empty?.must_equal true
+    _(definition.empty?).must_equal true
   end
 
   describe 'insert' do
@@ -56,23 +56,23 @@ describe HammerCLI::Output::Definition do
           definition.insert(:before, :id1, new_field)
         end
 
-        field_count.must_equal 0
+        _(field_count).must_equal 0
       end
 
       it 'should insert new specified field before the old one' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:before, :id1, new_field)
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 2
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 2
       end
 
       it 'should insert before field with few new specified' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:before, :id1, new_fields)
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 3
       end
 
       it 'should accept block with new fields' do
@@ -82,8 +82,8 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield2'
         end
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 3
       end
 
       it 'should accept both block and new fields' do
@@ -93,8 +93,8 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield4'
         end
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 5
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 5
       end
 
       it 'should work with labels' do
@@ -102,8 +102,8 @@ describe HammerCLI::Output::Definition do
         definition.fields << label_field
         definition.insert(:before, label_field.label, new_fields)
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 3
       end
     end
 
@@ -114,23 +114,23 @@ describe HammerCLI::Output::Definition do
           definition.insert(:after, :id1, new_field)
         end
 
-        field_count.must_equal 0
+        _(field_count).must_equal 0
       end
 
       it 'should insert new specified field after the old one' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:after, :id1, new_field)
 
-        definition.fields.first.label.must_equal 'oldfield'
-        field_count.must_equal 2
+        _(definition.fields.first.label).must_equal 'oldfield'
+        _(field_count).must_equal 2
       end
 
       it 'should insert after field with few new specified' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:after, :id1, new_fields)
 
-        definition.fields.first.label.must_equal 'oldfield'
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal 'oldfield'
+        _(field_count).must_equal 3
       end
 
       it 'should accept block with new fields' do
@@ -140,8 +140,8 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield2'
         end
 
-        definition.fields.first.label.must_equal 'oldfield'
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal 'oldfield'
+        _(field_count).must_equal 3
       end
 
       it 'should accept both block and new fields' do
@@ -151,8 +151,8 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield4'
         end
 
-        definition.fields.first.label.must_equal 'oldfield'
-        field_count.must_equal 5
+        _(definition.fields.first.label).must_equal 'oldfield'
+        _(field_count).must_equal 5
       end
 
       it 'should work with labels' do
@@ -160,8 +160,8 @@ describe HammerCLI::Output::Definition do
         definition.fields << label_field
         definition.insert(:after, label_field.label, new_fields)
 
-        definition.fields.first.label.must_equal label_field.label
-        field_count.must_equal 3
+        _(definition.fields.first.label).must_equal label_field.label
+        _(field_count).must_equal 3
       end
     end
 
@@ -172,23 +172,23 @@ describe HammerCLI::Output::Definition do
           definition.insert(:replace, :id1, new_field)
         end
 
-        field_count.must_equal 0
+        _(field_count).must_equal 0
       end
 
       it 'should replace field with new specified' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:replace, :id1, new_field)
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 1
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 1
       end
 
       it 'should replace field with few new specified' do
         definition.fields << Fields::Field.new(id: :id1, label: 'oldfield')
         definition.insert(:replace, :id1, new_fields)
 
-        definition.fields.first.label.must_equal new_field.label
-        field_count.must_equal 2
+        _(definition.fields.first.label).must_equal new_field.label
+        _(field_count).must_equal 2
       end
 
       it 'should accept block with new fields' do
@@ -198,7 +198,7 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield2'
         end
 
-        definition.fields.first.label.must_equal new_field.label
+        _(definition.fields.first.label).must_equal new_field.label
       end
 
       it 'should accept both block and new fields' do
@@ -208,7 +208,7 @@ describe HammerCLI::Output::Definition do
           field nil, 'newfield4'
         end
 
-        field_count.must_equal 4
+        _(field_count).must_equal 4
       end
 
       it 'should work with labels' do
@@ -216,7 +216,7 @@ describe HammerCLI::Output::Definition do
         definition.fields << label_field
         definition.insert(:replace, label_field.label, new_fields)
 
-        field_count.must_equal 2
+        _(field_count).must_equal 2
       end
     end
   end
@@ -224,21 +224,21 @@ describe HammerCLI::Output::Definition do
   describe 'find_field' do
     it 'should find a field' do
       definition.fields += [new_field, label_field]
-      definition.find_field(:new_id).must_equal new_field
+      _(definition.find_field(:new_id)).must_equal new_field
     end
 
     it 'should find a field in field output definition' do
       definition.fields += [label_field, cont_field]
       nested_definition = definition.find_field(:id1).output_definition
       nested_definition.fields << new_field
-      nested_definition.find_field(:new_id).must_equal new_field
+      _(nested_definition.find_field(:new_id)).must_equal new_field
     end
   end
 
   describe 'at' do
     it 'should return self if no specified path or empty' do
-      definition.at.must_equal definition
-      definition.at([]).must_equal definition
+      _(definition.at).must_equal definition
+      _(definition.at([])).must_equal definition
     end
 
     it 'should return output definition of specified field with path' do
@@ -246,7 +246,7 @@ describe HammerCLI::Output::Definition do
       definition.fields << cont_field
       path = [cont_field.id]
 
-      definition.at(path).must_equal cont_field.output_definition
+      _(definition.at(path)).must_equal cont_field.output_definition
     end
 
     it 'should work with labels' do
@@ -254,7 +254,7 @@ describe HammerCLI::Output::Definition do
       definition.fields << label_field
       path = ['labelfield']
 
-      definition.at(path).must_equal label_field.output_definition
+      _(definition.at(path)).must_equal label_field.output_definition
     end
   end
 
@@ -274,7 +274,7 @@ describe HammerCLI::Output::Definition do
                    "Cf/bca   |     |         | x  \n" \
                    "---------|-----|---------|----\n"
 
-      definition.sets_table.must_equal sets_table
+      _(definition.sets_table).must_equal sets_table
     end
   end
 end

data/test/unit/output/dsl_test.rb

@@ -17,7 +17,7 @@ describe HammerCLI::Output::Dsl do
   let(:last_field) { dsl.fields[-1] }
 
   it "should be empty after initialization" do
-    dsl.fields.length.must_equal 0
+    _(dsl.fields.length).must_equal 0
   end
 
   describe "fields" do
@@ -25,14 +25,14 @@ describe HammerCLI::Output::Dsl do
       dsl.build do
         field :f, "F"
       end
-      first_field.class.must_equal Fields::Field
+      _(first_field.class).must_equal Fields::Field
     end
 
     it "should create field of desired type" do
       dsl.build do
         field :f, "F", CustomFieldType
       end
-      first_field.class.must_equal CustomFieldType
+      _(first_field.class).must_equal CustomFieldType
     end
 
     it "should store all field details" do
@@ -40,9 +40,9 @@ describe HammerCLI::Output::Dsl do
         field :f, "F"
        end
 
-      first_field.must_equal last_field
-      first_field.path.must_equal [:f]
-      first_field.label.must_equal "F"
+      _(first_field).must_equal last_field
+      _(first_field.path).must_equal [:f]
+      _(first_field.label).must_equal "F"
     end
 
     it "can define multiple fields" do
@@ -52,7 +52,7 @@ describe HammerCLI::Output::Dsl do
         field :email, "Email"
       end
 
-      dsl.fields.length.must_equal 3
+      _(dsl.fields.length).must_equal 3
     end
   end
 
@@ -64,14 +64,14 @@ describe HammerCLI::Output::Dsl do
       dsl.build do
         custom_field CustomFieldType, :a => 1, :b => 2
       end
-      first_field.class.must_equal CustomFieldType
+      _(first_field.class).must_equal CustomFieldType
     end
 
     it "passes all options to the field instance" do
       dsl.build do
         custom_field CustomFieldType, :a => 1, :b => 2
       end
-      first_field.options.must_equal options
+      _(first_field.options).must_equal options
     end
 
   end
@@ -84,7 +84,7 @@ describe HammerCLI::Output::Dsl do
           field :email, "Email"
         end
       end
-      last_field.path.must_equal [:key1, :email]
+      _(last_field.path).must_equal [:key1, :email]
     end
 
     it "path can be nil to handle the parent structure" do
@@ -93,7 +93,7 @@ describe HammerCLI::Output::Dsl do
           field nil, "Email"
         end
       end
-      last_field.path.must_equal [:key1]
+      _(last_field.path).must_equal [:key1]
     end
 
     it "from can be nested" do
@@ -107,8 +107,8 @@ describe HammerCLI::Output::Dsl do
           end
         end
       end
-      first_field.path.must_equal [:key1, :key2, :key3, :name]
-      last_field.path.must_equal [:key1, :key2, :email]
+      _(first_field.path).must_equal [:key1, :key2, :key3, :name]
+      _(last_field.path).must_equal [:key1, :key2, :email]
     end
 
   end
@@ -120,7 +120,7 @@ describe HammerCLI::Output::Dsl do
       dsl.build do
         label "Label"
       end
-      first_field.class.must_equal Fields::Label
+      _(first_field.class).must_equal Fields::Label
     end
 
     it "allows to define subfields with dsl" do
@@ -131,7 +131,7 @@ describe HammerCLI::Output::Dsl do
         end
       end
 
-      first_field.fields.map(&:label).must_equal ["A", "B"]
+      _(first_field.fields.map(&:label)).must_equal ["A", "B"]
     end
 
     it "sets correct path to subfields" do
@@ -144,7 +144,7 @@ describe HammerCLI::Output::Dsl do
         end
       end
 
-      first_field.fields.map(&:path).must_equal [[:a], [:b]]
+      _(first_field.fields.map(&:path)).must_equal [[:a], [:b]]
     end
 
   end
@@ -156,7 +156,7 @@ describe HammerCLI::Output::Dsl do
       dsl.build do
         collection :f, "F"
       end
-      first_field.class.must_equal Fields::Collection
+      _(first_field.class).must_equal Fields::Collection
     end
 
     it "allows to define subfields with dsl" do
@@ -167,7 +167,7 @@ describe HammerCLI::Output::Dsl do
         end
       end
 
-      first_field.fields.map(&:label).must_equal ["A", "B"]
+      _(first_field.fields.map(&:label)).must_equal ["A", "B"]
     end
 
     it "sets correct path to subfields" do
@@ -178,7 +178,7 @@ describe HammerCLI::Output::Dsl do
         end
       end
 
-      first_field.fields.map(&:path).must_equal [[:a], [:b]]
+      _(first_field.fields.map(&:path)).must_equal [[:a], [:b]]
     end
 
   end

data/test/unit/output/field_filter_test.rb

@@ -22,51 +22,51 @@ describe HammerCLI::Output::FieldFilter do
 
   it 'lets all fields go by default' do
     f = HammerCLI::Output::FieldFilter.new(fields)
-    f.filtered_fields.map(&:label).sort.must_equal ['field', 'collection', 'id'].sort
+    _(f.filtered_fields.map(&:label).sort).must_equal ['field', 'collection', 'id'].sort
   end
 
   it 'filters fields by class' do
     f = HammerCLI::Output::FieldFilter.new(fields, classes_filter: [Fields::Id])
-    f.filter_by_classes.filtered_fields.map(&:label).sort.must_equal ['field', 'collection'].sort
+    _(f.filter_by_classes.filtered_fields.map(&:label).sort).must_equal ['field', 'collection'].sort
   end
 
   it 'filters fields by superclass' do
     f = HammerCLI::Output::FieldFilter.new(fields, classes_filter: [Fields::ContainerField])
-    f.filter_by_classes.filtered_fields.map(&:label).sort.must_equal ['field', 'id'].sort
+    _(f.filter_by_classes.filtered_fields.map(&:label).sort).must_equal ['field', 'id'].sort
   end
 
   it 'filters fields by sets' do
     f = HammerCLI::Output::FieldFilter.new(fields, sets_filter: ['THIN'])
-    f.filter_by_sets.filtered_fields.map(&:label).must_equal ['id']
+    _(f.filter_by_sets.filtered_fields.map(&:label)).must_equal ['id']
   end
 
   it 'filters fields by sets with labels' do
     f = HammerCLI::Output::FieldFilter.new(fields, sets_filter: ['THIN', 'field'])
-    f.filter_by_sets.filtered_fields.map(&:label).sort.must_equal ['field', 'id'].sort
+    _(f.filter_by_sets.filtered_fields.map(&:label).sort).must_equal ['field', 'id'].sort
   end
 
   it 'filters by full labels' do
     f = HammerCLI::Output::FieldFilter.new(container_fields, sets_filter: ['container/first'])
-    f.filter_by_sets.filtered_fields.first.fields.map(&:label).must_equal ['first']
+    _(f.filter_by_sets.filtered_fields.first.fields.map(&:label)).must_equal ['first']
   end
 
   it 'filters by superclass labels' do
     f = HammerCLI::Output::FieldFilter.new(container_fields, sets_filter: ['container'])
-    f.filter_by_sets.filtered_fields.first.fields.map(&:label).must_equal ['first', 'second']
+    _(f.filter_by_sets.filtered_fields.first.fields.map(&:label)).must_equal ['first', 'second']
   end
 
   it 'filters by labels with wildcards' do
     f = HammerCLI::Output::FieldFilter.new(container_fields, sets_filter: ['container/f*'])
-    f.filter_by_sets.filtered_fields.first.fields.map(&:label).must_equal ['first']
+    _(f.filter_by_sets.filtered_fields.first.fields.map(&:label)).must_equal ['first']
   end
 
   it 'allows chained filtering' do
     f = HammerCLI::Output::FieldFilter.new(fields, sets_filter: ['THIN'], classes_filter: [Fields::Id])
-    f.filter_by_classes.filter_by_sets.filtered_fields.map(&:label).must_equal []
+    _(f.filter_by_classes.filter_by_sets.filtered_fields.map(&:label)).must_equal []
   end
 
   it 'filters fields by data' do
     f = HammerCLI::Output::FieldFilter.new(fields)
-    f.filter_by_data(nil).filtered_fields.map(&:label).sort.must_equal ['id', 'collection'].sort
+    _(f.filter_by_data(nil).filtered_fields.map(&:label).sort).must_equal ['id', 'collection'].sort
   end
 end

data/test/unit/output/fields_test.rb

@@ -11,15 +11,15 @@ describe Fields::Field do
 
 
   it "stores label from constructor" do
-    field.label.must_equal label
+    _(field.label).must_equal label
   end
 
   it "stores path from constructor" do
-    field.path.must_equal path
+    _(field.path).must_equal path
   end
 
   it "default path should be empty array" do
-    Fields::Field.new.path.must_equal []
+    _(Fields::Field.new.path).must_equal []
   end
 
   describe "parameters" do
@@ -30,7 +30,7 @@ describe Fields::Field do
         :path => path,
         :some => :parameter
       }
-      field.parameters.must_equal expected_params
+      _(field.parameters).must_equal expected_params
     end
 
   end
@@ -40,11 +40,11 @@ describe Fields::Field do
     context "blank is allowed" do
 
       it "returns false the value is nil" do
-        field.display?(nil).must_equal true
+        _(field.display?(nil)).must_equal true
       end
 
       it "returns true when there is some data under the path" do
-        field.display?("some value").must_equal true
+        _(field.display?("some value")).must_equal true
       end
     end
 
@@ -52,11 +52,11 @@ describe Fields::Field do
     context "blank is not allowed" do
 
       it "returns false the value is nil" do
-        blank_field.display?(nil).must_equal false
+        _(blank_field.display?(nil)).must_equal false
       end
 
       it "returns true when there is some data under the path" do
-        blank_field.display?("some value").must_equal true
+        _(blank_field.display?("some value")).must_equal true
       end
     end
 
@@ -65,11 +65,11 @@ describe Fields::Field do
   describe "hide_blank?" do
 
     it "defaults to false" do
-      Fields::Field.new.hide_blank?.must_equal false
+      _(Fields::Field.new.hide_blank?).must_equal false
     end
 
     it "can be set to true in the constructor" do
-      blank_field.hide_blank?.must_equal true
+      _(blank_field.hide_blank?).must_equal true
     end
 
   end
@@ -85,19 +85,19 @@ describe Fields::ContainerField do
       let(:field) { Fields::ContainerField.new :label => "Label" }
 
       it "returns false the value is nil" do
-        field.display?(nil).must_equal true
+        _(field.display?(nil)).must_equal true
       end
 
       it "returns false the value is empty array" do
-        field.display?([]).must_equal true
+        _(field.display?([])).must_equal true
       end
 
       it "returns false the value is empty hash" do
-        field.display?({}).must_equal true
+        _(field.display?({})).must_equal true
       end
 
       it "returns true when there is some data under the path" do
-        field.display?(["some value"]).must_equal true
+        _(field.display?(["some value"])).must_equal true
       end
 
     end
@@ -106,19 +106,19 @@ describe Fields::ContainerField do
       let(:field) { Fields::ContainerField.new :label => "Label", :hide_blank => true }
 
       it "returns false the value is nil" do
-        field.display?(nil).must_equal false
+        _(field.display?(nil)).must_equal false
       end
 
       it "returns false the value is empty array" do
-        field.display?([]).must_equal false
+        _(field.display?([])).must_equal false
       end
 
       it "returns false the value is empty hash" do
-        field.display?({}).must_equal false
+        _(field.display?({})).must_equal false
       end
 
       it "returns true when there is some data under the path" do
-        field.display?(["some value"]).must_equal true
+        _(field.display?(["some value"])).must_equal true
       end
 
     end
@@ -141,19 +141,19 @@ describe Fields::Label do
       end
 
       it "returns true when all the keys are present" do
-        field.display?({:a => 1, :b => 2}).must_equal true
+        _(field.display?({:a => 1, :b => 2})).must_equal true
       end
 
       it "returns true when some of the keys are present" do
-        field.display?({:a => 1}).must_equal true
+        _(field.display?({:a => 1})).must_equal true
       end
 
       it "returns true the hash is empty" do
-        field.display?({}).must_equal true
+        _(field.display?({})).must_equal true
       end
 
       it "returns true the hash does not contain the required keys" do
-        field.display?({:c => 3}).must_equal true
+        _(field.display?({:c => 3})).must_equal true
       end
 
     end
@@ -167,23 +167,23 @@ describe Fields::Label do
       end
 
       it "returns true when all subfields are displayed" do
-        field.display?({:a => 1, :b => 2}).must_equal true
+        _(field.display?({:a => 1, :b => 2})).must_equal true
       end
 
       it "returns true when at least one or the subfields is displayed" do
-        field.display?({:a => 1}).must_equal true
+        _(field.display?({:a => 1})).must_equal true
       end
 
       it "returns false when none of the subfieldsis displayed" do
-        field.display?({:c => 3}).must_equal false
+        _(field.display?({:c => 3})).must_equal false
       end
 
       it "returns false when the value is empty hash" do
-        field.display?({}).must_equal false
+        _(field.display?({})).must_equal false
       end
 
       it "returns false when the value is nil" do
-        field.display?(nil).must_equal false
+        _(field.display?(nil)).must_equal false
       end
     end