Drupal Planet

Jacob Rockowitz: Defining the goals of the Schema.org Blueprints module

1 month 3 weeks ago

Over the past two years, it took a few blog posts for me to fully explore and explain how to use Schema.org as the foundation for content models; this exploration led me to create the Schema.org Blueprints module. Early into its development, three goals became apparent - they became the intro on the module's project page.

These concrete goals helped me focus on the module's core functionality and APIs, yet none of these "primary" goals acknowledge my underlying desire to use Schema.org as a collaborative, open source foundation for building websites and applications using Drupal core and its vast ecosystem of contributed modules.

Open source software development has so many nuances; writing and sharing some code online with an MIT license is not always enough. For example, after an experienced developer determines an open source project addresses their business requirements, they have to ponder if this "free" source code is stable and maintainable.

I recognize that the Schema.org Blueprints could be the foundation for applications or websites built using Drupal's ecosystem of contributed modules. The Schema.org Blueprints module's code needs to be compatible, stable, maintainable, and extendable, and this led me to expand my primary goals to include secondary and tertiary goals.

Below is my complete list of goals for the Schema.org Blueprints module.

Primary
Content modeling

  1. Structured Data
  2. Application Program Interfaces (APIs)
  3. Search Engine Optimization (SEO)

Secondary
Content authoring

  1. Administration interface
  2. Content authoring
  3. Multilingual support

Tertiary
Collaboration

  1. Open source
  2. Modular and extendable
  3. Stable and reliable

I’ll be the...Read More

Sooper Drupal Themes: DXPR Builder 2.0.0 is coming with a new visual live editing experience!

1 month 3 weeks ago

DXPR Builder, the only Drupal page builder with a proven track record on enterprise scale Drupal platforms will have its first major update this summer!

Live Editing User Experience

We are excited to present a completely new visual live editing experience that will speed up content authoring and editing even more! 

DXPR Builder 2.0.0 live editing demo. The depicted product design is not final.

When editing your Drupal content all of the changes you make with DXPR Builder will appear on the page in real time! The new editing experience is super fast and responsive. It's practically instant! DXPR has always put user-experience first and software performance a close second. The result is the most fluent and intuitive content authoring experience you've ever seen!

New GPL Compatible Drupal Module And Business modelMonthly Billing Option

When DXPR Builder 2.0.0 comes out we will offer new subscriptions. They will be priced similarly to our current offering but we will offer a monthly billing option alongside yearly billing. 

Along with this change we made DXPR Builder 2.0.0 completely GPL compatible. With our updated subscription terms, you no longer have to pay for a DXPR subscription for the lifetime of the web content you product with DXPR Builder. Instead you only pay as long as you need the editor!

Pay For The Editor Experience, Not The Consumer Experience

No vendor lock-in, no content lock-up. When your website is "finished" or you simply don't need editing capabilities for a while, you can cease the subscription and not pay a dime while the DXPR Builder module remains installed. DXPR's unique features like circle counters, countdown timers, etc., will keep working after you stop the subscription.

Only when you need the DXPR Builder editor again you will need to reactivate your subscription.

No More Site Licenses, Just User Licenses

For sites running DXPR Builder 2.x we are not charging anything per site. We believe the value of DXPR Builder is all in the productivity gains and happyness improvements for your content and communication talent. 

We are emphasizing this by getting rid of Site Licenses and keeping "DXPR Builder Editor Users" as the only "billable usage". To aid with this change we are including user licens dashboards and tools in DXPR Builder as well as at DXPR.com.

Former enterprise features now available to all DXPR Builder users!

The following features are moved from the DXPR Builder enterprise tier to all DXPR Builder 2.x users:

  • Content locking
  • Unlimited user profiles
  • Local video element

We will keep distinguising the enterprise tier with better services, training, and support, while maximixing product capabilities for all DXPR clients.

Join our beta testing group!

Can't wait to try the new DXPR Builder experience? We release a new beta version every week. Join our test group to receive the betas:

Join the test group

PreviousNext: A powerful React + Redux Toolkit pattern (reuseable state slices)

1 month 3 weeks ago

If you need global state management for your app(s) (and you probably do), a relatively new flavour of Redux called Redux Toolkit makes this considerably easier. Redux Toolkit includes a number of functions which make reusing similar "slices" of state quite easy, however there is a missing piece to this puzzle that will make things seamless!

