techdivision / import-attribute

src/Subjects/BunchSubject.php

Spacing +1 added lines, -1 removed lines

@@ -203,7 +203,7 @@
      */
     public function preLoadAttributeId(array $attribute)
     {
-        $this->preLoadedAttributeIds[$attribute[MemberNames::ATTRIBUTE_CODE]]= $attribute[MemberNames::ATTRIBUTE_ID];
+        $this->preLoadedAttributeIds[$attribute[MemberNames::ATTRIBUTE_CODE]] = $attribute[MemberNames::ATTRIBUTE_ID];
     }
 
     /**

src/Actions/Processors/CatalogAttributeUpdateProcessor.php

Spacing +1 added lines, -1 removed lines

@@ -76,7 +76,7 @@
             unset($keys[array_search(EntityStatus::MEMBER_NAME, $keys, true)]);
 
             // prepare the SET part of the SQL statement
-            array_walk($keys, function (&$value, $key) {
+            array_walk($keys, function(&$value, $key) {
                 $value = sprintf('%s=:%s', $value, $value);
             });
 

src/Observers/AttributeOptionValueExportObserver.php

Spacing +1 added lines, -1 removed lines

@@ -61,7 +61,7 @@
         $artefacts = array();
 
         // load the attribute option values for the custom store views
-        $attributeOptionValues = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_VALUES, array(), function ($value) {
+        $attributeOptionValues = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_VALUES, array(), function($value) {
             return $this->explode($value, $this->getMultipleFieldDelimiter());
         });
 

src/Observers/AttributeOptionExportObserver.php

Spacing +3 added lines, -3 removed lines

@@ -58,13 +58,13 @@
         $artefacts = array();
 
         // load the attribute option values/positions
-        $attributeOptionValues = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_VALUES, array(), function ($value) {
+        $attributeOptionValues = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_VALUES, array(), function($value) {
             return $this->explode($value, $this->getMultipleFieldDelimiter());
         });
-        $attributeOptionSortOrder = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_SORT_ORDER, array(), function ($value) {
+        $attributeOptionSortOrder = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_SORT_ORDER, array(), function($value) {
             return $this->explode($value, $this->getMultipleFieldDelimiter());
         });
-        $attributeOptionSwatch = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_SWATCH, array(), function ($value) {
+        $attributeOptionSwatch = $this->getValue(ColumnKeys::ATTRIBUTE_OPTION_SWATCH, array(), function($value) {
             return $this->explode($value, $this->getMultipleValueDelimiter());
         });
 

RoboFile.php

Indentation +12 added lines, -12 removed lines

@@ -57,9 +57,9 @@ 
     {
         // optimize autoloader with custom path
         return $this->taskComposerInstall()
-             ->preferDist()
-             ->optimizeAutoloader()
-             ->run();
+                ->preferDist()
+                ->optimizeAutoloader()
+                ->run();
     }
 
     /**
@@ -71,9 +71,9 @@ 
     {
         // optimize autoloader with custom path
         return $this->taskComposerUpdate()
-             ->preferDist()
-             ->optimizeAutoloader()
-             ->run();
+                ->preferDist()
+                ->optimizeAutoloader()
+                ->run();
     }
 
     /**
@@ -94,10 +94,10 @@ 
     public function prepare()
     {
         return $this->taskFileSystemStack()
-             ->mkdir($this->properties['dist.dir'])
-             ->mkdir($this->properties['target.dir'])
-             ->mkdir(sprintf('%s/reports', $this->properties['target.dir']))
-             ->run();
+                ->mkdir($this->properties['dist.dir'])
+                ->mkdir($this->properties['target.dir'])
+                ->mkdir(sprintf('%s/reports', $this->properties['target.dir']))
+                ->run();
     }
 
     /**
@@ -167,8 +167,8 @@ 
 
         // run PHPUnit
         return $this->taskPHPUnit(sprintf('%s/bin/phpunit', $this->properties['vendor.dir']))
-             ->configFile('phpunit.xml')
-             ->run();
+                ->configFile('phpunit.xml')
+                ->run();
     }
 
     /**

Spacing +1 added lines, -1 removed lines

@@ -122,7 +122,7 @@
     {
         // prepare the patterns for the files that has to be ignored
         $ignore = array(
-            $this->properties['vendor.dir'].'/techdivision/import-attribute-set/src/Utils',
+            $this->properties['vendor.dir'] . '/techdivision/import-attribute-set/src/Utils',
         );
 
         // run the copy past detector

src/Observers/AttributeOptionSwatchFileUploadObserver.php

Indentation +8 added lines, -8 removed lines

@@ -57,14 +57,14 @@
 
             // add debug log entry
             $this->getSubject()
-                 ->getSystemLogger()
-                 ->debug(
-                     sprintf(
-                         'Successfully copied image %s for swatch with id %s',
-                         $imagePath,
-                         $attributeOptionSwatch[MemberNames::SWATCH_ID]
-                     )
-                 );
+                    ->getSystemLogger()
+                    ->debug(
+                        sprintf(
+                            'Successfully copied image %s for swatch with id %s',
+                            $imagePath,
+                            $attributeOptionSwatch[MemberNames::SWATCH_ID]
+                        )
+                    );
         }
     }
 }

Spacing +1 added lines, -1 removed lines

@@ -47,7 +47,7 @@
         ));
 
         // skip this step for color swatches and text swatches
-        if (isset($attributeOptionSwatch[MemberNames::TYPE]) &&  $attributeOptionSwatch[MemberNames::TYPE] === SwatchTypes::IMAGE) {
+        if (isset($attributeOptionSwatch[MemberNames::TYPE]) && $attributeOptionSwatch[MemberNames::TYPE] === SwatchTypes::IMAGE) {
             // upload the file to the configured directory
             $imagePath = $this->getSubject()->uploadFile($attributeOptionSwatch[MemberNames::VALUE]);
 

src/Loaders/RawEntityLoader.php

Spacing +2 added lines, -2 removed lines

@@ -86,8 +86,8 @@
             // load the columns from the metadata
             $columns = array_filter(
                 $columnMetadataLoader->load($entityType),
-                function ($value) {
-                    return $value['Key'] !== 'PRI' && $value['Null'] === 'NO' ;
+                function($value) {
+                    return $value['Key'] !== 'PRI' && $value['Null'] === 'NO';
                 }
             );
             // initialize the raw entities and their default values, if available

tests/unit/Observers/CatalogAttributeObserverTest.php

Indentation +19 added lines, -19 removed lines

@@ -93,8 +93,8 @@ 
 
         // mock the attribute bunch processor
         $this->mockBunchProcessor = $this->getMockBuilder('TechDivision\Import\Attribute\Services\AttributeBunchProcessorInterface')
-                                         ->setMethods(get_class_methods('TechDivision\Import\Attribute\Services\AttributeBunchProcessorInterface'))
-                                         ->getMock();
+                                            ->setMethods(get_class_methods('TechDivision\Import\Attribute\Services\AttributeBunchProcessorInterface'))
+                                            ->getMock();
 
         // the observer instance we want to test
         $this->observer = new CatalogAttributeObserver($this->mockBunchProcessor);
@@ -148,7 +148,7 @@ 
                         array(ColumnKeys::IS_FILTERABLE_IN_GRID),
                         array(ColumnKeys::SEARCH_WEIGHT),
                         array(ColumnKeys::ADDITIONAL_DATA)
-                     )
+                        )
                     ->willReturnOnConsecutiveCalls(
                         true,
                         false,
@@ -190,23 +190,23 @@ 
 
         // mock the method that persists the entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('persistCatalogAttribute')
-                                 ->with(
-                                     array_merge(
-                                         array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
-                                         $this->rawEntity,
-                                         array(EntityStatus::MEMBER_NAME => EntityStatus::STATUS_CREATE)
-                                     )
-                                 )
-                                 ->willReturn(null);
+                                    ->method('persistCatalogAttribute')
+                                    ->with(
+                                        array_merge(
+                                            array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
+                                            $this->rawEntity,
+                                            array(EntityStatus::MEMBER_NAME => EntityStatus::STATUS_CREATE)
+                                        )
+                                    )
+                                    ->willReturn(null);
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('loadRawEntity')
-                                 ->willReturn(
-                                     array_merge(
-                                         array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
-                                         $this->rawEntity
-                                     )
-                                 );
+                                    ->method('loadRawEntity')
+                                    ->willReturn(
+                                        array_merge(
+                                            array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
+                                            $this->rawEntity
+                                        )
+                                    );
 
         // invoke the handle method
         $this->assertSame($row, $this->observer->handle($mockSubject));

tests/unit/Observers/CatalogAttributeUpdateObserverTest.php

Indentation +50 added lines, -50 removed lines

@@ -103,12 +103,12 @@ 
 
         // mock the attribute bunch processor
         $this->mockBunchProcessor = $this->getMockBuilder(AttributeBunchProcessorInterface::class)
-                                         ->setMethods(get_class_methods(AttributeBunchProcessorInterface::class))
-                                         ->getMock();
+                                            ->setMethods(get_class_methods(AttributeBunchProcessorInterface::class))
+                                            ->getMock();
 
         $this->mockEntityMerger = $this->getMockBuilder(EntityMergerInterface::class)
-                                       ->setMethods(get_class_methods(EntityMergerInterface::class))
-                                       ->getMock();
+                                        ->setMethods(get_class_methods(EntityMergerInterface::class))
+                                        ->getMock();
 
         // the observer instance we want to test
         $this->observer = new CatalogAttributeUpdateObserver($this->mockBunchProcessor, $this->mockEntityMerger);
@@ -190,36 +190,36 @@ 
 
         // mock the method that loads the existing entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('loadCatalogAttribute')
-                                 ->with($lastAttributeId)
-                                 ->willReturn($existingEntity);
+                                    ->method('loadCatalogAttribute')
+                                    ->with($lastAttributeId)
+                                    ->willReturn($existingEntity);
         // mock the method that persists the entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('persistCatalogAttribute')
-                                 ->with($expectedEntity)
-                                 ->willReturn(null);
+                                    ->method('persistCatalogAttribute')
+                                    ->with($expectedEntity)
+                                    ->willReturn(null);
         // mock the method that loads the raw entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('loadRawEntity')
-                                 ->willReturn(
-                                     array_merge(
-                                         array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
-                                         $this->rawEntity
-                                     )
-                                 );
+                                    ->method('loadRawEntity')
+                                    ->willReturn(
+                                        array_merge(
+                                            array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
+                                            $this->rawEntity
+                                        )
+                                    );
 
         // mock the entity merger method
         $this->mockEntityMerger->expects($this->any())
-             ->method('merge')
-             ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
-                 foreach (array_keys($attr) as $key) {
-                     if (isset($headers[$key])) {
-                         continue;
-                     }
-                     unset($attr[$key]);
-                 }
-                 return $attr;
-             });
+                ->method('merge')
+                ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
+                    foreach (array_keys($attr) as $key) {
+                        if (isset($headers[$key])) {
+                            continue;
+                        }
+                        unset($attr[$key]);
+                    }
+                    return $attr;
+                });
 
         // invoke the handle method
         $this->assertSame($row, $this->observer->handle($mockSubject));
@@ -403,36 +403,36 @@ 
 
         // mock the method that loads the existing entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('loadCatalogAttribute')
-                                 ->with($lastAttributeId)
-                                 ->willReturn($existingEntity);
+                                    ->method('loadCatalogAttribute')
+                                    ->with($lastAttributeId)
+                                    ->willReturn($existingEntity);
         // mock the method that persists the entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('persistCatalogAttribute')
-                                 ->with($expectedEntity)
-                                 ->willReturn(null);
+                                    ->method('persistCatalogAttribute')
+                                    ->with($expectedEntity)
+                                    ->willReturn(null);
         // mock the method that loads the raw entity
         $this->mockBunchProcessor->expects($this->once())
-                                 ->method('loadRawEntity')
-                                 ->willReturn(
-                                     array_merge(
-                                         array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
-                                         $this->rawEntity
-                                     )
-                                 );
+                                    ->method('loadRawEntity')
+                                    ->willReturn(
+                                        array_merge(
+                                            array(MemberNames::ATTRIBUTE_ID => $lastAttributeId),
+                                            $this->rawEntity
+                                        )
+                                    );
 
         // mock the entity merger method
         $this->mockEntityMerger->expects($this->any())
-             ->method('merge')
-             ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
-                 foreach (array_keys($attr) as $key) {
-                     if (isset($headers[$key])) {
-                         continue;
-                     }
-                     unset($attr[$key]);
-                 }
-                 return $attr;
-             });
+                ->method('merge')
+                ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
+                    foreach (array_keys($attr) as $key) {
+                        if (isset($headers[$key])) {
+                            continue;
+                        }
+                        unset($attr[$key]);
+                    }
+                    return $attr;
+                });
         // invoke the handle method
         $this->assertSame($row, $this->observer->handle($mockSubject));
     }

Spacing +8 added lines, -8 removed lines

@@ -137,16 +137,16 @@ 
                     ->willReturn($row);
         $mockSubject->expects($this->any())
                     ->method('hasHeader')
-                    ->willReturnCallback(function ($key) use ($headers) {
+                    ->willReturnCallback(function($key) use ($headers) {
                         return array_key_exists($key, $headers);
                     });
         $mockSubject->expects($this->any())
                     ->method('getHeader')
-                    ->willReturnCallback(function ($key) use ($headers) {
+                    ->willReturnCallback(function($key) use ($headers) {
                         if (array_key_exists($key, $headers)) {
                             return $headers[$key];
                         }
-                        throw new \InvalidArgumentException(sprintf('Header %s is not available', $key));;
+                        throw new \InvalidArgumentException(sprintf('Header %s is not available', $key)); ;
                     });
         $mockSubject->expects($this->once())
                     ->method('hasBeenProcessed')
@@ -211,7 +211,7 @@ 
         // mock the entity merger method
         $this->mockEntityMerger->expects($this->any())
              ->method('merge')
-             ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
+             ->willReturnCallback(function($observer, $entity, $attr) use ($headers) {
                  foreach (array_keys($attr) as $key) {
                      if (isset($headers[$key])) {
                          continue;
@@ -331,16 +331,16 @@ 
                     ->willReturn($lastAttributeId = 1001);
         $mockSubject->expects($this->any())
                     ->method('hasHeader')
-                    ->willReturnCallback(function ($key) use ($headers) {
+                    ->willReturnCallback(function($key) use ($headers) {
                         return array_key_exists($key, $headers);
                     });
         $mockSubject->expects($this->any())
                     ->method('getHeader')
-                    ->willReturnCallback(function ($key) use ($headers) {
+                    ->willReturnCallback(function($key) use ($headers) {
                         if (array_key_exists($key, $headers)) {
                             return $headers[$key];
                         }
-                        throw new \InvalidArgumentException(sprintf('Header %s is not available', $key));;
+                        throw new \InvalidArgumentException(sprintf('Header %s is not available', $key)); ;
                     });
 
         // initialize the existing entity
@@ -424,7 +424,7 @@ 
         // mock the entity merger method
         $this->mockEntityMerger->expects($this->any())
              ->method('merge')
-             ->willReturnCallback(function ($observer, $entity, $attr) use ($headers) {
+             ->willReturnCallback(function($observer, $entity, $attr) use ($headers) {
                  foreach (array_keys($attr) as $key) {
                      if (isset($headers[$key])) {
                          continue;