/ - Diff - Club Drupal - Forge Centrale Marseille

     # 7.x-4.0-alpha6
     Use update.php to rebuild the registry because of class changes.
     If that does not work use the rebuild_registry module.
     More importantly classes have been restructured and javascript loading
     has been redesigned.
     - Restructured test classes.
     - Restructured the way widget.js is included, how loading is done and
       how the addthis.js behaves.
       - The addthis.js is always loaded but is used as a library instead of
         executing everything directly like it was before.
       - The include of AddThisJson and AddThisWidgetJs in AddThis::getInstance()
         where removed because they should be autoloaded from the register.
       Restructuring classes.
       - In general the AddThis class has become a sort of module file that contains
         all kinds of addthis related functions. This is bad design and therefore step
         by step things are refactored. This breaks API but no official rc or release
         has been given out yet.
       - Classes are structured now in folders in a way namespace could be organised.
         Because PHP 5.2 does not support namespaces we only use classes but the
         structure is already there for future portability.
       - AddThisScriptManager is added as a Service. This handles the attachment of
         js and settings when needing addthis or widgets on your page. The AddThis->addWidgetJs,
         AddThis->includeWidgetJs and AddThis->addConfigurationOptionsJs where
         removed in favor of the AddThisScriptManager functionality.
       - AddThisJson is moved to the Util directory.
       - AddThisWidgetJs is renamed to AddThisWidgetJsUrl and moved to the Util
         directory. The name changed because it better displays the purpose of the
         class.
       - AddThis->getServiceNamesAsCommaSeparatedString was made public to be usable
         inside the AddThisScriptManager.
       - getWidgetJsLoadType was renamed to getWidgetJsInclude because it displays
         the type of information better.
       - Related to the previous the WIDGET_JS_LOAD_TYPE was removed and split into
         WIDGET_JS_LOAD_DOMREADY, WIDGET_JS_LOAD_ASYNC and WIDGET_JS_INCLUDE. The
         reason beeing that the old way was misinterpreted. The DOMREADY and ASYNC
         type of loading are two different things but where not possible separately.
       Examples
       - Expanded the example with a hook_page_build to run the attach functionality
         on the whole page.
       Test
       - A test module was added to be able to test extra things but seperate it from
         the main module.
       - addthis.test contained two test classes. These where split into two sperate
         files.
     # 7.x-4.0-alpha5
     Some undefined index where fixed on the block save for disabled display.
     - Unsupported operand types on block save. [#2181367]
     - Minor changes to the documentation.
     - Fixed issue #1943896 by fcjversc: Add Linkedin vertical counter.
     - Fixed issue #2247245 by jmuzz: Implement button orientation option for Facebook Share button.
     - Fixed issue #2250109 by matglas86, jmuzz: Add support for individual share counters.
     - Fixed issue #2233585 by matglas86, mstef: Uncaught TypeError: Object #<Object> has no method 'ready' .
     - Fixed issue #2206515 by matglas86, dubois: Add configuration 'services_excluded' (globally excluded services) to AddThis Basic Settings.
     - Fixed issue #1989152 by matglas86, labue, juampy: Allow alterations to 'addthis_share' variable in 'addthis_configuration' alter hook.
     - Fixed issue #2241967: Invalid preferred services on form validation.
     - Issue #2181367 by matglas86, dubois | 4fs: Error Fatal error: Unsupported operand types.
     # 7.x-4.0-alpha4
     Fixed two nasty bugs in 7.x-4.0-alpha3.
     - Undefined index: button_size & Undefined index: extra_css. [#2174975]
     - Double colon :: changed to -> because addWidgetJs was not static. [#2174771]
     # 7.x-4.0-alpha3
     Major changes

     -- SUMMARY --
     Add This module provides Drupal integration to addthis.com link sharing service. Integration has been implemented as a field.
     Add This module provides Drupal integration to addthis.com link sharing service.
     Integration has been implemented as a field.
     Description from addthis.com:
     The AddThis button spreads your content across the Web by making it easier for your visitors to bookmark and
     share it with other people, again... and again... and again. This simple yet powerful button is very easy to
     install and provides valuable Analytics about the bookmarking and sharing activity of your users. AddThis helps
     your visitors create a buzz for your site and increase its popularity and ranking.
     AddThis is already on hundreds of thousands of websites including SAP, TIME Magazine, Oracle, Freewebs,
     Entertainment Weekly, Topix, Lonely Planet, MapQuest, MySpace, PGA Tour, Tower Records, Squidoo, Zappos, Funny
     or Die, FOX, ABC, CBS, Glamour, PostSecret, WebMD, American Idol, and ReadWriteWeb, just to name a few. Each
     month our button is displayed 20 billion times.
     The AddThis button spreads your content across the Web by making it easier for
     your visitors to bookmark and share it with other people, again... and again...
     and again. This simple yet powerful button is very easy to install and provides
     valuable Analytics about the bookmarking and sharing activity of your users.
     AddThis helps your visitors create a buzz for your site and increase its
     popularity and ranking.
     AddThis is already on hundreds of thousands of websites including SAP,
     TIME Magazine, Oracle, Freewebs, Entertainment Weekly, Topix, Lonely Planet,
     MapQuest, MySpace, PGA Tour, Tower Records, Squidoo, Zappos, Funny or Die, FOX,
     ABC, CBS, Glamour, PostSecret, WebMD, American Idol, and ReadWriteWeb,
     just to name a few. Each month our button is displayed 20 billion times.
     -- REQUIREMENTS --
-...
     -- INSTALLATION --
     Normal Drupal module installation, see http://drupal.org/node/70151 for further information.
     Normal Drupal module installation, see http://drupal.org/node/70151 for further
     information.
     For link sharing statistics registration at http://addthis.com/ is required, but the module will work even without registration.
     For link sharing statistics registration at http://addthis.com/ is required, but
     the module will work even without registration.
     -- CONFIGURATION --
     Use the admin configuration page to configure settings and see http://drupal.org/node/1309922
     for a walkthrough on how to configure the rest.
     -- DEVELOPMENT --
     Please see the addthis.api.php for implementation options of different displays
     and altering configuration on rendering.
     -- CONTACT --

     - Update README.txt to refer to the addthis.api.php for implementation options.
     - Write addthis.api.php file with example of implementation.
     - Add custom button with upload functionality for a custom button image.
     - Move basic button to main module to provide a basic implementation.
     - Create a column view of the services on the settings page.
     - Create asynchronous load checkbox in settings page.
     - Refactor the order of methods in the AddThis class to collect same type of methods.
     - Refactor the rendering into classes per display type.
     - Delegate settings save validation to it corresponding display type class.

     .addthis_service_icon {
       display: inline-block;
       padding-left: 20px;
+    }
+    }
     #edit-addthis-enabled-services .form-item, #edit-addthis-excluded-services .form-item {
       float: left;
       width: 20%;
+    }
     #edit-addthis-enabled-services .form-item .description {
       clear: both;
+    }

         $markup['google_plusone']['#attributes']['g:plusone:size'] = 'small';