by jack.taranto / 4 August 2022

This article assumes an understanding of (on the React side) Context, hooks, components, (and on the Redux side) actions & reducers, Redux hooks, and at least a little dabble in Redux Toolkit.

The problem

Whilst developing a recent project which utilises an Elasticsearch backend to provide a number of independent search interfaces, a need came up to have very similar state management for each application. In Redux there can only be one store, and we put this to the test with an initial prototype that threw caution to the wind and used a separate store for each application. The choice of using separate stores allowed us to easily reuse React components that implemented Redux's useSelector hook to retrieve data from the store.

However, it quickly became apparent that Redux had not been designed to work this way. Redux's excellent dev tools stopped functioning as intended, and the dev tools being a big driving point behind using Redux in the first place - meant we had to rethink our implementation.

The initial build featured a suite of reusable components that each implement useDispatch and useSelector to act on their independent state management. Take a Pagination component for example. It needs to keep track of which page a user is currently on, as well as update the current page. A useSelector hook allows it to retrieve the current page, and a useDispatch hook allows it to call an action which updates the current page.

Our architecture has a top level App component which is unique for each search application. It acts as a container and wraps the layout and components. In our initial prototype it implemented it's own store and Redux's Provider component so the child components could implement Redux hooks directly.

So with a shared store, this architecture was at risk of becoming very complex. The App wrapper would need to implement the hooks and actions itself, and then pass them down via Context or props so child components could access the correct data and actions in the store.

Instead of doing this we came up with something new.

The architecture

The updated architecture uses a React Context Provider to pass the applications "slice" down via Context. Then a custom useContext hook allows each reusable component to access store data and actions for that slice, without needing to be aware of which slice they are part of.

Let's look at it from the top.

A single global store is broken up into slices using the Redux Toolkit createSlice function. Each slice has its own name, initial state, reducers and actions.

Each application has it's own container which implements a Context provider called SliceProvider, which imports the slice and allows that to be accessed across the application.

All child components can then be shared and access the state slice via a series of custom hooks that implement useContext.

When you view things through Redux Dev tools, this is what it looks like:

Demonstration

To take a look at things I've spun up an example application, with two search interfaces - a "global" search and an "image" search.

The index.js looks like this, All it's doing is wrapping everything in the Redux `Provider`:

import { createRoot } from 'react-dom/client'; import { Provider } from 'react-redux'; import { store } from './store/store'; import App from './components/App'; const container = document.getElementById('root'); const root = createRoot(container); root.render( );

And our App.js combines both applications purely for demonstration purposes so we can see them working on screen in tandem:

import Pager from './Pager'; import SliceProvider from './SliceProvider'; import { globalSearchSlice, imageSearchSlice } from '../store/slices'; const App = () => ( <> Search Global Images ); export default App;

Now components under each SliceProvider will have access to their slice of the shared store.

Reusable reducers

With this pattern, reducers are reusable chunks of logic. We'll maintain and export them from a reducers.js file:

export const updateCurrentPage = (state, action) => ({ ...state, currentPage: action.payload, }) export const updateResultsPerPage = (state, action) => ({ ...state, resultsPerPage: action.payload, })

If you haven't used Redux Toolkit yet, this simplified syntax for reducers makes it a clear winner. Also there is no need to use the Redux Toolkit createReducer function, as that is called below with createSlice.

Creating slices

Let's take a look at slices.js which creates each slice via a function which lets us:

  1. Define a default "initialState" for each slice.
  2. Define a set of default reducers for each slice.
  3. Takes an argument for initialState to override certain values.
  4. Takes an argument for reducers so we can add to the default reducers - if one application has more advanced features for example.
  5. Includes a way to pass through extraReducers (more on this later).
import { createSlice } from "@reduxjs/toolkit" import { updateCurrentPage, updateResultsPerPage, } from "./reducers"; const createSearchAppSlice = ({ name, initialState, reducers, extraReducers }) => { // Setup a default state, and allow the function arg to change the defaults. initialState = { currentPage: 1, resultsPerPage: 10, ...initialState } return createSlice({ name, initialState, reducers: { // The first reducer is a utility to reset the state. reset: () => ({ ...initialState }), // Our reusable reducers will go here... updateCurrentPage, updateResultsPerPage, // Then pass through any other reducers specific to this slice only. ...reducers, }, extraReducers: { // extraReducers are global reducers that apply to all slices. // We'll come back to these later. ...extraReducers, }, }) } // The global slice uses the default function. export const globalSearchSlice = createSearchAppSlice({ name: "globalSearch", }) // The image slice changes some of the defaults. export const imageSearchSlice = createSearchAppSlice({ name: "imageSearch", initialState: { resultsPerPage: 20, } })

This approach makes slice creation reusable but extensible.

The store

Our store.js makes use of combineReducers to add our slices.

import { combineReducers, configureStore } from "@reduxjs/toolkit" import { globalSearchSlice, imageSearchSlice } from "./slices.js" const reducers = combineReducers({ [globalSearchSlice.name]: globalSearchSlice.reducer, [imageSearchSlice.name]: imageSearchSlice.reducer, }) export const store = configureStore({ reducer: reducers, devTools: process.env.NODE_ENV !== "production", }) Secret magic sauce

Now, to the secret magic sauce of this pattern - the SliceProvider context:

import { createContext, useContext } from "react" import { useSelector } from 'react-redux'; const SliceContext = createContext({}) const SliceProvider = ({ slice, children }) => ( {children} ) const useSliceActions = () => useContext(SliceContext).actions const useSliceSelector = () => { const { name } = useContext(SliceContext) return useSelector(state => { return state[name] }) } export default SliceProvider export { useSliceActions, useSliceSelector }

And because our components are wrapped in a SliceProvider, the useSliceActions hook allows access to the actions and the useSliceSelector hook allows access to the slice store data (via the Redux useSelector hook).

A child component can then be implemented as so:

import { useDispatch } from "react-redux"; import { useSliceActions, useSliceSelector } from "./SliceProvider"; const Pager = () => { const dispatch = useDispatch(); const { currentPage } = useSliceSelector(); const { updateCurrentPage } = useSliceActions(); return ( {currentPage} dispatch(updateCurrentPage(currentPage + 1))}> Next page ); }; export default Pager;

Now both applications can share child components that provide totally unique sets of data and actions from each slice!

Using extraReducers

Now let's take things a step further and come back to the extraReducers piece I touched on above. In Redux Toolkit extraReducers are a way to listen to actions across all slices - meaning we can call an action in one place and have it update data everywhere!

To do this we need to define some actions in actions.js:

import { createAction } from "@reduxjs/toolkit" export const updateAllCurrentPage = createAction("updateCurrentPage")

We must also write a new reducer which is suitable to be used across the whole store in reducers.js:

export const updateAllCurrentPage = (state) => ({ ...state, currentPage: state.currentPage + 1 });

Now we can import the action and reducer and use them in slices.js (I love this syntax in Redux Toolkit):

import { updateAllCurrentPage as updateAllCurrentPageReducer, } from "./reducers"; import { updateAllCurrentPage } from "./actions"; export const globalSearchSlice = createSearchAppSlice({ name: "globalSearch", extraReducers: { [updateAllCurrentPage]: updateAllCurrentPageReducer, }, }); export const imageSearchSlice = createSearchAppSlice({ name: "imageSearch", initialState: { resultsPerPage: 20, }, extraReducers: { [updateAllCurrentPage]: updateAllCurrentPageReducer, }, });

A new component can import the action directly and call it via useDispatch:

import { useDispatch } from "react-redux"; import { updateAllCurrentPage } from "../store/actions"; const AllPager = () => { const dispatch = useDispatch(); return ( dispatch(updateAllCurrentPage())}> Next page(s) ); }; export default AllPager; Summation

This pattern can become very powerful for the following reasons:

  1. It utilises all features of Redux Toolkit to provide reusable slices, actions, and reducers.
  2. Each slice is completely independent, however it can share capabilities as needed.
  3. Any state aware component can access a slice directly and be reused across slices.
  4. Components can still update state across the whole store as needed.

Take a look a the example application.

Tagged ReactJS, Redux, Front End Development

Web Wash: How to Fix “This entity cannot be referenced” Error on Paragraphs in Drupal

1 month 3 weeks ago

Recently working on a Drupal site, creating new paragraph types as you do… While creating pages and testing the paragraphs, I got the following error: This entity (paragraph: ID) cannot be referenced. This was the first time I ever saw this error.

What I discovered was I accidentally unselected the paragraph type from the “Reference type” section on the entity reference revision field.