+      }
+    }
     /**
      * Implements hook_TYPE_alter().
+     *
      * @param array $configuration.
      */
     function hook_addthis_configuration($configuration) {
       if (isset($configuration['templates'])) {
         $configuration['templates']['twitter'] = 'Hello on twitter.';
+      }
       if (isset($configuration['addthis_share'])) {
         // Alter the share variable used for the javascript.
+      }
+    }

     <?php
     /**
      * Implements hook_page_build().
      */
     function hook_page_build(&$page) {
       // Load the scripts on a specific url or other case when you don't use the
       // Field API or Block.
       if (current_path() == 'node/1') {
         $manager = AddThisScriptManager::getInstance();
         // Adjust domready and async settings for this page.
         //
         // NOTE! that on pages where these settings are altered and attach is called
         // more then once but not altered he second time, you will get conflicts.
         // The widget js will be loaded multiple times with different settings.
         // So choose wisely!
         //
         $manager->setAsync(FALSE);
         $manager->setDomReady(FALSE);
         // Using $page['content'] or other area is neccesary because otherwise
         // #attached does not work. You can not attach on $page directly.
         $manager->attachJsToElement($page['content']);
+      }
+    }

     dependencies[] = field
     files[] = addthis.test
     files[] = classes/AddThis.php
     files[] = classes/AddThisJson.php
     files[] = classes/Services/AddThisScriptManager.php
     files[] = classes/Util/AddThisJson.php
     files[] = classes/Util/AddThisWidgetJsUrl.php
     files[] = tests/AddThisTestHelper.php
     files[] = tests/AddThisDrupalSettingsJsTestHelper.php
     files[] = tests/AddThisJsTest.test
     files[] = tests/AddThisFunctionalityTestCase.test
     files[] = tests/AddThisPermissionsTestCase.test
     configure = admin/config/user-interface/addthis
     ; Information added by Drupal.org packaging script on 2014-01-22
     version = "7.x-4.0-alpha4"
     ; Information added by Drupal.org packaging script on 2015-06-15
     version = "7.x-4.0-alpha6"
     core = "7.x"
     project = "addthis"
     datestamp = "1390384409"
     datestamp = "1434368594"

     <?php
     /**
      * @file
      * Install, update and uninstall functions for the AddThis module.
-...
       variable_del(AddThis::CUSTOM_CONFIGURATION_CODE_ENABLED_KEY);
       variable_del(AddThis::CUSTOM_CONFIGURATION_CODE_KEY);
       variable_del(AddThis::ENABLED_SERVICES_KEY);
       variable_del(AddThis::EXCLUDED_SERVICES_KEY);
       variable_del(AddThis::OPEN_WINDOWS_ENABLED_KEY);
       variable_del(AddThis::PROFILE_ID_KEY);
       variable_del(AddThis::SERVICES_CSS_URL_KEY);
-...
       variable_del(AddThis::UI_HEADER_BACKGROUND_COLOR_KEY);
       variable_del(AddThis::UI_HEADER_COLOR_KEY);
       variable_del(AddThis::WIDGET_JS_URL_KEY);
       variable_del(AddThis::WIDGET_JS_LOAD_TYPE);
       variable_del(AddThis::WIDGET_JS_LOAD_DOMREADY);
       variable_del(AddThis::WIDGET_JS_LOAD_ASYNC);
+    }
     /**
-...
     function addthis_update_7401() {
       variable_del('addthis_widget_async');
+    }
     /**
      * Remove old addthis_widget_load_type and transform it into new values.
+     *
      * Transform variable in settings for domready and async.
      * If value = async set domready TRUE and async TRUE.
      * If value = domready set domready TRUE and async FALSE.
      * If value = include set domready FALSE and async FALSE.
      */
     function addthis_update_7402() {
       $load_type = variable_get('addthis_widget_load_type', NULL);
       switch ($load_type) {
         case 'async':
           variable_set(AddThis::WIDGET_JS_LOAD_DOMREADY, TRUE);
           variable_set(AddThis::WIDGET_JS_LOAD_ASYNC, TRUE);
           break;
         case 'domready':
           variable_set(AddThis::WIDGET_JS_LOAD_DOMREADY, TRUE);
           variable_set(AddThis::WIDGET_JS_LOAD_ASYNC, FALSE);
           break;
         case 'include':
           variable_set(AddThis::WIDGET_JS_LOAD_DOMREADY, FALSE);
           variable_set(AddThis::WIDGET_JS_LOAD_ASYNC, FALSE);
           break;
         default:
           variable_set(AddThis::WIDGET_JS_LOAD_DOMREADY, TRUE);
           variable_set(AddThis::WIDGET_JS_LOAD_ASYNC, FALSE);
           break;
+      }
       variable_del('addthis_widget_load_type');
+    }

     (function ($) {
     /**
      * @file
      * AddThis javascript actions.
      */
     (function ($) {
       Drupal.behaviors.addthis = {
         scriptLoaded: false,
         attach: function(context, settings) {
           // If addthis settings are provided a display is loaded.
           if (typeof Drupal.settings.addthis != 'undefined') {
             if (typeof Drupal.settings.addthis.load_type != 'undefined') {
               if (Drupal.settings.addthis.load_type == 'async') {
                 addthis.init();
+              }
               if (Drupal.settings.addthis.load_type == 'domready') {
                 $.getScript(
                   Drupal.settings.addthis.widget_url,
                   function(data, textStatus) {});
+              }
               // Trigger ready on ajax attach.
               if (context != window.document && window.addthis != null) {
                 window.addthis.ost = 0;
                 window.addthis.ready();
+              }
           // The addthis configuration is not loaded but the settings are passed
           // to do so.
           if (!this.isConfigLoaded() && this.isSettingsLoaded()) {
             // Initialize config.
             this.initConfig();
             // Load widget js.
             if (!this.scriptLoaded) {
               this.loadDomready();
+            }
+          }
           // The addthis configuration is not loaded but no setting are available
           // to load anything.
           else if(!this.isConfigLoaded() && !this.isSettingsLoaded()) {
             // Do nothing
+          }
           // Trigger ready on ajax attach.
           if (context != window.document) {
             Drupal.behaviors.addthis.ajaxLoad(context, settings);
+          }
         },
         // Returns if the settings defined by the addthis module are loaded.
         isSettingsLoaded: function () {
           if (typeof Drupal.settings.addthis == 'undefined') {
             return false;
+          }
           return true;
         },
         // Returns if the configuration variables needed for widget.js are defined.
         isConfigLoaded: function() {
           if (typeof addthis_config == 'undefined' || typeof addthis_share == 'undefined') {
             return false;
+          }
           return true;
         },
         initConfig: function () {
           addthis_config = Drupal.settings.addthis.addthis_config;
           addthis_share = Drupal.settings.addthis.addthis_share;
         },
         // Load the js library when the dom is ready.
         loadDomready: function() {
           // If settings asks for loading the script after the dom is loaded, then
           // load the script here.
           if (!this.scriptLoaded &&
               this.isConfigLoaded() &&
               Drupal.settings.addthis.domready) {
             $.getScript(Drupal.settings.addthis.widget_url, Drupal.behaviors.addthis.scriptReady);
+          }
         },
         // Callback for loading the widget.js dynamically.
         scriptReady: function () {
           this.scriptLoaded = true;
         },
         // Called when a ajax request returned.
         ajaxLoad: function(context, settings) {
           if (typeof window.addthis != 'undefined' &&
               typeof window.addthis.toolbox == 'function')
+          {
               window.addthis.toolbox('.addthis_toolbox');
+          }
+        }
       };
       // This load the config in time to run any addthis functionality.
       if (Drupal.behaviors.addthis.isConfigLoaded()) {
         addthis_config = Drupal.settings.addthis.addthis_config;
         addthis_share = Drupal.settings.addthis.addthis_share;
+      }
       // Document ready in case we want to load AddThis into the dom after every
       // thing is loaded.
       //
       // Is executed once after the attach happened.
       $(document).ready(function() {
         Drupal.behaviors.addthis.loadDomready();
       });
     }(jQuery));

         'file' => AddThis::ADMIN_INCLUDE_FILE,
         'weight' => 10
       );
       return $menu_items;
+    }
-...
       );
+    }
     /**
      * Implements hook_page_build().
      */
     function addthis_page_build(&$page) {
       // Include the addthis.js as a library on every page. Widget js will be loaded
       // according to the settings.
       $addthis_js_path = drupal_get_path('module', 'addthis') . '/addthis.js';
       $page['content']['#attached']['js'][$addthis_js_path] = array(
         'type' => 'file',
         'scope' => 'footer',
       );
       // Include the widget js when we include on all but admin pages.
       if (!path_is_admin(current_path()) && AddThis::getInstance()->getWidgetJsInclude() == AddThis::WIDGET_JS_INCLUDE_PAGE) {
         $manager = AddThisScriptManager::getInstance();
         $manager->attachJsToElement($page['content']);
+      }
+    }
     /**
      * Implements hook_preprocess() for theme_addthis.
      */