This can happen on any entity reference field not just a paragraph field.

If you create a page and reference an entity or create a paragraph. If the content or paragraph type is unselected from the reference type section. The next time you save the form you’ll get the error.

Evolving Web: Evolving Web turns 15!

1 month 3 weeks ago

Founded in 2007, Evolving Web is happy to celebrate 15 years of improving the web and empowering organizations across the globe this year.

As one of our colleagues mentioned, a lot can happen in 15 years. We've seen some amazing technological advances. In 2007, Apple launched the iPhone, Facebook and Twitter went global; Kindle and Android were released; Airbnb was founded; Google bought YouTube; and IBM created its artificial intelligence system, Watson. 

And it's not just the tech sector that's evolving and growing – we're seeing changes across all industries. The way we work is changing, too. We're more connected than ever before, thanks to the internet and social media. And we're working in more collaborative, flexible ways. 

In 2007, Evolving Web was a 2-person business and is now an international company with 80+ employees and 30+ contractors, representing 22 nationalities, and speaking 30+ languages. This is the story of how we got here.

Alex & Suzanne, Evolving Web founders 

 

How it started

Evolving Web started from a passion for improving the web experience and making websites easier to use for everyone. Straight out of university, co-founders Alex and Suzanne started Evolving Web to help people create better websites. From the beginning, the goal was to make a difference in the web experience for everyone.

The very first website Evolving built

 

As we look back, we’re proud of the impact we’ve had. We’ve partnered with some amazing organizations and worked on incredible projects that have helped shape the web as we know it today. And though a lot has changed, our commitment to making the digital world a better place remains the same.

How it’s going

15 years after Evolving Web was founded, there are a few values that we’ve held on to since the beginning that continue to guide us as we grow:

15 years anniversary cake

Open source, international, inclusive

We’ve always been firm believers in the power of collaboration and community. We’ve seen how working together can create amazing things. We’ve also seen how building an inclusive and diverse community is essential to this process.

Evolving Web is an open-source company. This means that the work we do doesn’t exist in a vacuum, that it’s part of a larger community of people sharing code, design, and ideas. We believe that by collaborating openly, we can create better products and services that benefit everyone.

We’re also an international company, with employees and contractors located all over the world. This allows us to tap into a wealth of diverse perspectives and skillsets, which helps us create better solutions for our clients.

And finally, we’re an inclusive company. We believe that everyone should have the opportunity to participate in our work, regardless of background or experience. We’re committed to creating an environment where everyone feels welcome, respected, and valued.

 

"The best thing about working with Evolving Web, is to have the opportunity to be challenged and to grow. There is always something on the horizon that we are trying to accomplish and solve together as a team. It's that sense of collaboration."

Vuong Tong, Design Director

Impacting the world with our work

Our goal is to use our skills and expertise to make a positive impact in the world. We work with organizations that are making a difference in their communities, and we strive to create products and services that have a positive social and environmental impact.

We pride ourselves on training hundreds of Government of Canada employees to be more digitally savvy, helping their teams function better. We’ve also had the opportunity to work closely with the web services teams of universities across Canada to create or upgrade their underlying website platforms that back thousands of websites, including McGill University, Trent University and the University of Waterloo

Further, our contributions to Drupal multilingual have gone on to benefit millions of users around the world who speak different languages. All of this creates a positive, lasting impact — and we’re proud to have played a role in it!

 

“For me, it’s the belief in company goals. It’s all about the product with a capital P. It’s not about the portfolio of our prestigious clients or the ego of anyone at leadership.”

Chantal Theriault

 

Creating more reusable, shareable web components

The web has evolved from a static medium to a dynamic platform for collaboration and creativity. We’ve also seen how powerful open source tools and technologies can be in empowering people to build amazing things.

As we look to the future, we want to continue to build on these successes by creating more reusable, shareable web components. We believe that by making it easier for people to create and share components, we can help them build amazing things faster.

We’re also focused on continuing to evolve our own products and services. We want to make sure that they are always at the forefront of the latest trends and technologies, so that our clients can always rely on us to help them achieve their goals.

Looking forward to the next 15 years

We’re incredibly proud of what we’ve accomplished. We’ve come a long way and we’re excited to see what the future holds. We want to thank everyone who has been a part of our journey so far, whether you’ve worked with us, contributed to our work, or simply been a supporter. We couldn’t have done it without you, and we’re looking forward to continuing to build this amazing community together.