-...
     /**
      * Create a addthis settings form.
      */
     function _addthis_settings_form($form = array(), &$form_state, $display_type = NULL, $display_settings = NULL) {
       // Toggle variables
       $no_js = FALSE;
     function _addthis_settings_form($form = array(), &$form_state = array(), $display_type = NULL, $display_settings = array()) {
       // Check display setting to be not null.
       if (!isset($display_settings) || (isset($display_settings) && !is_array($display_settings))) {
         $display_settings = array();
+      }
       // Toggle variables.
       $no_js = FALSE;
       // Default display type if not set in the parameters.
       $display_type = (isset($display_type)) ? $display_type : 'addthis_disabled';

     <?php
     /**
      * @file
      * Tests for the AddThis-module.
      */
     class AddThisFunctionalityTestCase extends DrupalWebTestCase {
       private $user;
       public function setUp() {
         parent::setUp(AddThis::MODULE_NAME);
         $this->createAndLoginUser();
+      }
       public static function getInfo() {
         return array(
           'name' => 'AddThis: Functionality tests',
           'description' => 'Functionality tests for the AddThis-module.',
           'group' => 'AddThis',
         );
+      }
       public function testFunctionality() {
         $this->addThisShouldProvideHelp();
         $this->addThisShouldDefineField();
         $this->addThisShouldDefineBlock();
         $this->addThisShouldBeAbleToBeUsedAsField();
         $this->addThisSystemSettingsShouldBeAbleToBeSaved();
+      }
       private function addThisShouldProvideHelp() {
         $helpText = module_invoke(AddThis::MODULE_NAME, 'help', 'admin/help#addthis', NULL);
         $this->assertTrue(TestHelper::stringContains($helpText, t('About')), 'AddThis-module should provide help.');
+      }
       private function addThisShouldDefineField() {
         $fieldInfo = module_invoke(AddThis::MODULE_NAME, 'field_info');
         $this->assertTrue(is_array($fieldInfo), t('AddThis-module should define a field.'));
+      }
       private function addThisShouldDefineBlock() {
         $blockInfo = module_invoke(AddThis::MODULE_NAME, 'block_info');
         $this->assertTrue(is_array($blockInfo), t('AddThis-module should define a block.'));
+      }
       private function addThisShouldBeAbleToBeUsedAsField() {
         $edit = array();
         $label = TestHelper::generateRandomLowercaseString();
         $edit["fields[_add_new_field][label]"] = $label;
         $edit["fields[_add_new_field][field_name]"] = $label;
         $edit["fields[_add_new_field][type]"] = AddThis::FIELD_TYPE;
         $edit["fields[_add_new_field][widget_type]"] = AddThis::WIDGET_TYPE;
         $this->drupalPost('admin/structure/types/manage/article/fields', $edit, t('Save'));
         $this->assertText($label, 'AddThis-module should be able to be added as a field.');
         $this->addThisShouldNotHaveConfigurableFieldLevelSettings($label);
         $this->drupalGet('admin/structure/types/manage/article/display');
+      }
       private function addThisShouldNotHaveConfigurableFieldLevelSettings($label) {
         $this->assertText(t("@name has no field settings.", array('@name' => $label)),
                          'AddThis-module should not have configurable field level settings.');
+      }
       private function addThisSystemSettingsShouldBeAbleToBeSaved() {
         $edit_basic = array();
         // Basic settings
         $profileId = TestHelper::generateRandomLowercaseString();
         $edit_basic[AddThis::PROFILE_ID_KEY] = $profileId;
         $uiDelay = 400;
         $edit_basic[AddThis::UI_DELAY_KEY] = $uiDelay;
         $uiHeaderBackgroundColor = '#000000';
         $edit_basic[AddThis::UI_HEADER_BACKGROUND_COLOR_KEY] = $uiHeaderBackgroundColor;
         $uiHeaderColor = '#ffffff';
         $edit_basic[AddThis::UI_HEADER_COLOR_KEY] = $uiHeaderColor;
         $coBrand = TestHelper::generateRandomLowercaseString();
         $edit_basic[AddThis::CO_BRAND_KEY] = $coBrand;
         $edit_basic[AddThis::COMPLIANT_508_KEY] = TRUE;
         $edit_basic[AddThis::CLICKBACK_TRACKING_ENABLED_KEY] = TRUE;
         // Can only be tested with Google Analytics module installed.
         //$edit_basic[AddThis::GOOGLE_ANALYTICS_TRACKING_ENABLED_KEY] = TRUE;
         //$edit_basic[AddThis::GOOGLE_ANALYTICS_SOCIAL_TRACKING_ENABLED_KEY] = TRUE;
         $edit_basic[AddThis::ADDRESSBOOK_ENABLED_KEY] = TRUE;
         $edit_basic[AddThis::CLICK_TO_OPEN_COMPACT_MENU_ENABLED_KEY] = TRUE;
         $edit_basic[AddThis::OPEN_WINDOWS_ENABLED_KEY] = TRUE;
         $edit_basic[AddThis::STANDARD_CSS_ENABLED_KEY] = TRUE;
         $serviceName = '2linkme';
         $edit_basic["addthis_enabled_services[$serviceName]"] = $serviceName;
         $this->drupalPost('admin/config/user-interface/addthis', $edit_basic, t('Save configuration'));
         $this->assertText(t('The configuration options have been saved.'), 'AddThis system settings should be able to be saved.');
         $this->addThisProfileIdShouldBeAbleToBeSaved($profileId);
         $this->addThisUiDelayShouldBeAbleToBeSaved($uiDelay);
         $this->addThisUiHeaderBackgroundColorShouldBeAbleToBeSaved($uiHeaderBackgroundColor);
         $this->addThisUiHeaderColorShouldBeAbleToBeSaved($uiHeaderColor);
         $this->addThisCoBrandShouldBeAbleToBeSaved($coBrand);
         $this->addThis508CompliantSettingShouldBeAbleToBeSaved();
         $this->addThisClickbackTrackingEnabledSettingShouldBeAbleToBeSaved();
         // Can only be tested with Google Analytics module installed.
         //$this->addThisGoogleAnalyticsTrackingEnabledSettingShouldBeAbleToBeSaved();
         //$this->addThisGoogleAnalyticsSocialTrackingEnabledSettingShouldBeAbleToBeSaved();
         $this->addThisClickToOpenCompactMenuEnabledSettingShouldBeAbleToBeSaved();
         $this->addThisOpenWindowsEnabledSettingShouldBeAbleToBeSaved();
         $this->addThisStandardCssEnabledSettingShouldBeAbleToBeSaved();
         $this->addThisEnabledServicesShouldBeAbleToBeSaved($serviceName);
         // Advanced configuration
         $edit_basic = array();
         $servicesCssUrl = AddThis::DEFAULT_SERVICES_CSS_URL;
         $edit_basic[AddThis::SERVICES_CSS_URL_KEY] = $servicesCssUrl;
         $servicesJsonUrl = AddThis::DEFAULT_SERVICES_JSON_URL;
         $edit_basic[AddThis::SERVICES_JSON_URL_KEY] = $servicesJsonUrl;
         $widgetJsUrl = AddThis::DEFAULT_WIDGET_JS_URL;
         $edit_basic[AddThis::WIDGET_JS_URL_KEY] = $widgetJsUrl;
         $edit_basic[AddThis::CUSTOM_CONFIGURATION_CODE_ENABLED_KEY] = TRUE;
         $customConfigurationCode = TestHelper::generateRandomLowercaseString();
         $edit_basic[AddThis::CUSTOM_CONFIGURATION_CODE_KEY] = $customConfigurationCode;
         $this->drupalPost('admin/config/user-interface/addthis/advanced', $edit_basic, t('Save configuration'));
         $this->addThisServicesCssUrlShouldBeAbleToBeSaved($servicesCssUrl);
         $this->addThisServicesJsonUrlShouldBeAbleToBeSaved($servicesJsonUrl);
         $this->addThisWidgetJsUrlShouldBeAbleToBeSaved($widgetJsUrl);
         $this->addThisCustomConfigurationCodeEnabledSettingShouldBeAbleToBeSaved();
+      }
       private function addThisProfileIdShouldBeAbleToBeSaved($profileId) {
         $this->assertFieldByName(AddThis::PROFILE_ID_KEY, $profileId,
                                  'AddThis profile ID should be able to be saved.');
+      }
       private function addThisServicesCssUrlShouldBeAbleToBeSaved($servicesCssUrl) {
         $this->assertFieldByName(AddThis::SERVICES_CSS_URL_KEY, $servicesCssUrl,
                                  'AddThis services stylesheet URL should be able to be saved.');
+      }
       private function addThisServicesJsonUrlShouldBeAbleToBeSaved($servicesJsonUrl) {
         $this->assertFieldByName(AddThis::SERVICES_JSON_URL_KEY, $servicesJsonUrl,
                                  'AddThis services json URL should be able to be saved.');
+      }
       private function addThisWidgetJsUrlShouldBeAbleToBeSaved($widgetJsUrl) {
         $this->assertFieldByName(AddThis::WIDGET_JS_URL_KEY, $widgetJsUrl,
                                  'AddThis javascript widget URL should be able to be saved.');
+      }
       private function addThis508CompliantSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-508-compliant',
                                   'AddThis 508 compliant setting should be able to be saved.');
+      }
       private function addThisClickbackTrackingEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-clickback-tracking-enabled',
                                   'AddThis clickback tracking enabled setting should be able to be saved.');