"The family feel that we had 10 years ago, we have to find ways to keep that going as we grow in the next 15 years,"

Alex Dergachev, co-founder of Evolving Web.

As we look to the future, we’re excited to continue evolving and growing along with the digital ecosystem we’re part of.

"We aren’t just growing for the sake of growth. Growth means we can take a more strategic approach with our clients and choose projects we want to contribute to. We are looking forward to working with clients that are making an impact and changing the world for the better. Those are the projects that align with the Evolving Web culture."

Suzanne, co-founder, Evolving Web

Thank you for being a part of our journey! We can’t wait to see what the future will bring.

 

//--> //--> //-->

+ more awesome articles by Evolving Web

Finalist Blog: Extending the Office 365 Connector module

1 month 3 weeks ago
Using the Office 365 Connector module it is possible for developers to connect to the Graph API's from Microsoft. How to start First of all we need to know what we want to get from, or send to, Microsoft. For this blog I would like to show you how to search for files in SharePoint, but there are a lot more API's available. Microsoft offers good documentation and a Graph Explorer. Using the Graph Explorer you can test the endpoints and see what data is returned when you do a request. Custom scopes When developing it can happen that the scopes the default Office connector…

Specbee: Building component-based websites on Drupal using Acquia Site Studio

1 month 3 weeks ago
Building component-based websites on Drupal using Acquia Site Studio Subramanyam 02 Aug, 2022

If you find yourself thinking there’s got to be a better way to build a website than hiring a full time developer, you’re probably looking for something like Acquia’s Site Studio. It’s that perfect blend of robustness and usability that lets non-technical users like content editors, designers, marketers, and site owners build brand-compliant, unique websites. Formerly known as Cohesion, Site Studio provides the ability to create elegant and more powerful sites in half the time. Read more about Site studio and how to implement and use it for building beautiful Drupal sites.

Why use Acquia Site Studio?

As we said earlier, Site studio makes it really easy to build component-based websites. 

Think of components as lego blocks and your website as a house you want to build with these blocks. As a builder, you are assembling various blocks in a way that helps you build your design. So in website terms, a component can be a block of text, an image, a featured snippet, a live Twitter feed, a header, a footer or so much more! All those components together help you complete your house/website design.

Benefits of using Site Studio
  • Site Studio provides around 50 predefined components which you can start using immediately like Text, Image, Slider, Accordion, etc. Users can also use custom-built components that have been created by developers.
  • It provides an excellent content editing user interface for adding components or templates in the layout by simply dragging and dropping
  • It does not require as much time and effort
  • Low code makes it appealing to users with less to no knowledge of building pages
  • A powerful visual user interface and in-context editor that let’s you edit content directly on a live site
  • Empowers users to preview their layout in various devices jus by changing the settings of the device aspect ratios
  • Easy to maintain
How does it work?

Normally, to create a block type or paragraph type in Drupal 9, you need to have a specific Twig file for the markup. Then, based on the markup and design, you would write the CSS rules to create a card component. 

However, when building a card component in Site Studio, you use a template of the card that already includes the CSS properties within the component. Then, using its drag-and-drop feature, you can use predefined elements like image, text, and link to create a layout for the card. Each component has a ‘Properties’ tab, where you can control the look of the component. The best part is that all this is done without writing a single line of code.

Getting Started with Site Studio

Let’s get started by first installing and enabling the module and theme.

Installing
  • Download them with the help of Composer or manually
  • composer require acquia/cohesion:6.8.0
  • composer require acquia/cohesion-theme:6.8.0
  • Enable the modules
  • Install the Acquia Cohesion minimal theme from the UI

Once you have successfully installed the module and theme, you will see a new menu item on the admin toolbar called Site Studio. Here’s where you will be playing around with Components, Templates, Styles, Packages, etc (see below).

  Components

You can now create a component by navigating to the Components page. You can also see a list of components that are already available on the site.

  Customizing your components

You can add styles to the Component elements by editing or double-clicking the element and then clicking on the Styles tab. Here you can see all the available styles. You can now add the CSS Styles by clicking on Properties Tab

 

  Create a page

You can create a page and add your components to the page by just dragging and dropping them into your layout.

References:

You can refer to the official Site studio documentation here

Final Thoughts