+      }
       private function addThisGoogleAnalyticsTrackingEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-google-analytics-tracking-enabled',
                                   'AddThis Google Analytics tracking enabled setting should be able to be saved.');
+      }
       private function addThisGoogleAnalyticsSocialTrackingEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-google-analytics-tracking-enabled',
                                   'AddThis Google Analytics social tracking enabled setting should be able to be saved.');
+      }
       private function addThisClickToOpenCompactMenuEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-click-to-open-compact-menu-enabled',
                                   'AddThis click to open compact menu setting should be able to be saved.');
+      }
       private function addThisOpenWindowsEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-open-windows-enabled',
                                   'AddThis open windows setting should be able to be saved.');
+      }
       private function addThisStandardCssEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-open-windows-enabled',
                                   'AddThis open windows setting should be able to be saved.');
+      }
       private function addThisFacebookLikeEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-facebook-like-enabled',
                                   'AddThis Facebook Like enabled setting should be able to be saved.');
+      }
       private function addThisAddressbookEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-addressbook-enabled',
                                   'AddThis addressbook enabled setting should be able to be saved.');
+      }
       private function addThisCustomConfigurationCodeEnabledSettingShouldBeAbleToBeSaved() {
         $this->assertFieldChecked('edit-addthis-custom-configuration-code-enabled',
                                   'AddThis custom configuration code enabled setting should be able to be saved.');
+      }
       private function addThisCustomConfigurationCodeShouldBeAbleToBeSaved($customConfigurationCode) {
         $this->assertFieldByName(AddThis::CUSTOM_CONFIGURATION_CODE_KEY, $customConfigurationCode,
                                  'AddThis custom configuration code should be able to be saved.');
+      }
       private function addThisUiHeaderColorShouldBeAbleToBeSaved($uiHeaderColor) {
         $this->assertFieldByName(AddThis::UI_HEADER_COLOR_KEY, $uiHeaderColor,
                                  'AddThis UI header color should be able to be saved.');
+      }
       private function addThisUiDelayShouldBeAbleToBeSaved($uiDelay) {
         $this->assertFieldByName(AddThis::UI_DELAY_KEY, $uiDelay,
                                  'AddThis UI delay should be able to be saved.');
+      }
       private function addThisUiHeaderBackgroundColorShouldBeAbleToBeSaved($uiHeaderBackgroundColor) {
         $this->assertFieldByName(AddThis::UI_HEADER_BACKGROUND_COLOR_KEY, $uiHeaderBackgroundColor,
                                  'AddThis UI header background color should be able to be saved.');
+      }
       private function addThisCoBrandShouldBeAbleToBeSaved($coBrand) {
         $this->assertFieldByName(AddThis::CO_BRAND_KEY, $coBrand,
                                  'AddThis co-brand should be able to be saved.');
+      }
       private function addThisEnabledServicesShouldBeAbleToBeSaved($serviceName) {
         $this->assertFieldChecked('edit-addthis-enabled-services-' . $serviceName,
                                   'AddThis enabled services should be able to be saved.');
+      }
       private function createAndLoginUser() {
         $this->user = $this->createAdminUser();
         $this->drupalLogin($this->user);
+      }
       private function createAdminUser() {
         return $this->drupalCreateUser(
           array(
             AddThis::PERMISSION_ADMINISTER_ADDTHIS,
             AddThis::PERMISSION_ADMINISTER_ADVANCED_ADDTHIS,
             'administer blocks',
             'administer content types',
             'administer nodes'
+          )
         );
+      }
+    }
     class AddThisPermissionsTestCase extends DrupalWebTestCase {
       public function setUp() {
         parent::setUp(AddThis::MODULE_NAME);
+      }
       public static function getInfo() {
         return array(
           'name' => 'AddThis: Permission tests',
           'description' => 'Permission tests for the AddThis-module.',
           'group' => 'AddThis',
         );
+      }
       public function testUserWithoutAdministerAddThisPermissionShouldNotBeAllowedToAccessAddThisSystemSettings() {
         $this->drupalLogin($this->createAdminUserWithoutAddThisAdministrationPermission());
         $this->drupalGet('admin/config/system/addthis');
         $this->assertRaw(t('Access denied'),
                          'A user without administer addthis permission should not be able to access AddThis system settings.');
+      }
       public function testUserWithoutAdministerAdvancedAddThisPermissionShouldNotBeAllowedToAccessAdvancedAddThisSystemSettings() {
         $this->drupalLogin($this->createAdminUserWithoutAdvancedAddThisAdministrationPermission());
         $this->drupalGet('admin/config/system/addthis');
         $this->assertNoRaw(t('Advanced settings'),
                            'A user without administer advanced addthis permission should not be able to access advanced AddThis system settings.');
+      }
       private function createAdminUserWithoutAddThisAdministrationPermission() {
         return $this->drupalCreateUser(array('administer content types'));
+      }
       private function createAdminUserWithoutAdvancedAddThisAdministrationPermission() {
         return $this->drupalCreateUser(array('administer content types', AddThis::PERMISSION_ADMINISTER_ADDTHIS));
+      }
+    }
     class TestHelper {
       public static function stringContains($string, $contains) {
         return strpos($string, $contains) !== FALSE;
+      }
       public static function generateRandomLowercaseString() {
         return drupal_strtolower(DrupalWebTestCase::randomName());
+      }
+    }

       );
       $element['#attributes'] += $addthis->getAddThisAttributesMarkup($options);
       // Add the widget script.
       $script_manager = AddThisScriptManager::getInstance();
       $script_manager->attachJsToElement($element);
       $services = trim($options['#display']['settings']['share_services']);
       $services = str_replace(' ', '', $services);
       $services = explode(',', $services);
-...
           '#addthis_service' => $service,
         );
         // Add individual counters.
         if (strpos($service, 'counter_') === 0) {
           $items[$service]['#attributes']['class'] = array("addthis_$service");
+        }
         // Basic implementations of bubble counter orientation.
         // @todo Figure all the bubbles out and add them.
         //   Still missing: tweetme, hyves and stubleupon.
         //   Still missing: tweetme, hyves and stubleupon, google_plusone_badge.
         //
         // @todo Fix a way to use addthis_bubble_style.
         //   There is a conflict now with using the class addthis_button_[service].
         //   You can't add this bubble style now.
         $orientation = ($options['#display']['settings']['counter_orientation'] == 'horizontal' ? TRUE : FALSE);
         switch ($service) {
           case 'linkedin_counter':
               $items[$service]['#attributes'] += array(
                 'li:counter' => ($orientation ? '' : 'top'),
               );
             break;
           case 'facebook_like':
             $items[$service]['#attributes'] += array(
               'fb:like:layout' => ($orientation ? 'button_count' : 'box_count')
             );
             break;
           case 'facebook_share':
             $items[$service]['#attributes'] += array(
               'fb:share:layout' => ($orientation ? 'button_count' : 'box_count')
             );
             break;
           case 'google_plusone':
             $items[$service]['#attributes'] += array(
               'g:plusone:size' => ($orientation ? 'standard' : 'tall')
-...
               'tw:via' => AddThis::getInstance()->getTwitterVia(),
             );
             break;
           case 'bubble_style':
             $items[$service]['#attributes']['class'] = array(
               'addthis_counter', 'addthis_bubble_style'
             );
             break;
           case 'pill_style':
             $items[$service]['#attributes']['class'] = array(
               'addthis_counter', 'addthis_pill_style'
             );
             break;
+        }
+      }
       $element += $items;