Site Studio gives you the ability to build websites faster and is useful for everyone - from developers to marketers and even end users. Site managers, Content editors or Marketers can easily add entirely new sections to the website without needing the help of a designer or Drupal development team. They can simply reuse the assets that are available and then add new sections to the website or rearrange existing ones. As a Drupal development company, we can help build custom components to enable you to project your unique brand effectively. Thank you for reading!

Author: Subramanyam

Meet Subramanyam, a Drupal Frontend developer by profession. He dreams of traveling the world (or at least all of India) one day. Aside from working, you can find him guffawing at funny YouTube videos or binge-watching action movies.

Drupal Drupal 9 Drupal 9 Module Drupal Development Drupal Planet Subscribe to our Newsletter Now Subscribe Leave this field blank

Leave us a Comment

  Recent Blogs Image Building component-based websites on Drupal using Acquia Site Studio Image Setting up Responsive Images in Drupal 9 - A Step-by-Step Guide Image 7 Reasons Drupal is the Best CMS for Your Business in 2022 Want to extract the maximum out of Drupal? TALK TO US Featured Success Stories

Upgrading and consolidating multiple web properties to offer a coherent digital experience for Physicians Insurance

Upgrading the web presence of IEEE Information Theory Society, the most trusted voice for advanced technology

Great Southern Homes, one of the fastest growing home builders in the United States, sees greater results with Drupal 9

View all Case Studies

Dries Buytaert: My Drupal deployment workflow

1 month 3 weeks ago

I wanted to outline the deployment workflow I use on dri.es, my personal website.

My site uses Drupal (obviously) and runs on Acquia Cloud (of course), but a lot of this is a best practice for any web application.

I manage my website's code and configuration in Git. Each time I commit a change to my Git repository, I go through the following steps:

  1. I create a staging environment to test my code before deploying it to production. It's a complete staging environment: not just PHP, MySQL and Nginx, but also Varnish, Memcache, etc.
  2. I check out my Git repository. My Git repository hosts my custom files only. It's a best practice not to commit Drupal core or third-party Drupal modules to your Git repository.
  3. I run PHP Code Sniffer to make sure my code comforms my coding style rules. I specify my coding style rules in phpcs.xml and use phpcs to make sure my code adheres to them. If not, phpcbf tries to fix my code automatically. I like my code tidy.
  4. I run PHPStan, a static code analysis tool for PHP, that scans my code base for bugs. It will find dead code, type casting problems, incorrect function arguments, missing type hints, unknown function calls, and much more. PHPStan is a fantastic tool.
  5. I run PHP Unit, a PHP testing framework, to make sure my unit tests pass.
  6. I run phpcs-security-audit, a static code analysis tool for PHP. It scans my PHP code for security vulnerabilities and security weaknesses.
  7. I run ESLint, a static code analysis tool for JavaScript. It scans my JavaScript code for security vulnerabilities and weaknesses.
  8. I run nodejs-scan to find insecure code patterns in Node.js applications. I don't use Node.js though, so this is a no-op.
  9. I also run Semgrep, a static code analysis tool for a variety of programming languages.
  10. I run Rector to make sure I don't use deprecated Drupal code. When I do, Rector will try to programmatically update any deprecated code that it finds.
  11. As my Git repository only has custom files, I use Composer to download and install the latest version of Drupal and all third-party modules and components.
  12. I run drush pm:security. Drush is a Drupal-specific tool, and the pm:security option verifies that I have no insecure dependencies installed.

It might sound like a lot of work to set up, and it can be. For Acquia customers and partners, Acquia Code Studio automates all the steps above. Acquia Code Studio is a fully managed CI/CD based on Gitlab, with specific steps optimized for Drupal. It couldn't be easier.

A screenshot of Acquia Code Studio showing the automated tests feature. For more details, check this video.

Acquia Code Studio also takes care of automating dependency updates. Code Studio regularly checks if Drupal or any of its dependencies have a new release available. If there is a new release, it will run all the steps above. When all of the above tools pass, Acquia Code Studio can deploy new code to production with one click of a button.

A screenshot of Acquia Code Studio showing the automated update feature. For more details, check this video.

I love it!

Talking Drupal: Talking Drupal #358 - A Project Browser Update

1 month 3 weeks ago

Today we are talking about The Project Browser with Leslie Glynn & Tim Plunkett.

www.talkingDrupal.com/358

Topics
  • What is Project Browser
  • How are you involved?
  • What is the Drupal Acceleration Team and how is it involved with Project Browser
  • Will it be in Drupal 10 or 11?
  • How are you organizing module data on d.o?
  • How does PB showcase the community working on modules?
  • How does PB work with other initiatives like Automatic Updates
  • How has management changed over the project?
  • Security?
  • How is Chris Wells as an initiative lead?
  • What makes a good project lead?
  • Anything else?
Resources Guests

Tim Plunkett - @timplunkett Leslie Glynn - @leslieglynn

Hosts

Nic Laflin - www.nLighteneddevelopment.com @nicxvan John Picozzi - www.epam.com @johnpicozzi Ryan Price - ryanpricemedia.com - @liberatr

MOTW

Search API Algolia This module provides integration with the Algolia service, through Drupal’s Search API. This module is intended to be used by developers, as it does not currently provide any implementation of an actual search interface. Only indexing is currently supported. As a result, enabling that module will not have any visible effect on your application. Search functionality may be implemented using the Algolia Javascript API.

Acquia Developer Portal Blog: Evaluating Drupal Community Modules

1 month 3 weeks ago

When looking to use a module from the Drupal community there are a number of factors to consider, beyond its functional use, that determine suitable quality and support for your organisation to use.

When you deploy a Drupal site into production, who is responsible for maintaining it? How long will that site live for? These types of questions shape the risk tolerances of the project. E.g. Lower Drupal competencies means you need greater community support and more stable modules.

All modules on Drupal.org are open source and fall under the GPLv2 open source license. They are free to download and use at your own risk. Each project has its own set of maintainers and a sub-community that uses the module, interacts through issues and contributes bug fixes and feature enhancements.

#! code: Drupal 9: Running PHPStan On Drupal Custom Modules

1 month 3 weeks ago

PHPStan is a great command line tool for looking at how your PHP code will run without actually running it. It's great for finding potential bugs that you wouldn't have otherwise discovered using other tools or through unit testing.

With regards to Drupal projects there is a little problem in that PHPStan doesn't know how to interpret Drupal plugins, entities, controllers or all the other Drupal architecture that goes into a Drupal module. For this reason, if you try to run PHPStan on your module code you'll find that it produces a lot of errors regarding missing objects or incorrect parameters.

Thankfully, it's possible to easily teach PHPStan about Drupal and make the tool more useful when writing Drupal code. First we need to install it.

Install PHPStan In A Drupal Site

To install PHPStan into a Drupal site you need to use composer and include the following pages.

composer require --dev phpstan/phpstan phpstan/extension-installer mglaman/phpstan-drupal phpstan/phpstan-deprecation-rules

The packages we are installing are:

  • phpstan/phpstan - The core PHPStan package.
  • phpstan/extension-installer - This is a composer plugin for automatically installing PHPStan extensions which means we can load packages into the PHPStan runtime.
  • mglaman/phpstan-drupal - PHPStan Drupal is a package created by Matt Glaman that allows PHPStan to understand the Drupal object structure.
  • phpstan/phpstan-deprecation-rules - A PHPStan package that will print out deprecation messages, which helps us detect deprecations in Drupal code.

Next, we need to create a configuration file so that PHPStan knows what level to run at and what paths we are interested in. Create a file called phpstan.neon in the root of your project and add the following configuration to it.

Read more.

Peoples BLOG: Usage of Constraints (Validations) on Media Entities in Drupal Application

1 month 4 weeks ago
In this article we are going to see how drupal developers can use the Drupal Constraints to Validate the Media entities. Basically Drupal provides Constraints to do the Validations on the Entities, where Drupal uses the Symfony’s validator and extends with Symfony’s Typed Data API for validating specific Entity field definitions. These constraint validators can be used in different w

Promet Source: How to Fix Common Web Accessibility Barriers in Drupal

1 month 4 weeks ago
Drupal’s Fullcalendar View module is currently in use by more than 13,000 Drupal sites, and is among the most widely relied upon Drupal modules when developing event calendars. Until recently, though, the module was laden with accessibility barriers. Sites that leveraged the Fullcalendar View module required dozens and dozens of additional development hours to ensure accessibility. 
Checked
1 hour 3 minutes ago
Drupal.org - aggregated feeds in category Planet Drupal
Subscribe to Drupal Planet feed