-...
       );
       $element['#attributes'] += $addthis->getAddThisAttributesMarkup($options);
       // Add the widget script.
       $script_manager = AddThisScriptManager::getInstance();
       $script_manager->attachJsToElement($element);
       // Create img button.
       $image = array(
         '#theme' => 'addthis_element',

             '#default_value' => $settings['share_services'],
             '#required' => TRUE,
             '#element_validate' => array('_addthis_display_element_validate_services'),
             '#description' => t('Specify the names of the sharing services and seperate them with a , (comma). <a href="http://www.addthis.com/services/list">The names on this list are valid.</a>'),
             '#description' =>
               t('Specify the names of the sharing services and seperate them with a , (comma). <a href="http://www.addthis.com/services/list" target="_blank">The names on this list are valid.</a>') .
               t('Elements that are available but not ont the services list are (!services).',
                 array('!services' => 'bubble_style, pill_style, tweet, facebook_send, twitter_follow_native, google_plusone, stumbleupon_badge, counter_* (several supported services), linkedin_counter')
             ),
           );
           $element['buttons_size'] = array(
             '#title' => t('Buttons size'),
-...
       $services = trim($element['#value']);
       $services = str_replace(' ', '', $services);
       if (!preg_match('/^[a-z\_\,]+$/', $services)) {
       if (!preg_match('/^[a-z\_\,0-9]+$/', $services)) {
         $bad = TRUE;
+      }
       // @todo Validate the service names against AddThis.com. Give a notice when there are bad names.

     dependencies[] = addthis
     files[] = addthis_displays.field.inc
     ; Information added by Drupal.org packaging script on 2014-01-22
     version = "7.x-4.0-alpha4"
     ; Information added by Drupal.org packaging script on 2015-06-15
     version = "7.x-4.0-alpha6"
     core = "7.x"
     project = "addthis"
     datestamp = "1390384409"
     datestamp = "1434368594"

     name = AddThis tests
     description = Module for testing AddThis functionality.
     core = 7.x
     hidden = true
     dependencies[] = addthis
     dependencies[] = addthis_displays
     ; Information added by Drupal.org packaging script on 2015-06-15
     version = "7.x-4.0-alpha6"
     core = "7.x"
     project = "addthis"
     datestamp = "1434368594"

     <?php
     /**
      * Implements hook_page_build().
      */
     function addthis_test_page_build(&$page) {
       // See AddThisTestHelper.php.page.inc for more info.
       if (current_path() == 'addthis/test/2') {
         $manager = AddThisScriptManager::getInstance();
         $manager->attachJsToElement($page['content']);
+      }
+    }
     /**
      * Implements hook_menu().
      */
     function addthis_test_menu() {
       // Test pages.
       // Pages used in the test cases.
       $menu_items['addthis/test/1'] = array(
         'title' => 'Test no Javascript load',
         'type' => MENU_CALLBACK,
         'page callback' => 'addthis_test_no_js',
         'access arguments' => array(AddThis::PERMISSION_ADMINISTER_ADDTHIS),
         'file' => 'includes/addthis.test_pages.inc'
       );
       $menu_items['addthis/test/2'] = array(
         'title' => 'Test Javascript load on preprocess',
         'type' => MENU_CALLBACK,
         'page callback' => 'addthis_test_with_js',
         'access arguments' => array(AddThis::PERMISSION_ADMINISTER_ADDTHIS),
         'file' => 'includes/addthis.test_pages.inc'
       );
       return $menu_items;
+    }

     <?php
     /**
      * @file
      * Callbacks for test pages that include AddThis functionality.
      */
     /**
      * Page callback to test a page load without any js loaded.
+     *
      * @return array
      *   Render array for a page.
      */
     function addthis_test_no_js() {
       $content = array();
       $content['explanation'] = array(
         '#markup' => 'No widget js is loaded on this page. Unless specified in the settings.',
       );
       return $content;
+    }
     /**
      * Page callback to test a page load with js loaded.
+     *
      * @return array
      *   Render array for this page.
      */
     function addthis_test_with_js() {
       $content = array();
       $content['explanation'] = array(
         '#markup' => 'Widget js is loaded on this page through hook_page_build().<br>
         <!-- Go to www.addthis.com/dashboard to customize your tools -->
         <div class="addthis_sharing_toolbox"></div>',
       );
       return $content;
+    }

       const CUSTOM_CONFIGURATION_CODE_ENABLED_KEY = 'addthis_custom_configuration_code_enabled';
       const CUSTOM_CONFIGURATION_CODE_KEY = 'addthis_custom_configuration_code';
       const ENABLED_SERVICES_KEY = 'addthis_enabled_services';
       const EXCLUDED_SERVICES_KEY = 'addthis_excluded_services';
       const GOOGLE_ANALYTICS_TRACKING_ENABLED_KEY = 'addthis_google_analytics_tracking_enabled';
       const GOOGLE_ANALYTICS_SOCIAL_TRACKING_ENABLED_KEY = 'addthis_google_analytics_social_tracking_enabled';
       const FACEBOOK_LIKE_COUNT_SUPPORT_ENABLED = 'addthis_facebook_like_count_support_enabled';
-...
       const UI_HEADER_BACKGROUND_COLOR_KEY = 'addthis_ui_header_background_color';
       const UI_HEADER_COLOR_KEY = 'addthis_ui_header_color';
       const WIDGET_JS_URL_KEY = 'addthis_widget_js_url';
       const WIDGET_JS_LOAD_TYPE = 'addthis_widget_load_type';
       const WIDGET_JS_LOAD_DOMREADY = 'addthis_widget_load_domready';
       const WIDGET_JS_LOAD_ASYNC = 'addthis_widget_load_async';
       const WIDGET_JS_INCLUDE = 'addthis_widget_include';
       // Twitter.
       const TWITTER_VIA_KEY = 'addthis_twitter_via';
-...
       const DEFAULT_SERVICES_CSS_URL = 'http://cache.addthiscdn.com/icons/v1/sprites/services.css';
       const DEFAULT_SERVICES_JSON_URL = 'http://cache.addthiscdn.com/services/v1/sharing.en.json';
       const DEFAULT_WIDGET_JS_URL = 'http://s7.addthis.com/js/300/addthis_widget.js';
       const DEFAULT_WIDGET_JS_LOAD_TYPE = 'async';
       const DEFAULT_WIDGET_JS_LOAD_DOMREADY = TRUE;
       const DEFAULT_WIDGET_JS_LOAD_ASYNC = FALSE;
       // Type of inclusion.
       // 0 = don't include, 1 = pages no admin, 2 = on usages only.
       const DEFAULT_WIDGET_JS_INCLUDE = 2;
       const WIDGET_JS_INCLUDE_NONE = 0;
       const WIDGET_JS_INCLUDE_PAGE = 1;
       const WIDGET_JS_INCLUDE_USAGE = 2;
       // Internal resources.
       const ADMIN_CSS_FILE = 'addthis.admin.css';
-...
        *   Instance of AddThis.
        */
       public static function getInstance() {
         module_load_include('php', 'addthis', 'classes/AddThisJson');
         module_load_include('php', 'addthis', 'classes/AddThisWidgetJs');
         if (!isset(self::$instance)) {
           $add_this = new AddThis();
-...
           return array();
+        }
         // Load resources.
         self::$instance->includeWidgetJs();
         self::$instance->addConfigurationOptionsJs();
         // The display type exists. Now get it and get the markup.
         $display_information = $formatters[$display];
-...
         return $rows;
+      }
       /**
        * Add the AddThis Widget JavaScript to the page.
        */
       public function addWidgetJs() {
         $widgetjs = new AddThisWidgetJs(self::getWidgetUrl());
         $widgetjs->addAttribute('pubid', $this->getProfileId());
         if (self::getWidgetJsLoadType() != 'include') {
           $widgetjs->addAttribute(self::getWidgetJsLoadType(), '1');
+        }
         $url = $widgetjs->getFullUrl();
         switch (self::getWidgetJsLoadType()) {
           // Load as DOM is ready.
           case 'domready':
             drupal_add_js(
               array(
                 'addthis' => array(
                   'widget_url' => $url,
                   'load_type' => self::getWidgetJsLoadType(),
                 ),
               ),
               'setting'
             );
             break;
           // Load as async.
           case 'async':
             drupal_add_js(
               array(
                 'addthis' => array(
                   'load_type' => self::getWidgetJsLoadType(),
                 ),
               ),
               'setting'
             );
             drupal_add_js(
               $url,
               array(
                 'type' => 'external',
                 'scope' => 'footer',
+              )
             );
             break;
           // Load as include in the page.
           default:
             drupal_add_js(
               $url,
               array(
                 'type' => 'external',
                 'scope' => 'footer',
+              )
             );
             break;
+        }
         // Add local internal behaviours.
         drupal_add_js(
           drupal_get_path('module', 'addthis') . '/addthis.js',
           array(
             'type' => 'file',
             'scope' => 'footer',
+          )
         );
+      }
       /**
        * Load function for widget information.
+       *
        * Loading widget information only once.
        */
       public function includeWidgetJs() {
         static $loaded;
         if (!isset($loaded)) {
           $loaded = TRUE;
           $this->addWidgetJs();
           return TRUE;
+        }
         return FALSE;
+      }
       public function addConfigurationOptionsJs() {
         if ($this->isCustomConfigurationCodeEnabled()) {
           $configurationOptionsJavascript = $this->getCustomConfigurationCode();
+        }
         else {
           $enabledServices = $this->getServiceNamesAsCommaSeparatedString() . 'more';
           global $language;
           $configuration = array(
             'pubid' => $this->getProfileId(),
             'services_compact' => $enabledServices,
             'data_track_clickback' => $this->isClickbackTrackingEnabled(),
             'ui_508_compliant' => $this->get508Compliant(),
             'ui_click' => $this->isClickToOpenCompactMenuEnabled(),
             'ui_cobrand' => $this->getCoBrand(),
             'ui_delay' => $this->getUiDelay(),
             'ui_header_background' => $this->getUiHeaderBackgroundColor(),
             'ui_header_color' => $this->getUiHeaderColor(),
             'ui_open_windows' => $this->isOpenWindowsEnabled(),
             'ui_use_css' => $this->isStandardCssEnabled(),
             'ui_use_addressbook' => $this->isAddressbookEnabled(),
             'ui_language' => $language->language,
           );
           if (module_exists('googleanalytics')) {
             if ($this->isGoogleAnalyticsTrackingEnabled()) {
               $configuration['data_ga_property'] = variable_get('googleanalytics_account', '');
               $configuration['data_ga_social'] = $this->isGoogleAnalyticsSocialTrackingEnabled();
+            }
+          }
           $configuration['templates']['twitter'] = $this->getTwitterTemplate();
           drupal_alter('addthis_configuration', $configuration);
           $templates = array('templates' => $configuration['templates']);
           unset($configuration['templates']);
           $configurationOptionsJavascript = 'var addthis_config = ' . drupal_json_encode($configuration) . "\n";
           $configurationOptionsJavascript .= 'var addthis_share = ' . drupal_json_encode($templates);
+        }
         drupal_add_js(
           $configurationOptionsJavascript,
           array(
           'type' => 'inline',
           'scope' => 'footer',
           'every_page' => TRUE,
+        )
         );
+      }
       public function getAddThisAttributesMarkup($options) {
         if (isset($options)) {
           $attributes = array();
-...
         return variable_get(self::ENABLED_SERVICES_KEY, array());
+      }
       public function getExcludedServices() {
         return variable_get(self::EXCLUDED_SERVICES_KEY, array());
+      }
       /**
        * Return the type of loading.
        * Return the type of inclusion.
+       *
        * @return string
        *   Retuns domready or async.
        */
       public function getWidgetJsLoadType() {
         return variable_get(self::WIDGET_JS_LOAD_TYPE, self::DEFAULT_WIDGET_JS_LOAD_TYPE);
       public function getWidgetJsInclude() {
         return variable_get(self::WIDGET_JS_INCLUDE, self::DEFAULT_WIDGET_JS_INCLUDE);
+      }
       /**
        * Return if domready loading should be active.
+       *
        * @return bool
        *   Returns TRUE if domready is enabled.
        */
       public function getWidgetJsDomReady() {
         return variable_get(self::WIDGET_JS_LOAD_DOMREADY, self::DEFAULT_WIDGET_JS_LOAD_DOMREADY);
+      }
       /**
        * Return if async initialization should be active.
+       *
        * @return bool
        *   Returns TRUE if async is enabled.
        */
       public function getWidgetJsAsync() {
         return variable_get(self::WIDGET_JS_LOAD_ASYNC, self::DEFAULT_WIDGET_JS_LOAD_ASYNC);
+      }
       public function isClickToOpenCompactMenuEnabled() {
-...
         return $this->getBaseBookmarkUrl() . $this->getProfileIdQueryParameterPrefixedWithAmp();
+      }
       /**
        * Transform the entity title to a attribute.
+       *
        * @remarks
        *   The title of the entity and site can not contain double-qoutes. These are
        *   encoded into html chars.
        */
       private function getAttributeTitle($entity) {
         if (isset($entity->title)) {
           return array(
             self::TITLE_ATTRIBUTE => (check_plain($entity->title) . ' - ' . variable_get('site_name')),
             self::TITLE_ATTRIBUTE => htmlentities($entity->title . ' - ' . variable_get('site_name'), ENT_COMPAT),
           );
+        }
         return array();
-...
         return array();
+      }
       private function getServiceNamesAsCommaSeparatedString() {
         $enabledServiceNames = array_values($this->getEnabledServices());
         $enabledServicesAsCommaSeparatedString = '';
         foreach ($enabledServiceNames as $enabledServiceName) {
           if ($enabledServiceName != '0') {
             $enabledServicesAsCommaSeparatedString .= $enabledServiceName . ',';
       public function getServiceNamesAsCommaSeparatedString($services) {
         $serviceNames = array_values($services);
         $servicesAsCommaSeparatedString = '';
         foreach ($serviceNames as $serviceName) {
           if ($serviceName != '0') {
             $servicesAsCommaSeparatedString .= $serviceName . ',';
+          }
+        }
         return $enabledServicesAsCommaSeparatedString;
         return $servicesAsCommaSeparatedString;
+      }
       private function getAdminCssFilePath() {

     <?php
     /**
      * @file
      * Class definition of a script manager.
+     *
      * This class will be used on different places. The result of the attachJsToElement()
      * should be the same in every situation within one request and throughout the
      * loading of the site.
+     *
      * When manipulating the configuration do this very early in the request. This
      * could be hook_init() for example. Any other method should be before hook_page_build().
      * The implementation of addthis_page_build() is the first known instance where
      * this class might get used based on the configuration.
      */
     class AddThisScriptManager {
       private $addthis = NULL;
       private $async = NULL;
       private $domready = NULL;
       /**
        * Construct method.
        */
       private function __construct() {
         $this->addthis = AddThis::getInstance();
         $this->async = $this->addthis->getWidgetJsAsync();
         $this->domready = $this->addthis->getWidgetJsDomReady();
+      }
       /**
        * Return a single instance of the AddThisScriptManager.
+       *
        * @return AddThisScriptManager
        */
       public static function getInstance() {
         static $manager;
         if (!isset($manager)) {
           $manager = new AddThisScriptManager();
+        }
         return $manager;
+      }
       /**
        * Get the current widget js url.
+       *
        * @return string
        *   A url reference to the widget js.
        */
       public function getWidgetJsUrl() {
         return check_url(variable_get(AddThis::WIDGET_JS_URL_KEY, AddThis::DEFAULT_WIDGET_JS_URL));
+      }
       /**
        * Return if we are on https connection.
+       *
        * @return bool
        *   TRUE if the current request is on https.
        */
       public function isHttps() {
         global $is_https;
         return $is_https;
+      }
       /**
        * Change the schema from http to https if we are on https.
+       *
        * @param  string $url
        *   A full url.
+       *
        * @return string
        *   The changed url.
        */
       public function correctSchemaIfHttps($url) {
         if (is_string($url) && $this->isHttps()) {
           return str_replace('http://', 'https://', $url);
+        }
         else {
           return $url;
+        }
         throw new InvalidArgumentException('The argument was not a string value');
+      }
       /**
        * Attach the widget js to the element.
+       *
        * @todo Change the scope of the addthis.js.
        *   See if we can get the scope of the addthis.js into the header
        *   just below the settings so that the settings can be used in the loaded
        *   addthis.js of our module.
+       *
        * @param array $element
        *   The element to attach the JavaScript to.
        */
       public function attachJsToElement(&$element) {
         if ($this->addthis->getWidgetJsInclude() != AddThis::WIDGET_JS_INCLUDE_NONE) {
           $widget_js = new AddThisWidgetJsUrl($this->getWidgetJsUrl());
           $pubid = $this->addthis->getProfileId();
           if (isset($pubid) && !empty($pubid) && is_string($pubid)) {
             $widget_js->addAttribute('pubid', $pubid);
+          }
           $async = $this->async;
           if ($async) {
             $widget_js->addAttribute('async', 1);
+          }
           $domready = $this->domready;
           if ($domready) {
             $widget_js->addAttribute('domready', 1);
+          }
           // Only when the script is not loaded after the DOM is ready we include
           // the script with #attached.
           if (!$domready) {
             $element['#attached']['js'][$this->getWidgetJsUrl()] = array(
                 'type' => 'external',
                 'scope' => 'footer',
             );
+          }
           // Every setting value passed here overrides previously set values but
           // leaves the values that are already set somewhere else and that are not

Projet

Général

Profil

Club Drupal

Révision 2c8c2b87

Ajouté par Assos Assos il y a presque 9 ans